sc_variable.h

/*******************************************************************************
 * Copyright 2019 MINRES Technologies GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/
 
#ifndef _SCC_SC_VARIABLE_H_
#define _SCC_SC_VARIABLE_H_
 
#include "observer.h"
#include "report.h"
#include "utilities.h"
#include <array>
#include <functional>
#include <sstream>
#include <sysc/kernel/sc_event.h>
#include <sysc/kernel/sc_simcontext.h>
#include <sysc/tracing/sc_trace.h>
 
#ifndef SC_API
#define SC_API
#endif

namespace scc {
class trace_handle;
struct sc_variable_b : sc_core::sc_object {
    sc_variable_b(const char* name)
    : sc_core::sc_object(name) {}
    // Rule of 5 - non-copyable, non-assignable
    sc_variable_b() = delete;
    sc_variable_b(sc_variable_b const&) = delete;
    sc_variable_b(sc_variable_b&&) = delete;
    sc_variable_b& operator=(const sc_variable_b& other) = delete;
    sc_variable_b& operator=(sc_variable_b&& other) = delete;

    const char* kind() const { return "sc_variable"; }
    virtual std::string to_string() const { return ""; };
 
    virtual void trace(observer* obs) const = 0;
};

template <typename T> struct sc_variable : public sc_variable_b {
    using this_type = sc_variable<T>;
    const T& operator*() { return value; }
    const T* operator->() { return &value; }
    sc_variable(const std::string& name, const T& value)
    : sc_variable_b(name.c_str())
    , value(value)
    , hndl{} {}
    // Rule of 5 - non-copyable, non-assignable
    sc_variable() = delete;
    sc_variable(sc_variable<T> const&) = delete;
    sc_variable(sc_variable<T>&&) = delete;
    sc_variable& operator=(sc_variable<T>&& other) = delete;
 
    virtual ~sc_variable() = default;
    std::string to_string() const override {
        std::stringstream ss;
        ss << value;
        return ss.str();
    }

    T get() const { return value; }
    operator bool() const { return value; }

    operator T() const { return value; }
    // assignment operator overload
    sc_variable& operator=(T other) {
        value = other;
        for(auto h : hndl)
            h->notify();
        return *this;
    }
 
    sc_variable& operator=(const sc_variable<T>& other) {
        value = other.value;
        for(auto h : hndl)
            h->notify();
        return *this;
    }
    bool operator==(T other) const { return value == other; }
    bool operator!=(T other) const { return value != other; }
    bool operator>(T other) const { return value > other; }
    bool operator<(T other) const { return value < other; }
    bool operator>=(T other) const { return value >= other; }
    bool operator<=(T other) const { return value <= other; }
    sc_variable& operator++() {
        ++value; // increment this object
        for(auto h : hndl)
            h->notify();
        return *this;
    }

    T operator++(int) {
        auto orig = value;
        ++value;
        for(auto h : hndl)
            h->notify();
        return orig;
    }

    sc_variable& operator--() {
        --value; // increment this object
        for(auto h : hndl)
            h->notify();
        return *this;
    }

    T operator--(int) {
        auto orig = value;
        --value;
        for(auto h : hndl)
            h->notify();
        return orig;
    }
 
    //" arithmetic operator overloads
    T operator+=(const T other) {
        value += other;
        for(auto h : hndl)
            h->notify();
        return value;
    }
    T operator-=(const T other) {
        value -= other;
        for(auto h : hndl)
            h->notify();
        return value;
    }
    T operator*=(const T other) {
        value *= other;
        for(auto h : hndl)
            h->notify();
        return value;
    }
    T operator/=(const T other) {
        value /= other;
        for(auto h : hndl)
            h->notify();
        return value;
    }
    T operator+(const T other) const { return value + other; }
    T operator-(const T other) const { return value - other; }
    T operator*(const T other) const { return value * other; }
    T operator/(const T other) const { return value / other; }
    T operator+(const this_type& other) const { return value + other.value; }
    T operator-(const this_type& other) const { return value - other.value; }
    T operator*(const this_type& other) const { return value * other.value; }
    T operator/(const this_type& other) const { return value / other.value; }
    void trace(sc_core::sc_trace_file* tf) const override {
        if(auto* obs = dynamic_cast<observer*>(tf))
            hndl.push_back(observe(obs, value, name()));
        else
            sc_core::sc_trace(tf, value, name());
    }
 
    void trace(observer* obs) const override { hndl.push_back(observe(obs, value, name())); }
 
    struct creator {
        creator(T const& default_val)
        : default_val{default_val} {}
        sc_variable<T>* operator()(const char* n, size_t i) { return new sc_variable<T>(n, default_val); }
 
    private:
        T default_val{};
    };
 
private:
    T value;
    mutable std::vector<observer::notification_handle*> hndl;
};
 
template <typename T> T operator+(sc_variable<T> const& a, sc_variable<T> const& b) { return a.get() + b.get(); }
template <typename T> T operator-(sc_variable<T> const& a, sc_variable<T> const& b) { return a.get() - b.get(); }
template <typename T> T operator*(sc_variable<T> const& a, sc_variable<T> const& b) { return a.get() * b.get(); }
template <typename T> T operator/(sc_variable<T> const& a, sc_variable<T> const& b) { return a.get() / b.get(); }
template <typename T> T operator+(T const& a, sc_variable<T> const& b) { return a + b.get(); }
template <typename T> T operator-(T const& a, sc_variable<T> const& b) { return a - b.get(); }
template <typename T> T operator*(T const& a, sc_variable<T> const& b) { return a * b.get(); }
template <typename T> T operator/(T const& a, sc_variable<T> const& b) { return a / b.get(); }

template <> struct sc_variable<bool> : public sc_variable_b {
    const bool& operator*() { return value; }
    sc_variable(const std::string& name, const bool& value)
    : sc_variable_b(name.c_str())
    , value(value)
    , hndl{} {}
    sc_variable() = delete;
    sc_variable(sc_variable<bool> const&) = delete;
    sc_variable(sc_variable<bool>&&) = delete;
    sc_variable& operator=(sc_variable<bool>&& other) = delete;
    virtual ~sc_variable() = default;
    std::string to_string() const override {
        std::stringstream ss;
        ss << value;
        return ss.str();
    }
    bool get() const { return value; }
    operator bool() const { return value; }
    sc_variable& operator=(const bool other) {
        value = other;
        for(auto h : hndl)
            h->notify();
        return *this;
    }
    sc_variable& operator=(const sc_variable<bool>& other) {
        value = other.value;
        for(auto h : hndl)
            h->notify();
        return *this;
    }
    bool operator==(bool other) const { return value == other; }
    bool operator!=(bool other) const { return value != other; }
    void trace(sc_core::sc_trace_file* tf) const override {
        if(auto* obs = dynamic_cast<observer*>(tf))
            hndl.push_back(observe(obs, value, name()));
        else
            sc_core::sc_trace(tf, value, name());
    }
    void trace(observer* obs) const override { hndl.push_back(observe(obs, value, name())); }
 
    struct creator {
        creator(bool const& default_val)
        : default_val{default_val} {}
        sc_variable<bool>* operator()(const char* n, size_t i) { return new sc_variable<bool>(n, default_val); }
 
    private:
        bool default_val{};
    };
 
private:
    bool value;
    mutable std::vector<observer::notification_handle*> hndl;
};

template <typename T> struct sc_variable_vector {
 
    sc_variable_vector(std::string const& name, size_t size)
    : name(name)
    , values(size)
    , creator{} {}
 
    sc_variable_vector(std::string const& name, size_t size, T const& def_val)
    : name(name) {
        resize(size, def_val);
    }
 
    sc_variable_vector(std::string const& name, size_t size, std::function<sc_variable<T>*(char const*, size_t)> creator)
    : name(name)
    , values(size)
    , creator(std::move(creator)) {}
 
    size_t size() const { return values.size(); }
 
    void resize(size_t sz) {
        assert(!sc_core::sc_get_curr_simcontext()->elaboration_done());
        values.resize(sz);
    }
 
    void resize(size_t sz, T const& def_val) {
        assert(!sc_core::sc_get_curr_simcontext()->elaboration_done());
        auto old_size = values.size();
        values.resize(sz);
        auto idx = 0U;
        for(size_t i = old_size; i < sz; ++i) {
            std::stringstream ss;
            ss << name << "(" << i << ")";
            values[i] = scc::make_unique<sc_variable<T>>(ss.str().c_str(), def_val);
        }
    }
 
    bool is_valid(size_t idx) const { return values.size() > idx && values.at(idx) != nullptr; }
 
    sc_variable<T>& operator[](size_t idx) {
        auto& ret = values.at(idx);
        if(!ret) {
            if(sc_core::sc_get_curr_simcontext()->elaboration_done())
                SCCFATAL(sc_core::sc_get_current_object()->name()) << "Trying to create a sc_variable vector entry in " << name
                                                                   << " with index " << idx << " while elaboration finished is not allowed";
            assert(!sc_core::sc_get_curr_simcontext()->elaboration_done());
            assert(creator);
            std::stringstream ss;
            ss << name << "(" << idx << ")";
            ret.reset(creator(ss.str().c_str(), idx));
        }
        return *ret;
    }
 
    sc_variable<T> const& operator[](size_t idx) const {
        assert(values.at(idx) && "No initialized value in sc_variable_vector position");
        return *values.at(idx);
    }
 
private:
    std::string name{};
    std::vector<std::unique_ptr<sc_variable<T>>> values;
    std::function<sc_variable<T>*(char const*, size_t)> creator;
};

template <typename T> struct sc_ref_variable : public sc_variable_b {
    const T& value;
    const T& operator*() { return value; }
    sc_ref_variable(const std::string& name, const T& value, bool active_notification = false)
    : sc_variable_b(name.c_str())
    , value(value)
    , active_notification(active_notification) {}
 
    virtual ~sc_ref_variable() = default;
    std::string to_string() const override {
        std::stringstream ss;
        ss << value;
        return ss.str();
    }

    void trace(sc_core::sc_trace_file* tf) const override {
        if(active_notification)
            if(auto* obs = dynamic_cast<observer*>(tf)) {
                hndl.push_back(observe(obs, value, name()));
                return;
            }
        sc_core::sc_trace(tf, value, name());
    }
 
    void trace(observer* obs) const override { hndl.push_back(observe(obs, value, name())); }
 
    void notify() const {
        for(auto h : hndl)
            h->notify();
    }
 
private:
    const bool active_notification;
    mutable std::vector<observer::notification_handle*> hndl;
};
template <> struct sc_ref_variable<sc_core::sc_event> : public sc_variable_b {
    const sc_core::sc_event& value;
    const sc_core::sc_event& operator*() { return value; }
    sc_ref_variable(const std::string& name, const sc_core::sc_event& value)
    : sc_variable_b(name.c_str())
    , value(value) {}
    std::string to_string() const override {
        std::stringstream ss;
        ss << value.name();
        return ss.str();
    }
 
    void trace(observer* obs) const override {}
 
    void trace(sc_core::sc_trace_file* tf) const override { sc_core::sc_trace(tf, value, name()); }
};

template <typename T> struct sc_ref_variable_masked : public sc_variable_b {
    const T& value;
 
    const T mask;
 
    sc_ref_variable_masked(const std::string& name, const T& value, int width)
    : sc_variable_b(name.c_str())
    , value(value)
    , mask((1 << width) - 1) {}
 
    virtual ~sc_ref_variable_masked() = default;
 
    std::string to_string() const override {
        std::stringstream ss;
        ss << (value & mask);
        return ss.str();
    }
 
    void trace(observer* obs) const override {}
 
    void trace(sc_core::sc_trace_file* tf) const override { sc_core::sc_trace(tf, value, name()); }
};
 
} // namespace scc
 
namespace sc_core {
template <class T> inline void sc_trace(sc_trace_file* tf, const ::scc::sc_variable<T>& object, const char* name) { object.trace(tf); }
template <class T> inline void sc_trace(sc_trace_file* tf, const ::scc::sc_variable<T>* object, const char* name) { object->trace(tf); }
 
template <class T> inline void sc_trace(sc_trace_file* tf, const ::scc::sc_ref_variable<T>& object, const char* name) { object.trace(tf); }
template <class T> inline void sc_trace(sc_trace_file* tf, const ::scc::sc_ref_variable<T>* object, const char* name) { object->trace(tf); }
 
} // namespace sc_core // end of scc-sysc
#endif    /* _SCC_SC_VARIABLE_H_ */