StatisticDef.hpp

Go to the documentation of this file.

// <StatisticDef> -*- C++ -*-
 
 
#pragma once
 
#include <iostream>
#include <sstream>
#include <cstdarg>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/statistics/InstrumentationNode.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/StringManager.hpp"
#include "sparta/statistics/Expression.hpp"
 
namespace sparta
{
 
    namespace trigger {
        class ContextCounterTrigger;
    }  // namespace trigger
 
    class StatisticDef : public InstrumentationNode
    {
    public:
 
 
        struct ExpressionArg {
 
            ExpressionArg(const std::string& str) :
                expr_str(str)
            {;}
 
            ExpressionArg(const char str[]) :
                expr_str(str)
            {;}
 
            ExpressionArg(const sparta::statistics::expression::Expression& expr) :
                expr_obj(new sparta::statistics::expression::Expression(expr)),
                expr_str("")
            {;}
 
            ExpressionArg(const ExpressionArg& rhp) :
                expr_obj(rhp.expr_obj ? new sparta::statistics::expression::Expression(*rhp.expr_obj) : nullptr),
                expr_str(rhp.expr_str)
            {;}
 
            std::unique_ptr<sparta::statistics::expression::Expression> expr_obj;
            std::string expr_str;
        };
 
        enum ValueSemantic {
 
            VS_INVALID    = 0,
 
            VS_ABSOLUTE   = 1,
 
            VS_PERCENTAGE = 2,
 
            VS_FRACTIONAL = 3
 
            // * \brief A number (typically an absolute number) having specific
            // * units (i.e. not a percentage/fraction). See CounterBase::getUnits
            // * and StatisticDef::getUnits.
            // */
            //VS_UNITS      = 4
        };
 
        class ValueSemanticDetailed
        {
        public:
            ValueSemanticDetailed(ValueSemantic semantic) :
                ValueSemanticDetailed(semantic, {})
            {}
 
            ValueSemanticDetailed(ValueSemantic semantic,
                                  const InstrumentationNode::MetadataPairs & meta_data) :
                semantic_(semantic),
                meta_data_(meta_data)
            {}
 
            operator ValueSemantic() const { return semantic_; }
 
            const InstrumentationNode::MetadataPairs & getMetadata() const {
                return meta_data_;
            }
 
        private:
            const ValueSemantic semantic_;
            const InstrumentationNode::MetadataPairs meta_data_;
        };
 
 
 
        StatisticDef(const StatisticDef&) = delete;
 
        StatisticDef(const StatisticDef&&) = delete;
 
        StatisticDef(StatisticDef&& rhp) :
            InstrumentationNode(std::move(rhp)),
            prebuilt_expr_(std::move(rhp.prebuilt_expr_)),
            expr_str_(rhp.expr_str_),
            context_(rhp.context_),
            semantic_(rhp.semantic_)
        {
            // Note: this must happen in leaf type
            TreeNode* parent = rhp.getParent();
            if(parent != nullptr){
                parent->addChild(this);
            }
        }
 
        StatisticDef& operator=(const StatisticDef&) = delete;
 
        StatisticDef(TreeNode* parent,
                     const std::string& name,
                     const std::string& group,
                     group_idx_type group_idx,
                     const std::string& desc,
                     TreeNode* context,
                     ExpressionArg expression,
                     ValueSemanticDetailed semantic,
                     visibility_t visibility) :
            InstrumentationNode(name,
                                group,
                                group_idx,
                                desc,
                                InstrumentationNode::TYPE_STATISTICDEF,
                                visibility),
            prebuilt_expr_(std::move(expression.expr_obj)),
            expr_str_(std::move(expression.expr_str)),
            context_(context),
            semantic_(semantic)
        {
            setExpectedParent_(parent);
 
            sparta_assert(semantic_ != VS_INVALID,
                          "Cannot construct a StatisticDef with VS_INVALID value semantic");
 
            if(prebuilt_expr_ != nullptr){
                expr_str_ = prebuilt_expr_->stringize();
            }else{
                if(context_ == nullptr){
                    throw SpartaException("When constructing StatisticDef")
                        << getLocation() << " context must not be nullptr. It must be a TreeNode which "
                        "will be used to look up any Node names found in the expression";
                }
 
                if(expr_str_ == ""){
                    throw SpartaException("When constructing StatisticDef ")
                        << getLocation() << " without a prebuilt expression, the expression string "
                        "must not be \"\". It must be a non-empty string containing an arithmetic "
                        "expression referring to nodes relative to the context \""
                        << context_->getLocation() << "\"";
                }
            }
 
            ensureParentIsStatisticSet_(parent);
 
            // Other initialization here
            // ...
 
            if(parent){
                parent->addChild(this);
            }
 
            // Copy over the meta data to the InstrumentationNode.
            meta_data_.insert(meta_data_.begin(),
                              semantic.getMetadata().begin(),
                              semantic.getMetadata().end());
        }
 
        StatisticDef(const std::string& name,
                     const std::string& group,
                     group_idx_type group_idx,
                     const std::string& desc,
                     TreeNode* context,
                     ExpressionArg expression,
                     ValueSemanticDetailed semantic,
                     visibility_t visibility) :
            StatisticDef(nullptr,
                         name,
                         group,
                         group_idx,
                         desc,
                         context,
                         expression,
                         semantic,
                         visibility)
        {
            // Delegated constructor
        }
 
        StatisticDef(TreeNode* parent,
                     const std::string& name,
                     const std::string& desc,
                     TreeNode* context,
                     ExpressionArg expression,
                     ValueSemanticDetailed semantic,
                     visibility_t visibility) :
            StatisticDef(parent,
                         name,
                         GROUP_NAME_NONE,
                         GROUP_IDX_NONE,
                         desc,
                         context,
                         expression,
                         semantic,
                         visibility)
        {
            // Delegated constructor
        }
 
        StatisticDef(const std::string& name,
                     const std::string& desc,
                     TreeNode* context,
                     ExpressionArg expression,
                     ValueSemanticDetailed semantic,
                     visibility_t visibility) :
            StatisticDef(nullptr,
                         name,
                         GROUP_NAME_NONE,
                         GROUP_IDX_NONE,
                         desc,
                         context,
                         expression,
                         semantic,
                         visibility)
        {
            // Delegated Constructor
        }
 
        StatisticDef(TreeNode* parent,
                     const std::string& name,
                     const std::string& group,
                     group_idx_type group_idx,
                     const std::string& desc,
                     TreeNode* context,
                     ExpressionArg expression) :
            StatisticDef(parent,
                         name,
                         group,
                         group_idx,
                         desc,
                         context,
                         expression,
                         VS_ABSOLUTE,
                         DEFAULT_VISIBILITY)
        {
            // Delegated constructor
        }
 
        StatisticDef(const std::string& name,
                     const std::string& group,
                     group_idx_type group_idx,
                     const std::string& desc,
                     TreeNode* context,
                     ExpressionArg expression) :
            StatisticDef(nullptr,
                         name,
                         group,
                         group_idx,
                         desc,
                         context,
                         expression)
        {
            // Delegated constructor
        }
 
        StatisticDef(TreeNode* parent,
                     const std::string& name,
                     const std::string& desc,
                     TreeNode* context,
                     ExpressionArg expression) :
            StatisticDef(parent,
                         name,
                         GROUP_NAME_NONE,
                         GROUP_IDX_NONE,
                         desc,
                         context,
                         expression)
        {
            // Delegated constructor
        }
 
        StatisticDef(const std::string& name,
                     const std::string& desc,
                     TreeNode* context,
                     ExpressionArg expression) :
            StatisticDef(nullptr,
                         name,
                         GROUP_NAME_NONE,
                         GROUP_IDX_NONE,
                         desc,
                         context,
                         expression)
        {
            // Delegated Constructor
        }
 
        StatisticDef(TreeNode* parent,
                     const std::string& name,
                     const std::string& group,
                     group_idx_type group_idx,
                     const std::string& desc,
                     TreeNode* context,
                     ExpressionArg expression,
                     ValueSemanticDetailed semantic) :
            StatisticDef(parent,
                         name,
                         group,
                         group_idx,
                         desc,
                         context,
                         expression,
                         semantic,
                         DEFAULT_VISIBILITY)
        {
            // Delegated constructor
        }
 
        StatisticDef(const std::string& name,
                     const std::string& group,
                     group_idx_type group_idx,
                     const std::string& desc,
                     TreeNode* context,
                     ExpressionArg expression,
                     ValueSemanticDetailed semantic) :
            StatisticDef(nullptr,
                         name,
                         group,
                         group_idx,
                         desc,
                         context,
                         expression,
                         semantic)
        {
            // Delegated constructor
        }
 
        StatisticDef(TreeNode* parent,
                     const std::string& name,
                     const std::string& desc,
                     TreeNode* context,
                     ExpressionArg expression,
                     ValueSemanticDetailed semantic) :
            StatisticDef(parent,
                         name,
                         GROUP_NAME_NONE,
                         GROUP_IDX_NONE,
                         desc,
                         context,
                         expression,
                         semantic)
        {
            // Delegated constructor
        }
 
        StatisticDef(const std::string& name,
                     const std::string& desc,
                     TreeNode* context,
                     ExpressionArg expression,
                     ValueSemanticDetailed semantic) :
            StatisticDef(nullptr,
                         name,
                         GROUP_NAME_NONE,
                         GROUP_IDX_NONE,
                         desc,
                         context,
                         expression,
                         semantic)
        {
            // Delegated Constructor
        }
 
        virtual ~StatisticDef()
        { }
 
 
 
        class PendingSubStatCreationInfo
        {
        public:
            PendingSubStatCreationInfo(const TreeNode * stat_node,
                                       const std::string & stat_name) :
                stat_node_(stat_node),
                stat_name_(stat_name)
            {}
            const TreeNode * getNode() const {
                return stat_node_;
            }
            const std::string & getName() const {
                return stat_name_;
            }
        private:
            const TreeNode * stat_node_ = nullptr;
            std::string stat_name_;
        };
 
        inline const std::vector<PendingSubStatCreationInfo> & getSubStatistics() const {
            return sub_statistics_;
        }
 
        std::string getContextLocation() const {
            return context_ ? context_->getLocation() : "";
        }
 
    private:
 
        void deregisterAggregationFcnUponDestruction_() const {
            //It is possible that our auto-deregister object has been set already, which
            //happens when one ContextCounter has more than one registered aggregation
            //callback. So we need to check for null or we will inadvertently deregister
            //our aggregation callback too soon (calling .reset on a non-null unique_ptr
            //will trigger the AutoContextCounterDeregistration object's destructor of
            //course).
            if (auto_cc_deregister_ == nullptr) {
                auto_cc_deregister_.reset(new AutoContextCounterDeregistration(this));
            }
        }
 
        friend class trigger::ContextCounterTrigger;
 
    protected:
 
        inline void addSubStatistic_(const TreeNode * stat_node,
                                     const std::string & stat_name) const {
            sub_statistics_.emplace_back(stat_node, stat_name);
        }
 
    public:
 
        std::string getExpression() const {
            return expr_str_;
        }
 
        sparta::statistics::expression::Expression
        realizeExpression(std::vector<const TreeNode*>& used) const {
            if(prebuilt_expr_){
                return *prebuilt_expr_; // Returns a copy
            }
            // This is deferred until this point because the expression can
            // contain variables populated using the 'used' vector
            return sparta::statistics::expression::Expression(expr_str_, context_, used);
        }
 
        ValueSemantic getValueSemantic() const {
            return semantic_;
        }
 
 
 
        // Override from TreeNode
        virtual std::string stringize(bool pretty=false) const override {
            (void) pretty;
            std::stringstream ss;
            ss << '<' << getLocation() << " expr:" << getExpression();
            ss << " vis:" << getVisibility();
            stringizeTags(ss);
            ss << '>';
            return ss.str();
        }
 
 
    private:
 
        void ensureParentIsStatisticSet_(TreeNode*);
 
        virtual void validateNode_() const override {
            if(prebuilt_expr_){
                // Guaranteed OK because expression was built before this node was constructed
            }else{
                try{
                    sparta::statistics::expression::Expression(expr_str_, context_);
                }catch(SpartaException &ex){
                    throw SpartaException("Failed to validate StatisticDef: \"") << getLocation()
                                                                                 << "\": " << ex.what();
                }
            }
        }
 
        std::unique_ptr<sparta::statistics::expression::Expression> prebuilt_expr_;
 
        std::string expr_str_;
 
        TreeNode* const context_;
 
        const ValueSemanticDetailed semantic_;
 
        mutable std::vector<PendingSubStatCreationInfo> sub_statistics_;
 
        class AutoContextCounterDeregistration {
        public:
            explicit AutoContextCounterDeregistration(const StatisticDef * sd);
            ~AutoContextCounterDeregistration();
        private:
            const StatisticDef *const sd_;
        };
 
        mutable std::unique_ptr<AutoContextCounterDeregistration> auto_cc_deregister_;
    };
 
} // namespace sparta