Precedence.hpp

Go to the documentation of this file.

// <Precedence.hpp> -*- C++ -*-
 
#pragma once
 
#include <type_traits>
 
#include "sparta/utils/MetaStructs.hpp"
#include "sparta/events/Scheduleable.hpp"
#include "sparta/events/Event.hpp"
#include "sparta/events/UniqueEvent.hpp"
#include "sparta/events/PayloadEvent.hpp"
#include "sparta/events/SingleCycleUniqueEvent.hpp"
#include "sparta/events/GlobalOrderingPoint.hpp"
#include "sparta/ports/Port.hpp"
#include "sparta/ports/Bus.hpp"
 
namespace sparta
{
 
 
    // GOP -> EventNode types
 
    template<class ScheduleableTypeA>
    typename std::enable_if<std::is_base_of<EventNode, ScheduleableTypeA>::value, const GlobalOrderingPoint>::
    type & operator>>(ScheduleableTypeA & producer, const GlobalOrderingPoint & consumer)
    {
        producer.getScheduleable().precedes(*consumer.getGOPoint());
        return consumer;
    }
 
    template<class ScheduleableTypeA>
    typename std::enable_if<std::is_base_of<EventNode, ScheduleableTypeA>::value, ScheduleableTypeA>::
    type & operator>>(const GlobalOrderingPoint & producer, ScheduleableTypeA & consumer)
    {
        producer.getGOPoint()->precedes(consumer.getScheduleable());
        return consumer;
    }
 
    inline InPort & operator>>(const GlobalOrderingPoint & producer, InPort & consumer) {
        producer.getGOPoint()->precedes(consumer.getScheduleable_());
        return consumer;
    }
 
    inline const GlobalOrderingPoint & operator>>(InPort & producer, const GlobalOrderingPoint & consumer) {
        producer.getScheduleable_().precedes(*consumer.getGOPoint());
        return consumer;
    }
 
#ifndef DO_NOT_DOCUMENT
#define __SPARTA_PHASE_ERROR_MSG                                        \
    "\nERROR: You cannot set a precedence on two Scheduleable types"    \
    " that are on different phases.  This will happen automatically by the framework."
#endif
 
    // Start with easy, concrete, derived types
 
    // payloadevent_precedence PayloadEvent Precedence
    // Examples of PayloadEvent precedence
    //
    // PayloadEvent<T, P> >> PayloadEvent<T, P>;
    // PayloadEvent<T, P> >> UniqueEvent<P>;
    // PayloadEvent<T, P> >> SingleCycleUniqueEvent<P>;
    // PayloadEvent<T, P> >> Event<P>;
    // UniqueEvent<P>     >> PayloadEvent<T, P>;
    // SingleCycleUniqueEvent<P> >> PayloadEvent<T, P>;
    // Event<P>           >> PayloadEvent<T, P>;
    //
 
    template<class DataT1, SchedulingPhase PayloadPhaseT1,
             class DataT2, SchedulingPhase PayloadPhaseT2>
    PayloadEvent<DataT2, PayloadPhaseT2> & operator>>(PayloadEvent<DataT1, PayloadPhaseT1> & producer,
                                                      PayloadEvent<DataT2, PayloadPhaseT2> & consumer)
    {
        static_assert(PayloadPhaseT1 == PayloadPhaseT2, __SPARTA_PHASE_ERROR_MSG);
        producer.getScheduleable().precedes(consumer.getScheduleable());
        return consumer;
    }
 
    template<class DataT1,
             SchedulingPhase PayloadPhaseT1,
             SchedulingPhase PayloadPhaseT2>
    UniqueEvent<PayloadPhaseT2> & operator>>(PayloadEvent<DataT1, PayloadPhaseT1> & producer,
                                             UniqueEvent<PayloadPhaseT2> & consumer)
    {
        static_assert(PayloadPhaseT1 == PayloadPhaseT2, __SPARTA_PHASE_ERROR_MSG);
        producer.getScheduleable().precedes(consumer.getScheduleable());
        return consumer;
    }
 
    template<class DataT1,
             SchedulingPhase PayloadPhaseT1,
             SchedulingPhase PayloadPhaseT2>
    SingleCycleUniqueEvent<PayloadPhaseT2> & operator>>(PayloadEvent<DataT1, PayloadPhaseT1> & producer,
                                                        SingleCycleUniqueEvent<PayloadPhaseT2> & consumer)
    {
        static_assert(PayloadPhaseT1 == PayloadPhaseT2, __SPARTA_PHASE_ERROR_MSG);
        producer.getScheduleable().precedes(consumer.getScheduleable());
        return consumer;
    }
 
    template<class DataT1,
             SchedulingPhase PayloadPhaseT1,
             SchedulingPhase PayloadPhaseT2>
    Event<PayloadPhaseT2> & operator>>(PayloadEvent<DataT1, PayloadPhaseT1> & producer,
                                       Event<PayloadPhaseT2> & consumer)
    {
        static_assert(PayloadPhaseT1 == PayloadPhaseT2, __SPARTA_PHASE_ERROR_MSG);
        producer.getScheduleable().precedes(consumer.getScheduleable());
        return consumer;
    }
 
    template<SchedulingPhase PayloadPhaseT1,
             class DataT2,
             SchedulingPhase PayloadPhaseT2>
    PayloadEvent<DataT2, PayloadPhaseT2> & operator>>(UniqueEvent<PayloadPhaseT1> & producer,
                                                      PayloadEvent<DataT2, PayloadPhaseT2> & consumer)
    {
        static_assert(PayloadPhaseT1 == PayloadPhaseT2, __SPARTA_PHASE_ERROR_MSG);
        producer.precedes(consumer.getScheduleable());
        return consumer;
    }
 
    template<SchedulingPhase PayloadPhaseT1,
             class DataT2,
             SchedulingPhase PayloadPhaseT2>
    PayloadEvent<DataT2, PayloadPhaseT2> & operator>>(SingleCycleUniqueEvent<PayloadPhaseT1> & producer,
                                                      PayloadEvent<DataT2, PayloadPhaseT2> & consumer)
    {
        static_assert(PayloadPhaseT1 == PayloadPhaseT2, __SPARTA_PHASE_ERROR_MSG);
        producer.precedes(consumer.getScheduleable());
        return consumer;
    }
 
    template<SchedulingPhase PayloadPhaseT1,
             class DataT2,
             SchedulingPhase PayloadPhaseT2>
    PayloadEvent<DataT2, PayloadPhaseT2> & operator>>(Event<PayloadPhaseT1> & producer,
                                                      PayloadEvent<DataT2, PayloadPhaseT2> & consumer)
    {
        static_assert(PayloadPhaseT1 == PayloadPhaseT2, __SPARTA_PHASE_ERROR_MSG);
        producer.precedes(consumer.getScheduleable());
        return consumer;
    }
 
    // UniqueEvent Precedence
    //
    // UniqueEvent<P> >> UniqueEvent<P>;
    // UniqueEvent<P> >> SingleCycleUniqueEvent<P>;
    // SingleCycleUniqueEvent<P> >> UniqueEvent<P>;
    //
 
    template<SchedulingPhase PayloadPhaseT1,
             SchedulingPhase PayloadPhaseT2>
    UniqueEvent<PayloadPhaseT2> & operator>>(UniqueEvent<PayloadPhaseT1> & producer,
                                             UniqueEvent<PayloadPhaseT2> & consumer)
    {
        static_assert(PayloadPhaseT1 == PayloadPhaseT2, __SPARTA_PHASE_ERROR_MSG);
        producer.precedes(consumer.getScheduleable());
        return consumer;
    }
 
    template<SchedulingPhase PayloadPhaseT1,
             SchedulingPhase PayloadPhaseT2>
    SingleCycleUniqueEvent<PayloadPhaseT2> & operator>>(UniqueEvent<PayloadPhaseT1> & producer,
                                                        SingleCycleUniqueEvent<PayloadPhaseT2> & consumer)
    {
        static_assert(PayloadPhaseT1 == PayloadPhaseT2, __SPARTA_PHASE_ERROR_MSG);
        producer.precedes(consumer.getScheduleable());
        return consumer;
    }
 
    template<SchedulingPhase PayloadPhaseT1,
             SchedulingPhase PayloadPhaseT2>
    UniqueEvent<PayloadPhaseT2> & operator>>(SingleCycleUniqueEvent<PayloadPhaseT1> & producer,
                                             UniqueEvent<PayloadPhaseT2> & consumer)
    {
        static_assert(PayloadPhaseT1 == PayloadPhaseT2, __SPARTA_PHASE_ERROR_MSG);
        producer.precedes(consumer.getScheduleable());
        return consumer;
    }
 
    // SingleCycleUniqueEvent Precedence
    //
    template<SchedulingPhase PhaseT1, SchedulingPhase PhaseT2>
    SingleCycleUniqueEvent<PhaseT2> & operator>>(SingleCycleUniqueEvent<PhaseT1> & producer,
                                                 SingleCycleUniqueEvent<PhaseT2> & consumer)
    {
        static_assert(PhaseT1 == PhaseT2, __SPARTA_PHASE_ERROR_MSG);
        producer.getScheduleable().precedes(consumer.getScheduleable());
        return consumer;
    }
 
    // Event Precedence
    //
    template<SchedulingPhase PhaseT1, SchedulingPhase PhaseT2>
    Event<PhaseT2> & operator>>(Event<PhaseT1> & producer, Event<PhaseT2> & consumer)
    {
        static_assert(PhaseT1 == PhaseT2, __SPARTA_PHASE_ERROR_MSG);
        producer.precedes(consumer.getScheduleable());
        return consumer;
    }
 
    // // Unique Ptrs
    // std::unique_ptr<eventT> >> std::unique_ptr<eventT>;
    // std::unique_ptr<eventT> >> concrete_event;
    // std::unique_ptr<eventT> >> event_pointer;
    // concrete_event >> std::unique_ptr<eventT>;
    // event_pointer >> std::unique_ptr<eventT>;
 
    template<class EventT1, class EventT2>
    std::unique_ptr<EventT2> & operator>>(std::unique_ptr<EventT1> & producer,
                                          std::unique_ptr<EventT2> & consumer)
    {
        (*producer) >> (*consumer);
        return consumer;
    }
 
    template<class EventT1, class EventT2>
    std::unique_ptr<EventT2> & operator>>(EventT1 & producer, std::unique_ptr<EventT2> & consumer)
    {
        producer >> (*consumer);
        return consumer;
    }
 
    template<class EventT1, class EventT2>
    EventT2 & operator>>(std::unique_ptr<EventT1> & producer, EventT2 & consumer)
    {
        (*producer) >> consumer;
        return consumer;
    }
 
    // Scheduleable <-> PayloadEvent
 
    template<class DataT2, SchedulingPhase phase>
    PayloadEvent<DataT2, phase> & operator>>(Scheduleable & producer,
                                             PayloadEvent<DataT2, phase> & consumer)
    {
        sparta_assert(producer.getSchedulingPhase() == consumer.getSchedulingPhase(),
                    __SPARTA_PHASE_ERROR_MSG);
        producer.precedes(consumer.getScheduleable());
        return consumer;
    }
 
    template<class DataT1, SchedulingPhase phase>
    Scheduleable & operator>>(PayloadEvent<DataT1, phase> & producer,
                              Scheduleable & consumer)
    {
        sparta_assert(consumer.getSchedulingPhase() == producer.getSchedulingPhase(),
                    __SPARTA_PHASE_ERROR_MSG);
        producer.getScheduleable().precedes(consumer);
        return consumer;
    }
 
    // Bus Support
 
    // This is where an event must be scheduled before any events
    // scheduled as a results of OutPorts on the Bus.
 
    template<class ScheduleableType>
    typename
    std::enable_if<std::is_base_of<Scheduleable, ScheduleableType>::value, Bus>::
    type & operator>>(ScheduleableType & producer, Bus & consumer)
    {
        consumer.outportsSucceed(producer);
        return consumer;
    }
 
    // This is where an event must be scheduled after data arrival on
    // InPorts within the Bus:
    //
    //  my_incoming_bus >> ev_tick;
    //
 
    template<class ScheduleableType>
    typename
    std::enable_if<std::is_base_of<Scheduleable, ScheduleableType>::value, ScheduleableType>::
    type & operator>>(Bus & producer, ScheduleableType & consumer)
    {
        producer.inportsPrecede(consumer);
        return consumer;
    }
 
    // Add support for a group of event types
 
    class EventGroup : public std::vector<Scheduleable *>
    {
        // Make sure no one is adding a Port in the mix (this was the
        // old framework)
        template<SchedulingPhase phase, class ScheduleableT, class ...ArgsT>
        typename std::enable_if<std::is_base_of<Port, ScheduleableT>::value, void>::
        type addScheduable_(ScheduleableT & /*port*/, ArgsT&... /*scheds*/) {
            static_assert(std::is_base_of<Port, ScheduleableT>::value,
                          "\nERROR: You cannot set up a precedence between an Scheduleable type and a Port. "
                          "\n\tIf you want to do this, register the Scheduleable with the Port using the "
                          "registerConsumerEvent/registerProducingEvent method on the Port."
                          "\n\tSee the SPARTA documentation for more information."
                          "\n\tBTW, in this particular error, there is a Port type in the EventGroup that's bad");
        }
 
        // Add a Scheduable type, not a PayloadEventType
        template<SchedulingPhase phase, class ScheduleableT, class ...ArgsT>
        typename std::enable_if<std::is_base_of<sparta::Scheduleable, ScheduleableT>::value, void>::
        type addScheduable_(ScheduleableT & sched, ArgsT&... scheds) {
            static_assert(phase == ScheduleableT::event_phase,
                          "\nERROR: You cannot set a precedence on two Scheduleable types"
                          " that are on different phases.  This will happen automatically by the framework."
                          "\n\tIn this particular error, there is a Scheduleable type in the EventGroup that's bad");
            emplace_back(&sched);
            addScheduable_<ScheduleableT::event_phase>(scheds...);
        }
 
        // Need a specialization for PayloadEvents since they are not direct Scheduleables
        template<SchedulingPhase phase, class DataT, SchedulingPhase PLEPhase, class ...ArgsT>
        void addScheduable_(PayloadEvent<DataT, PLEPhase> & sched, ArgsT&... scheds) {
            static_assert(phase == PLEPhase,
                          "\nERROR: You cannot set a precedence on two Scheduleable types"
                          " that are on different phases.  This will happen automatically by the framework."
                          "\n\tIn this particular error, there is a PayloadEvent type in the EventGroup that's bad");
            emplace_back(&sched.getScheduleable());
            addScheduable_<PLEPhase>(scheds...);
        }
 
        // end of list
        template<SchedulingPhase phase>
        void addScheduable_() {}
 
    public:
 
        template<class ScheduleableT, class ...ArgsT>
        explicit EventGroup(ScheduleableT & sched, ArgsT&...scheds) {
            static_assert(std::is_same<Port, ScheduleableT>::value == false,
                          "\nERROR: You cannot add Ports to a precedence group as Ports do not support precedence. "
                          "If you have a zero-cycle Port and a receiving event, register that event with the Port instead."
                          "\n\tIn this particular error, there is a Port type in the EventGroup that's bad");
            static_assert(std::is_same<Bus, ScheduleableT>::value == false,
                          "\nERROR: You cannot add a Bus to a precedence group as Buses do not support precedence directly. "
                          "\n\tInstead, use Bus' inportsPrecede(event) or outportsSucceed(event) methods OR the >> operator.");
            addScheduable_<ScheduleableT::event_phase>(sched, scheds...);
        }
 
        template<class DataT, SchedulingPhase PhaseT, class ...ArgsT>
        explicit EventGroup(PayloadEvent<DataT, PhaseT> & sched, ArgsT&...scheds) {
            addScheduable_<PhaseT>(sched, scheds...);
        }
 
    };
 
    template<class ScheduleableTypeB>
    ScheduleableTypeB & operator>>(const EventGroup & producers,
                                   ScheduleableTypeB & consumer)
    {
        for(auto & prod : producers) {
            prod->precedes(consumer);
        }
        return consumer;
    }
 
    template<class ScheduleableTypeA>
    const EventGroup & operator>>(ScheduleableTypeA & producer,
                                  const EventGroup & consumers)
    {
        for(auto & cons : consumers) {
            producer.precedes(*cons);
        }
        return consumers;
    }
 
    inline const EventGroup & operator>>(const EventGroup & producers,
                                         const EventGroup & consumers)
    {
        for(auto & prod : producers) {
            for(auto & cons : consumers) {
                sparta_assert(prod->getSchedulingPhase() == cons->getSchedulingPhase(),
                                  "The scheduling phase of '"
                                  << prod->getLabel() << "' phase '" << prod->getSchedulingPhase()
                                  << "' does not equal the scheduling phase of '"
                                  << cons->getLabel() << "' phase '" << cons->getSchedulingPhase()
                                  <<"'");
 
                prod->precedes(cons);
            }
        }
        return consumers;
    }
 
}