The Sparta Modeling Framework
Loading...
Searching...
No Matches
sparta::ParameterSet Class Reference

Generic container of Parameters. More...

#include <ParameterSet.hpp>

Inheritance diagram for sparta::ParameterSet:
Collaboration diagram for sparta::ParameterSet:

Classes

class  ParameterSetIterator
 Non-const iterator for ParameterSet. More...
 

Public Types

typedef std::vector< sparta::ParameterBase * > ParameterVector
 Vector of ParameterBase pointers.
 
typedef std::unordered_map< std::string, ParameterBase * > ParameterPairs
 Mapping of parameter names to parameters (for fast lookup by name)
 
typedef ParameterSetIterator< ParameterPairs::iterator > iterator
 Non-const iterator.
 
typedef ParameterSetIterator< ParameterPairs::const_iterator > const_iterator
 Const iterator.
 
- 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< TreeNodeWeakPtr
 Weak pointer to a TreeNode. Acquire with getWeakPtr.
 
typedef std::weak_ptr< const TreeNodeConstWeakPtr
 Weak pointer to a const TreeNode. Acquire with getWeakPtr.
 
typedef std::shared_ptr< TreeNodeSharedPtr
 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

 ParameterSet ()=delete
 Default constructor disabled.
 
 ParameterSet (const ParameterSet &rhp)=delete
 Copying disabled. Do not override.
 
void operator= (const ParameterSet &rhp)=delete
 Copying disabled. Do not override.
 
 ParameterSet (TreeNode *parent)
 Constructor.
 
virtual ~ParameterSet ()=default
 Destructor.
 
bool validateIndependently (std::string &err_names) const
 
bool validateDependencies (const TreeNode *node, std::string &err_names) const
 
void resetReadCounts ()
 Reset the read-count on all Parameters in this set.
 
void resetWriteCounts ()
 Reset the write-count on all Parameters in this set.
 
void verifyAllRead () const
 Checks the read-count on all Parameters. If any have no been read at least once since last write (since initialization if never written) then throws ParameterException.
 
void ignoreAll () const
 Increments the read count of each Parameter in this set.
 
virtual std::string dumpList () const
 Print out a friendly set of parameters.
 
virtual std::string stringize (bool pretty=false) const override
 Create a string representation of this node.
 
template<class T >
const T getParameterValueAs (const std::string &name) const
 Finds a parameter and gets its value as the templated type.
 
template<class ContentT >
const Parameter< ContentT > & getParameterAs (const std::string &name) const
 Retrieves a sparta::Parameter<ContentT> reference from this parameter set.
 
template<class ContentT >
Parameter< ContentT > & getParameterAs (const std::string &name)
 
ParameterBasegetParameter (const std::string &name, bool must_exist=true)
 Gets a TreeNode by exact path relative to this node.
 
const ParameterBasegetParameter (const std::string &name, bool must_exist=true) const
 Const qualified variant of getParameter.
 
uint32_t findParameters (const std::string &name, std::vector< ParameterBase * > &results)
 
bool hasParameter (const std::string &name) const
 Determines whether this ParameterSet has the parameter with the given name.
 
bool hasModificationPermission (const ParameterBase *modifying_param, std::vector< const ParameterBase * > params) const
 Determine if the given parameter can safely modify the given list of parameters.
 
bool canParameterBeModifiedByLockingParam (const ParameterBase *modify_e)
 Determine if the given parameter can be modified by a parameter currently writing to the parameter set.
 
void lock (const ParameterBase *lock_param)
 Lock the parameter set for parameter to parameter updates.
 
bool isLocked () const
 Is the parameter set currently locked by another parameter.
 
void unlock (const ParameterBase *unlock_param)
 Unlock the parameter set for parameter to parameter updates.
 
std::vector< std::string > getNames () const
 
iterator begin ()
 
iterator end ()
 
const_iterator begin () const
 
const_iterator end () const
 
size_t getNumParameters () const
 
uint32_t readVolatileParamValuesFromVirtualTree ()
 Read values for each volatile parameter from the virtual tree and re-write them to the parameters the way SPARTA did before the virtual parameter tree existed.
 
uint32_t readAllParamValuesFromVirtualTree ()
 Read values for all parameters from the virtual tree and re-write them to the parameters the way SPARTA did before the virtual parameter tree existed.
 
- Public Member Functions inherited from sparta::TreeNode
const ClockgetClock () override
 Walks up parents (starting with self) until a parent with an associated local clock is found, then returns that clock.
 
const ClockgetClock () const
 
const ClockgetLocalClock ()
 Gets the clock associated directly with this Node. This is useful for configuration and simulator debug, but not at run-time.
 
const ClockgetLocalClock () const
 
virtual void setClock (const Clock *clk)
 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.
 
SchedulergetScheduler (const bool must_exist=false)
 Get the scheduler associated with this tree node's root.
 
const SchedulergetScheduler (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.
 
TreeNodeoperator= (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.
 
ExtensionsBasegetExtension (const std::string &extension_name)
 Get an extension object by type string. Returns nullptr if not found (unrecognized).
 
ExtensionsBasegetExtension ()
 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.
 
virtual bool isAttached () const
 Is this node part of a device tree with a proper RootTreeNode at the root.
 
virtual TreeNodegetParent ()
 Gets immediate parent of this node if one exists.
 
virtual const TreeNodegetParent () const
 
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>
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 TreeNodegetRoot ()
 Gets farthest ancestor of this node.
 
virtual const TreeNodegetRoot () const
 
TreeNodegetScopeRoot ()
 
const TreeNodegetScopeRoot () const
 
const TreeNodegetExpectedRoot () 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::SimulationgetSimulation () 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.
 
TreeNodegetChildAt (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::TreeNodefindAncestorByName (const std::string &name)
 Find ancestor by name.
 
template<typename T >
sparta::TreeNodefindAncestorByType ()
 Find ancestor by type.
 
sparta::TreeNodefindAncestorByTag (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 AliasVectorgetAliases () 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.
 
TreeNodegetChild (const std::string &name, bool must_exist=true)
 Retrieves a child with this dotted path name.
 
const TreeNodegetChild (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>
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>
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.
 
ResourcegetResource ()
 Gets the resource contained by this node if any. May only be called after finalization begins or during teardown.
 
const ResourcegetResource () 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>
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 isFinalized () 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 Member Functions

static uint32_t getNumBoundTypes ()
 Gets the number of bound types.
 
- 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 TreeNodegetVirtualGlobalNode ()
 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.
 

Public Attributes

ParameterSet__this_ps
 Pointer to this ParameterSet accessible in class declaration scope. This is used By parameters to attach themselves to the parent at construction.
 

Static Public Attributes

static constexpr char NODE_NAME [] = "params"
 Name of any ParameterSet TreeNode.
 
static constexpr char PARAMETER_SET_NODE_TAG [] = "SPARTA_ParameterSet"
 Tag added to ParameterSet nodes.
 
- 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.
 

Protected Member Functions

void addParameter_ (sparta::ParameterBase *p)
 Add a parameter to the parameter set. \temp This will be removed.
 
virtual void onAddingChild_ (TreeNode *child) override
 React to child registration.
 
virtual void onAddedAsChild_ () noexcept override
 When added to the tree after construction, try and pull values for paraemters. Finalize the ParameterSet before attaching it to a tree if this is not desired.
 
const ParameterTreegetSimParameterTree_ ()
 Find the virtual parameter tree for this node's tree from its root.
 
const ParameterTreegetSimArchParameterTree_ ()
 Find the virtual architectural parameter tree for this node's tree from its root.
 
void readValuesFromVirtualTree_ ()
 Read values for every parameter of possible from the virtual parameter tree if possible.
 
bool readValueFromVirtualTree_ (const ParameterTree *arch_pt, const ParameterTree *pt, sparta::ParameterBase *p)
 Read a value for a single parameter from the virtual tree and write it to the selected parameter. Also loads it's default from the arch virtual tree.
 
- 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.
 
ResourcegetResource_ () noexcept
 Returns the currently held resource of this node (if any). This method can be called at any time.
 
const ResourcegetResource_ () const noexcept
 Const variant of getResource_.
 
- Protected Member Functions inherited from sparta::PhasedObject
void setPhase_ (TreePhase phase)
 Sets the current phase.
 

Protected Attributes

ParameterPairs keys_
 Map of name (key) to ParameterBase* instances.
 
ParameterVector params_
 Straight vector of registered parameters.
 

Friends

class ParameterBase
 For invoking addParameter_.
 

Additional Inherited Members

- Protected Types inherited from sparta::TreeNode
typedef std::vector< delegateDelegateVector
 Vector of delegates representing a list of observers to notify.
 
typedef std::map< type_info_container, DelegateVectorNotificationObserverMap
 Map of delegate vectors containing all observers.
 
- 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.
 

Detailed Description

Generic container of Parameters.

Todo:
Deduce set of fields using boost::fusion or other instrospection fields instead of the current __collect method.
Note
non-copyable

Parameter names within a single ParameterSet cannot be duplicated. Parameters are added to the device tree as TreeNodes.

Typical use is to subclass this object for each simulator component/model which has a set of parameters it must consume. sparta::ParameterSet provides a generic interface through which config-file parsers or command-line parsers can populate the parameters from strings. Models that expose the ParameterSet full of sparta::Parameter instances should dynamic_cast a sparta::ParameterSet supplied to them at runtime back to a known type and operate through Parameters directly instead of through this generic interface.

Printing a ParameterSet and its Parameters

// For some ParamterSet& ps
cout << ps << endl;

Locating a single parameter within a ParameterSet

// For some ParamterSet& ps
cout << ps.getParameter("param1") << endl; // Exception if not found

Searching for parameters within a ParameterSet

// For some ParamterSet& ps
cout << p.getParameter("param1") << endl; // No exception if not found
Todo:
Allow defaulting the numeric display base for entire set (like sparta::Parameter::setNumericDisplayBase)

Definition at line 64 of file ParameterSet.hpp.

Member Typedef Documentation

◆ const_iterator

typedef ParameterSetIterator<ParameterPairs::const_iterator> sparta::ParameterSet::const_iterator

Const iterator.

Definition at line 557 of file ParameterSet.hpp.

◆ iterator

typedef ParameterSetIterator<ParameterPairs::iterator> sparta::ParameterSet::iterator

Non-const iterator.

Definition at line 554 of file ParameterSet.hpp.

◆ ParameterPairs

typedef std::unordered_map<std::string, ParameterBase*> sparta::ParameterSet::ParameterPairs

Mapping of parameter names to parameters (for fast lookup by name)

Definition at line 94 of file ParameterSet.hpp.

◆ ParameterVector

Vector of ParameterBase pointers.

Definition at line 91 of file ParameterSet.hpp.

Constructor & Destructor Documentation

◆ ParameterSet()

sparta::ParameterSet::ParameterSet ( TreeNode parent)
inline

Constructor.

Parameters
parentTreeNode parent of this ParameterSet node.
Note
ParameterSets do not currently inherit construction phase from the parent. They must be caught up later

Definition at line 102 of file ParameterSet.hpp.

Here is the call graph for this function:

Member Function Documentation

◆ addParameter_()

void sparta::ParameterSet::addParameter_ ( sparta::ParameterBase p)
protected

Add a parameter to the parameter set. \temp This will be removed.

Todo:
This must be done automatically by onAddingChild_ and not explicitly by anyone except ParametersThemselves

◆ begin() [1/2]

iterator sparta::ParameterSet::begin ( )
inline

Definition at line 568 of file ParameterSet.hpp.

◆ begin() [2/2]

const_iterator sparta::ParameterSet::begin ( ) const
inline

Definition at line 578 of file ParameterSet.hpp.

◆ canParameterBeModifiedByLockingParam()

bool sparta::ParameterSet::canParameterBeModifiedByLockingParam ( const ParameterBase modify_e)
inline

Determine if the given parameter can be modified by a parameter currently writing to the parameter set.

Parameters
modify_eThe modify-E
Exceptions
SpartaExceptionif the modify-E is the parameter at the top of the stack
Returns
true if can, false otherwise

Definition at line 436 of file ParameterSet.hpp.

Here is the call graph for this function:

◆ dumpList()

virtual std::string sparta::ParameterSet::dumpList ( ) const
inlinevirtual

Print out a friendly set of parameters.

Todo:
This should be optimized to store fields in a matrix such that each string isn't rendered twice

Definition at line 223 of file ParameterSet.hpp.

Here is the call graph for this function:

◆ end() [1/2]

iterator sparta::ParameterSet::end ( )
inline

Definition at line 573 of file ParameterSet.hpp.

◆ end() [2/2]

const_iterator sparta::ParameterSet::end ( ) const
inline

Definition at line 583 of file ParameterSet.hpp.

◆ findParameters()

uint32_t sparta::ParameterSet::findParameters ( const std::string &  name,
std::vector< ParameterBase * > &  results 
)
inline
Note
This method should not be called in performance sensitive areas

Definition at line 363 of file ParameterSet.hpp.

Here is the call graph for this function:

◆ getNames()

std::vector< std::string > sparta::ParameterSet::getNames ( ) const
inline

Definition at line 560 of file ParameterSet.hpp.

◆ getNumBoundTypes()

static uint32_t sparta::ParameterSet::getNumBoundTypes ( )
inlinestatic

Gets the number of bound types.

Returns
Number of bound type for this build of sparta.

Definition at line 392 of file ParameterSet.hpp.

◆ getNumParameters()

size_t sparta::ParameterSet::getNumParameters ( ) const
inline

Definition at line 588 of file ParameterSet.hpp.

◆ getParameter() [1/2]

ParameterBase * sparta::ParameterSet::getParameter ( const std::string &  name,
bool  must_exist = true 
)
inline

Gets a TreeNode by exact path relative to this node.

Parameters
nameSearch path from this node
must_existShould this method generate an exception if the parameter does not exist
Returns
A valid TreeNode*. If child cannot be found, method throws

See sparta::TreeNode::getChild for more information on using get* methods in a TreeNode.

Definition at line 351 of file ParameterSet.hpp.

◆ getParameter() [2/2]

const ParameterBase * sparta::ParameterSet::getParameter ( const std::string &  name,
bool  must_exist = true 
) const
inline

Const qualified variant of getParameter.

Definition at line 358 of file ParameterSet.hpp.

◆ getParameterAs() [1/2]

template<class ContentT >
Parameter< ContentT > & sparta::ParameterSet::getParameterAs ( const std::string &  name)
inline

Definition at line 329 of file ParameterSet.hpp.

◆ getParameterAs() [2/2]

template<class ContentT >
const Parameter< ContentT > & sparta::ParameterSet::getParameterAs ( const std::string &  name) const
inline

Retrieves a sparta::Parameter<ContentT> reference from this parameter set.

Template Parameters
ContentTType of Parameter to get
Parameters
nameName of parameter to get. Parameter with this name must be of the type specified by ContentT
Returns
Parameter as sparta::Parameter<ContentT>& if the parameter is found by name and was of type ContentT
Exceptions
SpartaExecptionif parameter with given name does not exist or was not a Parameter containing ContentT.
Note
Returns a reference. Therefore, requested parameter must exist

Example

Parameter<uint32_t>& p = paramset->getParameterAs<uint32_t>("myint");
Parameter instance, templated to contain only a specific type.

Definition at line 315 of file ParameterSet.hpp.

Here is the call graph for this function:

◆ getParameterValueAs()

template<class T >
const T sparta::ParameterSet::getParameterValueAs ( const std::string &  name) const
inline

Finds a parameter and gets its value as the templated type.

Template Parameters
TType of parameter to get.
Parameters
nameName of parameter whose value should be retrieved. Must match parameter name exactly.
Returns
Value of parameter as type T if T is the internally held type of this parameter.
Exceptions
ParameterExceptionif the parameter of name cannot be found or the found parameter does not actually hold a value of (exactly) type T.
Note
Type t must match exactly. There is no intelligent casting. If the variable stores its value as a uint32_t, the template type T must be uint32_t, not uint64_t, int32_t, or string,
Warning
Uses a dynamic cast. Do not use in performance critical code
See also
ParameterBase::getValueAsString
ParameterBase::getTypeName

Definition at line 286 of file ParameterSet.hpp.

Here is the call graph for this function:

◆ getSimArchParameterTree_()

const ParameterTree * sparta::ParameterSet::getSimArchParameterTree_ ( )
protected

Find the virtual architectural parameter tree for this node's tree from its root.

Returns
nullptr if this node is not attached to a root or the root has no simulator pointer or the simulator has no virutal parmater tree.

◆ getSimParameterTree_()

const ParameterTree * sparta::ParameterSet::getSimParameterTree_ ( )
protected

Find the virtual parameter tree for this node's tree from its root.

Returns
nullptr if this node is not attached to a root or the root has no simulator pointer or the simulator has no virutal parmater tree.

◆ hasModificationPermission()

bool sparta::ParameterSet::hasModificationPermission ( const ParameterBase modifying_param,
std::vector< const ParameterBase * >  params 
) const
inline

Determine if the given parameter can safely modify the given list of parameters.

Parameters
modifying_paramThe modifying (or writing) parameter
paramsVector of parameters to question
Exceptions
SpartaExceptionspecifying which parameter cannot be modified
Returns
True if has permission; false in NDEBUG mode

Definition at line 404 of file ParameterSet.hpp.

◆ hasParameter()

bool sparta::ParameterSet::hasParameter ( const std::string &  name) const
inline

Determines whether this ParameterSet has the parameter with the given name.

Definition at line 383 of file ParameterSet.hpp.

◆ ignoreAll()

void sparta::ParameterSet::ignoreAll ( ) const
inline

Increments the read count of each Parameter in this set.

Note
This method is for testing purposes only. Normal framework use should not require artificially incrementing read counts
See also
sparta::Parameter::ignore
Warning
Read counts must may be reset by sparta infrastructure so this method may have no effect if called within a ParameterSet constructor. The point of this behavior is to prevent early reads of any parameter in this ParameterSet from appearing as if the Resource that owns this ParmeterSet read it.

Definition at line 216 of file ParameterSet.hpp.

◆ isLocked()

bool sparta::ParameterSet::isLocked ( ) const
inline

Is the parameter set currently locked by another parameter.

Returns
true if locked; false otherwise

Definition at line 456 of file ParameterSet.hpp.

◆ lock()

void sparta::ParameterSet::lock ( const ParameterBase lock_param)

Lock the parameter set for parameter to parameter updates.

Parameters
lock_paramThe parameter doing the locking

◆ onAddedAsChild_()

virtual void sparta::ParameterSet::onAddedAsChild_ ( )
overrideprotectedvirtualnoexcept

When added to the tree after construction, try and pull values for paraemters. Finalize the ParameterSet before attaching it to a tree if this is not desired.

Reimplemented from sparta::TreeNode.

◆ onAddingChild_()

virtual void sparta::ParameterSet::onAddingChild_ ( TreeNode child)
overrideprotectedvirtual

React to child registration.

Parameters
childTreeNode child that must be downcastable to a sparta::ParameterBase. This is a borrowed reference - child is not copied. Child lifetime must exceed that of this ParmeterSet instance.

Overrides TreeNode::onAddingChild_

Reimplemented from sparta::TreeNode.

◆ readAllParamValuesFromVirtualTree()

uint32_t sparta::ParameterSet::readAllParamValuesFromVirtualTree ( )

Read values for all parameters from the virtual tree and re-write them to the parameters the way SPARTA did before the virtual parameter tree existed.

Precondition
Must be in TREE_CONFIGURING phase
All parameters found must either not have been read or must be volatile parameters. Errors will occur if the virtual tree contains values for non-volatile parameters which have already been read.
Returns
Number of parameters which found falues in the virtual tree
Note
Ignores whether the parameters have been read or already written from the virtual tree

◆ readValueFromVirtualTree_()

bool sparta::ParameterSet::readValueFromVirtualTree_ ( const ParameterTree arch_pt,
const ParameterTree pt,
sparta::ParameterBase p 
)
protected

Read a value for a single parameter from the virtual tree and write it to the selected parameter. Also loads it's default from the arch virtual tree.

Parameters
[in]arch_ptArchitectural Parameter Tree from which the default value of the target parameter should be retrieved (if available)
[in]ptParameter Tree from which the value for the target parameter should be retrieved
[in]pParameter to which a value from the virtual parameter tree shold be written. Should either be a volatile parameter (sparta::Parameter::isVolatile) or have a 0 read count.
Todo:
Merge this into ParameterBase construction if possible
Returns
true if value was read from virtual tree, false if not (no value available)

◆ readVolatileParamValuesFromVirtualTree()

uint32_t sparta::ParameterSet::readVolatileParamValuesFromVirtualTree ( )

Read values for each volatile parameter from the virtual tree and re-write them to the parameters the way SPARTA did before the virtual parameter tree existed.

Precondition
Must be in TREE_CONFIGURING phase
Returns
Number of volatile parameters which found falues in the virtual tree
Note
Ignores whether the parameters have been read or already written from the virtual tree

◆ resetReadCounts()

void sparta::ParameterSet::resetReadCounts ( )
inline

Reset the read-count on all Parameters in this set.

Definition at line 158 of file ParameterSet.hpp.

◆ resetWriteCounts()

void sparta::ParameterSet::resetWriteCounts ( )
inline

Reset the write-count on all Parameters in this set.

Definition at line 167 of file ParameterSet.hpp.

◆ stringize()

virtual std::string sparta::ParameterSet::stringize ( bool  pretty = false) const
inlineoverridevirtual

Create a string representation of this node.

Parameters
prettyPrint a more verbose, multi-line representaiton (if available).
Returns
string representation of this node "<" <location> ">"
Note
this representation contains some basic information and is not meant for deserialization.

Subclasses should override this with representations appropriate for their type.

Reimplemented from sparta::TreeNode.

Definition at line 261 of file ParameterSet.hpp.

Here is the call graph for this function:

◆ unlock()

void sparta::ParameterSet::unlock ( const ParameterBase unlock_param)

Unlock the parameter set for parameter to parameter updates.

Parameters
unlock_paramThe parameter doing the unlocking – must be the last parameter that locked the set

◆ validateDependencies()

bool sparta::ParameterSet::validateDependencies ( const TreeNode node,
std::string &  err_names 
) const
inline

Definition at line 139 of file ParameterSet.hpp.

◆ validateIndependently()

bool sparta::ParameterSet::validateIndependently ( std::string &  err_names) const
inline

Definition at line 123 of file ParameterSet.hpp.

◆ verifyAllRead()

void sparta::ParameterSet::verifyAllRead ( ) const
inline

Checks the read-count on all Parameters. If any have no been read at least once since last write (since initialization if never written) then throws ParameterException.

See also
sparta::Parameter::getReadCount
Exceptions
ParameterExceptionif any parameter

This method is to ensure that the parameters were actually consumed by the model that defined them.

Definition at line 183 of file ParameterSet.hpp.

Here is the call graph for this function:

Friends And Related Symbol Documentation

◆ ParameterBase

friend class ParameterBase
friend

For invoking addParameter_.

Definition at line 66 of file ParameterSet.hpp.

Member Data Documentation

◆ __this_ps

ParameterSet* sparta::ParameterSet::__this_ps

Pointer to this ParameterSet accessible in class declaration scope. This is used By parameters to attach themselves to the parent at construction.

Definition at line 74 of file ParameterSet.hpp.

◆ keys_

ParameterPairs sparta::ParameterSet::keys_
protected

Map of name (key) to ParameterBase* instances.

Definition at line 695 of file ParameterSet.hpp.

◆ NODE_NAME

constexpr char sparta::ParameterSet::NODE_NAME[] = "params"
staticconstexpr

Name of any ParameterSet TreeNode.

Definition at line 83 of file ParameterSet.hpp.

◆ PARAMETER_SET_NODE_TAG

constexpr char sparta::ParameterSet::PARAMETER_SET_NODE_TAG[] = "SPARTA_ParameterSet"
staticconstexpr

Tag added to ParameterSet nodes.

Definition at line 88 of file ParameterSet.hpp.

◆ params_

ParameterVector sparta::ParameterSet::params_
protected

Straight vector of registered parameters.

Definition at line 700 of file ParameterSet.hpp.


The documentation for this class was generated from the following file: