SignalPort.hpp

Go to the documentation of this file.

// <SignalPort> -*- C++ -*-
 
#pragma once
#include <set>
#include <list>
#include <unordered_map>
 
#include "sparta/ports/Port.hpp"
#include "sparta/utils/DataContainer.hpp"
#include "sparta/events/Precedence.hpp"
#include "sparta/events/EventSet.hpp"
#include "sparta/events/UniqueEvent.hpp"
 
namespace sparta
{
 
    // Signal Ports
 
    class SignalInPort;
 
    class SignalOutPort final : public OutPort
    {
    public:
 
        SignalOutPort(TreeNode * portset, const std::string & name,
                      bool presume_zero_delay = true) :
            OutPort(portset, name, presume_zero_delay)
        {
            sparta_assert(name.length() != 0, "You cannot have an unnamed port.");
        }
 
        void bind(Port * in) override;
 
        using Port::bind;
 
        void send(sparta::Clock::Cycle rel_time = 0);
 
        SignalOutPort(const SignalOutPort &) = delete;
 
        SignalOutPort & operator=(const SignalOutPort &) = delete;
 
    private:
 
        std::vector <SignalInPort*> bound_in_ports_;
    };
 
    class SignalInPort final : public InPort, public DataContainer<bool>
    {
    public:
 
        SignalInPort(TreeNode * portset, const std::string & name,
                     sparta::SchedulingPhase phase, sparta::Clock::Cycle delay) :
            InPort(portset, name, phase),
            DataContainer<bool>(getClock()),
            port_delay_(delay),
            signal_events_(this)
        {
            receiver_clock_ = getClock();
            scheduler_ = receiver_clock_->getScheduler();
 
            sparta_assert(receiver_clock_ != nullptr,
                        "SignalInPort " << name << " does not have a clock");
            sparta_assert(name.length() != 0, "You cannot have an unnamed port.");
            user_signal_delivery_.
                reset(new PhasedUniqueEvent(&signal_events_, name + "_forward_event",
                                            phase, CREATE_SPARTA_HANDLER(SignalInPort, receiveSignal_)));
        }
 
        SignalInPort(TreeNode* portset, const std::string & name, sparta::Clock::Cycle delay = 0) :
            SignalInPort(portset, name, (delay == 0 ?
                                         sparta::SchedulingPhase::Tick :
                                         sparta::SchedulingPhase::PortUpdate), delay)
        {}
 
        SignalInPort(const SignalInPort &) = delete;
 
        SignalInPort & operator=(const SignalInPort &) = delete;
 
        void bind(Port * out) override;
 
        using Port::bind;
 
        Clock::Cycle getPortDelay() const override final {
            return port_delay_;
        }
 
        void setContinuing(bool continuing) override final {
            // signal_arrive_event_.setContinuing(continuing);
            user_signal_delivery_->setContinuing(continuing);
        }
 
    private:
 
        Scheduleable & getScheduleable_() override final {
            return user_signal_delivery_->getScheduleable();
        }
 
        void setProducerPrecedence_(Scheduleable * pd) override final {
            if(pd->getSchedulingPhase() == user_signal_delivery_->getSchedulingPhase()) {
                pd->precedes(*user_signal_delivery_, "Port::bind of OutPort to " + getName() + ": '" +
                             pd->getLabel() + "' is a registered driver");
            }
        }
 
        void registerConsumerHandler_(const SpartaHandler & handler) override final {
            sparta_assert(handler.argCount() == 0,
                        "SignalInPort: " << getName()
                        << ": The handler associated with the SignalInPort must not expect an argument: "
                        << handler.getName());
            // Help the user identify their events/callbacks from the Scheduler debug
            handler_name_ = getName() + "<SignalInPort>[" + explicit_consumer_handler_.getName() + "]";
            user_signal_delivery_->setLabel(handler_name_.c_str());
        }
 
        // The SignalOutPort will send the transaction over as well as bind
        friend class SignalOutPort;
 
        void bind_(Port * out) override final
        {
            InPort::bind_(out);
            for(auto & consumer : port_consumers_)
            {
                if(consumer->getSchedulingPhase() == user_signal_delivery_->getSchedulingPhase()) {
                    user_signal_delivery_->precedes(consumer, "Port::bind(" + getName() + "->" + out->getName() + "),'"
                                                    + consumer->getLabel() + "' is registered driver");
                }
            }
        }
 
        void send_(sparta::Clock::Cycle rel_time)
        {
            const uint32_t total_delay = rel_time + port_delay_;
            // Most of the time there is a delay.
            if(SPARTA_EXPECT_FALSE(total_delay == 0))
            {
                checkSchedulerPhaseForZeroCycleDelivery_(user_signal_delivery_->getSchedulingPhase());
                if(user_signal_delivery_->getSchedulingPhase() == scheduler_->getCurrentSchedulingPhase()) {
                    // Receive the port data now
                    receiveSignal_();
                    return;
                }
            }
            user_signal_delivery_->schedule(total_delay, receiver_clock_);
       }
 
        const Clock::Cycle port_delay_;
 
        void receiveSignal_() {
            // Set's the timestamp
            DataContainer<bool>::setData_(true);
            if(SPARTA_EXPECT_TRUE(explicit_consumer_handler_)) {
                explicit_consumer_handler_();
            }
        }
 
        std::string handler_name_;
 
        sparta::EventSet signal_events_;
 
        // sparta::UniqueEvent<SchedulingPhase::PortUpdate> signal_arrive_event_ {
        //     &signal_events_, getName() + "_port_delivery_event",
        //         CREATE_SPARTA_HANDLER(SignalInPort, receiveSignal_)};
        std::unique_ptr<PhasedUniqueEvent> user_signal_delivery_;
    };
 
 
    // External definitions
 
    inline void SignalInPort::bind(Port * out)
    {
        SignalOutPort * outp;
        if((outp = dynamic_cast<SignalOutPort*>(out)) == 0) {
            throw SpartaException("ERROR: Attempt to bind to something that isn't a SignalOutPort: '" +
                                out->getName() + "' to '" + getName() + "'");
        }
        InPort::bind(outp);
    }
 
    inline void SignalOutPort::bind(Port * in)
    {
        SignalInPort * inp;
        if((inp = dynamic_cast<SignalInPort *>(in)) == 0) {
            throw SpartaException("ERROR: Attempt to bind to something that isn't a SignalInPort: '" +
                                in->getName() + "' to '" + getName() + "'");
        }
        OutPort::bind(in);
        bound_in_ports_.push_back(inp);
    }
 
    inline void SignalOutPort::send(sparta::Clock::Cycle rel_time)
    {
        sparta_assert(!bound_in_ports_.empty(),
                    "ERROR! Attempt to send data on unbound port: " << getLocation());
        for(SignalInPort* itr : bound_in_ports_) {
            itr->send_(rel_time);
        }
    }
}