Expression.hpp

// <Expression.hpp> -*- C++ -*-
 
#pragma once
 
#include <iostream>
#include <sstream>
#include <memory>
#include <string>
#include <vector>
 
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/statistics/ExpressionNode.hpp"
#include "sparta/statistics/ExpressionNodeTypes.hpp"
 
namespace sparta {
 
class StatisticInstance;
class Clock;
 
namespace statistics {
 
typedef std::pair<std::string, std::unique_ptr<StatisticInstance>> stat_pair_t;
 
typedef std::vector<stat_pair_t> StatisticPairs;
 
namespace expression {
 
class Expression
{
    std::unique_ptr<ExpressionNode> content_;
 
public:
 
    Expression() = default;
 
    Expression(const Expression& rhp)
    {
        //std::cout << "Copying      " << this << " <- " << &rhp << std::endl;
 
        if(rhp.content_ != nullptr){
            content_.reset(rhp.content_->clone());
        }
    }
 
    Expression(Expression&& rhp) :
        content_(std::move(rhp.content_))
    {
        //std::cout << "Moving      " << this << " <- " << &rhp << std::endl;
    }
 
    Expression(const std::string& expression,
               TreeNode* context);
 
    Expression(const std::string& expression,
               TreeNode* context,
               const StatisticPairs&report_si);
 
    Expression(const std::string& expression,
               TreeNode* context,
               std::vector<const TreeNode*>& already_used);
 
    Expression(ExpressionNode* item) :
        Expression()
    {
        sparta_assert(item != nullptr);
        content_.reset(item);
    }
 
    Expression(double d);
 
    Expression(operation_t type,
               ExpressionNode * op1,
               ExpressionNode * op2=nullptr,
               ExpressionNode * op3=nullptr);
 
    Expression(const TreeNode* n,
               std::vector<const TreeNode*>& used);
 
    template<typename RetT, typename ArgT>
    Expression(const std::string& name,
               RetT(*fxn)(ArgT),
               const Expression& a);
 
    template<typename RetT, typename ArgT>
    Expression(const std::string& name,
               std::function<RetT (ArgT)>&,
               const Expression& a);
 
    template<typename RetT, typename ArgT>
    Expression(const std::string& name,
               RetT(*fxn)(ArgT, ArgT),
               const Expression& a,
               const Expression& b);
 
    template<typename RetT>
    Expression(const std::string& name,
               const RetT& functor,
               const Expression& a,
               const Expression& b);
 
    template<typename RetT, typename ArgT>
    Expression(const std::string& name,
               RetT(*fxn)(ArgT, ArgT, ArgT),
               const Expression& a,
               const Expression& b,
               const Expression& c);
 
    virtual ~Expression();
 
    Expression& operator=(const Expression& rhp)
    {
        //std::cout << "Assignment   " << this << " <- " << &rhp << std::endl;
 
        if(rhp.content_ != nullptr){
            content_.reset(rhp.content_->clone());
        }
 
        return *this;
    }
 
    Expression& operator=(Expression&& rhp)
    {
        //std::cout << "Move   " << this << " <- " << &rhp << std::endl;
 
        content_ = std::move(rhp.content_);
        return *this;
    }
 
    ExpressionNode* cloneContent() const {
        if(content_ == nullptr){
            throw SpartaException("Cannot clone content of an expression with null content");
        }
        return content_->clone();
    }
 
    uint32_t getStats(std::vector<const StatisticInstance*>& results) const {
        return getStats_(results);
    }
 
    bool hasContent() const {
        return content_ != nullptr;
    }
 
    template<typename RetT, typename ArgT>
    Expression ufunc(const std::string& name,
                     RetT(*fxn)(ArgT),
                     const Expression& a) const;
 
    template<typename RetT, typename ArgT>
    Expression ufunc(const std::string& name,
                     std::function<RetT (ArgT)>&,
                     const Expression& a) const;
 
    template<typename RetT, typename ArgT>
    Expression bfunc(const std::string& name,
                     RetT(*fxn)(ArgT, ArgT),
                     const Expression& a,
                     const Expression& b) const;
 
    template<typename RetT>
    Expression bfunc(const std::string& name,
                     const RetT& functor,
                     const Expression& a,
                     const Expression& b) const;
 
    template<typename RetT, typename ArgT>
    Expression tfunc(const std::string& name,
                     RetT(*fxn)(ArgT, ArgT, ArgT),
                     const Expression& a,
                     const Expression& b,
                     const Expression& c) const;
 
    Expression& operator=(double d);
 
    Expression operator+() const;
 
    Expression operator-() const;
 
    Expression operator+(const Expression& rhp) const;
 
    Expression operator-(const Expression& rhp) const;
 
    Expression operator*(const Expression& rhp) const;
 
    Expression operator/(const Expression& rhp) const;
 
    Expression& operator+=(const Expression& rhp);
 
    Expression& operator-=(const Expression& rhp);
 
    Expression& operator*=(const Expression& rhp);
 
    Expression& operator/=(const Expression& rhp);
 
    double evaluate() const {
        if(content_ == nullptr){
            throw SpartaException("Cannot evaluate expression because it has no content. Test with "
                                "hasContent before blindly evaluating foreign expressions");
        }
 
        return content_->evaluate();
    };
 
    void start() {
        if(content_){
            content_->start();
        }
    }
 
    void end() {
        if(content_){
            content_->end();
        }
    }
 
    void dump(std::ostream& o,
              bool show_range=true,
              bool resolve_subexprs=true) const {
        if(!content_){
            o << "???";
        }else{
            content_->dump(o, show_range, resolve_subexprs);
        }
    }
 
    bool supportsCompression() const {
        if (content_ == nullptr) {
            return false;
        }
        return content_->supportsCompression();
    }
 
    std::string stringize(bool show_range=true,
                          bool resolve_subexprs=true) const {
        std::stringstream ss;
        dump(ss, show_range, resolve_subexprs);
        return ss.str();
    }
 
    const Clock* getClock() {
        std::vector<const Clock*> clocks;
        getClocks(clocks);
        if(clocks.size() == 0){
            return nullptr;
        }
        const Clock* result = *(clocks.begin());
        for(auto itr = clocks.begin()+1; itr != clocks.end(); ++itr){
            if(*itr != result){
                throw SpartaException("Multiple TreeNodes found with different clocks when "
                                    "attempting to determine the clock associated with the "
                                    "expression: ") << stringize();
            }
        }
        return result;
    }
 
    void getClocks(std::vector<const Clock*>& clocks) const{
        if(content_){
            content_->getClocks(clocks);
        }
    }
 
private:
 
    uint32_t getStats_(std::vector<const StatisticInstance*>& results) const {
        return content_ ? content_->getStats(results) : 0;
    }
 
    void parse_(const std::string& expression,
                TreeNode* context,
                std::vector<const TreeNode*>& already_used,
                const StatisticPairs&report_si);
};
 
inline Expression::Expression(double d) :
    Expression()
{
    content_.reset(new Constant(d));
}
 
inline Expression::Expression(operation_t type,
                              ExpressionNode * op1,
                              ExpressionNode * op2,
                              ExpressionNode * op3) :
    Expression()
{
    content_.reset(new Operation(type, op1, op2, op3));
}
 
template <typename RetT, typename ArgT>
inline Expression::Expression(const std::string& name,
                              RetT(*fxn)(ArgT),
                              const Expression& a) {
    sparta_assert(fxn != nullptr,
                      "function pointer of unary function \"" << fxn << "\" must not be nullptr");
    content_.reset(new UnaryFunction<RetT, ArgT>(name, fxn, a.cloneContent()));
}
 
template <typename RetT, typename ArgT>
inline Expression::Expression(const std::string& name,
                              std::function<RetT (ArgT)>& fxn,
                              const Expression& a) {
    sparta_assert(fxn,
        "function pointer of unary function \"" << "\" must not be nullptr");
    content_.reset(new UnaryFunction<RetT, ArgT, std::function<RetT (ArgT)>>(name, fxn, a.cloneContent()));
}
 
template <typename RetT, typename ArgT>
inline Expression::Expression(const std::string& name,
                              RetT(*fxn)(ArgT, ArgT),
                              const Expression& a,
                              const Expression& b) {
    sparta_assert(fxn != nullptr,
                      "function pointer of binary function \"" << fxn << "\" must not be nullptr");
    content_.reset(new BinaryFunction<RetT, ArgT>(name, fxn, a.cloneContent(), b.cloneContent()));
}
 
template <typename RetT>
inline Expression::Expression(const std::string& name,
                              const RetT& functor,
                              const Expression& a,
                              const Expression& b) {
    content_.reset(new BinaryFunction<RetT>(name, functor, a.cloneContent(), b.cloneContent()));
}
 
template <typename RetT, typename ArgT>
inline Expression::Expression(const std::string& name,
                              RetT(*fxn)(ArgT, ArgT, ArgT),
                              const Expression& a,
                              const Expression& b,
                              const Expression& c) {
    sparta_assert(fxn != nullptr,
                      "function pointer of ternary function \"" << fxn << "\" must not be nullptr");
    content_.reset(new TernaryFunction<RetT, ArgT>(name, fxn, a.cloneContent(), b.cloneContent(), c.cloneContent()));
}
 
template <typename RetT, typename ArgT>
inline Expression Expression::ufunc(const std::string& name,
                                    RetT(*fxn)(ArgT),
                                    const Expression& a) const {
    sparta_assert(fxn != nullptr,
                      "function pointer of unary function \"" << fxn << "\" must not be nullptr");
    //std::cout << "unary func \"" << name << "\"" << std::endl;
    return Expression(new UnaryFunction<RetT, ArgT>(name, fxn, a.cloneContent()));
}
 
template <typename RetT, typename ArgT>
inline Expression Expression::ufunc(const std::string& name,
                                    std::function<RetT (ArgT)>& fxn,
                                    const Expression& a) const {
    sparta_assert(fxn,
        "function pointer of unary function \"" << "\" must not be nullptr");
    return Expression(new UnaryFunction<RetT, ArgT, std::function<RetT (ArgT)>>(name, fxn, a.cloneContent()));
}
 
template <typename RetT, typename ArgT>
inline Expression Expression::bfunc(const std::string& name,
                                    RetT(*fxn)(ArgT, ArgT),
                                    const Expression& a,
                                    const Expression& b) const {
    sparta_assert(fxn != nullptr,
                      "function pointer of binary function \"" << fxn << "\" must not be nullptr");
    return Expression(new BinaryFunction<RetT, ArgT>(name, fxn, a.cloneContent(), b.cloneContent()));
}
 
template <typename RetT>
inline Expression Expression::bfunc(const std::string& name,
                                    const RetT& functor,
                                    const Expression& a,
                                    const Expression& b) const {
    return Expression(new BinaryFunction<RetT>(name, functor, a.cloneContent(), b.cloneContent()));
}
 
template <typename RetT, typename ArgT>
inline Expression Expression::tfunc(const std::string& name,
                                    RetT(*fxn)(ArgT, ArgT, ArgT),
                                    const Expression& a,
                                    const Expression& b,
                                    const Expression& c) const {
    sparta_assert(fxn != nullptr,
                      "function pointer of ternary function \"" << fxn << "\" must not be nullptr");
    return Expression(new TernaryFunction<RetT, ArgT>(name, fxn, a.cloneContent(), b.cloneContent(), c.cloneContent()));
}
 
inline Expression& Expression::operator=(double d)
{
    sparta_assert(content_ == nullptr, "Cannot call operator= on an expression which already has an item. Item would ""be discarded");
    content_.reset(new Constant(d));
    return *this;
}
 
inline Expression Expression::operator+() const
{
    sparta_assert(content_ != nullptr, "Cannot call operator+() on an expression which has no item. A lhp is ""required in order to promote");
 
    return Expression(new Operation(OP_PROMOTE,
                                    cloneContent()));
}
 
inline Expression Expression::operator-() const
{
    sparta_assert(content_ != nullptr, "Cannot call operator-() on an expression which has no item. A lhp is ""required in order to negate");
 
    return Expression(new Operation(OP_NEGATE,
                                    cloneContent()));
}
 
inline Expression Expression::operator+(const Expression& rhp) const
{
    sparta_assert(content_ != nullptr, "Cannot call operator+(rhp) on an expression which has no item. A lhp is ""required in order to add");
 
    return Expression(new Operation(OP_ADD,            // Operation
                                    cloneContent(),    // Takes ownership of content
                                    rhp.cloneContent() // Clones content
                                   ));
}
 
inline Expression Expression::operator-(const Expression& rhp) const
{
    sparta_assert(content_ != nullptr, "Cannot call operator-(rhp) on an expression which has no item. A lhp is ""required in order to subtract");
 
    return Expression(new Operation(OP_SUB,            // Operation
                                    cloneContent(),    // Takes ownership of content
                                    rhp.cloneContent() // Clones content
                                   ));
}
 
inline Expression Expression::operator*(const Expression& rhp) const
{
    sparta_assert(content_ != nullptr, "Cannot call operator*(rhp) on an expression which has no item. A lhp is ""required in order to multiply");
 
    return Expression(new Operation(OP_MUL,            // Operation
                                    cloneContent(),    // Takes ownership of content
                                    rhp.cloneContent() // Clones content
                                   ));
}
 
inline Expression Expression::operator/(const Expression& rhp) const
{
    sparta_assert(content_ != nullptr, "Cannot call operator/(rhp) on an expression which has no item. A lhp is ""required in order to divide");
 
    return Expression(new Operation(OP_DIV,            // Operation
                                    cloneContent(),    // Takes ownership of content
                                    rhp.cloneContent() // Clones content
                                   ));
}
 
inline Expression& Expression::operator+=(const Expression& rhp)
{
    sparta_assert(content_ != nullptr, "Cannot call operator+=(rhp) on an expression which has no item. A lhp is ""required in order to add");
 
    content_.reset(new Operation(OP_ADD,            // Operation
                                 cloneContent(),    // Takes ownership of content
                                 rhp.cloneContent() // Clones content
                                ));
    return *this;
}
 
inline Expression& Expression::operator-=(const Expression& rhp)
{
    sparta_assert(content_ != nullptr, "Cannot call operator-=(rhp) on an expression which has no item. A lhp is ""required in order to subtract");
 
    content_.reset(new Operation(OP_SUB,            // Operation
                                 cloneContent(),    // Takes ownership of content
                                 rhp.cloneContent() // Clones content
                                ));
    return *this;
}
 
 
inline Expression& Expression::operator*=(const Expression& rhp)
{
    sparta_assert(content_ != nullptr, "Cannot call operator*=(rhp) on an expression which has no item. A lhp is ""required in order to divide");
 
    content_.reset(new Operation(OP_MUL,            // Operation
                                 cloneContent(),    // Takes ownership of content
                                 rhp.cloneContent() // Clones content
                                ));
    return *this;
}
 
inline Expression& Expression::operator/=(const Expression& rhp)
{
    sparta_assert(content_ != nullptr, "Cannot call operator/=(rhp) on an expression which has no item. A lhp is ""required in order to divide");
 
    content_.reset(new Operation(OP_DIV,            // Operation
                                 cloneContent(),    // Takes ownership of content
                                 rhp.cloneContent() // Clones content
                                ));
    return *this;
}
 
inline std::ostream& operator<<(std::ostream& o, const sparta::statistics::expression::Expression& ex){
    ex.dump(o);
    return o;
}
 
        } // namespace expression
    } // namespace statistics
} // namespace sparta