HistogramFunctionManager.hpp

Go to the documentation of this file.

// <HistogramFunctionManager.h> -*- C++ -*-
 
 
#pragma once
 
#include <iostream>
#include <functional>
#include <map>
#include <string>
 
#include "sparta/statistics/Histogram.hpp"
#include "sparta/statistics/CycleHistogram.hpp"
#include "sparta/utils/MetaStructs.hpp"
 
namespace sparta{
 
    // The signature of the methods that should be
    // registered with this macro is aliased here.
    template<typename T>
    using HistStatCalcFcn = double (*)(const T*);
 
    class FunctionManager{
    public:
 
        FunctionManager(const FunctionManager&) = delete;
 
        FunctionManager(FunctionManager&&) = delete;
 
        FunctionManager& operator = (const FunctionManager&) = delete;
 
        FunctionManager& operator = (FunctionManager*&) = delete;
 
        static FunctionManager& get(){
            static FunctionManager function_manager;
            return function_manager;
        }
 
        const std::string& getToken() const {
            return token_;
        }
 
        template<typename T>
        MetaStruct::enable_if_t<
            std::is_same<MetaStruct::decay_t<T>,
                CycleHistogramTreeNode>::value, void>
        add(const std::string& name, HistStatCalcFcn<T> fcn){
 
            // Registering the same function twice should throw an exception.
            if(functions_cycle_.find(name) != functions_cycle_.end()){
                throw sparta::SpartaException(
                "This method " + name + " was already registered with the REGISTER_HISTOGRAM_STAT_CALC_FCN macro.");
            }
            functions_cycle_[name] = fcn;
        }
 
        template<typename T>
        MetaStruct::enable_if_t<
            std::is_same<MetaStruct::decay_t<T>,
                HistogramTreeNode>::value, void>
        add(const std::string& name, HistStatCalcFcn<T> fcn){
 
            // Registering the same function twice should throw an exception.
            if(functions_normal_.find(name) != functions_normal_.end()){
                throw sparta::SpartaException(
                "This method " + name + "was already registered with the REGISTER_HISTOGRAM_STAT_CALC_FCN macro.");
            }
            functions_normal_[name] = fcn;
        }
 
        template<typename T>
        MetaStruct::enable_if_t<
            std::is_same<MetaStruct::decay_t<T>,
                CycleHistogramTreeNode>::value,
                    HistStatCalcFcn<T>&>
        find(const std::string& name){
            const auto& iter = functions_cycle_.find(name);
 
            // If no such function pointers were found, it should throw.
            if(iter == functions_cycle_.end()){
                throw sparta::SpartaException(
                "This method " + name + " was never registered with the REGISTER_HISTOGRAM_STAT_CALC_FCN macro.");
            }
            return iter->second;
        }
 
        template<typename T>
        MetaStruct::enable_if_t<
            std::is_same<MetaStruct::decay_t<T>,
                HistogramTreeNode>::value,
                    HistStatCalcFcn<T>&>
        find(const std::string& name){
            const auto& iter = functions_normal_.find(name);
 
            // If no such function pointers were found, it should throw.
            if(iter == functions_normal_.end()){
                throw sparta::SpartaException(
                "This method " + name + " was never registered with the REGISTER_HISTOGRAM_STAT_CALC_FCN macro.");
            }
            return iter->second;
        }
    private:
 
        // Singleton private default constructor.
        FunctionManager() = default;
 
        // Constant string token which the users will use as a prefix
        // while writing their statdefinitions in yaml files.
        const std::string token_ = "hist_def";
 
        // The map of method names to function pointers for CycleHistogramNodes.
        std::map<std::string, HistStatCalcFcn<CycleHistogramTreeNode>> functions_cycle_;
 
        // The map of method names to function pointers for CycleHistogramNodes.
        std::map<std::string, HistStatCalcFcn<HistogramTreeNode>> functions_normal_;
    };
}
 
#define REGISTER_HISTOGRAM_STAT_CALC_FCN(histogram_type, fcn_name)                              \
{                                                                                               \
    static_assert(MetaStruct::matches_any<sparta::histogram_type,                                 \
                                          sparta::HistogramTreeNode,                              \
                                          sparta::CycleHistogramTreeNode>::value,                 \
        "Invalid class type used for histogram stat calculation registration.");                \
    std::string key = #fcn_name;                                                                \
    sparta::HistStatCalcFcn<sparta::histogram_type> callable = fcn_name;                            \
    sparta::FunctionManager::get().add<sparta::histogram_type>(key, callable);                      \
}