Precedence.hpp File Reference

File that defines Precedence operator>> rules between EventNode types. More...

#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"

Go to the source code of this file.

Classes
class	sparta::EventGroup
	Group a series of events together for precedence establishment. More...

Namespaces
namespace	sparta
	Macros for handling exponential backoff.

Functions
template<class ScheduleableTypeA >
std::enable_if< std::is_base_of< EventNode, ScheduleableTypeA >::value, constGlobalOrderingPoint >::type &	sparta::operator>> (ScheduleableTypeA &producer, const GlobalOrderingPoint &consumer)
	Place a precedence between a Scheduleable object and a GlobalOrderingPoint.
template<class ScheduleableTypeA >
std::enable_if< std::is_base_of< EventNode, ScheduleableTypeA >::value, ScheduleableTypeA >::type &	sparta::operator>> (const GlobalOrderingPoint &producer, ScheduleableTypeA &consumer)
	Place a precedence between a Scheduleable object and a GlobalOrderingPoint.
InPort &	sparta::operator>> (const GlobalOrderingPoint &producer, InPort &consumer)
	Place a precedence between a GlobalOrderingPoint and an InPort.
const GlobalOrderingPoint &	sparta::operator>> (InPort &producer, const GlobalOrderingPoint &consumer)
	Place a precedence between a Scheduleable object and a GlobalOrderingPoint.
template<class DataT1 , SchedulingPhase PayloadPhaseT1, class DataT2 , SchedulingPhase PayloadPhaseT2>
PayloadEvent< DataT2, PayloadPhaseT2 > &	sparta::operator>> (PayloadEvent< DataT1, PayloadPhaseT1 > &producer, PayloadEvent< DataT2, PayloadPhaseT2 > &consumer)
	Place a precedence between a PayloadEvent and another PayloadEvent.
template<class DataT1 , SchedulingPhase PayloadPhaseT1, SchedulingPhase PayloadPhaseT2>
UniqueEvent< PayloadPhaseT2 > &	sparta::operator>> (PayloadEvent< DataT1, PayloadPhaseT1 > &producer, UniqueEvent< PayloadPhaseT2 > &consumer)
	Place a precedence between a PayloadEvent and UniqueEvent.
template<class DataT1 , SchedulingPhase PayloadPhaseT1, SchedulingPhase PayloadPhaseT2>
SingleCycleUniqueEvent< PayloadPhaseT2 > &	sparta::operator>> (PayloadEvent< DataT1, PayloadPhaseT1 > &producer, SingleCycleUniqueEvent< PayloadPhaseT2 > &consumer)
	Place a precedence between a PayloadEvent and SingleCycleUniqueEvent.
template<class DataT1 , SchedulingPhase PayloadPhaseT1, SchedulingPhase PayloadPhaseT2>
Event< PayloadPhaseT2 > &	sparta::operator>> (PayloadEvent< DataT1, PayloadPhaseT1 > &producer, Event< PayloadPhaseT2 > &consumer)
	Place a precedence between a PayloadEvent and an Event.
template<SchedulingPhase PayloadPhaseT1, class DataT2 , SchedulingPhase PayloadPhaseT2>
PayloadEvent< DataT2, PayloadPhaseT2 > &	sparta::operator>> (UniqueEvent< PayloadPhaseT1 > &producer, PayloadEvent< DataT2, PayloadPhaseT2 > &consumer)
	Place a precedence between a PayloadEvent and an UniqueEvent.
template<SchedulingPhase PayloadPhaseT1, class DataT2 , SchedulingPhase PayloadPhaseT2>
PayloadEvent< DataT2, PayloadPhaseT2 > &	sparta::operator>> (SingleCycleUniqueEvent< PayloadPhaseT1 > &producer, PayloadEvent< DataT2, PayloadPhaseT2 > &consumer)
	Place a precedence between a PayloadEvent and an SingleCycleUniqueEvent.
template<SchedulingPhase PayloadPhaseT1, class DataT2 , SchedulingPhase PayloadPhaseT2>
PayloadEvent< DataT2, PayloadPhaseT2 > &	sparta::operator>> (Event< PayloadPhaseT1 > &producer, PayloadEvent< DataT2, PayloadPhaseT2 > &consumer)
	Place a precedence between a Event and an PayloadEvent.
template<SchedulingPhase PayloadPhaseT1, SchedulingPhase PayloadPhaseT2>
UniqueEvent< PayloadPhaseT2 > &	sparta::operator>> (UniqueEvent< PayloadPhaseT1 > &producer, UniqueEvent< PayloadPhaseT2 > &consumer)
	Place a precedence between a UniqueEvent and an UniqueEvent.
template<SchedulingPhase PayloadPhaseT1, SchedulingPhase PayloadPhaseT2>
SingleCycleUniqueEvent< PayloadPhaseT2 > &	sparta::operator>> (UniqueEvent< PayloadPhaseT1 > &producer, SingleCycleUniqueEvent< PayloadPhaseT2 > &consumer)
	Place a precedence between a UniqueEvent and an SingleCycleUniqueEvent.
template<SchedulingPhase PayloadPhaseT1, SchedulingPhase PayloadPhaseT2>
UniqueEvent< PayloadPhaseT2 > &	sparta::operator>> (SingleCycleUniqueEvent< PayloadPhaseT1 > &producer, UniqueEvent< PayloadPhaseT2 > &consumer)
	Place a precedence between a SingleCycleUniqueEvent and an UniqueEvent.
template<SchedulingPhase PhaseT1, SchedulingPhase PhaseT2>
SingleCycleUniqueEvent< PhaseT2 > &	sparta::operator>> (SingleCycleUniqueEvent< PhaseT1 > &producer, SingleCycleUniqueEvent< PhaseT2 > &consumer)
	Place a precedence between a SingleCycleUniqueEvent and a SingleCycleUniqueEvent.
template<SchedulingPhase PhaseT1, SchedulingPhase PhaseT2>
Event< PhaseT2 > &	sparta::operator>> (Event< PhaseT1 > &producer, Event< PhaseT2 > &consumer)
	Place a precedence between a Event and another Event.
template<class EventT1 , class EventT2 >
std::unique_ptr< EventT2 > &	sparta::operator>> (std::unique_ptr< EventT1 > &producer, std::unique_ptr< EventT2 > &consumer)
	Place a precedence between a std::unique_ptr<EventT1> and another std::unique_ptr<EventT2>
template<class EventT1 , class EventT2 >
std::unique_ptr< EventT2 > &	sparta::operator>> (EventT1 &producer, std::unique_ptr< EventT2 > &consumer)
	Place a precedence between an EventT1 and std::unique_ptr<EventT2>
template<class EventT1 , class EventT2 >
EventT2 &	sparta::operator>> (std::unique_ptr< EventT1 > &producer, EventT2 &consumer)
	Place a precedence between a std::unique_ptr<EventT1> and EventT2.
template<class DataT2 , SchedulingPhase phase>
PayloadEvent< DataT2, phase > &	sparta::operator>> (Scheduleable &producer, PayloadEvent< DataT2, phase > &consumer)
	Place a precedence between a Scheduleable and a PayloadEvent.
template<class DataT1 , SchedulingPhase phase>
Scheduleable &	sparta::operator>> (PayloadEvent< DataT1, phase > &producer, Scheduleable &consumer)
	Place a precedence between a PayloadEvent and a Scheduleable.
template<class ScheduleableType >
std::enable_if< std::is_base_of< Scheduleable, ScheduleableType >::value, Bus >::type &	sparta::operator>> (ScheduleableType &producer, Bus &consumer)
	Place a precedence between a Scheduleable and a Bus.
template<class ScheduleableType >
std::enable_if< std::is_base_of< Scheduleable, ScheduleableType >::value, ScheduleableType >::type &	sparta::operator>> (Bus &producer, ScheduleableType &consumer)
	Place a precedence between a Bus and a Scheduleable.
template<class ScheduleableTypeB >
ScheduleableTypeB &	sparta::operator>> (const EventGroup &producers, ScheduleableTypeB &consumer)
template<class ScheduleableTypeA >
const EventGroup &	sparta::operator>> (ScheduleableTypeA &producer, const EventGroup &consumers)
const EventGroup &	sparta::operator>> (const EventGroup &producers, const EventGroup &consumers)

Detailed Description

File that defines Precedence operator>> rules between EventNode types.

Definition in file Precedence.hpp.