CycleCounter.hpp

// <Counter> -*- C++ -*-
 
 
#pragma once
 
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/utils/ByteOrder.hpp"
#include "sparta/statistics/Counter.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/simulation/Clock.hpp"
 
 
namespace sparta
{
    class CycleCounter : public CounterBase
    {
    public:
 
 
        CycleCounter(TreeNode* parent,
                     const std::string& name,
                     const std::string& group,
                     TreeNode::group_idx_type group_idx,
                     const std::string& desc,
                     CounterBehavior behave,
                     const sparta::Clock * clk,
                     visibility_t visibility) :
            CounterBase(parent,
                        name,
                        group,
                        group_idx,
                        desc,
                        behave,
                        visibility),
            clk_(clk)
        {
            sparta_assert(clk_ != nullptr, "CycleCounter must be given a clock through it's parent node");
        }
 
        // Alternate constructor
        CycleCounter(TreeNode* parent,
                     const std::string& name,
                     const std::string& desc,
                     CounterBehavior behave,
                     const sparta::Clock * clk,
                     visibility_t visibility) :
            CycleCounter(parent,
                         name,
                         TreeNode::GROUP_NAME_NONE,
                         TreeNode::GROUP_IDX_NONE,
                         desc,
                         behave,
                         clk,
                         visibility)
        {
            // Initialization handled in delegated constructor
        }
 
        // Alternate Constructor
        CycleCounter(TreeNode* parent,
                     const std::string& name,
                     const std::string& group,
                     TreeNode::group_idx_type group_idx,
                     const std::string& desc,
                     CounterBehavior behave,
                     const sparta::Clock * clk) :
            CycleCounter(parent,
                         name,
                         group,
                         group_idx,
                         desc,
                         behave,
                         clk,
                         DEFAULT_VISIBILITY)
        {
            sparta_assert(clk_ != nullptr, "CycleCounter must be given a clock through it's parent node");
        }
 
        // Alternate constructor
        CycleCounter(TreeNode* parent,
                     const std::string& name,
                     const std::string& desc,
                     CounterBehavior behave,
                     const sparta::Clock * clk) :
            CycleCounter(parent,
                         name,
                         TreeNode::GROUP_NAME_NONE,
                         TreeNode::GROUP_IDX_NONE,
                         desc,
                         behave,
                         clk,
                         DEFAULT_VISIBILITY)
        {
            // Initialization handled in delegated constructor
        }
 
 
        CycleCounter(CycleCounter&& rhp) :
            CounterBase(std::move(rhp)),
            clk_(rhp.clk_),
            count_(0),
            start_count_(0),
            counting_(false)
        {
            TreeNode* parent = rhp.getParent();
            if(parent != nullptr){
                parent->addChild(this);
            }
        }
 
        ~CycleCounter() {}
 
 
 
        void startCounting(uint32_t delay = 0) {
            sparta_assert(counting_ == false);
            mult_ = 1;
            start_count_ = clk_->elapsedCycles() + delay;
            counting_ = true;
        }
 
        void startCountingWithMultiplier(uint32_t add_per_cycle, uint32_t delay = 0) {
            sparta_assert(counting_ == false);
            mult_ = add_per_cycle;
            start_count_ = clk_->elapsedCycles() + delay;
            counting_ = true;
        }
 
 
        void updateCountingMultiplier(uint32_t add_per_cycle) {
            if (isCounting()) {
                stopCounting();
            }
            startCountingWithMultiplier(add_per_cycle);
        }
 
        void stopCounting(uint32_t delay = 0) {
            sparta_assert(counting_ == true);
            sparta_assert ((clk_->elapsedCycles() + delay) >= start_count_);
            count_ += (clk_->elapsedCycles() + delay - start_count_) * mult_;
            counting_ = false;
        }
 
        bool isCounting() const {
            return counting_;
        }
 
        uint32_t getCurrentMultiplier() const {
            return mult_;
        }
 
 
 
 
        virtual counter_type get() const override {
            counter_type count = count_;
            if(counting_) {
                Clock::Cycle elapsed = clk_->elapsedCycles();
                if (elapsed > start_count_) {
                    count += (elapsed - start_count_) * mult_;
                }
            }
            return count;
        }
        operator counter_type() const {
            return get();
        }
 
        bool operator==(const Counter& rhp) const {
            return get() == rhp.get();
        }
 
        bool operator==(const CycleCounter& rhp) const {
            return get() == rhp.get();
        }
 
 
        virtual bool supportsCompression() const override {
            return true;
        }
 
 
        // Override from TreeNode
        virtual std::string stringize(bool pretty=false) const override {
            (void) pretty;
            std::stringstream ss;
            ss << '<' << getLocation() << " val:" << std::dec;
            ss << get() << ' ';
            ss << Counter::getBehaviorName(getBehavior());
            ss << " vis:" << getVisibility() << '>';
            return ss.str();
        }
 
    protected:
 
        virtual void onAddingChild_(TreeNode* child) override {
            (void) child;            throw SpartaException("Cannot add children to a CycleCounter");
        }
 
    private:
 
        const sparta::Clock * clk_ = nullptr;
 
        uint32_t mult_ = 1;
 
        counter_type count_ = 0;
        counter_type start_count_ = 0;
 
        bool counting_ = false;
 
    }; // class CycleCounter
 
} // namespace sparta