Unit.hpp

Go to the documentation of this file.

// <Unit.hpp> -*- C++ -*-
 
 
#pragma once
 
#include <string>
 
#include "sparta/simulation/Resource.hpp"
#include "sparta/statistics/StatisticSet.hpp"
#include "sparta/ports/PortSet.hpp"
#include "sparta/events/EventSet.hpp"
#include "sparta/log/MessageSource.hpp"
#include "sparta/log/categories/CategoryManager.hpp"
 
namespace sparta {
 
    class TreeNode;
 
 
    class Unit : public Resource
    {
    friend class DAG;
    public:
 
        static constexpr const char * INFO_LOG  = "info";
        static constexpr const char * WARN_LOG  = log::categories::WARN_STR;
        static constexpr const char * DEBUG_LOG = log::categories::DEBUG_STR;
 
        Unit(TreeNode* rc, const std::string & name) :
            Resource(rc, name),
            unit_port_set_(rc),
            unit_event_set_(rc),
            unit_stat_set_(rc),
            info_logger_ (rc, INFO_LOG,  rc->getName() + " Info Messages"),
            warn_logger_ (rc, WARN_LOG,  rc->getName() + " Warn Messages"),
            debug_logger_(rc, DEBUG_LOG, rc->getName() + " Debug Messages")
        {}
 
        Unit(TreeNode* rc) :
            Unit(rc, rc->getName())
        {}
 
        virtual ~Unit() {}
 
        void setAutoPrecedence(bool auto_p) {
            auto_precedence_ = auto_p;
        }
 
        PortSet * getPortSet() {
            return &unit_port_set_;
        }
 
        EventSet * getEventSet() {
            return &unit_event_set_;
        }
 
        StatisticSet * getStatisticSet() {
            return &unit_stat_set_;
        }
 
    protected:
        sparta::PortSet      unit_port_set_;
 
        sparta::EventSet     unit_event_set_;
 
        sparta::StatisticSet unit_stat_set_;
 
        virtual void onBindTreeEarly_() override {
            if(!auto_precedence_) {
                return;
            }
 
            for(auto & event_node : unit_event_set_.getEvents(sparta::SchedulingPhase::Tick))
            {
                // This event does not participate in auto precedence.
                if(!event_node->doesParticipateInAutoPrecedence()) {
                    continue;
                }
 
                // Go through all of the registered InPorts and set these
                // ports to precede any events that are on the Tick phase.
                // This is for 0-cycle precedence only.
                for(auto & pt : unit_port_set_.getPorts(Port::Direction::IN)) {
                    InPort * inp = dynamic_cast<InPort *>(pt.second);
                    sparta_assert(inp != nullptr);
                    if(inp->doesParticipateInAutoPrecedence()) {
                        inp->registerConsumerEvent(event_node->getScheduleable());
                    }
                }
 
                // Go through all of the registered OutPorts and set these
                // ports to succeed any events that are on the Tick phase.
                // This is for 0-cycle precedence only.
                for(auto & pt : unit_port_set_.getPorts(Port::Direction::OUT)) {
                    OutPort * outp = dynamic_cast<OutPort *>(pt.second);
                    sparta_assert(outp != nullptr);
                    if(outp->doesParticipateInAutoPrecedence()) {
                        outp->registerProducingEvent(event_node->getScheduleable());
                    }
                }
            }
        }
 
        virtual void onBindTreeLate_() override;
 
        log::MessageSource info_logger_;
 
        log::MessageSource warn_logger_;
 
        log::MessageSource debug_logger_;
 
    private:
        bool auto_precedence_ = true;
 
    };
 
} // namespace sparta