StateHistogram.hpp

Go to the documentation of this file.

// <StateHistogram.h> -*- C++ -*-
 
 
#pragma once
 
#include <iostream>
#include <string>
#include <vector>
#include "sparta/utils/MathUtils.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/statistics/Counter.hpp"
#include "sparta/statistics/CycleCounter.hpp"
#include "sparta/statistics/StatisticDef.hpp"
#include "sparta/statistics/StatisticSet.hpp"
#include "sparta/simulation/Resource.hpp"
 
namespace sparta
{
template <class StateEnumType>
class StateHistogram : public TreeNode
{
public:
 
    StateHistogram() = delete;
 
    StateHistogram(const StateHistogram&) = delete;
 
    StateHistogram(StateHistogram&&) = delete;
 
    void operator=(const StateHistogram&) = delete;
 
    StateHistogram(TreeNode* parent_treenode,
                   std::string histogram_name,
                   std::string description,
                   const StateEnumType idle_value = StateEnumType::__FIRST) :
        TreeNode(histogram_name, description),
        lower_val_(static_cast<uint64_t>(StateEnumType::__FIRST)),
        upper_val_(static_cast<uint64_t>(StateEnumType::__LAST) - 1),
        idle_value_(static_cast<uint64_t>(idle_value)),
        stats_(this)
    {
        if(parent_treenode){
            setExpectedParent_(parent_treenode);
        }
 
        sparta_assert_context(upper_val_ > lower_val_,
                            "StateHistogram: upper value must be greater than lower value");
        num_bins_ = upper_val_ - lower_val_ + 1;
 
        // Reserve to use emplacement without tree child reordering
        bin_.reserve(num_bins_);
 
        uint64_t val = lower_val_;
        std::string total_str;
 
        for (uint32_t i = 0; i < num_bins_; ++i) {
            std::stringstream str;
            str << "bin_" << std::string(typename sparta::utils::Enum<StateEnumType>::Value(static_cast<StateEnumType>(val)));
 
            bin_.emplace_back(sparta::CycleCounter(&stats_,
                                                 str.str(),
                                                 str.str() + " histogram bin",
                                                 sparta::Counter::COUNT_NORMAL,
                                                 parent_treenode->getClock()));
 
            probabilities_.emplace_back(new StatisticDef(&stats_,
                                                         str.str() + "_probability",
                                                         str.str() + " bin probability",
                                                         &stats_,
                                                         str.str() + "/total"));
            ++val;
 
            if (total_str == "") {
                total_str += str.str();
            } else {
                total_str += " + " + str.str();
            }
        }
 
        total_.reset(new StatisticDef(&stats_,
                                      "total",
                                      "Aggregated total",
                                      &stats_,
                                      total_str));
 
        if(parent_treenode){
            parent_treenode->addChild(this);
        }
 
        // Start capturing the idle value
        startCounting_(idle_value_);
    }
 
 
 
    void setState(const StateEnumType new_state)
    {
        uint32_t new_val = static_cast<uint32_t>(new_state);
        if (new_val != curr_value_) {
            stopCounting_(curr_value_);
            startCounting_(new_val);
        }
    }
 
    void setNextState(const StateEnumType new_state)
    {
        uint32_t new_val = static_cast<uint32_t>(new_state);
        if (new_val != curr_value_) {
            stopCounting_(curr_value_, 1);
            startCounting_(new_val, 1);
        }
    }
 
    StateEnumType getState() const
    {
        return static_cast<StateEnumType>(curr_value_);
    }
 
 
    uint64_t getHistogramUpperValue() const { return upper_val_; }
    uint64_t getHistogramLowerValue() const { return lower_val_; }
    uint32_t getNumBins() const { return num_bins_; }
    uint32_t getNumValuesPerBin() const { return 1; }
 
    std::string getDisplayStringCumulative() const
    {
        std::stringstream str;
        str << std::dec;
        uint64_t val = lower_val_;
        for (uint32_t i = 0; i < num_bins_; ++i) {
            str << "\t" << getName()
                << "[ " << std::string(typename sparta::utils::Enum<StateEnumType>::Value(static_cast<StateEnumType>(val))) << "] = "
                << bin_[i] << std::endl;
            ++val;
        }
        return str.str();
    }
 
private:
    void startCounting_(uint32_t val, uint32_t delay = 0) {
        sparta_assert(val >= lower_val_);
        sparta_assert(val <= upper_val_);
 
        uint32_t idx = val - lower_val_;
        sparta_assert((bin_.at(idx)).isCounting() == false);
        (bin_.at(idx)).startCounting(delay);
 
        curr_value_ = val;
    }
 
    void stopCounting_(uint32_t val, uint32_t delay = 0) {
        sparta_assert(val >= lower_val_);
        sparta_assert(val <= upper_val_);
 
        uint32_t idx = val - lower_val_;
        sparta_assert((bin_.at(idx)).isCounting() == true);
        (bin_.at(idx)).stopCounting(delay);
    }
 
    const uint64_t lower_val_; 
    const uint64_t upper_val_; 
    const uint32_t idle_value_; 
 
    sparta::StatisticSet stats_; 
    std::unique_ptr<sparta::StatisticDef> total_; 
    std::vector<sparta::CycleCounter> bin_; 
    std::vector<std::unique_ptr<sparta::StatisticDef>> probabilities_; 
 
    uint32_t num_bins_; 
    uint32_t curr_value_ = 0; 
}; // class StateHistogram
 
} // namespace sparta