CounterBase.hpp

// <Counter> -*- C++ -*-
 
 
#pragma once
 
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/statistics/InstrumentationNode.hpp"
#include "sparta/utils/ByteOrder.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
 
 
namespace sparta
{
    class CounterBase : public InstrumentationNode
    {
    public:
 
 
        typedef uint64_t counter_type;
 
        enum CounterBehavior {
 
            COUNT_NORMAL   = 1,
 
            COUNT_INTEGRAL = 2,
 
            COUNT_LATEST   = 3
        };
 
 
    public:
 
        class CounterBehaviorDetailed
        {
        public:
            CounterBehaviorDetailed(CounterBehavior behavior) :
                CounterBehaviorDetailed(behavior, {})
            {}
 
            CounterBehaviorDetailed(CounterBehavior behavior,
                                    const InstrumentationNode::MetadataPairs & meta_data) :
                behavior_(behavior),
                meta_data_(meta_data)
            {}
 
            operator CounterBehavior() const { return behavior_; }
 
            const InstrumentationNode::MetadataPairs & getMetadata() const {
                return meta_data_;
            }
 
        private:
            const CounterBehavior behavior_;
            const InstrumentationNode::MetadataPairs meta_data_;
        };
 
 
        CounterBase(TreeNode* parent,
                    const std::string& name,
                    const std::string& group,
                    TreeNode::group_idx_type group_idx,
                    const std::string& desc,
                    CounterBehaviorDetailed behave,
                    visibility_t visibility) :
            InstrumentationNode(nullptr,
                                name,
                                group,
                                group_idx,
                                desc,
                                InstrumentationNode::TYPE_COUNTER,
                                visibility
                                ),
            behave_(behave)
        {
            setExpectedParent_(parent);
 
            ensureParentIsValid_(parent);
 
            parent->addChild(this);
 
            // Copy over the meta data to the InstrumentationNode.
            meta_data_.insert(meta_data_.begin(),
                              behave.getMetadata().begin(),
                              behave.getMetadata().end());
 
        }
 
        // Alternate constructor
        CounterBase(TreeNode* parent,
                    const std::string& name,
                    const std::string& group,
                    TreeNode::group_idx_type group_idx,
                    const std::string& desc,
                    CounterBehaviorDetailed behave) :
            CounterBase(parent,
                        name,
                        group,
                        group_idx,
                        desc,
                        behave,
                        DEFAULT_VISIBILITY)
        {
            // Initialization handled in delegated constructor
        }
 
        // Alternate constructor
        CounterBase(TreeNode* parent,
                    const std::string& name,
                    const std::string& desc,
                    CounterBehaviorDetailed behave) :
            CounterBase(parent,
                        name,
                        TreeNode::GROUP_NAME_NONE,
                        TreeNode::GROUP_IDX_NONE,
                        desc,
                        behave)
        {
            // Initialization handled in delegated constructor
        }
 
        CounterBase(const CounterBase& rhp) = delete;
 
        CounterBase(CounterBase&& rhp) :
            InstrumentationNode(std::move(rhp)),
            behave_(rhp.behave_)
        {;}
 
        virtual ~CounterBase() {}
 
 
 
        CounterBehavior getBehavior() const { return behave_; }
 
 
 
        virtual counter_type get() const = 0;
 
        operator counter_type() const {
            return get();
        }
 
        virtual bool supportsCompression() const {
            return false;
        }
 
 
 
        // Override from TreeNode
        virtual std::string stringize(bool pretty=false) const = 0;
 
        static std::string getBehaviorName(CounterBehaviorDetailed behave) {
            switch(behave){
            case COUNT_NORMAL:
                return "normal";
            case COUNT_INTEGRAL:
                return "integral";
            case COUNT_LATEST:
                return "current";
            }
            throw SpartaException("unknown counter behavior: ") << behave;
        }
 
 
    protected:
 
        virtual void onAddingChild_(TreeNode* child) {
            (void) child;
            throw SpartaException("Cannot add children to a CounterBase");
        }
 
    private:
 
        void ensureParentIsValid_(TreeNode* parent);
 
        const CounterBehaviorDetailed behave_;
 
    }; // class CounterBase
 
} // namespace sparta