ContextCounter.hpp

// <ContextCounter> -*- C++ -*-
 
 
#pragma once
 
#include <boost/lexical_cast.hpp>
#include <cstddef>
#include <cstdint>
#include <string>
#include <cinttypes>
#include <iterator>
#include <ostream>
#include <set>
#include <type_traits>
#include <utility>
#include <vector>
 
#include "sparta/statistics/StatisticSet.hpp"
#include "sparta/statistics/StatisticDef.hpp"
#include "sparta/statistics/ReadOnlyCounter.hpp"
#include "sparta/report/Report.hpp"
#include "sparta/utils/StringUtils.hpp"
#include "sparta/trigger/ContextCounterTrigger.hpp"
#include "sparta/statistics/InstrumentationNode.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/kernel/SpartaHandler.hpp"
#include "sparta/statistics/StatisticInstance.hpp"
 
namespace sparta {
class CounterBase;
class ReadOnlyCounter;
class StatisticSet;
}  // namespace sparta
 
// Non-template internal counter information for JSON serialization
struct ContextCounterInfo {
    std::string name_;
    std::string desc_;
    sparta::InstrumentationNode::visibility_t vis_ = 0;
    double val_ = 0;
    const void * ctx_addr_ = nullptr;
};
 
bool __groupedPrinting(
    std::set<const void*> & dont_print_these,
    void * grouped_json_, void * doc_,
    const std::vector<ContextCounterInfo> & ctx_info,
    const std::string & aggregate_desc,
    const sparta::InstrumentationNode::visibility_t aggregate_vis);
 
bool __groupedPrintingReduced(
    std::set<const void*> & dont_print_these,
    void * grouped_json_, void * doc_,
    const std::vector<ContextCounterInfo> & ctx_info);
 
bool __groupedPrintingDetail(
    std::set<const void*> & dont_print_these,
    void * grouped_json_, void * doc_,
    const std::vector<ContextCounterInfo> & ctx_info);
 
namespace sparta
{
    template<class CounterT>
    class ContextCounter : public sparta::StatisticDef
    {
 
        StatisticDef::ExpressionArg generateExprArg_(uint32_t num_contexts, const std::string & context_name) const
        {
            std::stringstream expr;
            uint32_t i = 0;
            expr << context_name << i;
            ++i;
            while(i < num_contexts) {
                expr << "+" << context_name << i;
                ++i;
            }
            return expr.str();
        }
 
        virtual bool groupedPrinting(const std::vector<const StatisticInstance*> & sub_stats,
                                     std::set<const void*> & dont_print_these,
                                     void * grouped_json_,
                                     void * doc_) const override
        {
            extractCtxInfo_(sub_stats);
            return __groupedPrinting(dont_print_these, grouped_json_, doc_,
                                     ctx_info_, getDesc(), getVisibility());
        }
 
        virtual bool groupedPrintingReduced(const std::vector<const StatisticInstance*> & sub_stats,
                                            std::set<const void*> & dont_print_these,
                                            void * grouped_json_,
                                            void * doc_) const override
        {
            extractCtxInfo_(sub_stats);
            return __groupedPrintingReduced(dont_print_these, grouped_json_, doc_, ctx_info_);
        }
 
        virtual bool groupedPrintingDetail(const std::vector<const StatisticInstance*> & sub_stats,
                                           std::set<const void*> & dont_print_these,
                                           void * grouped_json_,
                                           void * doc_) const override
        {
            extractCtxInfo_(sub_stats);
            return __groupedPrintingDetail(dont_print_these, grouped_json_, doc_, ctx_info_);
        }
 
        void extractCtxInfo_(const std::vector<const StatisticInstance*> & sub_stats) const
        {
            if (!ctx_info_.empty()) {
                sparta_assert(sub_stats.size() == ctx_info_.size());
                for (size_t idx = 0; idx < sub_stats.size(); ++idx) {
                    const auto & stat_si = sub_stats[idx];
                    auto & ctx_info = ctx_info_[idx];
                    ctx_info.val_ = stat_si->getValue();
                }
                return;
            }
 
            sparta_assert(sub_stats.size() == internal_counters_.size());
 
            ctx_info_.reserve(internal_counters_.size());
            for (size_t idx = 0; idx < sub_stats.size(); ++idx) {
                const auto & counter = internal_counters_[idx];
                const auto & stat_si = sub_stats[idx];
 
                ContextCounterInfo info;
                info.name_ = counter.getName();
                info.desc_ = counter.getDesc();
                info.vis_ = counter.getVisibility();
                info.val_ = stat_si->getValue();
                info.ctx_addr_ = &counter;
                ctx_info_.push_back(info);
 
                //There is code that needs to know our internal_counter_
                //variables' this pointers. That code goes through the
                //StatisticDef::getSubStatistics() method to get those
                //pointers without asking the ContextCounter directly.
                //This assertion is to prevent that outside logic from
                //breaking unexpectedly.
                sparta_assert(stat_si->getCounter() == &counter);
            }
        }
 
        mutable std::vector<ContextCounterInfo> ctx_info_;
 
    public:
        using counter_type = CounterT;
 
 
        template <class... CounterTArgs>
        ContextCounter(StatisticSet * stat_set,
                       const std::string & name,
                       const std::string & desc,
                       const uint32_t num_contexts,
                       const std::string & context_name,
                       CounterTArgs && ...args) :
            ContextCounter(stat_set,
                           name,
                           desc,
                           num_contexts,
                           generateExprArg_(num_contexts, context_name),
                           context_name,
                           std::forward<CounterTArgs>(args)...)
        { }
 
        template <class... CounterTArgs>
        ContextCounter(StatisticSet * stat_set,
                       const std::string & name,
                       const std::string & desc,
                       const uint32_t num_contexts,
                       const StatisticDef::ExpressionArg & expression,
                       const std::string & context_name,
                       CounterTArgs && ...args) :
            sparta::StatisticDef(stat_set, name, desc + " aggregate", this, expression)
        {
            static_assert(std::is_same<sparta::ReadOnlyCounter, CounterT>::value == false,
                          "The Counter type (CounterT) of ContextCounter cannot be a ReadOnlyCounter -- doesn't make sense!");
            static_assert(std::is_base_of<sparta::CounterBase, CounterT>::value,
                          "The Counter type (CounterT) of ContextCounter must be a sparta::CounterBase type");
 
            // You MUST reserve memory for the Counters in the vector
            // otherwise, the vector will MOVE the counters internally
            // on each growth and reorder the counters in the tree --
            // putting them out-of-order
            internal_counters_.reserve(num_contexts);
            for(uint32_t i = 0; i < num_contexts; ++i) {
                internal_counters_.emplace_back(this,
                                                context_name + utils::uint32_to_str(i),
                                                "A context of counter " + name, args...);
            }
 
            auto make_sub_stat_name = [&context_name](const std::string & name,
                                                      const size_t sub_stat_index) {
                std::ostringstream oss;
                oss << name << "_" << context_name << sub_stat_index;
                return oss.str();
            };
 
            size_t sub_stat_index = 0;
            for (const auto & counter : internal_counters_) {
                addSubStatistic_(&counter, make_sub_stat_name(name, sub_stat_index));
                ++sub_stat_index;
            }
 
            addMetadata_("context_name", context_name);
            addMetadata_("num_contexts", std::to_string(num_contexts));
 
            begin_counter_ = &internal_counters_.front();
            end_counter_ = &internal_counters_.back();
            ++end_counter_;
        }
 
        const counter_type & context(const uint32_t idx) const {
            sparta_assert(idx < internal_counters_.size());
            return internal_counters_[idx];
        }
 
        counter_type & context(const uint32_t idx) {
            sparta_assert(idx < internal_counters_.size());
            return internal_counters_[idx];
        }
 
        const counter_type * begin() const {
            sparta_assert(begin_counter_);
            return begin_counter_;
        }
 
        const counter_type * end() const {
            sparta_assert(end_counter_);
            return end_counter_;
        }
 
        uint32_t numContexts() const {
            return std::distance(begin(), end());
        }
 
    private:
        // Internal counters
        std::vector<CounterT> internal_counters_;
        counter_type * begin_counter_ = nullptr;
        counter_type * end_counter_ = nullptr;
    };
 
}
 
#define REGISTER_CONTEXT_COUNTER_AGGREGATE_FCN(ClassT, method, aggregated_value) \
    static_assert(std::is_base_of<sparta::TreeNode, ClassT>::value, \
                  "Invalid attempt to register a context counter aggregate function " \
                  "that is not a method of a sparta::TreeNode subclass."); \
    { \
    auto handler = CREATE_SPARTA_HANDLER(ClassT, method); \
    sparta::trigger::ContextCounterTrigger:: \
        registerContextCounterAggregateFcn(handler, this, #method, aggregated_value); \
    }