The Sparta Modeling Framework
|
Macros for handling exponential backoff. More...
Namespaces | |
namespace | app |
Sparta Application framework. | |
namespace | exp_backoff |
Contains utilities and types of exponential backoff helpers. | |
namespace | log |
Diagnostic logging framework. This node generates logging messages of a specific category. | |
namespace | memory |
Namespace containing memory interfaces, types, and storage objects. | |
namespace | statistics |
Namespace containing methods for computing and generating statistical information using instrumentation extracted from sparta structures such as Counters. | |
Classes | |
class | __RegisterDefintionSet |
Type that holds a set of register definitions. More... | |
class | ArchData |
Contains a set of contiguous line of architectural data which can be referred to by any architected object model. When layout() is called, reserves space for each element in a registered set of ArchDataSegment instances at offsets within Lines within the ArchData. More... | |
class | ArchDataContainer |
Container class for any number of ArchData pointers owned externally. More... | |
class | ArchDataSegment |
class | Array |
Array is essentially a fixed size vector, maintains a concept of validity of its indexes, and provides access via stl iteration and general get methods. More... | |
class | AssertContext |
Creates a helper traits class for determining whehther a type has a member named getClock. More... | |
class | AssignOnceObject |
Object which can only have it's value set once. Throws exception if being set more than once. More... | |
class | AsyncEvent |
In a multi-threaded sim environment, this event is used to schedule an event asynchronously. More... | |
class | Audience |
Class used maintain a list of sparta::Scheduleable objects; used by observation-type classes. More... | |
class | BasicHistogram |
class | Baz |
struct | bit_reference_to_bool |
Helper type for converting _Bit_reference types into bool types for the purpose of determining how to lexically cast a string into that type. More... | |
struct | bit_reference_to_bool< typename std::_Bit_reference > |
class | BoolEnum |
The class responsible for handling State<bool> instances and converts bool instances into actual EnumTValueType instances to satisfy exisiting function signatures. More... | |
class | bounded_int |
Bounded integer type with range-checking. More... | |
class | Buffer |
A data structure allowing appending at the end, beginning, or middle, but erase anywhere with collapse. More... | |
class | Bus |
Class that defines a Bus type. More... | |
class | BusSet |
A TreeNode that represents a set of Buses. More... | |
class | CircularBuffer |
A data structure allowing appending at the end, beginning, or insert in the middle, but erase anywhere with collapse. More... | |
class | Clock |
A representation of simulated time. More... | |
class | ClockManager |
Manages building a clock tree. More... | |
class | ContextCounter |
A container type that allows a modeler to build, store, and charge counts to a specific context. More... | |
class | Counter |
Represents a counter of type counter_type (uint64_t). 2 and greater than 0 with a ceiling specified. A ceiling value that is a power of two is optimized to perform operations faster. More... | |
class | CounterBase |
The base class for all Counters. More... | |
class | CycleCounter |
Represents a cycle counter. More... | |
class | CycleHistogramBase |
CycleHistogramBase class for uint64_t values. More... | |
class | CycleHistogramStandalone |
CycleHistogramStandalone class for uint64_t values. More... | |
class | CycleHistogramTreeNode |
CycleHistogramTreeNode class for uint64_t values. More... | |
class | DAG |
class | DataContainer |
Used by DataInPort and SyncInPort, this class holds received data from these ports and remembers the time in which the data was set. It also maintains the validity of the data. More... | |
class | DataInPort |
DataInPort receives data from sender using a DataOutPort. More... | |
class | DataOutPort |
DataOutPort is used for transferring any data to another module. More... | |
class | DataView |
View into a backend block of memory in an ArchData. More... | |
class | DynamicResourceTreeNode |
TreeNode subclass representing a node in the device tree which creates and owns a resource. This node is created at run-time and, although it takes a parameter set at construction, is not part of the SPARTA configuration phase and is not user configurable through any sparta::ParameterSet. More... | |
class | EnumCycleHistogram |
EnumCycleHistogram class for C++ Enum values. More... | |
class | EnumHistogram |
EnumHistogram class for sparta::utils::Enum. More... | |
class | Event |
Event is a simple class for scheduling random events on the Scheduler. More... | |
class | EventGroup |
Group a series of events together for precedence establishment. More... | |
class | EventNode |
EventNode is the base class for all event types in SPARTA. Not to be used by the modeler. Its main purpose is to look for a clock and scheduler for the event. More... | |
class | EventSet |
Set of Events that a unit (or sparta::TreeNode, sparta::Resource) contains and are visible through a sparta Tree. More... | |
class | ExportedPort |
Class that "exports" a port that's contained in the same ResourceTreeNode structure. More... | |
class | ExtensionDescriptor |
Descriptor class which provides basic information about an extended tree node: device tree location, extension name, and parameter name-values. More... | |
class | ExtensionsParamsOnly |
Helper class used to trivially extend TreeNode parameter sets (but not any additional functionality beyond that) More... | |
class | FrontArray |
a type of Array with special allocation policies to support writing to the front most valid entry in the Array, as well as reading the nth valid entry in the array. More... | |
class | FunctionManager |
Singleton Function Manager class. This class contains two maps and one constant string token. These maps contain a string as key and function pointers as value. The string key is the same as the name of the free functions as defined by the users and the keys are the function pointers to those methods. One map is dedicated for HistogramTreeNodes while the other is dedicated for CycleHistogramTreeNodes. This was necessary because these two classes do not share a common polymorphic base. More... | |
class | FutureStatisticRange |
Exception indicating that the range of a StatisticInstance starts or ends in the future (probably caused by to checkpointing) More... | |
class | GlobalEvent |
A type of "global" reusable event. More... | |
class | GlobalEventProxy |
A helper class of GlobalEvent. More... | |
class | GlobalOrderingPoint |
Used to set precedence between Scheduleable types across simulation. More... | |
class | GlobalTreeNode |
TreeNode which represents some "global" namespace of the device tree, containing only RootTreeNodes, for performing searches. More... | |
class | HistogramBase |
Histogram base class for uint64_t values. More... | |
class | HistogramStandalone |
class | HistogramTreeNode |
class | InPort |
Base class for all InPort types. More... | |
class | InstrumentationNode |
Base class requiring. More... | |
class | IntParameterSet |
struct | is_sparta_enum |
Detect whether template parameter is sparta::utils::Enum type. More... | |
struct | is_sparta_enum< sparta::utils::Enum< T > > |
Detect whether template parameter is sparta::utils::Enum type. More... | |
struct | is_vector |
Templated for determining if ValueType is std::vector for use in metaprogramming constructs. This is intended to be be consumed by enable_if. More... | |
struct | is_vector< std::vector< T > > |
class | KeyValue |
The type-to-type name map. Not really necessary, but useful. More... | |
class | LineStringStream |
Helper class for building a set of lines through an ostream-like interface. More... | |
class | MemoryProfiler |
Utility used to periodically collect heap usage statistics throughout a simulation. Supported phases for inspection include Build, Configure, Bind, and Simulate. More... | |
class | MirrorNotificationSource |
essentially a pass through notification source that is a placeholder in a shadow tree. More... | |
class | NotificationSource |
A TreeNode that generates a specific type of notification which propagates up a tree of TreeNodes (using the NotificationPropagator base class. More... | |
class | NotificationSourceBase |
A TreeNode that generates a single specific type of notification which propagates up a tree of TreeNodes using TreeNode's builtin functionality. More... | |
class | ObjectAllocator |
class | OneWayBool |
Boolean with a default capable of being changed to the opposite value only. it can never set to the default even if already at the default value. More... | |
class | OutPort |
Base class for all OutPort types. More... | |
class | Parameter |
Parameter instance, templated to contain only a specific type. More... | |
class | ParameterBase |
Non-templated base class for generic parameter access and iteration. More... | |
class | ParameterException |
Exception indicating a misconfigured Parameter or invalid Parameter access. More... | |
class | ParameterSet |
Generic container of Parameters. More... | |
class | ParameterTree |
Virtual Parameter Tree. This represents a tree of parameters read from some source but does not necessarily correspond to the parameters in the simulation itself or even to the simulation tree. This is meant to provide a hierarchical view into simulation parameters before they are actually applied to a real TreeNode tree. More... | |
class | PayloadEvent |
Class to schedule a Scheduleable in the future with a payload, typed on both the data type and the scheduling phase. This is the preferred class to use in simulation, but the main API is found in sparta::PhasedPayloadEvent. More... | |
class | PhasedObject |
Object having a specific phase in the sparta construction paradigm. More... | |
class | PhasedPayloadEvent |
Class to schedule a Scheduleable in the future with a payload, but the class itself is not typed on the phase, but is constructed with one. The preference, however, is for the modeler to use sparta::PayloadEvent instead. More... | |
class | PhasedSingleCycleUniqueEvent |
An event that can only be schedule one cycle into the future. More... | |
class | PhasedUniqueEvent |
A type of Event that uniquely schedules itself on the schedule within a single time quantum. This UniqueEvent is not typed on the SchedulingPhase. It is discouraged to use this class – use UniqueEvent templatized on the SchedulingPhase. More... | |
class | Pipe |
A very simple pipe, not part of the DES paradigm. More... | |
class | Pipeline |
A simple pipeline. More... | |
class | Port |
The port interface used to bind port types together and defines a port behavior. More... | |
class | PortSet |
A TreeNode that represents a set of ports used by a Resource. More... | |
class | PostRunValidationInfo |
Information describing the type of validation being done. More... | |
class | PriorityQueue |
A data structure that allows pushing/emplacing into it with a given sorter. More... | |
struct | ptr_to_const_obj_ptr |
Template type helper that removes a pointer, adds a const, and then re-adds the pointer. This is useful to turn "T" [T=U*] into "U const *" in places where simply using "const T" results in "U* const". More... | |
class | Queue |
A data structure that allows appending at the back and invalidating from the front. More... | |
class | ReadOnlyCounter |
Represents a non-writable and non-observable counter with a very similar interface to sparta::Counter. The value of this counter In most cases, a normal counter should be used. However, if a value must be stored as an integer outside of counter for any reason, a ReadOnly counter can be used to wrap that value and expose it to sparta Report and statistics infrastructure. More... | |
class | Register |
An implementation of a RegisterBase. More... | |
class | RegisterBankTable |
Container of register banks as a helper for RegisterSet. Instances of this class will be owned by a single RegisterSet. More... | |
class | RegisterBase |
Base class to represents an architected register of any size that is a power of 2 and greater than 0 with a ceiling specified. More... | |
class | RegisterBits |
class | RegisterProxy |
Represents an interface to a pseudo-"Register" of a fixed size which indirectly references other registers (having the same group num, group idx, and size) depending on simulator state. Essentially, this hides banking and register aliasing (shared data) information from the client of this interface which is useful for presenting debugginer-visible and software-visible registers without regard for the underlying banking or aliasing. More... | |
class | RegisterProxyBase |
class | RegisterSet |
Holds and can create a set of Register objects having various names and groups. More... | |
class | Resource |
The is the base class for all types of resources used by the SPARTA framework. More... | |
class | ResourceContainer |
PhasedObject which can hold 0 or 1 Resource pointers to an associatedresource. Contains logic for setting and getting the associated Resource. More... | |
class | ResourceFactory |
Templated ResourceFactoryBase implementation which can be used to trivially define Resource Factories. More... | |
class | ResourceFactoryBase |
Factory which can create Resources as well as the Parameter sets that can be modified before actually instantiating the resources themselves. Packages providing resources to the simulator implement this interface. More... | |
class | ResourceSet |
Set of published ResourceFactories which can be referenced by name. More... | |
class | ResourceTreeNode |
TreeNode subclass representing a node in the device tree which contains a single ResourceFactory and a sparta::ParameterSet. A ResourceTreeNode is also associated with a clock. More... | |
class | ReversedStatisticRange |
Exception indicating that the range of a StatisticInstance was reversed when it was accessed (probably caused by checkpointing) More... | |
class | RootTreeNode |
TreeNode which represents the root ("top") of a device tree. More... | |
class | Scheduleable |
A class that defines the basic scheduling interface to the Scheduler. Not intended to be used by modelers directly, but certainly can be. More... | |
class | ScheduleableHandle |
A light-weight reference counting handle for Scheduleables – DOES NOT delete. More... | |
class | Scheduler |
A class that lets you schedule events now and in the future. More... | |
class | Scoreboard |
Class used to track operand dependencies (timed) between units. More... | |
class | ScoreboardView |
A ScoreboardView is a view into the master Scoreboard for operand readiness. More... | |
class | SharedData |
Class that allows the writing of data this cycle, but not visable until next cycle. More... | |
class | SignalInPort |
SignalInPort receives data from sender using a SignalOutPort. More... | |
class | SignalOutPort |
SignalOutPort is used for transferring a simple signal to another module. More... | |
class | SimulationInfo |
Contains information describing the simulation instance for the purpose of identifying the simulation and possible recreating it. This information should be written to all log files, reports, cmdline, etc. More... | |
class | SingleCycleUniqueEvent |
An event that can only be schedule one cycle into the future. More... | |
class | SpartaCriticalError |
Indicates something went seriously wrong and likely indicates corruption in simulator runtime state. More... | |
class | SpartaException |
Used to construct and throw a standard C++ exception. Inherits from std::exception. More... | |
class | SpartaFatalError |
Indicates something went seriously wrong and likely indicates unrecoverable corruption in simulator runtime state or misuse. This is the only exception that should ever be generated by a destructor since its semantics are that the simulation should terminate. More... | |
class | SpartaSharedPointer |
Used for garbage collection, will delete the object it points to when all objects are finished using it. More... | |
class | SpartaSharedPointerAllocator |
A memory allocator complementing SpartaSharedPointer that reuses old memory. More... | |
class | SpartaStaticInitializer |
Static-initialization order controller. More... | |
class | SpartaTester |
A simple testing class. More... | |
class | SpartaWeakPointer |
Like in STL, create a weak pointer to a SpartaSharedPointer. More... | |
class | StartupEvent |
StartupEvent is a simple class for scheduling a starting event on the Scheduler. It does not support precedence. More... | |
class | State |
The State class for watching transition between enum states. More... | |
class | State< T, typename std::enable_if< std::is_same< T, PhasedObject::TreePhase >::value >::type > |
class | StateHistogram |
StateHistogram class for uint64_t values. More... | |
class | StateTimerUnit |
A high level wrapper contains the StateTimerPool and StateTimerHistogram. More... | |
class | StatInstCalculator |
class | StatisticDef |
Contains a statistic definition (some useful information which can be computed) More... | |
class | StatisticInstance |
Instance of either a StatisticDef or CounterBase or an Expression. Has a sample window (simulator ticks) over which it will compute the value of the contained expression/counter for that range. More... | |
class | StatisticSet |
Set of StatisticDef and CounterBase-derived objects for visiblility through a sparta Tree. More... | |
class | StringManager |
Manages string internment for SPARTA. This allows strings to be compared by pointer once interned. More... | |
class | SyncInPort |
Class that defines an synchronized input port on modules on two different clocks. More... | |
class | SyncOutPort |
Class that defines a synchronized SyncOutPort for data writes on different clocks. More... | |
class | SysCSpartaSchedulerAdapter |
Class that "connects" Sparta to SystemC. More... | |
class | Tag |
Tag(): Simple class to provide nested sequence numbering. More... | |
class | TieredMap |
N-Tier lookup map for sparse-representation of large memory spaces. This is essentially a M-Tree where the child lookup at each node is a simple offset computed by a rshift and mask. More... | |
class | TimeManager |
Singleton which manages wall-clock time for simulations in SPARTA This is not a "timer" manager, but rather an information service and could possible become a timing interval manager. More... | |
class | TreeNode |
Node in a composite tree representing a sparta Tree item. More... | |
class | TreeNodePrivateAttorney |
class | UniqueEvent |
A type of Event that uniquely schedules itself on the schedule within a single time quantum. This class is typed on the SchedulingPhase and is the preferred type to use for UniqueEvent use, but the main API is found in PhasedUniqueEvent. More... | |
class | Unit |
The is the base class for user defined blocks in simulation. More... | |
class | ValidationCheckCallback |
Delegate for Parameter validation. More... | |
class | VirtualGlobalTreeNode |
Virtual global node for all device trees in a single simulation. This node acts a potential notification observation point for every node in the simulation regardless hierarchy. More... | |
class | WeightedContextCounter |
This is an example context counter subclass used to show how users may supply their own "aggregated value calculation" method via the REGISTER_CONTEXT_COUNTER_AGGREGATE_FCN macro. More... | |
Typedefs | |
using | RegisterDefinitionSet = __RegisterDefintionSet< sparta::RegisterBase > |
using | ProxyDefinitionSet = __RegisterDefintionSet< sparta::RegisterProxyBase > |
typedef std::shared_ptr< std::unordered_map< uint32_t, std::vector< sparta::Clock::Cycle > * > > | StateTimerDataContainerPtr |
typedef std::vector< std::unique_ptr< ExtensionDescriptor > > | ExtensionDescriptorVec |
using | CycleHistogram = CycleHistogramTreeNode |
typedef HistogramTreeNode | Histogram |
template<typename T > | |
using | HistStatCalcFcn = double(*)(const T *) |
Enumerations | |
enum class | SchedulingPhase { Update , PortUpdate , Flush , Collection , Tick , PostTick } |
The SchedulingPhases used for events (Tick, Update, PortUpdate, etc) More... | |
enum class | ArrayType { NORMAL , AGED } |
Defines how a sparta::Array should behave. The array will have different features depending on the type. More... | |
enum | ByteOrder { LE = 0 , BE = 1 } |
Byte order enum for read/write methods. More... | |
Functions | |
template<typename T > | |
std::enable_if< std::is_same< T, app::FeatureConfiguration >::value, bool >::type | IsFeatureValueEqualTo (const T &cfg, const std::string &feature_name, const unsigned int feature_value) |
template<typename T > | |
std::enable_if< MetaStruct::is_any_pointer< T >::value, bool >::type | IsFeatureValueEqualTo (const T &cfg, const std::string &feature_name, const unsigned int feature_value) |
template<typename T > | |
std::enable_if< std::is_same< T, app::FeatureConfiguration >::value, bool >::type | IsFeatureValueEnabled (const T &cfg, const std::string &feature_name) |
template<typename T > | |
std::enable_if< MetaStruct::is_any_pointer< T >::value, bool >::type | IsFeatureValueEnabled (const T &cfg, const std::string &feature_name) |
template<typename T > | |
std::enable_if< std::is_same< T, app::FeatureConfiguration >::value, constapp::FeatureConfiguration::FeatureOptions * >::type | GetFeatureOptions (const T &cfg, const std::string &feature_name) |
template<typename T > | |
std::enable_if< MetaStruct::is_any_pointer< T >::value, constapp::FeatureConfiguration::FeatureOptions * >::type | GetFeatureOptions (const T &cfg, const std::string &feature_name) |
std::ostream & | operator<< (std::ostream &o, const SimulationInfo &info) |
ostream insertion operator for SimulationInfo | |
template<class ScheduleableTypeA > | |
std::enable_if< std::is_base_of< EventNode, ScheduleableTypeA >::value, constGlobalOrderingPoint >::type & | 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 & | operator>> (const GlobalOrderingPoint &producer, ScheduleableTypeA &consumer) |
Place a precedence between a Scheduleable object and a GlobalOrderingPoint. | |
InPort & | operator>> (const GlobalOrderingPoint &producer, InPort &consumer) |
Place a precedence between a GlobalOrderingPoint and an InPort. | |
const GlobalOrderingPoint & | 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 > & | 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 > & | 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 > & | 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 > & | 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 > & | 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 > & | 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 > & | operator>> (Event< PayloadPhaseT1 > &producer, PayloadEvent< DataT2, PayloadPhaseT2 > &consumer) |
Place a precedence between a Event and an PayloadEvent. | |
template<SchedulingPhase PayloadPhaseT1, SchedulingPhase PayloadPhaseT2> | |
UniqueEvent< PayloadPhaseT2 > & | operator>> (UniqueEvent< PayloadPhaseT1 > &producer, UniqueEvent< PayloadPhaseT2 > &consumer) |
Place a precedence between a UniqueEvent and an UniqueEvent. | |
template<SchedulingPhase PayloadPhaseT1, SchedulingPhase PayloadPhaseT2> | |
SingleCycleUniqueEvent< PayloadPhaseT2 > & | operator>> (UniqueEvent< PayloadPhaseT1 > &producer, SingleCycleUniqueEvent< PayloadPhaseT2 > &consumer) |
Place a precedence between a UniqueEvent and an SingleCycleUniqueEvent. | |
template<SchedulingPhase PayloadPhaseT1, SchedulingPhase PayloadPhaseT2> | |
UniqueEvent< PayloadPhaseT2 > & | operator>> (SingleCycleUniqueEvent< PayloadPhaseT1 > &producer, UniqueEvent< PayloadPhaseT2 > &consumer) |
Place a precedence between a SingleCycleUniqueEvent and an UniqueEvent. | |
template<SchedulingPhase PhaseT1, SchedulingPhase PhaseT2> | |
SingleCycleUniqueEvent< PhaseT2 > & | operator>> (SingleCycleUniqueEvent< PhaseT1 > &producer, SingleCycleUniqueEvent< PhaseT2 > &consumer) |
Place a precedence between a SingleCycleUniqueEvent and a SingleCycleUniqueEvent. | |
template<SchedulingPhase PhaseT1, SchedulingPhase PhaseT2> | |
Event< PhaseT2 > & | 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 > & | 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 > & | 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 & | 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 > & | operator>> (Scheduleable &producer, PayloadEvent< DataT2, phase > &consumer) |
Place a precedence between a Scheduleable and a PayloadEvent. | |
template<class DataT1 , SchedulingPhase phase> | |
Scheduleable & | 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 & | 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 & | operator>> (Bus &producer, ScheduleableType &consumer) |
Place a precedence between a Bus and a Scheduleable. | |
template<class ScheduleableTypeB > | |
ScheduleableTypeB & | operator>> (const EventGroup &producers, ScheduleableTypeB &consumer) |
template<class ScheduleableTypeA > | |
const EventGroup & | operator>> (ScheduleableTypeA &producer, const EventGroup &consumers) |
const EventGroup & | operator>> (const EventGroup &producers, const EventGroup &consumers) |
Scheduleable & | operator>> (Scheduleable &producer, Scheduleable &consumer) |
std::ostream & | operator<< (std::ostream &os, const SchedulingPhase &phase) |
Print the SchedulingPhase. | |
bool | operator== (const RegisterBase::Definition &a, const RegisterBase::Definition &b) |
bool | operator!= (const RegisterBase::Definition &a, const RegisterBase::Definition &b) |
bool | operator== (const RegisterProxyBase::Definition &a, const RegisterProxyBase::Definition &b) |
bool | operator!= (const RegisterProxyBase::Definition &a, const RegisterProxyBase::Definition &b) |
std::ostream & | operator<< (std::ostream &os, const DAG &d) |
std::ostream & | operator<< (std::ostream &os, const DAG *d) |
std::ostream & | operator<< (std::ostream &o, const NotificationSourceBase::ObservationStateCallback &osc) |
std::ostream & | operator<< (std::ostream &o, const NotificationSourceBase::ObservationStateCallback *osc) |
void | bind (Bus *p1, Bus *p2) |
Bind two buses together. | |
void | bind (Bus &p1, Bus &p2) |
Bind two buses together. | |
void | bind (Bus *p1, Bus &p2) |
Bind two buses together. | |
void | bind (Bus &p1, Bus *p2) |
Bind two buses together. | |
void | bind (Port *p1, Port *p2) |
Bind two ports together. | |
void | bind (Port &p1, Port &p2) |
Bind two ports together. | |
void | bind (Port *p1, Port &p2) |
Bind two ports together. | |
void | bind (Port &p1, Port *p2) |
Bind two ports together. | |
std::string | printBitSet (const Scoreboard::RegisterBitMask &bits) |
std::ostream & | operator<< (std::ostream &os, const sparta::Clock &clk) |
Scheduler::Tick | calculateClockCrossingDelay (Scheduler::Tick src_delay, const Clock *src_clk, Scheduler::Tick dst_delay, const Clock *dst_clk) |
Scheduler::Tick | calculateReverseClockCrossingDelay (Scheduler::Tick dst_arrival_tick, Scheduler::Tick src_delay, const Clock *src_clk, Scheduler::Tick dst_delay, const Clock *dst_clk) |
std::ostream & | operator<< (std::ostream &os, const ClockManager &m) |
template<typename T > | |
T | smartLexicalCast (const ParameterBase *p, const std::string &s, size_t &end_pos, bool allow_recursion=true, bool allow_prefix=true) |
smartLexicalCast wrapper with parameter information added to exceptions | |
std::ostream & | operator<< (std::ostream &o, const ParameterTree::Node &n) |
std::ostream & | operator<< (std::ostream &o, const ParameterTree::Node *n) |
template<class Ch , class Tr > | |
std::basic_ostream< Ch, Tr > & | operator<< (std::basic_ostream< Ch, Tr > &out, sparta::TreeNode const &tn) |
TreeNode stream operator. | |
std::ostream & | operator<< (std::ostream &out, sparta::TreeNode const *tn) |
TreeNode stream operator. | |
ExtensionDescriptorVec | createExtensionDescriptorsFromFile (const std::string &def_file, TreeNode *context) |
Given a tree node extension YAML file, parse it out into individual descriptors, one for each extension defined in the file. | |
ExtensionDescriptorVec | createExtensionDescriptorsFromDefinitionString (const std::string &def_string, TreeNode *context) |
Given a tree node extension definition string, parse it out into individual descriptors. | |
template<typename U > | |
MetaStruct::enable_if_t< not sparta::is_sparta_enum< U >::value and sparta::utils::has_ostream_operator< U >::value, void > | getHumanReadableHistogramBinNames (std::vector< std::string > &enum_name_strings) |
Given an enum class type, this method figures out the string. | |
template<typename U > | |
MetaStruct::enable_if_t< not sparta::is_sparta_enum< U >::value and not sparta::utils::has_ostream_operator< U >::value, void > | getHumanReadableHistogramBinNames (std::vector< std::string > &) |
Given an enum class type, this method figures out the string. | |
template<typename U > | |
MetaStruct::enable_if_t< sparta::is_sparta_enum< U >::value, void > | getHumanReadableHistogramBinNames (std::vector< std::string > &enum_name_strings) |
Given an enum class type, this method figures out the string. | |
std::ostream & | operator<< (std::ostream &out, sparta::StatisticInstance const &si) |
StatisticInstance stream operator. | |
std::ostream & | operator<< (std::ostream &out, sparta::StatisticInstance const *si) |
TreeNode stream operator. | |
template<typename T > | |
std::enable_if< std::is_integral< T >::value, T >::type | byte_swap (T val) |
Swaps the order of bytes for various types. | |
template<> | |
uint8_t | byte_swap (uint8_t val) |
template<> | |
int8_t | byte_swap (int8_t val) |
template<> | |
uint16_t | byte_swap (uint16_t val) |
template<> | |
int16_t | byte_swap (int16_t val) |
template<> | |
uint32_t | byte_swap (uint32_t val) |
template<> | |
int32_t | byte_swap (int32_t val) |
template<> | |
uint64_t | byte_swap (uint64_t val) |
template<> | |
int64_t | byte_swap (int64_t val) |
template<typename T , enum ByteOrder BO> | |
std::enable_if< std::is_same< boost::mpl::int_< BO >, boost::mpl::int_< BE > >::value, T >::type | reorder (const T &t) |
template<typename T , enum ByteOrder BO> | |
std::enable_if< std::is_same< boost::mpl::int_< BO >, boost::mpl::int_< LE > >::value, T >::type | reorder (const T &t) |
template<class T > | |
T | lexicalCast (const std::string &str, uint32_t base=10) |
template<class T > | |
MetaStruct::enable_if_t< MetaStruct::is_stl< T >::value and std::is_same< typename T::value_type, bool >::value, T > | lexicalCast (const std::string &str, uint32_t base=10)=delete |
template<> | |
std::string | lexicalCast (const std::string &str, uint32_t base) |
template<> | |
bool | lexicalCast (const std::string &str, uint32_t base) |
template<> | |
uint64_t | lexicalCast (const std::string &str, uint32_t base) |
template<> | |
int64_t | lexicalCast (const std::string &str, uint32_t base) |
template<> | |
uint32_t | lexicalCast (const std::string &str, uint32_t base) |
template<> | |
int32_t | lexicalCast (const std::string &str, uint32_t base) |
uint32_t | numDecDigits (uint32_t val) |
Gets number of decimal digits in a uint32_t. | |
template<typename PtrT , typename Ptr2 > | |
bool | operator== (const SpartaSharedPointer< PtrT > &ptr1, const SpartaSharedPointer< Ptr2 > &ptr2) noexcept |
template<typename PtrT > | |
bool | operator== (const SpartaSharedPointer< PtrT > &ptr1, std::nullptr_t) noexcept |
template<typename PtrT > | |
bool | operator== (std::nullptr_t, const SpartaSharedPointer< PtrT > &ptr1) noexcept |
template<typename PtrT , typename Ptr2 > | |
bool | operator!= (const SpartaSharedPointer< PtrT > &ptr1, const SpartaSharedPointer< Ptr2 > &ptr2) noexcept |
template<typename PtrT > | |
bool | operator!= (const SpartaSharedPointer< PtrT > &ptr1, std::nullptr_t) noexcept |
template<typename PtrT > | |
bool | operator!= (std::nullptr_t, const SpartaSharedPointer< PtrT > &ptr1) noexcept |
template<typename PtrT > | |
std::ostream & | operator<< (std::ostream &os, const SpartaSharedPointer< PtrT > &p) |
template<typename PointerT , typename... Args> | |
SpartaSharedPointer< PointerT > | allocate_sparta_shared_pointer (SpartaSharedPointerAllocator< PointerT > &alloc, Args &&...args) |
Allocate a SpartaSharedPointer. | |
std::ostream & | operator<< (std::ostream &os, const Tag &tag) |
<<(): Stream insertion operator | |
std::ostream & | operator<< (std::ostream &os, const Tag *tag) |
<<(): Stream insertion operator (for Tag pointers) | |
template<typename K , typename V , typename... Args, template< typename... > class MapType> | |
MapType< V, K > | flipMap (const MapType< K, V, Args... > &map) |
Function to invert a maps or an unordered_map, or any type of class that has key/value semantics. The variadic template argument is necessary 'cause map/unordered_map don't have just two template parameters. | |
bool | isPowerOf2 (uint64_t x) |
Determines if input is 0 or a power of 2. | |
template<typename T > | |
T | computeMask (T size, T &lsb_pos) |
Computes a maks and the lsb-position given a block size. The mask generated can be AND-ed with any number to get a value rounded down to the nearest multiple of size. | |
template<typename T > | |
T | computeMaskShift (T size) |
Convenience wrapper around computeMask to get the shift value. | |
std::string | demangle (const std::string &name) noexcept |
Demangles a C++ symbol. | |
template<typename T > | |
T * | notNull (T *p) |
Ensures that a pointer is not null. | |
uint32_t | replaceSubstring (std::string &s, const std::string &from, const std::string &to) |
Replaces within a string 's' all instances of some string 'from' with 'to'. | |
std::string | copyWithReplace (const std::string &s, char from, const std::string &to) |
Copies from 1 string to another with replacement of a single character with a string. | |
std::string | convertCPPStringToPython (const std::string &s) |
Take all of the C++-isms out of a string (like parens, angle brackets, colons, etc) and replace them with an '_'. | |
void | writeNChars (std::ostream &out, uint32_t num, char chr=' ') |
Insert a number of some character into an ostream. | |
std::string | toLower (const std::string &s) |
Makes a copy of an input string s in lower-case. | |
template<typename T > | |
std::ostream & | operator<< (std::ostream &o, const AssignOnceObject< T > &v) |
Variables | |
const uint32_t | NUM_SCHEDULING_PHASES |
The number of phases. | |
static class sparta::SpartaStaticInitializer | _SpartaStaticInitializer |
Macros for handling exponential backoff.
using sparta::CycleHistogram = typedef CycleHistogramTreeNode |
Definition at line 796 of file CycleHistogram.hpp.
typedef std::vector<std::unique_ptr<ExtensionDescriptor> > sparta::ExtensionDescriptorVec |
Definition at line 180 of file TreeNode.hpp.
typedef HistogramTreeNode sparta::Histogram |
Definition at line 526 of file Histogram.hpp.
using sparta::HistStatCalcFcn = typedef double (*)(const T*) |
Definition at line 75 of file HistogramFunctionManager.hpp.
using sparta::ProxyDefinitionSet = typedef __RegisterDefintionSet<sparta::RegisterProxyBase> |
Definition at line 64 of file RegisterDefinitionSet.hpp.
using sparta::RegisterDefinitionSet = typedef __RegisterDefintionSet<sparta::RegisterBase> |
Definition at line 61 of file RegisterDefinitionSet.hpp.
typedef std::shared_ptr<std::unordered_map<uint32_t, std::vector<sparta::Clock::Cycle> *> > sparta::StateTimerDataContainerPtr |
Definition at line 24 of file StateTimerUnit.hpp.
|
strong |
Defines how a sparta::Array should behave. The array will have different features depending on the type.
Enumerator | |
---|---|
NORMAL | The array does NOT allow access or maintain information about age. |
AGED | The array allows fuctions that require a concept of age in each entry |
enum sparta::ByteOrder |
Byte order enum for read/write methods.
Example 32 Byte register layout which can be accessed as smaller types by index. Layout in memory is unaware of byte-order. Read/Write methods dictate the storage.
The following shows how the value index offset and access sizes map to some data in memory.
* MEMORY addr: 0x 0 2 4 6 8 a c e 10 12 14 16 18 1a 1c 1e 20 * [- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 32 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ) * [- -- -- -- -- -- -- -- 16 -- -- -- -- -- -- -- ) , , * [- -- -- -- 8- -- -- -- ) , * [- -- 4- -- ) , , , , * [- 2- ) , * [- ) . , . , . , . , * val: 0x 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f , * * Little (LE) , , , * LSB , MSB, * type idx , , , * uint64_t 0 [- -- -- -- -- -- -- -] , , => 0x0706050403020100 * uint64_t 3 , , [- -- -- -- -- -- -- -] , => 0x1f1e1d1c1b1a1918 * uint32_t 0 [- -- -- -] , , => 0x03020100 * uint32_t 1 , [- -- -- -] , , => 0x07060504 * uint8_t 1 , [] , , => 0x01 * * Big (BE) , , , * MSB , LSB, * uint64_t 0 [- -- -- -- -- -- -- -] , , => 0x0001020304050607 * uint64_t 3 , , [- -- -- -- -- -- -- -] m => 0x18191a1b1c1d1e1f * uint8_t 1 , [] , , => 0x01 * * Bitfield (LE) , , , * 07-00 [] , , => 0x00 * 15-08 , [] , , => 0x01 * 23-16 , [] , , => 0x02 * 31-24 , [] , , => 0x03 * *
Enumerator | |
---|---|
BE | Little endian. |
Definition at line 73 of file ByteOrder.hpp.
|
strong |
The SchedulingPhases used for events (Tick, Update, PortUpdate, etc)
SchedulingPhase are phases within the SPARTA framework that allow a user to "categorize" events, ports, collection, and updatables into groups for auto-precedence establishment.
The current organization of this framework is UPCaT (Updateables, Ports, Collection, and Tick [incl PostTick]) or more specifically:
What happens in the framework is that all Scheduleable objects that are in the SchedulingPhase::Update phase will be organized on the Scheduler before SchedulingPhase::PortUpdate Scheduleable events, which are before SchedulingPhase::Collection Scheduleable objects, and so on. Within a specific phase, a modeler can order events as well. For example, two events in the SchedulingPhase::Tick can be ordered using the ">>" operator. See Precedence.h for more information.
For 0-cycle Ports, SchedulingPhase::PortUpdate events occur in the SchedulingPhase::Tick scheduling phase and are ordered with other events also in the SchedulingPhase::Tick scheduling phase. This only happens, however, when precedence is established between the Port and that subsequent events. This precedence is established by calling Port::registerConsumerEvent or Port::registerProducingEvent (depending on the sparta::Port::Direction).
Enumerator | |
---|---|
Update | Resources are updated in this phase. |
PortUpdate | N-cycle Ports are updated in this phase. |
Flush | Phase where flushing of pipelines, etc can occur. |
Collection | Pipeline collection occurs here. |
Tick | Most operations (combinational logic) occurs in this phase. |
PostTick | Operations such as post-tick pipeline collection occur here. |
Definition at line 57 of file SchedulingPhases.hpp.
SpartaSharedPointer< PointerT > sparta::allocate_sparta_shared_pointer | ( | SpartaSharedPointerAllocator< PointerT > & | alloc, |
Args &&... | args | ||
) |
Allocate a SpartaSharedPointer.
PointerT | The pointer type to allocate |
args | Arguments to the class being instantiated |
Allocate a SpartaSharedPointer using the SpartaSharedPointerAllocator instance found in the PointerT.
See SpartaSharedPointerAllocator for example usage
Definition at line 488 of file SpartaSharedPointerAllocator.hpp.
|
inline |
Definition at line 109 of file ByteOrder.hpp.
|
inline |
Definition at line 121 of file ByteOrder.hpp.
|
inline |
Definition at line 133 of file ByteOrder.hpp.
|
inline |
Definition at line 97 of file ByteOrder.hpp.
|
inline |
Swaps the order of bytes for various types.
Definition at line 83 of file ByteOrder.hpp.
|
inline |
Definition at line 103 of file ByteOrder.hpp.
|
inline |
Definition at line 115 of file ByteOrder.hpp.
|
inline |
Definition at line 127 of file ByteOrder.hpp.
|
inline |
Definition at line 91 of file ByteOrder.hpp.
|
inline |
|
inline |
|
inline |
Computes a maks and the lsb-position given a block size. The mask generated can be AND-ed with any number to get a value rounded down to the nearest multiple of size.
T | Type of value to compute mask for. Expected to be uint[XX]_t. |
size | Size for which the mask and lsbshould be computed. |
lsb_pos | Bit position of lsb in mask. A value can be shifted right by this amount to effectively get a "block index" which is the mask / size. |
If size = 0, lsb_pos is number of bits in T and mask returned is 0.
|
inline |
Convenience wrapper around computeMask to get the shift value.
This exists so that the shift can be computed in a constructor initialization list.
Definition at line 187 of file Utils.hpp.
|
inline |
|
inline |
|
inlinenoexcept |
Demangles a C++ symbol.
Name | Symbol name to demangle |
MapType< V, K > sparta::flipMap | ( | const MapType< K, V, Args... > & | map | ) |
std::enable_if< std::is_same< T, app::FeatureConfiguration >::value, constapp::FeatureConfiguration::FeatureOptions * >::type sparta::GetFeatureOptions | ( | const T & | cfg, |
const std::string & | feature_name | ||
) |
Utility in the sparta namespace that gets the named FeatureOptions object from a FeatureConfiguration set
Definition at line 308 of file FeatureConfiguration.hpp.
std::enable_if< MetaStruct::is_any_pointer< T >::value, constapp::FeatureConfiguration::FeatureOptions * >::type sparta::GetFeatureOptions | ( | const T & | cfg, |
const std::string & | feature_name | ||
) |
Utility in the sparta namespace which gets the named FeatureOptions object from a FeatureConfiguration which may be null
Definition at line 320 of file FeatureConfiguration.hpp.
MetaStruct::enable_if_t< not sparta::is_sparta_enum< U >::value and not sparta::utils::has_ostream_operator< U >::value, void > sparta::getHumanReadableHistogramBinNames | ( | std::vector< std::string > & | ) |
Given an enum class type, this method figures out the string.
Definition at line 72 of file EnumCycleHistogram.hpp.
MetaStruct::enable_if_t< not sparta::is_sparta_enum< U >::value and sparta::utils::has_ostream_operator< U >::value, void > sparta::getHumanReadableHistogramBinNames | ( | std::vector< std::string > & | enum_name_strings | ) |
Given an enum class type, this method figures out the string.
Definition at line 49 of file EnumCycleHistogram.hpp.
MetaStruct::enable_if_t< sparta::is_sparta_enum< U >::value, void > sparta::getHumanReadableHistogramBinNames | ( | std::vector< std::string > & | enum_name_strings | ) |
Given an enum class type, this method figures out the string.
Definition at line 79 of file EnumCycleHistogram.hpp.
std::enable_if< std::is_same< T, app::FeatureConfiguration >::value, bool >::type sparta::IsFeatureValueEnabled | ( | const T & | cfg, |
const std::string & | feature_name | ||
) |
Utility in the sparta namespace that checks if a feature value has been set to any positive number (0=disabled, >0=enabled)
Definition at line 281 of file FeatureConfiguration.hpp.
std::enable_if< MetaStruct::is_any_pointer< T >::value, bool >::type sparta::IsFeatureValueEnabled | ( | const T & | cfg, |
const std::string & | feature_name | ||
) |
Utility in the sparta namespace that asks a FeatureConfiguration if the provided feature is enabled, for a FeatureConfiguration that may be null
Definition at line 295 of file FeatureConfiguration.hpp.
std::enable_if< std::is_same< T, app::FeatureConfiguration >::value, bool >::type sparta::IsFeatureValueEqualTo | ( | const T & | cfg, |
const std::string & | feature_name, | ||
const unsigned int | feature_value | ||
) |
Utility in the sparta namespace that checks a FeatureConfiguration for a specific feature's current value (typically 1=enabled, and 0=disabled, but there could be more feature values too)
Definition at line 253 of file FeatureConfiguration.hpp.
std::enable_if< MetaStruct::is_any_pointer< T >::value, bool >::type sparta::IsFeatureValueEqualTo | ( | const T & | cfg, |
const std::string & | feature_name, | ||
const unsigned int | feature_value | ||
) |
Utility in the sparta namespace that checks for a FeatureConfiguration value, with a FeatureConfiguration that may be null
Definition at line 267 of file FeatureConfiguration.hpp.
|
inline |
Determines if input is 0 or a power of 2.
|
inline |
Definition at line 100 of file LexicalCast.hpp.
|
inline |
Definition at line 106 of file LexicalCast.hpp.
|
inline |
Definition at line 130 of file LexicalCast.hpp.
|
inline |
Definition at line 144 of file LexicalCast.hpp.
|
inline |
Definition at line 158 of file LexicalCast.hpp.
|
inline |
Definition at line 176 of file LexicalCast.hpp.
|
inlinedelete |
Cast string to T where T is either ValueType or (if ValueType is a vector) a vector's value_type.
boost::lexical_cast and ios_base::operator>> fail to determine type of an integer literal. For example, 0xdeadbeef is blindly interpreted as 0 with leftover characters. 070 is interpreted as decimal 70.
This attempts to interpret hex and octal in addition to decimal, and string values.
SpartaException | if cast fails. |
Definition at line 79 of file LexicalCast.hpp.
|
inlinedelete |
Cast string to T where T is either ValueType or (if ValueType is a vector) a vector's value_type.
boost::lexical_cast and ios_base::operator>> fail to determine type of an integer literal. For example, 0xdeadbeef is blindly interpreted as 0 with leftover characters. 070 is interpreted as decimal 70.
This attempts to interpret hex and octal in addition to decimal, and string values.
SpartaException | if cast fails. |
Definition at line 79 of file LexicalCast.hpp.
|
inline |
Ensures that a pointer is not null.
p | Pointer to check |
SpartaException | if pointer is null. |
Useful for checking for null in constructor initializer lists which refer to members through object pointers.
Definition at line 224 of file Utils.hpp.
|
inline |
Gets number of decimal digits in a uint32_t.
Definition at line 190 of file LexicalCast.hpp.
|
inline |
Definition at line 1463 of file Register.hpp.
|
inline |
Definition at line 126 of file RegisterSet.hpp.
|
noexcept |
Definition at line 539 of file SpartaSharedPointer.hpp.
|
noexcept |
Definition at line 543 of file SpartaSharedPointer.hpp.
|
noexcept |
Definition at line 547 of file SpartaSharedPointer.hpp.
|
inline |
TreeNode stream operator.
Definition at line 180 of file TreeNode.hpp.
|
inline |
|
inline |
Definition at line 1216 of file NotificationSource.hpp.
|
inline |
Definition at line 1222 of file NotificationSource.hpp.
|
inline |
Definition at line 1310 of file ParameterTree.hpp.
|
inline |
Definition at line 1315 of file ParameterTree.hpp.
|
inline |
ostream insertion operator for SimulationInfo
Definition at line 492 of file SimulationInfo.hpp.
|
inline |
|
inline |
|
inline |
Print the SchedulingPhase.
os | ostream to print to |
phase | The SchedulingPhase to print out |
Definition at line 84 of file SchedulingPhases.hpp.
|
inline |
std::ostream & sparta::operator<< | ( | std::ostream & | os, |
const SpartaSharedPointer< PtrT > & | p | ||
) |
Definition at line 551 of file SpartaSharedPointer.hpp.
|
inline |
|
inline |
|
inline |
StatisticInstance stream operator.
Definition at line 719 of file StatisticInstance.hpp.
|
inline |
TreeNode stream operator.
Definition at line 726 of file StatisticInstance.hpp.
|
inline |
TreeNode stream operator.
Definition at line 4548 of file TreeNode.hpp.
|
inline |
Definition at line 1404 of file Register.hpp.
|
inline |
Definition at line 101 of file RegisterSet.hpp.
|
noexcept |
Definition at line 527 of file SpartaSharedPointer.hpp.
|
noexcept |
Definition at line 531 of file SpartaSharedPointer.hpp.
|
noexcept |
Definition at line 535 of file SpartaSharedPointer.hpp.
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.
producer | The Bus to succeed a Scheduleable |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 995 of file Precedence.hpp.
|
inline |
This template supports the following:
producers | Group of Scheduleables that must come before each of the consumers in the EventGroup |
consumers | Group of Scheduleables that must come after each of the producers in the EventGroup sparta::EventGroup( ProdEvent1, ProdEvent2, ProdEvent3, ... )
>> sparta::EventGroup( ConsEvent1, ConsEvent2, ConsEvent3, ... );
Group a series of events together for precedence establishment. Definition Precedence.hpp:1042 |
Where each consuming event is preceded by each producing event. The consuming and producing events are still independent of each other.
Definition at line 1188 of file Precedence.hpp.
ScheduleableTypeB & sparta::operator>> | ( | const EventGroup & | producers, |
ScheduleableTypeB & | consumer | ||
) |
This template supports the following:
producers | Group of Scheduleables that must come before the given consumer |
consumer | The Scheduleable that succeed each of the Scheduleables in the EventGroup |
Where the consuming event is preceded by each producing event. The producing events are still independent.
Definition at line 1144 of file Precedence.hpp.
|
inline |
Place a precedence between a GlobalOrderingPoint and an InPort.
Methods used for precedence have access to the internal scheduleable.
producer | The GlobalOrderingPoint to succeed the ScheduleableType |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a GlobalOrderingPoint on the LHS preceding a InPort and ensures the two events are within the same phase.
Definition at line 206 of file Precedence.hpp.
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.
producer | The GlobalOrderingPoint to succeed the ScheduleableType |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a GlobalOrderingPoint on the LHS preceding a Scheduleable type and ensures the two events are within the same phase.
Definition at line 173 of file Precedence.hpp.
PayloadEvent< DataT2, PayloadPhaseT2 > & sparta::operator>> | ( | Event< PayloadPhaseT1 > & | producer, |
PayloadEvent< DataT2, PayloadPhaseT2 > & | consumer | ||
) |
Place a precedence between a Event and an PayloadEvent.
producer | The Event to succeed a PayloadEvent |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 523 of file Precedence.hpp.
Event< PhaseT2 > & sparta::operator>> | ( | Event< PhaseT1 > & | producer, |
Event< PhaseT2 > & | consumer | ||
) |
Place a precedence between a Event and another Event.
producer | The Event to succeed a Event |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 720 of file Precedence.hpp.
std::unique_ptr< EventT2 > & sparta::operator>> | ( | EventT1 & | producer, |
std::unique_ptr< EventT2 > & | consumer | ||
) |
Place a precedence between an EventT1 and std::unique_ptr<EventT2>
producer | The EventT1 to succeed a EventT2 |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 798 of file Precedence.hpp.
|
inline |
Place a precedence between a Scheduleable object and a GlobalOrderingPoint.
producer | The GlobalOrderingPoint to succeed the ScheduleableType |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a InPort on the LHS preceding a GlobalOrderingPoint (which is a Vertex type) and ensures the two events are within the same phase.
Definition at line 238 of file Precedence.hpp.
Event< PayloadPhaseT2 > & sparta::operator>> | ( | PayloadEvent< DataT1, PayloadPhaseT1 > & | producer, |
Event< PayloadPhaseT2 > & | consumer | ||
) |
Place a precedence between a PayloadEvent and an Event.
producer | The PayloadEvent to succeed an Event |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 409 of file Precedence.hpp.
PayloadEvent< DataT2, PayloadPhaseT2 > & sparta::operator>> | ( | PayloadEvent< DataT1, PayloadPhaseT1 > & | producer, |
PayloadEvent< DataT2, PayloadPhaseT2 > & | consumer | ||
) |
Place a precedence between a PayloadEvent and another PayloadEvent.
producer | The PayloadEvent to succeed another PayloadEvent |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 295 of file Precedence.hpp.
SingleCycleUniqueEvent< PayloadPhaseT2 > & sparta::operator>> | ( | PayloadEvent< DataT1, PayloadPhaseT1 > & | producer, |
SingleCycleUniqueEvent< PayloadPhaseT2 > & | consumer | ||
) |
Place a precedence between a PayloadEvent and SingleCycleUniqueEvent.
producer | The PayloadEvent to succeed SingleCycleUniqueEvent |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 371 of file Precedence.hpp.
UniqueEvent< PayloadPhaseT2 > & sparta::operator>> | ( | PayloadEvent< DataT1, PayloadPhaseT1 > & | producer, |
UniqueEvent< PayloadPhaseT2 > & | consumer | ||
) |
Place a precedence between a PayloadEvent and UniqueEvent.
producer | The PayloadEvent to succeed UniqueEvent |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 333 of file Precedence.hpp.
Scheduleable & sparta::operator>> | ( | PayloadEvent< DataT1, phase > & | producer, |
Scheduleable & | consumer | ||
) |
Place a precedence between a PayloadEvent and a Scheduleable.
producer | The PayloadEvent to succeed a Scheduleable |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 907 of file Precedence.hpp.
PayloadEvent< DataT2, phase > & sparta::operator>> | ( | Scheduleable & | producer, |
PayloadEvent< DataT2, phase > & | consumer | ||
) |
Place a precedence between a Scheduleable and a PayloadEvent.
producer | The Scheduleable to succeed the PayloadEvent |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 870 of file Precedence.hpp.
|
inline |
Definition at line 625 of file Scheduleable.hpp.
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.
producer | The Scheduleable to succeed a Bus |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 953 of file Precedence.hpp.
const EventGroup & sparta::operator>> | ( | ScheduleableTypeA & | producer, |
const EventGroup & | consumers | ||
) |
This template supports the following:
producer | The Scheduleable that precedes each of the Scheduleables in the EventGroup |
consumer | Group of Scheduleables that must come after the given producer ProEvent1 >> sparta::EventGroup(ConsEvent1, ConsEvent2, ConsEvent3, ... );
|
Where each consuming event is preceded by the single producing event. The consuming events are still independent.
Definition at line 1165 of file Precedence.hpp.
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.
producer | The producer (LHS) must come before consumer (RHS) |
consumer | The GlobalOrderingPoint (Vertex type) to succeed the ScheduleableType |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable on the LHS preceding a GlobalOrderingPoint point and ensures the two events are within the same phase.
Definition at line 138 of file Precedence.hpp.
PayloadEvent< DataT2, PayloadPhaseT2 > & sparta::operator>> | ( | SingleCycleUniqueEvent< PayloadPhaseT1 > & | producer, |
PayloadEvent< DataT2, PayloadPhaseT2 > & | consumer | ||
) |
Place a precedence between a PayloadEvent and an SingleCycleUniqueEvent.
producer | The SingleCycleUniqueEvent to succeed a PayloadEvent |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 485 of file Precedence.hpp.
UniqueEvent< PayloadPhaseT2 > & sparta::operator>> | ( | SingleCycleUniqueEvent< PayloadPhaseT1 > & | producer, |
UniqueEvent< PayloadPhaseT2 > & | consumer | ||
) |
Place a precedence between a SingleCycleUniqueEvent and an UniqueEvent.
producer | The SingleCycleUniqueEvent to succeed an UniqueEvent |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 642 of file Precedence.hpp.
SingleCycleUniqueEvent< PhaseT2 > & sparta::operator>> | ( | SingleCycleUniqueEvent< PhaseT1 > & | producer, |
SingleCycleUniqueEvent< PhaseT2 > & | consumer | ||
) |
Place a precedence between a SingleCycleUniqueEvent and a SingleCycleUniqueEvent.
producer | The SingleCycleUniqueEvent to succeed a SingleCycleUniqueEvent |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 681 of file Precedence.hpp.
EventT2 & sparta::operator>> | ( | std::unique_ptr< EventT1 > & | producer, |
EventT2 & | consumer | ||
) |
Place a precedence between a std::unique_ptr<EventT1> and EventT2.
producer | The EventT1 to succeed a EventT2 |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 832 of file Precedence.hpp.
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>
producer | The EventT1 to succeed a EventT2 |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 763 of file Precedence.hpp.
PayloadEvent< DataT2, PayloadPhaseT2 > & sparta::operator>> | ( | UniqueEvent< PayloadPhaseT1 > & | producer, |
PayloadEvent< DataT2, PayloadPhaseT2 > & | consumer | ||
) |
Place a precedence between a PayloadEvent and an UniqueEvent.
producer | The UniqueEvent to succeed a PayloadEvent |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 447 of file Precedence.hpp.
SingleCycleUniqueEvent< PayloadPhaseT2 > & sparta::operator>> | ( | UniqueEvent< PayloadPhaseT1 > & | producer, |
SingleCycleUniqueEvent< PayloadPhaseT2 > & | consumer | ||
) |
Place a precedence between a UniqueEvent and an SingleCycleUniqueEvent.
producer | The UniqueEvent to succeed a SingleCycleUniqueEvent |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 605 of file Precedence.hpp.
UniqueEvent< PayloadPhaseT2 > & sparta::operator>> | ( | UniqueEvent< PayloadPhaseT1 > & | producer, |
UniqueEvent< PayloadPhaseT2 > & | consumer | ||
) |
Place a precedence between a UniqueEvent and an UniqueEvent.
producer | The UniqueEvent to succeed a UniqueEvent |
consumer | The producer (LHS) must come before consumer (RHS) |
Place a precedence on a producer to the consumer. The consumer is returned, not the producer. This is to allow chaining:
This implementation of the precedence operator catches a Scheduleable/EventNode on the LHS preceding another and ensures the two events are within the same phase.
Definition at line 568 of file Precedence.hpp.
|
inline |
Takes a value of type T from native byte order to the designed byte order Specialization for Big-Endian
Definition at line 143 of file ByteOrder.hpp.
|
inline |
Takes a value of type T from native byte order to the designed byte order Specialization for Little-Endian
Definition at line 152 of file ByteOrder.hpp.
|
inline |
Replaces within a string 's' all instances of some string 'from' with 'to'.
s | String to perform replacement on |
from | String to replace with <to> |
to | String to replace all instances of <from> with. |
Replaces based on found instances of <from> starting from position 0. After replacing, the loop advances to the end of the replaced text and continues there. Characters inserted from <to> will never be matched as part of a <from>
|
inline |
smartLexicalCast wrapper with parameter information added to exceptions
Definition at line 2551 of file Parameter.hpp.
|
inline |
|
inline |
const uint32_t sparta::NUM_SCHEDULING_PHASES |
The number of phases.
Definition at line 75 of file SchedulingPhases.hpp.