StatisticInstance.hpp

Go to the documentation of this file.

// <StatisticInstance.hpp> -*- C++ -*-
 
#pragma once
 
#include <iostream>
#include <sstream>
#include <math.h>
#include <utility>
 
#include "sparta/kernel/Scheduler.hpp"
#include "sparta/statistics/StatisticDef.hpp"
#include "sparta/statistics/CounterBase.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/simulation/Parameter.hpp"
#include "sparta/simulation/Clock.hpp"
#include "sparta/statistics/Expression.hpp"
#include "sparta/statistics/StatInstCalculator.hpp"
#include "sparta/statistics/dispatch/StatisticSnapshot.hpp"
 
namespace sparta
{
    using statistics::expression::Expression;
 
    class ReversedStatisticRange : public SpartaException
    {
    public:
 
        explicit ReversedStatisticRange(const std::string & reason) :
            SpartaException(reason)
        { }
 
        virtual ~ReversedStatisticRange() noexcept {}
    };
 
    class FutureStatisticRange : public SpartaException
    {
    public:
 
        explicit FutureStatisticRange(const std::string & reason) :
            SpartaException(reason)
        { }
 
        virtual ~FutureStatisticRange() noexcept {}
    };
 
    class StatisticInstance final
    {
        StatisticInstance() = default;
 
        StatisticInstance(const StatisticDef* sd,
                          const CounterBase* ctr,
                          const ParameterBase* par,
                          const TreeNode* n,
                          std::vector<const TreeNode*>* used);
 
    public:
 
 
        explicit StatisticInstance(statistics::expression::Expression&& expr) :
            stat_expr_(expr)
        { }
 
        explicit StatisticInstance(const TreeNode* node) :
            StatisticInstance(nullptr, nullptr, nullptr, node, nullptr)
        { }
 
        StatisticInstance(const TreeNode* node, std::vector<const TreeNode*>& used) :
            StatisticInstance(nullptr, nullptr, nullptr, node, &used)
        { }
 
        StatisticInstance(std::shared_ptr<StatInstCalculator> & calculator,
                          std::vector<const TreeNode*>& used);
 
        StatisticInstance(const StatisticInstance& rhp);
 
        StatisticInstance(StatisticInstance&& rhp);
 
        ~StatisticInstance() {;}
 
        const std::vector<StatisticDef::PendingSubStatCreationInfo> & getSubStatistics() const {
            return sub_statistics_;
        }
 
 
        StatisticInstance& operator=(const StatisticInstance& rhp);
 
 
        void start();
 
        void end();
 
        Scheduler::Tick getStart() const {
            return start_tick_;
        }
 
        Scheduler::Tick getEnd() const {
            return end_tick_;
        }
 
 
 
        void accumulateStatistic() const {
            initial_.setIsCumulative(true);
            std::vector<const StatisticInstance*> stats_in_expr;
            stat_expr_.getStats(stats_in_expr);
            for (const auto & stat : stats_in_expr) {
                stat->accumulateStatistic();
            }
        }
 
        double getValue() const;
 
        double getInitial() const {
            return initial_.getValue();
        }
 
        double getRawLatest() const;
 
        bool supportsCompression() const;
 
        std::string stringize(bool show_range=true,
                              bool resolve_subexprs=true) const;
 
        std::string getExpressionString(bool show_range=true,
                                        bool resolve_subexprs=true) const;
 
        std::string getDesc(bool show_stat_node_expressions) const;
 
        void dump(std::ostream& o, bool show_range=false) const;
 
        void addSnapshotLogger(statistics::StatisticSnapshot & snapshot) const
        {
            snapshot_loggers_.emplace_back(snapshot);
        }
 
        void disableSnapshotLogging() const
        {
            snapshot_loggers_.clear();
        }
 
 
 
        std::string getLocation() const;
 
        StatisticDef::ValueSemantic getValueSemantic() const;
 
        InstrumentationNode::visibility_t getVisibility() const;
 
        InstrumentationNode::class_t getClass() const;
 
        const StatisticDef* getStatisticDef() {
            return sdef_;
        }
        const StatisticDef* getStatisticDef() const {
            return sdef_;
        }
 
        const Expression & getStatisticExpression() const {
            return stat_expr_;
        }
 
        const CounterBase* getCounter() {
            return ctr_;
        }
        const CounterBase* getCounter() const {
            return ctr_;
        }
 
        const ParameterBase* getParameter() {
            return par_;
        }
        const ParameterBase* getParameter() const {
            return par_;
        }
 
        void getClocks(std::vector<const Clock*>& clocks) const;
 
 
        void setContext(const TreeNode * context) {
            sparta_assert(nullptr != context->getClock());
            scheduler_ = context->getClock()->getScheduler();
            sparta_assert(nullptr != scheduler_);
        }
 
        void setContext(const Scheduler * scheduler) {
            scheduler_ = scheduler;
            sparta_assert(nullptr != scheduler_);
        }
 
    private:
 
        double computeValue_() const;
 
        void addSubStatistic_(const StatisticDef::PendingSubStatCreationInfo & creation_info) const {
            sub_statistics_.emplace_back(creation_info);
        }
 
        TreeNode::ConstWeakPtr node_ref_;
 
        const StatisticDef* sdef_ = nullptr;
 
        const CounterBase* ctr_ = nullptr;
 
        const ParameterBase* par_ = nullptr;
 
        sparta::statistics::expression::Expression stat_expr_;
 
        Scheduler::Tick start_tick_{0};
 
        Scheduler::Tick end_tick_{Scheduler::INDEFINITE};
 
        mutable const Scheduler * scheduler_ = nullptr;
 
        const Scheduler * getScheduler_() const;
 
        class InitialStatValue {
        public:
            InitialStatValue(const double value) :
                is_cumulative_(false),
                initial_(value)
            {
                if (std::isnan(initial_.getValue())) {
                    initial_.clearValid();
                }
            }
 
            InitialStatValue(const InitialStatValue & rhp) :
                is_cumulative_(rhp.is_cumulative_),
                initial_(rhp.initial_)
            {}
 
            InitialStatValue & operator=(const InitialStatValue & rhp) {
                is_cumulative_ = rhp.is_cumulative_;
                initial_ = rhp.initial_;
                return *this;
            }
 
            void setIsCumulative(const bool is_cumulative) {
                is_cumulative_ = is_cumulative;
            }
 
            double getValue() const {
                return initial_.isValid() ? initial_.getValue() : 0;
            }
 
            void resetValue(const double initial) {
                if (is_cumulative_) {
                    if (!initial_.isValid()) {
                        initial_ = initial;
                    }
                    return;
                }
                initial_ = initial;
            }
 
        private:
            bool is_cumulative_ = false;
            utils::ValidValue<double> initial_;
        };
 
        mutable InitialStatValue initial_{NAN};
 
        double result_{NAN};
 
        mutable std::vector<statistics::StatisticSnapshot> snapshot_loggers_;
 
        mutable std::vector<StatisticDef::PendingSubStatCreationInfo> sub_statistics_;
 
        std::shared_ptr<StatInstCalculator> user_calculated_si_value_;
    }; // class StatisticInstance
 
 
    inline std::ostream& operator<< (std::ostream& out,
                                     sparta::StatisticInstance const & si) {
        out << si.stringize();
        return out;
    }
 
    inline std::ostream& operator<< (std::ostream& out,
                                     sparta::StatisticInstance const * si) {
        if(nullptr == si){
            out << "null";
        }else{
            out << si->stringize();
        }
        return out;
    }
 
} // namespace sparta