The Sparta Modeling Framework
|
A class that lets you schedule events now and in the future. More...
#include <Scheduler.hpp>
Public Types | |
typedef uint64_t | Tick |
Typedef for our unit of time. | |
Public Types inherited from sparta::RootTreeNode | |
typedef NotificationSource< TreeNode > | NewDescendantNotiSrc |
Type for notification source in this node which is posted when a new descendent is attached. | |
Public Types inherited from sparta::TreeNode | |
typedef uint64_t | node_uid_type |
Type of unique-identifier assigned to every node. | |
typedef std::vector< TreeNode * > | ChildrenVector |
Vector of TreeNode children. | |
typedef std::vector< std::string > | AliasVector |
Vector of aliases (other names for this node) | |
typedef std::multimap< std::string, TreeNode * > | ChildNameMapping |
Mapping of names, aliases, and groups to individual child nodes within one node. This must be in a deterministic order, so an ordered container (e.g. std::map) is required. A sorted contained is probably desirable, but not required. | |
typedef uint32_t | group_idx_type |
Index within a group. | |
typedef std::weak_ptr< TreeNode > | WeakPtr |
Weak pointer to a TreeNode. Acquire with getWeakPtr. | |
typedef std::weak_ptr< const TreeNode > | ConstWeakPtr |
Weak pointer to a const TreeNode. Acquire with getWeakPtr. | |
typedef std::shared_ptr< TreeNode > | SharedPtr |
Shared pointer to TreeNode. Acquire with WeakPtr::lock(). | |
typedef std::map< const std::string *, std::vector< TreeNode * > > | TagsMap |
Map of strings (interned in StringManager) tags to TreeNodes. | |
Public Types inherited from sparta::PhasedObject | |
enum | TreePhase { TREE_BUILDING = 0 , TREE_CONFIGURING = 1 , TREE_FINALIZING = 2 , TREE_FINALIZED = 3 , TREE_TEARDOWN = 4 } |
Current phase of tree construction (applies to node and entire tree). More... | |
Public Member Functions | |
constexpr Tick | calcIndexTime (const Tick rel_time) const |
Const expression to calculate tick value for indexing. | |
template<typename DurationT > | |
DurationT | getRunCpuTime () const |
Return the number of nanoseconds the scheduler has been in run. | |
template<typename DurationT > | |
DurationT | getRunWallTime () const |
Get the wall clock run time. | |
Scheduler () | |
Constructor. | |
Scheduler (const std::string &name) | |
Constructor with name. | |
Scheduler (const std::string &name, GlobalTreeNode *search_scope) | |
Construct with a name and a specific global search scope (global parent) | |
~Scheduler () | |
Dey-stroy. | |
void | reset () |
void | registerClock (sparta::Clock *clk) |
void | deregisterClock (sparta::Clock *clk) |
template<SchedulingPhase sched_phase_T = SchedulingPhase::Update> | |
PhasedPayloadEvent< GlobalEventProxy > * | getGlobalPhasedPayloadEventPtr () |
Get the raw pointer of "global" PhasedPayloadEvent inside sparta::Scheduler. | |
Setup | |
void | finalize () |
Finalize the scheduler and allow running. | |
DAG * | getDAG () const |
Get the internal DAG. | |
Scheduler Management | |
void | stopRunning () |
Tell the scheduler to stop running. | |
void | clearEvents () |
Clears all events in the scheduler without executing any of them. | |
void | restartAt (Tick t) |
Clears the events in the scheduler, sets the current tick to tick and the elapsed ticks to either tick or tick plus 1. | |
template<class StreamType > | |
void | printNextCycleEventTree (StreamType &os, uint32_t curr_grp=0, uint32_t curr_event=0, uint32_t future=0) const |
A method used for debugging the scheduler. Prints the scheduler's schedule of events. | |
void | scheduleEvent (Scheduleable *scheduleable, Tick rel_time, uint32_t dag_group=0, bool continuing=true, bool add_if_not_scheduled=false) |
Schedule a single event. This method should also be thread safe. | |
void | scheduleAsyncEvent (Scheduleable *sched, Scheduler::Tick delay) |
Asynchronously schedule an event. | |
bool | isScheduled (const Scheduleable *scheduleable) const |
Is the given Scheduleable item anywhere (in time now -> future) on the Scheduler? | |
bool | isScheduled (const Scheduleable *scheduleable, Tick rel_time) const |
Is the given Scheduleable item already scheduled? | |
void | cancelEvent (const Scheduleable *scheduleable) |
Cancel the given Scheduleable if on the Scheduler. | |
void | cancelEvent (const Scheduleable *scheduleable, Tick rel_time) |
Cancel the given Scheduleable if on the Scheduler at the given time. | |
void | cancelAsyncEvent (Scheduleable *scheduleable) |
Cancel the given Scheduleable. | |
Running | |
void | run (Tick num_ticks=INDEFINITE, const bool exacting_run=false, const bool measure_run_time=true) |
Enter running state and runs the scheduler until running is stopped (e.g. through a stop event) or the scheduler runs out of queued, continuing events. | |
bool | isFinished () const |
Returns true if there are no more pending non-continuing events. | |
Tick | nextEventTick () const |
Returns the next tick an event is pending. | |
Scheduler State & Attributes | |
bool | isFinalized () const noexcept override |
Is the scheduler finalized. | |
bool | isRunning () const noexcept |
Query if the scheduler is running. | |
Tick | getCurrentTick () const noexcept |
The current tick the Scheduler is working on or just finished. | |
Tick | getElapsedTicks () const noexcept |
The total elapsed ticks. | |
Tick | getSimulatedPicoSeconds () const noexcept |
void | kickTheDog () noexcept |
Reset the watchdog timer. | |
void | enableWatchDog (uint64_t watchdog_timeout_ps) |
Enable the watchdog timer. | |
Tick | getNumFired () const noexcept |
Tick | getNextContinuingEventTime () const noexcept |
Returns the Tick quantum where the next continuing event resides. | |
const Scheduleable * | getCurrentFiringEvent () const |
uint32_t | getCurrentFiringEventIdx () const |
SchedulingPhase | getCurrentSchedulingPhase () const |
Instrumentation | |
Tick | getFrequency () const |
Returns the frequency (in ticks per simulated second) of this Scheduler. | |
ReadOnlyCounter & | getCurrentTicksROCounter () |
Returns a counter holding the current tick count of this scheduler. | |
ReadOnlyCounter & | getCurrentPicosecondsROCounter () |
Returns a counter holding the current picosecond count of this scheduler. | |
StatisticDef & | getSecondsStatisticDef () |
Returns a StatisticDef holding the picosecond count of this scheduler. | |
StatisticDef & | getCurrentMillisecondsStatisticDef () |
Returns a StatisticDef holding the millisecond count of this scheduler. | |
StatisticDef & | getCurrentMicrosecondsStatisticDef () |
Returns a StatisticDef holding the microsecond count of this scheduler. | |
StatisticDef & | getCurrentNanosecondsStatisticDef () |
Returns a StatisticDef holding the nanosecond count of this scheduler. | |
Public Member Functions inherited from sparta::RootTreeNode | |
RootTreeNode (const std::string &name, const std::string &desc, app::Simulation *sim, GlobalTreeNode *search_scope) | |
Constructor. | |
RootTreeNode (const std::string &name, const std::string &desc, GlobalTreeNode *search_scope) | |
Constructor with name, desc, and search scope. | |
RootTreeNode (const std::string &name) | |
Constructor with name only. | |
RootTreeNode (const std::string &name, const std::string &desc, app::Simulation *sim) | |
Consturctor with name, desc, and simulator. | |
RootTreeNode (const std::string &name, const std::string &desc) | |
Constructor with name and desc. | |
RootTreeNode (app::Simulation *sim) | |
Constructor with only a simulator. | |
RootTreeNode (GlobalTreeNode *search_scope) | |
Constructor with only a search scope. | |
RootTreeNode (app::Simulation *sim, GlobalTreeNode *search_scope) | |
Constructor with only a simulator and search scope. | |
RootTreeNode () | |
Default constuctor. | |
virtual | ~RootTreeNode () |
Destructor. | |
virtual bool | isAttached () const override final |
Is this node part of a device tree with a proper RootTreeNode at the root. | |
virtual TreeNode * | getParent () override final |
Gets immediate parent of this node if one exists. | |
virtual const TreeNode * | getParent () const override final |
virtual void | setClock (const Clock *clk) override final |
Assigns a clock to this node. This clock will then be accessed by any descendant which has no assigned clock or an ancestor with an assigned clock between that descendant and this node. getClock returns the Clock associated with the nearest ancestor. | |
app::Simulation * | getSimulator () const |
Gets the simulator (if any) associated with this Root node. | |
GlobalTreeNode * | getSearchScope () |
Gets the search node "parent" of this root node which is suitable for performing searches that include the name of this root node (e.g. "top.x.y.z"). | |
void | enterConfiguring () |
Public method to crystalize the tree structure and begin configuring. | |
void | enterFinalized (sparta::python::PythonInterpreter *pyshell=nullptr) |
Public method for recursive tree finalization. Places tree temporarily into TREE_FINALIZING phase before finalizing, then places tree into TREE_FINALIZED. | |
void | bindTreeEarly () |
Public method for recursively giving all resources and nodes a chance to bind ports locally. Recurses depth first by order of construction of each child in each node encountered. | |
void | bindTreeLate () |
Public method for recursively giving all resources and nodes a chance to bind ports locally. Recurses depth first by order of construction of each child in each node encountered. | |
void | simulationTerminating () |
Called after simulation has stopped, but before statistic/report generation. | |
void | validatePreRun () |
Validate the entire tree immediately prior to running. All ports should be bound ,etc. Does not change phase. | |
void | validatePostRun () |
Validate all resources in the simulator, throwing exceptions if invalid state is detected. Exceptions are allowed to propogate out of this method. | |
void | dumpDebugContent (std::ostream &out) noexcept |
Dump all debug content from each resource in the tree to an ostream. | |
void | enterTeardown () |
Places this tree into TREE_TEARDOWN phase so that nodes may be deleted without errors. | |
virtual std::string | stringize (bool pretty=false) const override |
Render description of this RootTreeNode as a string. | |
NewDescendantNotiSrc & | getNodeAttachedNotification () |
Returns the post-write notification-source node for this register which can be used to observe writes to this register. This notification is posted immediately after the register has been written and populates a sparta::Register::PostWriteAccess object with the results. | |
void | getArchDataAssociations (std::vector< const ArchData * > &ad_this_tree, std::vector< const ArchData * > &ad_no_assoc, std::vector< const ArchData * > &ad_not_attached, std::vector< const ArchData * > &ad_other_tree) const noexcept |
Gets vectors of all the ArchData instances in existance now categorized into several groups. Inputs are cleared before appending. | |
void | validateArchDataAssociations () const |
Gets the results. | |
void | dumpArchDataAssociations (std::ostream &o) const noexcept |
Debugging tool which checks all ArchDatas in existence to see if they are associated with this tree. Prints all ArchDatas in several categories (see getArchDataAssociations) | |
void | dumpTypeMix (std::ostream &o) const |
Dumps the mix of tree node concrete types to the ostream. | |
Public Member Functions inherited from sparta::TreeNode | |
const Clock * | getClock () override |
Walks up parents (starting with self) until a parent with an associated local clock is found, then returns that clock. | |
const Clock * | getClock () const |
const Clock * | getLocalClock () |
Gets the clock associated directly with this Node. This is useful for configuration and simulator debug, but not at run-time. | |
const Clock * | getLocalClock () const |
Scheduler * | getScheduler (const bool must_exist=false) |
Get the scheduler associated with this tree node's root. | |
const Scheduler * | getScheduler (const bool must_exist=false) const |
WeakPtr | getWeakPtr () |
Gets a weak pointer to this TreeNode. This weak pointer is guaranteed to expire when this TreeNode is destructed unless locked. | |
ConstWeakPtr | getWeakPtr () const |
Const variant of getWeakPtr. | |
virtual void | addLink (TreeNode *node, const std::string &label) |
Link this tree node with another tree node. | |
virtual void | activateLink (const std::string &label) |
Activate one of the links added with addLink. | |
TreeNode ()=delete | |
Not default-constructable. | |
TreeNode (const TreeNode &)=delete | |
Not copy-constructable. | |
TreeNode (TreeNode &&rhp) | |
Move constructor. | |
TreeNode & | operator= (const TreeNode &)=delete |
Not assign-constructable. | |
TreeNode (TreeNode *parent, const std::string &name, const std::string &group, group_idx_type group_idx, const std::string &desc, bool is_indexable) | |
TreeNode full constructor. Initializes node and adds it as a child of an existing tree node (if parent is not null). | |
TreeNode (TreeNode *parent, const std::string &name, const std::string &group, group_idx_type group_idx, const std::string &desc) | |
TreeNode constructor with no is_indexable parameter [defaults to true]. | |
TreeNode (const std::string &name, const std::string &group, group_idx_type group_idx, const std::string &desc) | |
TreeNode constructor with no parent Node. | |
TreeNode (TreeNode *parent, const std::string &name, const std::string &desc) | |
TreeNode constructor with no group information. | |
TreeNode (TreeNode *parent, const std::string &group, group_idx_type group_idx, const std::string &desc) | |
TreeNode constructor for anonymous node with group information. | |
TreeNode (const std::string &name, const std::string &desc) | |
TreeNode constructor with no parent node or group information. | |
virtual | ~TreeNode () |
Virtual destructor. | |
void | addAlias (const std::string &alias) |
Add a single alias for this node. | |
void | addAliases (const AliasVector &v) |
Adds each element of a vector of aliases to this node.. | |
void | addTag (const std::string &tag) |
Adds single tag to this node. | |
void | addTags (const std::vector< std::string > &v) |
Adds each elements of a vector of tags to this node. | |
void | stringizeTags (std::stringstream &ss) const |
Render tags to a string in the form: " tags:[tag0, tag1]" If there are any tags. The leading space makes this a useful sub-utility of stringize because if there are no tags, returns empty string with no leading space. | |
node_uid_type | getNodeUID () const |
Gets the unique ID of this node. | |
const std::string & | getName () const override |
Gets the name of this node. | |
const std::string * | getNamePtr () const |
Gets the name of this node's string pointer which isinterned in StringManager) | |
bool | isAnonymous () const |
Is this node anonymous. | |
bool | isExpired () const |
Is this expired (i.e. has it been the rhp of a move constructor) | |
bool | isIndexableByGroup () const |
Returns whether this object is accessible through its parent's interfaces for getting children by group and index. | |
const std::string & | getGroup () const |
Gets the group name of this node. | |
const std::string * | getGroupNamePtr () const |
Gets the group name string pointer (interned in StringManager singleton) of this node. | |
group_idx_type | getGroupIdx () const |
Gets the group index of this node. | |
const std::vector< const std::string * > & | getTags () const |
Gets the set of tags associated with this TreeNode. | |
bool | hasTag (const std::string &tag) const |
Does this node have a specific tag (by name) | |
bool | hasTag (const std::string *interned_tag_name) const |
Does this node have a specific tag (by string pointer interned with StringManager). This is faster than the alternate hasTag method because it relies only on pointer comparisons. | |
const std::string & | getDesc () const |
Gets the description of this node. | |
bool | isBuiltin () const |
Is this node in the builtins group. | |
void | markHidden (bool hidden=true) |
Marks this TreeNode hidden for the purposes of printint out nodes. This does not make the node inaccessible, but causes it (and its subtree) to be hidden from typical recursive tree printouts. | |
bool | isHidden () const |
Is this TreeNode supposed to be hidden during tree printouts This value does not have to be respected by anything using TreeNode and is mainly a UI/printout convenience. | |
void | validateName (const std::string &nm) |
Validates the given name string for this TreeNode. Does not consider context (e.g. name collisions) | |
void | validateGroup (const std::string &name, const std::string &group, group_idx_type idx) |
Validates the given group name string and group index for this TreeNode. Does not consider context (e.g. name collisions) | |
void | validateDesc (const std::string &desc) |
Validates the given description string for this TreeNode. | |
void | addExtensionParameters (const std::string &extension_name, std::unique_ptr< ParameterSet > extension_params) |
Add a named parameter set to extend this tree node's metadata. | |
void | addExtensionFactory (const std::string &extension_name, std::function< ExtensionsBase *()> factory) |
Add an extension factory to this tree node by its type (name). This method does not actually create any objects at this time. It will validate and create the extension only if asked for later on during simulation. | |
ExtensionsBase * | getExtension (const std::string &extension_name) |
Get an extension object by type string. Returns nullptr if not found (unrecognized). | |
ExtensionsBase * | getExtension () |
Get an extension without needing to specify any particular type string. If no extensions exist, returns nullptr. If only one extension exists, returns that extension. If more than one extension exists, throws an exception. | |
const std::set< std::string > & | getAllExtensionNames () |
Extension names, if any. Tree node extensions are typically instantiated on-demand for best performance (you have to explicitly ask for an extension by its name, or it won't be created) - so note that calling this method will trigger the creation of all this node's extensions. The performance cost is proportional to the number of nodes in the virtual parameter tree. | |
void | addChild (TreeNode *child, bool inherit_phase=true) |
Adds a TreeNode to this node as a child. | |
void | addChild (TreeNode &child) |
AddChild by reference for convenience. | |
void | makeSubtreePrivate () |
Make the entire subtree private. | |
void | setScopeRoot () |
bool | isScopeRoot () const |
void | lockdownParameters () |
Method to put the device tree in lockdown phase. All LOCKED and HIDDEN parameters are frozen after this point. Regular parameters are not affected by this phase. This method requires a Simulation pointer and will assert at compile time if anyone tries to lockdown the tree without the context of a Simulation. | |
template<class T , typename = typename std::enable_if<std::is_pointer<T>::value>::type> | |
const T | getParentAs (bool must_exist=true) const |
Retrieves a parent casted to type T* if this node has a parent. | |
template<class T , typename = typename std::enable_if<!std::is_pointer<T>::value>::type> | |
const T * | getParentAs (bool must_exist=true) const |
template<class T , typename = typename std::enable_if<std::is_pointer<T>::value>::type> | |
T | getParentAs (bool must_exist=true) |
template<class T , typename = typename std::enable_if<!std::is_pointer<T>::value>::type> | |
T * | getParentAs (bool must_exist=true) |
virtual TreeNode * | getRoot () |
Gets farthest ancestor of this node. | |
virtual const TreeNode * | getRoot () const |
TreeNode * | getScopeRoot () |
const TreeNode * | getScopeRoot () const |
const TreeNode * | getExpectedRoot () const |
build-time equivalent to getRoot before an object is actually attached to a tree. This is a mainly a framework and debugging tool for determining what the root of a node being constructed will be when complete | |
app::Simulation * | getSimulation () const |
Gets the simulation (if any) associated with this tree. | |
uint32_t | getNumChildren () const |
Gets the number of children that this node has including those in the sparta builtins group. | |
TreeNode * | getChildAt (uint32_t idx) const |
Gets a child at a position in the children vector in the order in which they were added to this node. | |
const ChildrenVector | getChildren () const |
Gets a vector of all children of this node in any group in the order in which they were added to this node. | |
uint32_t | getChildren (std::vector< TreeNode * > &results, bool ignore_builtin_group=true, bool ignore_anonymous_nodes=true) |
Gets all children of this node in the order in which they were added to this node. | |
template<class T > | |
uint32_t | getChildrenOfType (std::vector< T * > &results) const |
return all the children matching a particular type using dynamic cast. | |
sparta::TreeNode * | findAncestorByName (const std::string &name) |
Find ancestor by name. | |
template<typename T > | |
sparta::TreeNode * | findAncestorByType () |
Find ancestor by type. | |
sparta::TreeNode * | findAncestorByTag (const std::string &tag) |
Find the first ancestor with a particular tag. | |
template<typename T > | |
T * | findAncestorResourceByType () |
Find an ancestor's resource with a certain type. | |
const AliasVector & | getAliases () const |
Gets a vector of all aliases of this node. | |
uint32_t | getChildrenIdentifiers (std::vector< std::string > &idents, bool ignore_builtin_group=true) const |
Gets all child identifiers, aliases, group names, and group-aliases which can be used to refer to a child of this node. | |
std::vector< const std::string * > | getIdentifiers () const |
Gets all the identifiers for this node (excluding groups) | |
uint32_t | getGroupSize (const std::string &group) |
Gets the number of nodes in a group. | |
group_idx_type | getGroupIndexMax (const std::string &group) |
Gets the largest index of a node in the given group. | |
uint32_t | getGroup (const std::string &group, std::vector< TreeNode * > &results) |
Gets all nodes in a child group. | |
uint32_t | findChildren (const std::string &pattern, std::vector< TreeNode * > &results, std::vector< std::vector< std::string > > &replacements) |
Finds all children starting at this node with a given pattern relative to this node by matching names an aliases. Appends each found child to <results>. | |
uint32_t | findChildren (const std::string &pattern, std::vector< TreeNode * > &results) |
Version of findChildren with no replacements vector. | |
virtual uint32_t | findImmediateChildren_ (std::regex &expr, std::vector< TreeNode * > &found, std::vector< std::vector< std::string > > &replacements, bool allow_private=false) |
Finds immediate children with some identity (name or alias) matching a regex. | |
uint32_t | findImmediateChildren_ (std::regex &expr, std::vector< TreeNode * > &found, bool allow_private=false) |
Variant of findImmediateChildren_ with no replacements vector. | |
virtual uint32_t | findImmediateChildren_ (std::regex &expr, std::vector< const TreeNode * > &found, std::vector< std::vector< std::string > > &replacements, bool allow_private=false) const |
Const-qualified variant of findImmediateChildren_. | |
uint32_t | findImmediateChildren_ (std::regex &expr, std::vector< const TreeNode * > &found, bool allow_private=false) const |
Variant of const-qualified findImmediateChildren_ with no replacements vector. | |
bool | locationMatchesPattern (const std::string &pattern, const TreeNode *pat_loc) const |
Determines if the given pattern (which may contain wildcards) can describe this node. | |
TreeNode * | getChild (const std::string &name, bool must_exist=true) |
Retrieves a child with this dotted path name. | |
const TreeNode * | getChild (const std::string &name, bool must_exist=true) const |
Overloaded const-qualified. | |
std::string | getDeepestMatchingPath (const std::string &path) const |
Gets the deepest whole node location starting from this node that matches some part of path starting at its beginning. | |
bool | hasChild (const std::string &name) const noexcept |
Determines if a child can be found with the given dotted path. | |
bool | hasImmediateChild (const TreeNode *n) const noexcept |
Determines if the node n is an immediate child of this node. | |
template<class T , typename = typename std::enable_if<std::is_pointer<T>::value>::type, class ConstT = typename ptr_to_const_obj_ptr<T>::type> | |
const ConstT | getChildAs (const std::string &name, bool must_exist=true) const |
Retrieves a child that is castable to T with the given dotted path. | |
template<class T , typename = typename std::enable_if<!std::is_pointer<T>::value>::type> | |
const T * | getChildAs (const std::string &name, bool must_exist=true) const |
template<class T , typename = typename std::enable_if<std::is_pointer<T>::value>::type> | |
T | getChildAs (const std::string &name, bool must_exist=true) |
template<class T , typename = typename std::enable_if<!std::is_pointer<T>::value>::type> | |
T * | getChildAs (const std::string &name, bool must_exist=true) |
template<class T , typename = typename std::enable_if<std::is_pointer<T>::value>::type, class ConstT = typename ptr_to_const_obj_ptr<T>::type> | |
ConstT | getAs () const |
Retrieves this node after casting to type T. | |
template<class T , typename = typename std::enable_if<!std::is_pointer<T>::value>::type> | |
const T * | getAs () const |
Retrieves this node after casting to type const T. | |
template<class T , typename = typename std::enable_if<std::is_pointer<T>::value>::type> | |
T | getAs () |
Retrieves this node after casting to type const T. | |
template<class T , typename = typename std::enable_if<!std::is_pointer<T>::value>::type> | |
T * | getAs () |
Retrieves this node after casting to type const T. | |
uint32_t | findChildrenByTag (const std::string &tag, std::vector< TreeNode * > &results, int32_t max_depth=-1) |
Finds a set of all children having the selected tag which this node or descendants of this node within a distance of the given max_depth. | |
bool | isDescendantOf (const TreeNode *ancestor, int32_t max_depth=-1) const |
Determines if this node is a descendant of the specified ancestor node within some number of generations (depth). | |
std::string | getLocation () const override final |
std::string | getDisplayLocation () const |
Returns the location of this node in the device tree which might not be usable for navigating the device tree (it cannot be used as an argument for getChild/findChildren). | |
std::string | getExpectedLocation () const |
build-time equivalent to getLocation before an object is actually attached to a tree. This is a mainly a framework and debugging tool for determining what the location of a node currently being constructed will be when complete. | |
std::string | renderSubtree (int32_t max_depth=-1, bool show_builtins=false, bool names_only=false, bool hide_hidden=false, bool(*leaf_filt_fxn)(const TreeNode *)=nullptr) const |
Renders the subtree starting at this node as a string containing an indentation-based depth-first representation. | |
uint32_t | getLevel () const |
Gets the level of this node. 0 is root. | |
template<typename T > | |
uint32_t | getRecursiveNodeCount () const |
Recursively gets the count of a nodes that are a subclass of a particular type (determined by dynamic_cast). Includes all descendants of this node in the tree, but excludes this node. | |
uint32_t | getPossibleNotifications (std::vector< NotificationInfo > &infos) const |
Gets information on the possible notifications generated by this node (excludes children). | |
void | dumpPossibleNotifications (std::ostream &o) const noexcept |
Dumps a listing of the notifications which this node can generate to the ostream o. | |
template<typename DataT = ANY_TYPE> | |
uint32_t | locateNotificationSources (std::vector< TreeNode * > &nodes, const std::string &name="") |
Gets all possible notification info from NotificationSources within this node's subtree. | |
template<typename DataT = ANY_TYPE> | |
void | dumpLocatedNotificationSources (std::ostream &o, const std::string &name="") |
Retrieves the relevant NotificationSources from locateNotificationSources and prints them to the output o. | |
uint32_t | getPossibleSubtreeNotifications (std::vector< NotificationInfo > &infos) const noexcept |
Gets information on the possible notifications generated by this node and all its descendants. | |
void | dumpPossibleSubtreeNotifications (std::ostream &o) const noexcept |
Dumps a listing of the notifications which this node and its descendants can generate to the ostream o. | |
bool | canGenerateNotification (const std::type_info &tinfo, const std::string *name) const |
Can this TreeNode generate a notification of the given type having the given name or pattern. | |
bool | canGenerateNotification (const std::type_info &tinfo, const std::string &name) const |
Can this TreeNode generate a notification of the given type having the given name (does not require interned string - will intern automatically with StringManager). | |
bool | canGenerateNotification (const NotificationInfo &info) const |
Can this TreeNode generate a notification of the given NotificationInfo. | |
bool | canSubtreeGenerateNotification (const std::type_info &tinfo, const std::string *name) const |
Can this TreeNode or its descendants (of any distance) generate a notification of the given type having the given name. | |
bool | canSubtreeGenerateNotification (const std::type_info &tinfo, const std::string &name) const |
Can this TreeNode or its descendants (of any distance) generate a notification of the given type having the given name (does not require interned string) | |
bool | canSubtreeGenerateNotifications (const std::type_info &tinfo, const std::vector< const std::string * > &names) const |
Checks to see if any a subtree can generate any of several notification names which may be patterns. | |
template<typename DataT , typename T , void(T::*)(const TreeNode &, const TreeNode &, const DataT &) TMethod> | |
void | registerForNotification (T *obj, const std::string &name, bool ensure_possible=true) |
Registers a callback method to listen for all notifications having the specified data type DataT and name (or any name if name is "") occuring on this node or any descendant (subtree). | |
template<typename DataT , typename T , void(T::*)(const DataT &) TMethod> | |
void | registerForNotification (T *obj, const std::string &name, bool ensure_possible=true) |
template<typename DataT , typename T , void(T::*)(const TreeNode &, const TreeNode &, const DataT &) TMethod> | |
void | deregisterForNotification (T *obj, const std::string &name) |
Removes at most one registration made with registerForNotification. | |
template<typename DataT , typename T , void(T::*)(const DataT &) TMethod> | |
void | deregisterForNotification (T *obj, const std::string &name) |
bool | hasObserversRegisteredForNotification (const std::type_info &tinfo, const std::string *name) const noexcept |
Determines if this TreeNode (not descendants) has any observers for this type of event and name. | |
void | getDelegatesRegisteredForNotification (const std::type_info &tinfo, const std::string *name, std::vector< delegate > &dels) noexcept |
Gets the vector of delegates registered for a notification on this TreeNode. | |
Public Member Functions inherited from sparta::ResourceContainer | |
ResourceContainer () | |
Consturct with a null, unlocked resource. | |
ResourceContainer (const ResourceContainer &)=delete | |
Copy construction disbled. | |
ResourceContainer (ResourceContainer &&)=default | |
Move constructor. | |
virtual | ~ResourceContainer () |
Destructor. | |
Resource * | getResource () |
Gets the resource contained by this node if any. May only be called after finalization begins or during teardown. | |
const Resource * | getResource () const |
Const variant of getResource. | |
bool | hasResource () const |
Determines if this node has a resource. This method exists in case the TreeNode is being explored by a tool or interactive UI. Typical TreeNode clients (such as Resources) will assume that there is a resource if they are expecting one. | |
template<class T , typename = typename std::enable_if<std::is_pointer<T>::value>::type> | |
const T | getResourceAs () const |
Gets the resource contained by this node (if any) as the given type. | |
template<class T , typename = typename std::enable_if<!std::is_pointer<T>::value>::type> | |
const T * | getResourceAs () const |
Overload of getResourceAs for const access with a non-pointer template type. | |
template<class T , typename = typename std::enable_if<std::is_pointer<T>::value>::type> | |
T | getResourceAs () |
Non-const overload of getResourceAs. | |
template<class T , typename = typename std::enable_if<!std::is_pointer<T>::value>::type> | |
T * | getResourceAs () |
Non-const overload of getResourceAs. | |
virtual std::string | getResourceType () const |
Gets the typename of the resource that this node will eventually contain. | |
virtual std::string | getResourceTypeRaw () const |
Gets the typename of the resource that this node will eventually contain. | |
Public Member Functions inherited from sparta::PhasedObject | |
PhasedObject (PhasedObject &&)=default | |
TreePhase | getPhase () const |
Gets the trees current phase. | |
virtual bool | isBuilding () const |
Is this node (and thus the entire tree above and below it) currently in the TREE_BUILDING phase. | |
virtual bool | isBuilt () const |
Is this node (and thus the entire tree above it) "built". Checks that getPhase has passed TREE_BUILDING. | |
virtual bool | isConfigured () const |
Is this node (and thus the entire tree above it) "configured". Checks that getPhase has passed TREE_CONFIGURING (i.e. FINALIZED, FINALIZING, TEARDOWN, etc). | |
virtual bool | isConfiguring () const |
Is this node (and thus the entire tree above it) currently in the TREE_CONFIGURING phase. | |
virtual bool | isFinalizing () const |
Is this node (and thus the entire tree above it) "finalized". | |
virtual bool | isTearingDown () const |
Is this node (and thus the entire tree above it) in the "teardown" phase. | |
Public Member Functions inherited from sparta::ArchDataContainer | |
std::vector< ArchData * > | getAssociatedArchDatas () |
Retrieves all ArchDatas associated with this TreeNode so that children can use it to allocate their data. | |
const std::vector< ArchData * > | getAssociatedArchDatas () const |
Const variant of getAssociatedArchDatas. | |
ArchDataContainer ()=default | |
Default constructor. | |
ArchDataContainer (ArchDataContainer &)=delete | |
Copy construction disabled. | |
ArchDataContainer (ArchDataContainer &&)=default | |
Move constructor. | |
virtual | ~ArchDataContainer () |
Virtual destructor. | |
Static Public Attributes | |
static const Tick | INDEFINITE |
Constant for infinite tick count. | |
static constexpr char | NODE_NAME [] = "scheduler" |
Name of the Scheduler' TreeNode. | |
Static Public Attributes inherited from sparta::TreeNode | |
static const group_idx_type | GROUP_IDX_NONE = (group_idx_type)-1 |
GroupIndex indicating that a node has no group index because it belongs to no group. | |
static const node_uid_type | MAX_NODE_UID |
Maximum value of node_uid_ before the framework throws an exception. | |
static constexpr char | GROUP_NAME_NONE [] = "" |
Group name indicating that a node belongs to no group. | |
static constexpr char | NODE_NAME_NONE [] = "" |
Node name for anonymous node. | |
static const std::string | DEBUG_DUMP_SECTION_DIVIDER |
String dividing sections in a debug dump file. | |
static constexpr char | NODE_NAME_VIRTUAL_GLOBAL [] = "_SPARTA_virtual_global_" |
Node name for the virtual glopbal node. | |
static constexpr char | LOCATION_NODE_SEPARATOR_ATTACHED = '.' |
Separator character between node identifiers in a location string when the child is attached to the parent. | |
static constexpr char | LOCATION_NODE_SEPARATOR_EXPECTING = ',' |
Separator character between node identifiers in a location string when the child is being attached to the parent but has not been entirely attached (i.g. during construction of the child node) | |
static constexpr char | LOCATION_NODE_SEPARATOR_UNATTACHED = '~' |
Separator character preceding a node identifiers in a location string when that node has no parent and is not in the process of being attached to one. | |
static const uint32_t | RENDER_SUBTREE_INDENT = 2 |
Spaces to indent for each tree level in sparta::TreeNode::renderSubtree. | |
static constexpr char | GROUP_NAME_BUILTIN [] = "_SPARTA_builtin_group_" |
Reserved name for built-in nodes. | |
static const uint64_t | CHILD_FIND_THRESHOLD = 100000 |
Threshold for number of findChildren calls after finalization before a warning message is printed about framework misuse. | |
static const uint64_t | CHILD_GET_THRESHOLD = 100000 |
Threshold for number of getChild calls after finalization before a warning message is printed about framework misuse. | |
static const uint32_t | TEARDOWN_ERROR_LIMIT = 5 |
Number of teardown-phase-related messages that can be printed before the rest will be suppressed. | |
static const std::vector< std::pair< const char *, std::function< void(std::string &)> > > | TREE_NODE_PATTERN_SUBS |
List of pattern susbtitutions when creating a search pattern from a TreeNode name containing wildcards. | |
Friends | |
class | StartupEvent |
Additional Inherited Members | |
Static Public Member Functions inherited from sparta::TreeNode | |
static std::string | createSearchRegexPattern (const std::string &pat) |
Compute a regex pattern for a node child path containing any number of wildcard characters (not a dot-separated location) which can be used to test against child node names. | |
static bool | hasWildcardCharacters (const std::string &name) |
Determines if a given node name has any wildcard characters which will be substituted in createSearchRegexPattern. | |
static std::string | getNextName (const std::string &name, size_t &pos) |
Gets the next name between two '.' chars in a string starting at pos. | |
static bool | matchesGlobLike (const std::string &pattern, const std::string &other) |
Determine if a glob-like search pattern matches some other string. | |
static const std::map< const TreeNode *, WeakPtr > & | getParentlessNodes () |
static const std::map< const TreeNode *, WeakPtr > & | getAllNodes () |
Gets the vector of all TreeNodes currently known to be constructed. | |
static std::string | formatAllNodes () |
Prints the list of all TreeNodes currently known to be constructed. | |
static bool | isNodeConstructed (const TreeNode *) |
Is a given node constructed? | |
static TreeNode * | getVirtualGlobalNode () |
Gets the virtual global node singleton. This node can have no parent and no children. It receives notifications from all nodes in the simulator as if it were the parent of every node in the simulation that has no parent. | |
static std::vector< const std::string * > | parseNotificationNameString (const std::string &csl) |
Parses a comma-separated list of notification names (or patterns) separated by commas and ignoring whitespace around commas. | |
static bool | notificationCategoryMatch (const std::string *query_id, const std::string *node_id) |
Checks if two notification categories match where one is an actual category. | |
Protected Types inherited from sparta::TreeNode | |
typedef std::vector< delegate > | DelegateVector |
Vector of delegates representing a list of observers to notify. | |
typedef std::map< type_info_container, DelegateVector > | NotificationObserverMap |
Map of delegate vectors containing all observers. | |
Protected Member Functions inherited from sparta::TreeNode | |
std::pair< uint32_t, std::string > | recursGetDeepestMatchingPath_ (const std::string &path, size_t name_pos) const |
Finds the deepest node path mathing the input path. Implements getDeepestMatchingPath. | |
void | setExpectedParent_ (const TreeNode *parent) |
Tracks a node as an expected parent without actually adding this node as a child. This is used almost exclusively for printing error messages which include a device-tree location BEFORE actually inserting this node into the device tree since node construction can fail. | |
void | enterFinalizing_ () |
Recursively enter TREE_FINALIZING phase. | |
void | finalizeTree_ () |
Recursively create resources based on tree configuration. enter_finalize_ should be invoked after this method successfully completes for an entire tree. Finalizes in the order of construction. | |
void | validateTree_ () |
Iterates the finalized tree and validates each node (e.g. ensures statistics can be evaluated) | |
void | enterFinalized_ () |
Recursively enter TREE_FINALIZED phase. | |
void | enterConfig_ () noexcept |
Recursively enter TREE_CONFIGURING phase. | |
void | bindTreeEarly_ () |
Recursively invoke TreeNode::onBindTreeEarly_ and Resource::onBindTreeEarly_ (in that order for each node) | |
void | bindTreeLate_ () |
Recursively invoke TreeNode::onBindTreeEarly_ and Resource::onBindTreeLate_ (in that order for each node) | |
void | simulationTerminating_ () |
Hook to allow simulation resources to clean-up before simulation is ended. | |
void | validatePostRun_ (const PostRunValidationInfo &info) const |
Hook to check the state of the simulator post-run and throw exceptions if something is incorrect. | |
void | dumpDebugContent_ (std::ostream &out) const noexcept |
Allows resources to write out detailed textual debugging information about the node. This is typically called by a simulator when shutting down due to an exception (or depending on simulator config). However, it could also be called at other times. | |
void | enterTeardown_ () noexcept |
Recursively enter TREE_TEARDOWN phase while alerting nodes through onEnteringTeardown_ and alterting Resources through Resource::onStartingTeardown_. Nodes already in TREE_TEARDOWN phase will not be alerted (neither will their associated Resources). All nodes are visited regardless of their parent's phase. | |
void | verifyUniqueChildIdentifier_ (const std::string &ident, bool ignore_group_collision=false) |
Verifies that the given identifier is unique for all children of this node by comparing against names, groups, and aliases. Throws SpartaException if not unique. | |
void | removeChildForTeardown_ (TreeNode *child) |
"Removes" the given child by invoking onDestroyingChild_ then removing this child from the children_ list | |
void | removeFromParentForTeardown_ (TreeNode *parent) |
Protected Wrapper for getParent()->removeChildForTeardown_ which allows subclases of TreeNode to indirectly invoke removeChildForTeardown_ with themselves as the argument. | |
void | detachFromParent_ () |
Removes a node from its parent with the expectation this node will be immediately destroyed (i.e. is an xvalue) | |
void | detachFromChildren_ () |
Removes a node from its children with the expectation this node will be immediately destroyed (i.e. is an xvalue) | |
bool | areParametersLocked_ () const |
This method informs whether the tree is past the lockdown phase for all LOCKED and HIDDEN parameters. Modifying LOCKED and HIDDEN parameters after this phase is disallowed. Tree can be locked down during TREE_BUILDING phase or TREE_CONFIGURING phase. During TREE_FINALIZING phase, all parameters are locked down as is. | |
template<typename DataT > | |
void | postPropagatingNotification_ (const TreeNode *origin, const DataT &data, const std::string *name_id) |
Starts a notification propagating up the tree. | |
template<typename DataT , typename T , void(T::*)(const TreeNode &, const TreeNode &, const DataT &) TMethod> | |
DelegateVector::iterator | findDelegate_ (DelegateVector &dvec, T *obj, const std::string &target_name) |
Finds a delegate associated with the given type T, object pointer, DataT, and TMethod within a DelevateVector. The intent of this function is to help see if a delegate is already registered with a calback by checking all known information associated with that callback against the input arguments. | |
template<typename DataT , typename T , void(T::*)(const DataT &) TMethod> | |
DelegateVector::iterator | findDelegate_ (DelegateVector &dvec, T *obj, const std::string &target_name) |
virtual void | broadcastRegistrationForNotificationToChildren_ (const std::type_info &tinfo, const std::vector< const std::string * > &name_ids, TreeNode *obs_node, const delegate *del, const bool allow_private) |
Recursively notifies children that the notification described is now (or still is) being observed at the observation point TreeNode obs_node with the newly registered delegate del. | |
virtual void | broadcastDeregistrationForNotificationToChildren_ (const std::type_info &tinfo, const std::vector< const std::string * > &name_ids, TreeNode *obs_node, const delegate *del, const bool allow_private) |
Recursively notifies children that the notification described has lost one particular observer (del) which was observing at the observation point TreeNode obs_node with the delegate del. | |
void | broadcastRegistrationForNotificationListStringToChildren_ (const std::type_info &tinfo, const std::string &name, TreeNode *obs_node, const delegate *del, const bool private_only) |
Entry point to broadcastRegistrationForNotificationToChildren_ recursion. Breaks a name string. | |
void | broadcastDeregistrationForNotificationListStringToChildren_ (const std::type_info &tinfo, const std::string &name, TreeNode *obs_node, const delegate *del, const bool private_only) |
Symmetric oppostie of broadcastRegistrationForNotificationListStringToChildren_. | |
template<typename DataT > | |
void | invokeDelegatesOn_ (TreeNode *to_invoke, const DataT &data, const std::string *name_id) |
Protected wrapper for invokeDelegates_ which allows a TreeNode to invoke delegates on another TreeNode using itself as the origin. | |
Protected Member Functions inherited from sparta::ResourceContainer | |
std::string | getResourceTypeName_ () const |
Gets the rtti type name (demangled) of the resource type held by this container. If there is no resource held, returns empty string. | |
void | setResource_ (Resource *r) |
Allows subclasses to assign the resource associated with this node. | |
void | unsetResource_ () |
Allows a resource to unset the resource set with setResource_. | |
void | lockResource_ () |
Allows subclasses to assign the resource associated with this node. | |
Resource * | getResource_ () noexcept |
Returns the currently held resource of this node (if any). This method can be called at any time. | |
const Resource * | getResource_ () const noexcept |
Const variant of getResource_. | |
Protected Member Functions inherited from sparta::PhasedObject | |
void | setPhase_ (TreePhase phase) |
Sets the current phase. | |
Static Protected Member Functions inherited from sparta::TreeNode | |
static bool | identityMatchesPattern_ (const std::string &ident, std::regex &expr, std::vector< std::string > &replacements) |
Performs pattern matching on a identity string. | |
static bool | identityMatchesPattern_ (const std::string &ident, std::regex &expr) |
Variant of identityMatchesPattern_ with no replacements vector. | |
static std::string | getPreviousName_ (const std::string &name, size_t &pos) |
Gets the previous name between two '.' chars in a string starting at pos. | |
A class that lets you schedule events now and in the future.
The sparta::Scheduler class simply schedules callback methods for some time in the future. These callbacks are typically scheduled by sparta::Scheduleable class and its derivatives, but the sparta::scheduler is open to anyone who wishes to schedule a callback (but this is highly discouraged).
The callback type is sparta::SpartaHandler, a copyable method delegate that allows a user to specify a function of their class as a callback point. The callback form is expected to be of the following:
Time in the sparta::Scheduler can be interpreted anyway the user wishes, but the base unit is a sparta::Scheduler::Tick. For most simulation uses, the Tick is considered a PS of time. To convert a Tick to a higher-order unit such as a clock cycle, use a sparta::Clock made from a sparta::ClockManager to perform the conversions.
A typical flow for scheduling events is:
The sparta::Scheduler is a sparta::RootTreeNode so that it can be seen in a global search scope, and loggers can be attached. For example, try this on the CoreExample:
Or do this in your C++ code:
The sparta::Scheduler has a concept of "phased grouping" that allows a user to specify which callback they want called before another in time. Each SPARTA event type has an associated sparta::SchedulingPhase phase in its template parameter list that the event will always be placed in. In that phase, the event will always come before a "higher priority phase" and always after a "lower priority phase." But, within its assigned phase, the event will still be semi-random with respect to other events. It's "semi-random," meaning order will be indentical between simulation runs, but possibly different once the simulator is modified at the source-code level. This can be annoying.
Ordering within a phase is provided by a Direct Acyclic Graph or sparta::DAG. The DAG uses a class called sparta::Scheduleable that represents a position within the DAG and an ordering group within a SchedulingPhase. By default the sparta::Scheduleable is not in a group and is standalone within its assigned sparta::SchedulingPhase. Once a precedence between two sparta::Scheduleable objects is established, an ordering with assigned. This results in each sparta::Scheduleable being designated into an ordering group by the DAG. Event types (sparta::Event, sparta::UniqueEvent, sparta::PayloadEvent) provide this support. The developer can order an event type to precede another event, but only if the events are in the same SchedulingPhase:
The sparta::Scheduler is responsible for finalizing the DAG. The DAG is finalized when the sparta::Scheduler is finalized through the sparta::Scheduler::finalize method called by the framework. Therefor, all events can only be scheduled after the sparta::scheduler is finalized. It is illegal to schedule events before the dag is finalized because precedence has not been fully established. Any startup work can be scheduled via the sparta::StartupEvent class before sparta::Scheduler finalization.
The expected usage is something like:
Definition at line 193 of file Scheduler.hpp.
typedef uint64_t sparta::Scheduler::Tick |
Typedef for our unit of time.
Definition at line 198 of file Scheduler.hpp.
|
inline |
Constructor with name.
See other scheduler constructor
Definition at line 349 of file Scheduler.hpp.
sparta::Scheduler::Scheduler | ( | const std::string & | name, |
GlobalTreeNode * | search_scope | ||
) |
Construct with a name and a specific global search scope (global parent)
name | Name of this scheduler node. |
search_scope | Scope in which this global scheduler node will exist |
Const expression to calculate tick value for indexing.
Definition at line 313 of file Scheduler.hpp.
void sparta::Scheduler::cancelAsyncEvent | ( | Scheduleable * | scheduleable | ) |
Cancel the given Scheduleable.
scheduleable | The Scheduleable to cancel (remove) |
This method should only be called from the main scheduler thread.
void sparta::Scheduler::cancelEvent | ( | const Scheduleable * | scheduleable | ) |
Cancel the given Scheduleable if on the Scheduler.
scheduleable | The Scheduleable to cancel (remove) |
Will search in all time quantums for the given Scheduleable instance and cancel it everywhere found.
void sparta::Scheduler::cancelEvent | ( | const Scheduleable * | scheduleable, |
Tick | rel_time | ||
) |
Cancel the given Scheduleable if on the Scheduler at the given time.
scheduleable | The Scheduleable to cancel (remove) |
rel_time | The time quantum to search in |
Will search only in the given time quantum for the given Scheduleable and cancel it.
void sparta::Scheduler::clearEvents | ( | ) |
Clears all events in the scheduler without executing any of them.
SpartaException | if the scheduler is running. This method can not be called while running. |
void sparta::Scheduler::deregisterClock | ( | sparta::Clock * | clk | ) |
Deregister a clock from this Scheduler
clk | Pointer to a sparta::Clock to be deregistered |
|
inline |
Enable the watchdog timer.
watchdog_timeout_ps | The timeout period for the watchdog timer |
If the watchdog is enabled, then the Scheduler will assert if simulation ever runs for 'watchdog_timeout_ps' picoseconds without someone calling kickTheDog().
By default, the watchdog is disabled.
Definition at line 768 of file Scheduler.hpp.
void sparta::Scheduler::finalize | ( | ) |
Finalize the scheduler and allow running.
|
inline |
Definition at line 808 of file Scheduler.hpp.
|
inline |
Definition at line 821 of file Scheduler.hpp.
|
inline |
Returns a StatisticDef holding the microsecond count of this scheduler.
Definition at line 883 of file Scheduler.hpp.
|
inline |
Returns a StatisticDef holding the millisecond count of this scheduler.
Definition at line 875 of file Scheduler.hpp.
|
inline |
Returns a StatisticDef holding the nanosecond count of this scheduler.
Definition at line 891 of file Scheduler.hpp.
|
inline |
Returns a counter holding the current picosecond count of this scheduler.
Definition at line 859 of file Scheduler.hpp.
|
inline |
Definition at line 826 of file Scheduler.hpp.
|
inlinenoexcept |
The current tick the Scheduler is working on or just finished.
Definition at line 718 of file Scheduler.hpp.
|
inline |
Returns a counter holding the current tick count of this scheduler.
Definition at line 851 of file Scheduler.hpp.
|
inline |
|
inlinenoexcept |
The total elapsed ticks.
This function returns the number of elapsed ticks since the beginning of simulation. This is different from the tick returned from getCurrentTick() in that it will be typically one tick ahead of the current tick at the end of a time quantum.
For example, prior to a call to run(), current tick could be 100, while the number of elapsed ticks is 101. During the run, both numbers will be the same, 101 until the Scheduler finishes the current time quantum. Once complete, the return from getCurrentTick() will be 101 and elapsed tick will be 102.
Definition at line 738 of file Scheduler.hpp.
|
inline |
Returns the frequency (in ticks per simulated second) of this Scheduler.
Definition at line 843 of file Scheduler.hpp.
|
inline |
Get the raw pointer of "global" PhasedPayloadEvent inside sparta::Scheduler.
Definition at line 1074 of file Scheduler.hpp.
|
inlinenoexcept |
Returns the Tick quantum where the next continuing event resides.
You cannot use this function to determine if there are continuing events left in the Scheduler. Use isFinished() to determine that.
Definition at line 800 of file Scheduler.hpp.
|
inlinenoexcept |
Definition at line 785 of file Scheduler.hpp.
|
inline |
Return the number of nanoseconds the scheduler has been in run.
Definition at line 319 of file Scheduler.hpp.
|
inline |
Get the wall clock run time.
Definition at line 326 of file Scheduler.hpp.
|
inline |
Returns a StatisticDef holding the picosecond count of this scheduler.
Definition at line 867 of file Scheduler.hpp.
|
inlinenoexcept |
Definition at line 746 of file Scheduler.hpp.
|
inlineoverridevirtualnoexcept |
Is the scheduler finalized.
Reimplemented from sparta::PhasedObject.
Definition at line 696 of file Scheduler.hpp.
|
inline |
Returns true if there are no more pending non-continuing events.
Definition at line 665 of file Scheduler.hpp.
|
inlinenoexcept |
Query if the scheduler is running.
Definition at line 706 of file Scheduler.hpp.
bool sparta::Scheduler::isScheduled | ( | const Scheduleable * | scheduleable | ) | const |
Is the given Scheduleable item anywhere (in time now -> future) on the Scheduler?
scheduleable | The Scheduleable item (used for pointer compare) |
This function will look for the given Scheduleable item and determine if it is on the scheduler at any time either now or in the future. The function does not do a full blown Scheduleable class compare, but rather a pointer comparison.
This function is expensive and should be used with caution.
bool sparta::Scheduler::isScheduled | ( | const Scheduleable * | scheduleable, |
Tick | rel_time | ||
) | const |
Is the given Scheduleable item already scheduled?
scheduleable | The Scheduleable item (used for pointer compare) |
rel_time | The intended delivery time |
This function will look for the given Scheduleable item and determine if it is on the scheduler at the given time. The function does not do a full blown Scheduleable class compare, but rather a pointer comparison.
This function is rather inefficient for rel_times that are pretty large.
|
inlinenoexcept |
Reset the watchdog timer.
Definition at line 754 of file Scheduler.hpp.
|
inline |
Returns the next tick an event is pending.
Definition at line 676 of file Scheduler.hpp.
|
inline |
A method used for debugging the scheduler. Prints the scheduler's schedule of events.
os | the stream to print the schedule to. |
curr_grp | The group to start printing from (set to 0) |
curr_event | Within a group, the current event to start printing from |
future | By default equals 0 which will print the scheduled events for the next cycle. |
Definition at line 1127 of file Scheduler.hpp.
void sparta::Scheduler::registerClock | ( | sparta::Clock * | clk | ) |
void sparta::Scheduler::reset | ( | ) |
Reset the scheduler. Tears down all events, the DAG, and sets all outstanding TopoSortables to an invalid group ID
void sparta::Scheduler::restartAt | ( | Tick | t | ) |
Clears the events in the scheduler, sets the current tick to tick and the elapsed ticks to either tick or tick plus 1.
t | Tick to set scheduler at |
A call to restartAt is asking the Scheduler to back up to the given time as if it were either at the beginning or end of that time. Events scheduled with a zero rel_time will be scheduled at time t. Elapsed time still reflects t + 1 in the case where t != 0, indicating how many ticks have elapsed.
In the case where t == 0, elapsed time is also set to zero as no time has elapsed.
void sparta::Scheduler::run | ( | Tick | num_ticks = INDEFINITE , |
const bool | exacting_run = false , |
||
const bool | measure_run_time = true |
||
) |
Enter running state and runs the scheduler until running is stopped (e.g. through a stop event) or the scheduler runs out of queued, continuing events.
num_ticks | The most number of ticks to advance. This number is not inclusive (see notes) |
exacting_run | If num_ticks < Inf, should the Scheduler run to exactly the number given? Default is no. |
measure_run_time | Capture running time (user and system). Default is true. This can be expensive in back-to-back-to-back calls of run. |
Runs the Scheduler for the given number of ticks. Default behavior is "run forever" where the Scheduler will only stop if one of the following condition occur:
#. A call to Scheduler::stopRunning() #. There are no more non-continuing events on the Scheduler
If a finite number of ticks are given to run, then the Scheduler will stop when one of the following conditions is met:
#. The Scheduler reaches the end of the tick quantum determined by current time + num_ticks - 1, regardless of the setting of exacting_run
#. If exacting_run == false and there are no more events or there are no more non-continuing events scheduled, the Scheduler will cease before num_ticks have elapsed. To change this behavior, set exacting_run to true.
void sparta::Scheduler::scheduleAsyncEvent | ( | Scheduleable * | sched, |
Scheduler::Tick | delay | ||
) |
Asynchronously schedule an event.
sched | The sparta::Scheduleable to schedule |
delay | Delay relative to the time the event is actually scheduled |
This method is intended to be called by threads other than the main scheduling thread (i.e., the thread that runs Scheduler::run()) that wants to schedule events on the scheduler.
This method does not necessarily schedule the event right away. The event will be queued up and scheduled at the schedulers first convenience. The delay parameter is relative to the time when the event is actually being scheduled.
void sparta::Scheduler::scheduleEvent | ( | Scheduleable * | scheduleable, |
Tick | rel_time, | ||
uint32_t | dag_group = 0 , |
||
bool | continuing = true , |
||
bool | add_if_not_scheduled = false |
||
) |
Schedule a single event. This method should also be thread safe.
scheduleable | The sparta::Scheduleable to schedule |
rel_time | The relative time to schedule the event (i.e. 10 hyper-cycles from now) |
dag_group | the group id assigned by the Dag, default 0 |
continuing | If true, this event will cause the simulator to continue running at least until it is fired (or something explicitly stops the scheduler). If false, the simulator can exhaust its list of continuing events and stop before this event is reached. This usage is typically for infrastructure events or counters, etc. |
add_if_not_scheduled | Only add the event if not already scheduled at the given rel_time |
|
inline |
Tell the scheduler to stop running.
If scheduler is not running or not finalized, has no effect.
Definition at line 424 of file Scheduler.hpp.
|
friend |
Definition at line 901 of file Scheduler.hpp.
|
static |
Constant for infinite tick count.
Definition at line 334 of file Scheduler.hpp.
|
staticconstexpr |
Name of the Scheduler' TreeNode.
Definition at line 339 of file Scheduler.hpp.