StatisticSet.hpp

Go to the documentation of this file.

// <StatisticSet> -*- C++ -*-
 
 
#pragma once
 
#include <iostream>
 
#include "sparta/statistics/StatisticDef.hpp"
#include "sparta/statistics/CounterBase.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
 
 
namespace sparta
{
    class StatisticSet : public TreeNode
    {
    public:
 
        typedef std::vector<StatisticDef*> StatisticVector;
 
        typedef std::vector<CounterBase*> CounterVector;
 
        static constexpr char NODE_NAME[] = "stats";
 
        StatisticSet(TreeNode* parent) :
            TreeNode(NODE_NAME,
                     TreeNode::GROUP_NAME_BUILTIN,
                     TreeNode::GROUP_IDX_NONE,
                     "Statistic and Counter Set")
        {
            if(parent){
                setExpectedParent_(parent);
                parent->addChild(this);
            }
        }
 
        ~StatisticSet()
        {;}
 
        // Overload of TreeNode::stringize
        virtual std::string stringize(bool pretty=false) const override {
            (void) pretty;
            std::stringstream ss;
            ss << '<' << getLocation() << ' ' << (stats_.size()) << " stats, "
               << (ctrs_.size()) << " counters>";
            return ss.str();
        }
 
 
        uint32_t getNumStatisticDefs() const { return stats_.size(); }
 
        const StatisticVector& getStatisticDefs() const { return stats_; }
 
        StatisticDef* getStatisticDef(const std::string& name) {
            return getChildAs<StatisticDef>(name);
        };
 
        template<typename... _Args>
        StatisticDef & createStatisticDef(_Args&&... __args) {
            if(isFinalized()){
                throw SpartaException("Cannot create a new StatisticDef once a StatisticSet is finalized. "
                                    "Error with: ")
                    << getLocation();
            }
            owned_stats_.emplace_back(new StatisticDef(this, __args...));
            return *(static_cast<StatisticDef *>(owned_stats_.back().get()));
        }
 
 
 
 
        uint32_t getNumCounters() const {
            return ctrs_.size();
        }
 
        const CounterVector& getCounters() const {
            return ctrs_;
        }
 
        const CounterBase* getCounter(const std::string& name) const {
            return getChildAs<CounterBase>(name);
        }
 
        CounterBase* getCounter(const std::string& name) {
            return getChildAs<CounterBase>(name);
        }
 
        template<class CounterT>
        const CounterT* getCounterAs(const std::string& name) const {
            return getChildAs<CounterT>(name);
        }
 
        template<class CounterT>
        CounterT* getCounterAs(const std::string& name) {
            return getChildAs<CounterT>(name);
        }
 
        template<class CounterT, typename... _Args>
        CounterT & createCounter(_Args&&... __args) {
            if(isFinalized()){
                throw SpartaException("Cannot create a new Counter once a StatisticSet is finalized. "
                                    "Error with: ")
                    << getLocation();
            }
            owned_ctrs_.emplace_back(new CounterT(this, __args...));
            return *((CounterT *)owned_ctrs_.back().get());
        }
 
 
    private:
 
        virtual void onAddingChild_(TreeNode* child) override {
            if(isFinalized()){
                throw SpartaException("Cannot add a child Counter once a StatisticSet is finalized. "
                                    "Error with: ")
                    << getLocation();
            }
 
            StatisticDef* stat = dynamic_cast<StatisticDef*>(child);
            if(nullptr != stat){
                // Add stat to stats_ list for tracking.
                stats_.push_back(stat);
                return;
            }
 
            CounterBase* ctr = dynamic_cast<CounterBase*>(child);
            if(nullptr != ctr){
                // Add Counter to ctrs_ list for tracking.
               ctrs_.push_back(ctr);
               return;
            }
 
            throw SpartaException("Cannot add TreeNode child ")
                << child->getName() << " to StatisticSet " << getLocation()
                << " because the child is not a CounterBase or StatisticDef";
        }
 
        typedef std::vector<std::unique_ptr<StatisticDef>> OwnedStatisticVector;
 
        OwnedStatisticVector owned_stats_;
 
        StatisticVector stats_;
 
        typedef std::vector<std::unique_ptr<CounterBase>> OwnedCounterVector;
 
        OwnedCounterVector owned_ctrs_;
 
        CounterVector ctrs_;
    };
 
} // namespace sparta