ExpressionNodeVariables.hpp

Go to the documentation of this file.

// <ExpressionNodeVariables> -*- C++ -*-
 
#pragma once
 
#include <memory>
 
#include "sparta/statistics/ExpressionNode.hpp"
#include "sparta/statistics/StatisticInstance.hpp"
 
namespace sparta {
 
class StatInstCalculator;
 
    namespace statistics {
        namespace expression {
 
struct StatVariable : public ExpressionNode
{
    sparta::StatisticInstance stat_;
 
    StatVariable() = delete;
 
    StatVariable(const TreeNode* n, std::vector<const TreeNode*>& used) :
        stat_(n, used)
    {
        //std::cout << "StatVariable at " << this << " with stat " << &stat_ << std::endl;
    }
 
    StatVariable(std::shared_ptr<StatInstCalculator> & calculator,
                 std::vector<const TreeNode*>& used) :
        stat_(calculator, used)
    { }
 
    StatVariable(const StatVariable& rhp) :
        ExpressionNode(),
        stat_(rhp.stat_)
    { }
 
    virtual ~StatVariable() {
        //std::cout << "~StatVariable at " << this << " with stat " << &stat_ << std::endl;
    }
 
    virtual StatVariable* clone_() const override {
        return new StatVariable(*this);
    }
 
    virtual double evaluate_() const override {
        return stat_.getValue();
    }
 
    virtual bool supportsCompression() const override {
        return stat_.supportsCompression();
    }
 
    StatisticInstance* getStatisticInstance() {
        return &stat_;
    }
 
    virtual void start() override {
        stat_.start();
    }
    virtual void end() override {
        stat_.end();
    }
 
    virtual void dump(std::ostream& o,
                      bool show_range=true,
                      bool resolve_subexprs=true) const override {
        o << stat_.getExpressionString(show_range, resolve_subexprs);
    }
 
    virtual void getClocks(std::vector<const Clock*>& clocks) const override {
        stat_.getClocks(clocks);
    }
 
private:
 
    virtual uint32_t getStats_(std::vector<const StatisticInstance*>& results) const override {
        results.push_back(&stat_);
        return 1;
    }
}; // class StatVariable
 
struct SimVariable : public ExpressionNode
{
    typedef double (*getter_t)();
 
    std::string which_;
 
    getter_t getter_;
 
    SimVariable() = delete;
 
    SimVariable(const SimVariable& rhp) :
        ExpressionNode(),
        which_(rhp.which_),
        getter_(rhp.getter_)
    { }
 
    SimVariable(const std::string& which, const getter_t getter) :
        which_(which),
        getter_(getter)
    { }
 
    virtual SimVariable* clone_() const override {
        return new SimVariable(*this);
    }
 
    virtual double evaluate_() const override {
        // Look up the value
        return getter_();
    }
 
    virtual bool supportsCompression() const override {
        return false;
    }
 
    virtual void start() override {
        // No action on start
    }
 
    virtual void end() override {
        // No action on end
    }
 
    virtual void dump(std::ostream& o,
                      bool show_range=true,
                      bool resolve_subexprs=true) const override {
        (void) show_range;
        (void) resolve_subexprs;
        o << "{simvar " << which_ << "}";
    }
 
    virtual void getClocks(std::vector<const Clock*>& clocks) const override {
        (void) clocks;
        // No clocks in a SimVariable
    }
 
private:
 
    virtual uint32_t getStats_(std::vector<const StatisticInstance*>& results) const override {
        (void) results;
        // No stats used
        return 0;
    }
}; // class SimVariable
 
struct ReferenceVariable : public ExpressionNode
{
    std::string which_;
 
    const double& ref_;
 
    ReferenceVariable() = delete;
 
    ReferenceVariable(const ReferenceVariable& rhp) :
        ExpressionNode(),
        which_(rhp.which_),
        ref_(rhp.ref_)
    { }
 
    template <typename T>
    ReferenceVariable(const std::string& which,
                      const T& ref) :
        which_(which),
        ref_(ref)
    {
        // C++ was allowing implicit casting from uint64_t& to double& which
        // compiles but produces incorrect results. This assertion exists to
        // catch misuses.
        static_assert(std::is_same<T,double>::value,
                      "ReferenceVariable must be constructed with a double&. Someone called this "
                      "method with a non-double argument");
    }
 
    ReferenceVariable operator=(const ReferenceVariable&) = delete;
 
    virtual ReferenceVariable* clone_() const override {
        return new ReferenceVariable(*this);
    }
 
    virtual double evaluate_() const override {
        // Read the value by refrence
        return ref_;
    }
 
    virtual bool supportsCompression() const override {
        return false;
    }
 
    virtual void start() override {
        // No action on start
    }
 
    virtual void end() override {
        // No action on end
    }
 
    virtual void dump(std::ostream& o,
                      bool show_range=true,
                      bool resolve_subexprs=true) const override {
        (void) show_range;
        (void) resolve_subexprs;
        o << "{" << which_ << ": " << ref_ << "}";
    }
 
    virtual void getClocks(std::vector<const Clock*>& clocks) const override {
        (void) clocks;
        // No clocks in a ReferenceVariable
    }
 
private:
 
    virtual uint32_t getStats_(std::vector<const StatisticInstance*>& results) const override {
        (void) results;
        // No stats used
        return 0;
    }
}; // class ReferenceVariable
 
 
        } // namespace expression
    } // namespace statistics
} // namespace sparta