DataPort.hpp

Go to the documentation of this file.

// <Port> -*- C++ -*-
 
 
#pragma once
 
#include <set>
#include <vector>
 
#include "sparta/ports/Port.hpp"
#include "sparta/utils/DataContainer.hpp"
#include "sparta/events/EventSet.hpp"
#include "sparta/events/PayloadEvent.hpp"
#include "sparta/events/Precedence.hpp"
#include "sparta/events/Scheduleable.hpp"
#include "sparta/collection/Collectable.hpp"
 
namespace sparta
{
 
    // Data Ports
 
    // Forward declaration
    template<class DataT>
    class DataInPort;
 
    template<class DataT>
    class DataOutPort final : public OutPort
    {
    public:
        typedef DataT DataType;
 
        DataOutPort(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.");
            sparta_assert(getClock() != nullptr, "DataOutPort '" << name << "' created without a clock");
        }
 
        DataOutPort(const DataOutPort &) = delete;
 
        DataOutPort & operator=(const DataOutPort &) = delete;
 
        void bind(Port * in) override
        {
            DataInPort<DataT> * inp;
            if((inp = dynamic_cast<DataInPort<DataT> *>(in)) == 0) {
                throw SpartaException("ERROR: Attempt to bind DataInPort of a disparate types: '" +
                                    in->getLocation() + "' to '" + getLocation() + "'");
            }
            OutPort::bind(in);
            bound_in_ports_.push_back(inp);
        }
 
        using Port::bind;
 
        void send(const DataT & dat, sparta::Clock::Cycle rel_time = 0)
        {
            sparta_assert(!bound_in_ports_.empty(),
                          "ERROR! Attempt to send data on unbound port: " << getLocation());
            for(DataInPort<DataT>* itr : bound_in_ports_) {
                itr->send_(dat, rel_time);
            }
        }
 
        bool isDriven(Clock::Cycle rel_cycle) const override {
            for(DataInPort<DataT>* itr : bound_in_ports_) {
                if(itr->isDriven(rel_cycle)) {
                    return true;
                }
            }
            return false;
        }
 
         bool isDriven() const override {
            for(DataInPort<DataT>* itr : bound_in_ports_) {
                if(itr->isDriven()) {
                    return true;
                }
            }
            return false;
        }
 
        uint32_t cancel()
        {
            uint32_t cancel_cnt = 0;
            for(DataInPort<DataT>* itr : bound_in_ports_) {
                cancel_cnt += itr->cancel();
            }
            return cancel_cnt;
        }
 
        uint32_t cancelIf(const DataT & criteria) {
            uint32_t cancel_cnt = 0;
            for(DataInPort<DataT>* itr : bound_in_ports_) {
                cancel_cnt += itr->cancelIf(criteria);
            }
            return cancel_cnt;
        }
 
        uint32_t cancelIf(std::function<bool(const DataT &)> compare) {
            uint32_t cancel_cnt = 0;
            for(DataInPort<DataT>* itr : bound_in_ports_) {
                cancel_cnt += itr->cancelIf(compare);
            }
            return cancel_cnt;
        }
 
    private:
        std::vector <DataInPort<DataT>*> bound_in_ports_;
    };
 
    template<class DataT>
    class DataInPort final : public InPort, public DataContainer<DataT>
    {
        // Pipeline collection type
        typedef collection::Collectable<DataT> CollectorType;
 
    public:
 
        typedef DataT DataType;
 
        DataInPort(TreeNode* portset, const std::string & name,
                   sparta::SchedulingPhase delivery_phase, sparta::Clock::Cycle delay) :
            InPort(portset, name, delivery_phase),
            DataContainer<DataT>(getClock()),
            data_in_port_events_(this),
            port_delay_(delay)
        {
            receiver_clock_ = getClock();
            scheduler_ = receiver_clock_->getScheduler();
 
            sparta_assert(receiver_clock_ != nullptr,
                          "DataInPort " << name << " does not have a clock");
            sparta_assert(name.length() != 0, "You cannot have an unnamed port.");
 
            user_payload_delivery_.reset(new PhasedPayloadEvent<DataT>(&data_in_port_events_, name + "_forward_event",
                                                                       delivery_phase,
                                                                       CREATE_SPARTA_HANDLER_WITH_DATA(DataInPort<DataT>, receivePortData_, DataT)));
        }
 
        DataInPort(TreeNode* portset, const std::string & name, sparta::Clock::Cycle delay = 0) :
            DataInPort(portset, name, (delay == 0 ? sparta::SchedulingPhase::Tick : sparta::SchedulingPhase::PortUpdate), delay)
        {}
 
        DataInPort(const DataInPort &) = delete;
 
        DataInPort & operator=(const DataInPort &) = delete;
 
        void bind(Port * out) override
        {
            DataOutPort<DataT> * outp;
            if((outp = dynamic_cast<DataOutPort<DataT> *>(out)) == 0) {
                throw SpartaException("ERROR: Attempt to bind DataOutPort of a disparate types: '" +
                                      out->getLocation() + "' to '" + getLocation() + "'");
            }
            InPort::bind(out);
        }
 
        using Port::bind;
 
        Clock::Cycle getPortDelay() const override final {
            return port_delay_;
        }
 
        void setContinuing(bool continuing) override final {
            Port::setContinuing(continuing);
            user_payload_delivery_->getScheduleable().setContinuing(continuing);
        }
 
        bool isDriven(Clock::Cycle rel_cycle) const override {
            return user_payload_delivery_->isScheduled(rel_cycle);
        }
 
        bool isDriven() const override {
            return user_payload_delivery_->isScheduled();
        }
 
        uint32_t cancel() {
           return user_payload_delivery_->cancel();
        }
 
        uint32_t cancelIf(const DataT & criteria) {
            return user_payload_delivery_->cancelIf(criteria);
        }
 
        uint32_t cancelIf(std::function<bool(const DataT &)> compare) {
            return user_payload_delivery_->cancelIf(compare);
        }
 
        void enableCollection(TreeNode* node) override {
            collector_.reset(new CollectorType(node, Port::name_, 0,
                                               "Data being received on this DataInPort"));
        }
 
    private:
 
        Scheduleable & getScheduleable_() override final {
            return user_payload_delivery_->getScheduleable();
        }
 
        void setProducerPrecedence_(Scheduleable * pd) override final {
            if(pd->getSchedulingPhase() == user_payload_delivery_->getSchedulingPhase()) {
                pd->precedes(user_payload_delivery_->getScheduleable(), "Port::bind of OutPort to " + getName() + ": '" +
                             pd->getLabel() + "' is a registered driver");
            }
       }
 
        void registerConsumerHandler_(const SpartaHandler & handler) override final
        {
            sparta_assert(handler.argCount() == 1,
                        "DataInPort: " << getName()
                        << ": The handler associated with the DataInPort must take at least one argument: "
                        << handler.getName());
            handler_name_ = getName() + "<DataInPort>[" + handler.getName() + "]";
            user_payload_delivery_->getScheduleable().setLabel(handler_name_.c_str());
        }
 
        void bind_(Port * outp) override final
        {
            InPort::bind_(outp);
            for(auto & consumer : port_consumers_)
            {
                if(consumer->getSchedulingPhase() == user_payload_delivery_->getSchedulingPhase()) {
                    user_payload_delivery_->getScheduleable().precedes(consumer, "Port::bind(" + getName() + "->" + outp->getName() + "),'"
                                                                       + consumer->getLabel() + "' is registered consumer");
                }
            }
        }
 
        friend class DataOutPort<DataT>;
 
        void send_(const DataT & dat, 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_payload_delivery_->getSchedulingPhase());
                if(user_payload_delivery_->getSchedulingPhase() == scheduler_->getCurrentSchedulingPhase()) {
                    // Receive the port data now
                    receivePortData_(dat);
                    return;
                }
            }
            user_payload_delivery_->preparePayload(dat)->schedule(total_delay, receiver_clock_);
        }
 
        sparta::EventSet data_in_port_events_;
 
        std::unique_ptr<PhasedPayloadEvent<DataT>> user_payload_delivery_;
 
        std::string handler_name_;
 
        const Clock * receiver_clock_ = nullptr;
 
        std::unique_ptr<CollectorType> collector_;
 
        void receivePortData_(const DataT & dat)
        {
            DataContainer<DataT>::setData_(dat);
            if(SPARTA_EXPECT_TRUE(explicit_consumer_handler_)) {
                explicit_consumer_handler_((const void*)&dat);
            }
            if(SPARTA_EXPECT_FALSE(collector_ != nullptr)) {
                if(SPARTA_EXPECT_FALSE(collector_->isCollected())) {
                    collector_->collect(dat);
                }
            }
        }
 
        const Clock::Cycle port_delay_;
    };
}