EnumCycleHistogram.hpp

Go to the documentation of this file.

// <EnumCycleHistogram.h> -*- C++ -*-
 
 
#pragma once
 
#include <iostream>
#include <string>
#include <vector>
#include "sparta/utils/MathUtils.hpp"
#include "sparta/utils/MetaStructs.hpp"
#include "sparta/utils/DetectMemberUtils.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"
#include "sparta/statistics/CycleHistogram.hpp"
 
namespace sparta{
 
//  Case when it is not a sparta::utils::Enum type.
template<typename T>
struct is_sparta_enum : public std::false_type{};
 
//  Case when it is a sparta::utils::Enum type.
template<typename T>
struct is_sparta_enum<sparta::utils::Enum<T>> : public std::true_type{};
 
//  name equivalents of the different enum constants. For this,
//  we need to invoke the << operator on individual enum constants.
//  This template overload is SFINAEd out to enable if this enum
//  type U has a << operator overloaded for it.
template<typename U>
MetaStruct::enable_if_t<not sparta::is_sparta_enum<U>::value and
                        sparta::utils::has_ostream_operator<U>::value, void>
getHumanReadableHistogramBinNames(std::vector<std::string>& enum_name_strings){
    typedef typename std::underlying_type<U>::type enum_type;
    constexpr enum_type last_index = static_cast<enum_type>(U::__LAST);
    enum_name_strings.reserve(last_index);
    std::stringstream ss;
    for(enum_type e = 0; e < last_index; ++e){
        auto val = static_cast<U>(e);
        ss << val;
        enum_name_strings.emplace_back(ss.str());
        ss.str("");
        ss.clear();
    }
}
 
//  name equivalents of the different enum constants. For this,
//  we need to invoke the << operator on individual enum constants.
//  This template overload is SFINAEd out to disable if this enum
//  type U does not have a << operator overloaded for it. We fill
//  the resulting vector with empty strings.
template<typename U>
MetaStruct::enable_if_t<not sparta::is_sparta_enum<U>::value and
                        not sparta::utils::has_ostream_operator<U>::value, void>
getHumanReadableHistogramBinNames(std::vector<std::string>&){}
 
//  name equivalents of the different enum constants.
//  Template specialization for types which are actually sparta::utils::Enum type.
template<typename U>
MetaStruct::enable_if_t<sparta::is_sparta_enum<U>::value, void>
getHumanReadableHistogramBinNames(std::vector<std::string>& enum_name_strings){
    U::populateNames(enum_name_strings);
}
 
template<typename EnumType>
class EnumCycleHistogram final : public sparta::TreeNode, private sparta::CycleHistogramBase{
public:
 
    EnumCycleHistogram() = delete;
 
    EnumCycleHistogram(const EnumCycleHistogram&) = delete;
 
    EnumCycleHistogram(EnumCycleHistogram&&) = delete;
 
    EnumCycleHistogram& operator = (const EnumCycleHistogram&) = delete;
 
    EnumCycleHistogram& operator = (EnumCycleHistogram&&) = delete;
 
    template<typename T = EnumType>
    EnumCycleHistogram(TreeNode* parent_treenode,
                       const std::string& histogram_name,
                       const std::string& description,
                       const T idle_value = T::__FIRST,
                       const InstrumentationNode::visibility_t stat_vis_general =
                                           InstrumentationNode::AUTO_VISIBILITY,
                       const InstrumentationNode::visibility_t stat_vis_detailed =
                                            InstrumentationNode::AUTO_VISIBILITY,
                       InstrumentationNode::visibility_t stat_vis_max =
                                            InstrumentationNode::AUTO_VISIBILITY,
                       InstrumentationNode::visibility_t stat_vis_avg =
                                            InstrumentationNode::AUTO_VISIBILITY,
                       MetaStruct::enable_if_t<not sparta::is_sparta_enum<T>::value>* = 0) :
        sparta::TreeNode(histogram_name, description),
        sparta::CycleHistogramBase(static_cast<uint64_t>(T::__FIRST),
                                 static_cast<uint64_t>(T::__LAST) - 1,
                                 1,
                                 static_cast<uint64_t>(idle_value)),
        stats_(this)
        {
            static_assert(std::is_enum<T>::value, "The template type must be a std::enum class type.");
            sparta_assert(parent_treenode and parent_treenode->getClock());
            setExpectedParent_(parent_treenode);
            std::vector<std::string> enum_name_strings;
            getHumanReadableHistogramBinNames<T>(enum_name_strings);
            initializeStats_ (&stats_, parent_treenode->getClock(), std::string(),
                              description, stat_vis_general, stat_vis_detailed,
                              stat_vis_max, stat_vis_avg, enum_name_strings);
            parent_treenode->addChild(this);
            total_->startCounting();
            // Start capturing the idle value
            startCounting_(idle_value_);
            updateMaxValues_(idle_value_);
    }
 
    template<typename T = EnumType>
    EnumCycleHistogram(TreeNode* parent_treenode,
                       const std::string& histogram_name,
                       const std::string& description,
                       const typename T::value_type idle_value = T::value_type::__FIRST,
                       const InstrumentationNode::visibility_t stat_vis_general =
                                           InstrumentationNode::AUTO_VISIBILITY,
                       const InstrumentationNode::visibility_t stat_vis_detailed =
                                            InstrumentationNode::AUTO_VISIBILITY,
                       InstrumentationNode::visibility_t stat_vis_max =
                                            InstrumentationNode::AUTO_VISIBILITY,
                       InstrumentationNode::visibility_t stat_vis_avg =
                                            InstrumentationNode::AUTO_VISIBILITY,
                       MetaStruct::enable_if_t<sparta::is_sparta_enum<T>::value>* = 0) :
        sparta::TreeNode(histogram_name, description),
        sparta::CycleHistogramBase(static_cast<uint64_t>(T::value_type::__FIRST),
                                 static_cast<uint64_t>(T::value_type::__LAST) - 1,
                                 1,
                                 static_cast<uint64_t>(idle_value)),
        stats_(this)
        {
            static_assert(sparta::is_sparta_enum<T>::value, "The template type must be sparta enum class type.");
            sparta_assert(parent_treenode and parent_treenode->getClock());
            setExpectedParent_(parent_treenode);
            std::vector<std::string> enum_name_strings;
            getHumanReadableHistogramBinNames<T>(enum_name_strings);
            initializeStats_ (&stats_, parent_treenode->getClock(), std::string(),
                              description, stat_vis_general, stat_vis_detailed,
                              stat_vis_max, stat_vis_avg, enum_name_strings);
            parent_treenode->addChild(this);
            total_->startCounting();
            // Start capturing the idle value
            startCounting_(idle_value_);
            updateMaxValues_(idle_value_);
    }
 
    template<typename T = EnumType>
    void startCounting(const T enum_val, uint64_t delay = 0){
        stopCounting_(last_value_);
        startCounting_(static_cast<uint64_t>(enum_val), delay);
        updateMaxValues_(static_cast<uint64_t>(enum_val));
    }
 
    template<typename T = EnumType>
    void stopCounting(const T enum_val, uint64_t delay = 0){
        stopCounting_(static_cast<uint64_t>(enum_val), delay);
        startCounting_(idle_value_);
    }
 
    uint64_t getHistogramUpperValue() const{
        return this->sparta::CycleHistogramBase::getHistogramUpperValue();
    }
 
    uint64_t getHistogramLowerValue() const{
        return this->sparta::CycleHistogramBase::getHistogramLowerValue();
    }
 
    uint64_t getNumBins() const{
        return this->sparta::CycleHistogramBase::getNumBins();
    }
 
    uint64_t getNumValuesPerBin() const{
        return this->sparta::CycleHistogramBase::getNumValuesPerBin();
    }
 
    private:
    sparta::StatisticSet stats_;
}; // class EnumCycleHistogram
}  // namespace sparta