SharedData.hpp

Go to the documentation of this file.

// <SharedData.h> -*- C++ -*-
 
 
#pragma once
 
#include <array>
#include "sparta/utils/ValidValue.hpp"
#include "sparta/events/GlobalEvent.hpp"
 
namespace sparta
{
    template<class DataT, bool manual_update = false>
    class SharedData
    {
        // Convenient typedef for internal data type
        typedef std::array<utils::ValidValue<DataT>, 2> PSNSData;
 
        // Next state index
        uint32_t NState_() const {
            return (current_state_ + 1) & 0x1;
        }
 
        // Present state index
        uint32_t PState_() const {
            return current_state_;
        }
 
        void resetHandler_()
        {
            ev_update_.resetHandler(CREATE_SPARTA_HANDLER(SharedData, update_));
        }
 
    public:
        template<typename U = DataT>
        SharedData(const std::string & name,
                   const Clock * clk,
                   U && init_val = U()) :
            name_(name),
            ev_update_(clk, CREATE_SPARTA_HANDLER(SharedData, update_))
        {
            writePS(std::forward<U>(init_val));
        }
 
        SharedData(const SharedData& rhs) :
            name_(rhs.name_),
            ev_update_(rhs.ev_update_),
            current_state_(rhs.current_state_),
            data_(rhs.data_)
        {
            resetHandler_();
        }
 
        SharedData(SharedData&& rhs) :
            name_(std::move(rhs.name_)),
            ev_update_(std::move(rhs.ev_update_)),
            current_state_(std::move(rhs.current_state_)),
            data_(std::move(rhs.data_))
        {
            resetHandler_();
        }
 
        SharedData& operator=(const SharedData& rhs)
        {
            name_ = rhs.name_;
            ev_update_ = rhs.ev_update_;
            resetHandler_();
 
            current_state_ = rhs.current_state_;
            data_ = rhs.data_;
 
            return *this;
        }
 
        SharedData& operator=(SharedData&& rhs)
        {
            name_ = std::move(rhs.name_);
            ev_update_ = std::move(rhs.ev_update_);
            resetHandler_();
 
            current_state_ = std::move(rhs.current_state_);
            data_ = std::move(rhs.data_);
 
            return *this;
        }
 
        const std::string & getName() const {
            return name_;
        }
 
        void writePS(const DataT & dat) {
            writePSImpl_(dat);
        }
 
        void writePS(DataT && dat) {
            writePSImpl_(std::move(dat));
        }
 
        bool isValid() const {
            return data_[PState_()].isValid();
        }
 
        const DataT & read() const {
            sparta_assert(isValid());
            return data_[PState_()];
        }
 
        DataT & access() {
            sparta_assert(isValid());
            return data_[PState_()];
        }
 
        void write(const DataT & dat) {
            writeImpl_(dat);
        }
 
        void write(DataT && dat) {
            writeImpl_(std::move(dat));
        }
 
        bool isValidNS() const {
            return data_[NState_()].isValid();
        }
 
        const DataT & readNS() const {
            sparta_assert(isValidNS());
            return data_[NState_()];
        }
 
        DataT & accessNS() {
            sparta_assert(isValidNS());
            return data_[NState_()];
        }
 
        void clear() {
            data_[PState_()].clearValid();
            data_[NState_()].clearValid();
        }
 
        void clearNS() {
            data_[NState_()].clearValid();
        }
 
        void clearPS() {
            data_[PState_()].clearValid();
        }
 
        void update() {
            static_assert(manual_update == true,
                          "Cannot call update on a SharedData object if manual_update == false");
            update_();
        }
 
    private:
        template<typename U>
        void writePSImpl_(U && dat) {
            data_[PState_()] = std::forward<U>(dat);
        }
 
        template<typename U>
        void writeImpl_(U && dat) {
            data_[NState_()] = std::forward<U>(dat);
            if constexpr (!manual_update) {
                ev_update_.schedule(1);
            }
        }
 
        void update_()
        {
            current_state_ = NState_();
            clearNS();
        }
 
        // SharedData's name
        std::string name_;
 
        // Global Event
        GlobalEvent<SchedulingPhase::Update> ev_update_;
 
        // Current state
        uint32_t current_state_ = 0;
 
        // The PS/NS data
        PSNSData data_;
    };
}