Counter.hpp

// <Counter> -*- C++ -*-
 
 
#pragma once
 
#include <iostream>
#include <sstream>
#include <limits>
 
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/statistics/CounterBase.hpp"
 
 
namespace sparta
{
    class Counter final : public CounterBase
    {
    public:
 
 
        Counter(TreeNode* parent,
                const std::string& name,
                const std::string& group,
                TreeNode::group_idx_type group_idx,
                const std::string& desc,
                CounterBehavior behave,
                visibility_t visibility) :
            CounterBase(parent,
                        name,
                        group,
                        group_idx,
                        desc,
                        behave,
                        visibility),
            val_(0)
        { }
 
        Counter(TreeNode* parent,
                const std::string& name,
                const std::string& group,
                TreeNode::group_idx_type group_idx,
                const std::string& desc,
                CounterBehavior behave) :
            Counter(parent,
                    name,
                    group,
                    group_idx,
                    desc,
                    behave,
                    CounterBase::DEFAULT_VISIBILITY)
        {
            // Initialization handled in constructor delegation
        }
 
        Counter(TreeNode* parent,
                const std::string& name,
                const std::string& desc,
                CounterBehavior behave,
                visibility_t visibility) :
            Counter(parent,
                    name,
                    TreeNode::GROUP_NAME_NONE,
                    TreeNode::GROUP_IDX_NONE,
                    desc,
                    behave,
                    visibility)
        {
            // Initialization handled in constructor delegation
        }
 
        Counter(TreeNode* parent,
                const std::string& name,
                const std::string& desc,
                CounterBehavior behave) :
            Counter(parent,
                    name,
                    TreeNode::GROUP_NAME_NONE,
                    TreeNode::GROUP_IDX_NONE,
                    desc,
                    behave)
        {
            // Initialization handled in constructor delegation
        }
 
        Counter(const Counter& rhp) = delete;
 
        Counter(Counter&& rhp) :
            CounterBase(std::move(rhp)),
            val_(rhp.val_)
        {
            TreeNode* parent = rhp.getParent();
            if(parent != nullptr){
                parent->addChild(this);
            }
        }
 
        ~Counter() {}
 
 
 
        counter_type set(counter_type val) {
            if(__builtin_expect(getBehavior() != COUNT_LATEST, 0) == true){
                throw SpartaException("Cannot write a new counter value for ")
                    << getLocation() << " because its behavior is not COUNT_LATEST. "
                    << "Other behaviors should only support incrementing or adding";
            }
 
            val_ = val;
            return val;
        }
 
        Counter& operator=(counter_type val) {
            set(val);
            return *this;
        }
 
        Counter& operator=(const Counter& rhp) {
            set(rhp.get());
            return *this;
        }
 
        counter_type increment(counter_type add) {
            //See if we need to throw any increment exceptions.
            static_assert(std::numeric_limits<counter_type>::is_signed == false,
                          "Counter type expected to be unsigned. If counter type "
                          "is changed or made templated, ths following test should "
                          "probably be enabled and increment should be changed to accept an unsigned value only.");
 
            // Tempting idea, but very costly in performance.
            // Specifically, the assert is expensive.  :(
            //
            // static_assert(sizeof(counter_type) == sizeof(uint64_t),
            //               "Counter type expected to be the size of an unsigned long (64-bits)");
            // const bool ret = __builtin_uaddl_overflow(val_, add, &val_);
            // sparta_assert(ret != true, "Encountered an overflowing Counter: " << getLocation());
 
            val_ += add;
            return val_;
        }
 
        counter_type operator++() {
            return ++val_;
        }
 
        counter_type operator++(int) {
            return val_++;
        }
 
        counter_type operator+=(counter_type add){
            return increment(add);
        }
 
        counter_type get() const override {
            return val_;
        }
 
        operator counter_type() const {
            return get();
        }
 
        bool operator==(const Counter& 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 << getBehaviorName(getBehavior());
            ss << " vis:" << getVisibility();
            stringizeTags(ss);
            ss  << '>';
            return ss.str();
        }
 
 
    protected:
 
        virtual void onAddingChild_(TreeNode* child) override {
            (void) child;
            throw SpartaException("Cannot add children to a Counter");
        }
 
    private:
 
        uint64_t val_;
    };
 
} // namespace sparta