| ►Nboost | |
| ►Nprogram_options | |
| Cbasic_parsed_options | |
| ►Ncore_example | |
| ►CBIU | |
| CBIUParameterSet | Parameters for BIU model |
| ►CCore | |
| CCoreParameterSet | Parameters for Core model |
| CCoreTopology_1 | CoreTopology_1 topology class |
| ►CCPU | |
| CCPUParameterSet | Parameters for CPU model |
| CCPUFactories | |
| CCPUFactory | |
| ►CCPUTopology | |
| CPortConnectionInfo | Structure to represent a port binding between units in device tree |
| CUnitInfo | Structure to represent a resource unit in device tree |
| ►CDecode | |
| CDecodeParameterSet | Parameters for Decode model |
| ►CDispatch | |
| CDispatchParameterSet | Parameters for Dispatch model |
| ►CExampleInst | Example instruction that flows through the example/CoreModel |
| CStaticInfo | |
| CExampleInstPairDef | Pair Definition class of the Example instruction that flows through the example/CoreModel |
| ►CExecute | |
| CExecuteParameterSet | Parameters for Execute model |
| ►CFetch | |
| CFetchParameterSet | Parameters for Fetch model |
| ►CFlushManager | Class used by performance models for signaling a flushing event across blocks |
| CFlushManagerParameters | |
| ►CLSU | |
| CLoadStoreInstInfo | |
| CLoadStoreInstInfoPairDef | Pair Definition class of the load store instruction that flows through the example/CoreModel |
| CLSUParameterSet | Parameters for LSU model |
| CMemoryAccessInfo | |
| CMemoryAccessInfoPairDef | Pair Definition class of the Memory Access Information that flows through the example/CoreModel |
| ►CMSS | |
| CMSSParameterSet | Parameters for MSS model |
| ►CPreloader | Implement a PreloaderIF with appropriate knowledge of how to preload yaml files into the lsu's L1 cache |
| CPreloaderParameterSet | |
| ►CRename | |
| CRenameParameterSet | Parameters for Rename model |
| ►CROB | |
| CROBParameterSet | Parameters for ROB model |
| CSimpleCacheLine | |
| CSimpleDL1 | |
| ►CSimpleTLB | |
| CTLBParameterSet | |
| CSimpleTLBEntry | |
| ►Nhashtuple | |
| Chash | Base struct for types which have std::hash() defined |
| Chash< std::tuple< TT... > > | Template specialization where the template parameter |
| ►NMetaStruct | |
| Cadd_pointer | This templated struct takes a type and gives back a nested typedef of a pointer to that type |
| Cadd_pointer< const T * > | |
| Cadd_pointer< const T *const > | |
| Cadd_pointer< T * > | |
| Cadd_pointer< T *const > | |
| Cgenerate_sequence | This is the generic template |
| Cgenerate_sequence< 0, S... > | This is the specialization which kicks in when the first template parameter is 0 |
| Cis_any_pointer | This templated struct lets us know about whether the datatype is actually an ordinary object or pointer to that object. This is specialized for a couple different signatures |
| Cis_any_pointer< const T * > | |
| Cis_any_pointer< const T *const > | |
| Cis_any_pointer< std::shared_ptr< T > & > | |
| Cis_any_pointer< std::shared_ptr< T > > | |
| Cis_any_pointer< std::shared_ptr< T > const & > | |
| Cis_any_pointer< std::shared_ptr< T > const > | |
| Cis_any_pointer< std::unique_ptr< T > & > | |
| Cis_any_pointer< std::unique_ptr< T > > | |
| Cis_any_pointer< std::unique_ptr< T > const & > | |
| Cis_any_pointer< std::unique_ptr< T > const > | |
| Cis_any_pointer< std::weak_ptr< T > & > | |
| Cis_any_pointer< std::weak_ptr< T > > | |
| Cis_any_pointer< std::weak_ptr< T > const & > | |
| Cis_any_pointer< std::weak_ptr< T > const > | |
| Cis_any_pointer< T * > | |
| Cis_any_pointer< T *const > | |
| Cis_bool | Templated struct for detecting Boolean Type |
| Cis_bool< bool & > | |
| Cis_bool< bool > | |
| Cis_bool< bool const & > | |
| Cis_bool< bool const > | |
| Cis_char_pointer | Templated struct for detecting char pointer type |
| Cis_char_pointer< char * > | |
| Cis_char_pointer< char *const > | |
| Cis_char_pointer< const char * > | |
| Cis_char_pointer< const char *const > | |
| Cis_pair | This templated struct lets us know about whether the datatype is actually an std::pair object. This is specialized for a couple different signatures. The collection procedure for a pair object is broken down into first collecting the first member and then, the second |
| Cis_pair< std::pair< T, U > & > | |
| Cis_pair< std::pair< T, U > > | |
| Cis_pair< std::pair< T, U > const & > | |
| Cis_pair< std::pair< T, U > const > | |
| Cis_sparta_enum | Detect whether template parameter is sparta::utils::Enum type. Case when it is not a sparta::utils::Enum type |
| Cis_sparta_enum< sparta::utils::Enum< T > > | Detect whether template parameter is sparta::utils::Enum type. Case when it is a sparta::utils::Enum type |
| Cis_stl | |
| Cis_stl_container | This templated struct takes a type and tells us whether that type is a STL container |
| Cis_stl_container< std::array< T, N > > | |
| Cis_stl_container< std::deque< Args... > > | |
| Cis_stl_container< std::forward_list< Args... > > | |
| Cis_stl_container< std::list< Args... > > | |
| Cis_stl_container< std::map< Args... > > | |
| Cis_stl_container< std::multimap< Args... > > | |
| Cis_stl_container< std::multiset< Args... > > | |
| Cis_stl_container< std::priority_queue< Args... > > | |
| Cis_stl_container< std::queue< Args... > > | |
| Cis_stl_container< std::set< Args... > > | |
| Cis_stl_container< std::stack< Args... > > | |
| Cis_stl_container< std::unordered_map< Args... > > | |
| Cis_stl_container< std::unordered_multimap< Args... > > | |
| Cis_stl_container< std::unordered_multiset< Args... > > | |
| Cis_stl_container< std::unordered_set< Args... > > | |
| Cis_stl_container< std::vector< Args... > > | |
| Cis_string | Templated struct for detecting String Type |
| Cis_string< std::string & > | |
| Cis_string< std::string > | |
| Cis_string< std::string const & > | |
| Cis_string< std::string const > | |
| Clast_index_type | This Variadic templated struct helps us know about the type of the very last or tail item in a parameter pack. It works by peeling of one parameter at a time from the pack and when it hits the last item, it specializes the struct by typedefing the template parameter T in its namespace |
| Clast_index_type< 0, T > | Base case when we have just the last item of the parameter pack |
| Clast_index_type< N, T, Args... > | Recursive case when we recursively peel off items from the front of the pack until we hit the last item |
| Cmatches_any | This templated struct takes a target type and another parameter pack of types and returns a nested boolean value of true, if the target type matches any one of the types in the parameter pack |
| Cmatches_any< T > | This templated struct takes a target type and another parameter pack of types and returns a nested boolean value of true, if the target type matches any one of the types in the parameter pack |
| Cmatches_any< T, Head, Tail... > | This templated struct takes a target type and another parameter pack of types and returns a nested boolean value of true, if the target type matches any one of the types in the parameter pack |
| Cparameter_pack_length | This Variadic templated struct contains a nested value which stores the length of any parameter pack it gets templatized on |
| Cpeek_last_type | |
| Cpeek_last_type< Head, Tail... > | |
| Cpeek_last_type< Tail > | |
| Cremove_any_pointer | Template type helper that removes any pointer. A modeler may call certain APIs with shared pointers to the actual Collectable classes, or templatize Collectables with pointers to collectable objects. To make our API have a single interface and still work when passed pointers, we will remove the pointer and then do all the decision making work, by default. It is harmless if the modeler passes a non pointer type as removing a pointer from something which is not a pointer results in itself |
| Cremove_any_pointer< const T * > | |
| Cremove_any_pointer< const T *const > | |
| Cremove_any_pointer< std::shared_ptr< T > & > | |
| Cremove_any_pointer< std::shared_ptr< T > > | |
| Cremove_any_pointer< std::shared_ptr< T > const & > | |
| Cremove_any_pointer< std::shared_ptr< T > const > | |
| Cremove_any_pointer< std::unique_ptr< T > & > | |
| Cremove_any_pointer< std::unique_ptr< T > > | |
| Cremove_any_pointer< std::unique_ptr< T > const & > | |
| Cremove_any_pointer< std::unique_ptr< T > const > | |
| Cremove_any_pointer< std::weak_ptr< T > & > | |
| Cremove_any_pointer< std::weak_ptr< T > > | |
| Cremove_any_pointer< std::weak_ptr< T > const & > | |
| Cremove_any_pointer< std::weak_ptr< T > const > | |
| Cremove_any_pointer< T * > | |
| Cremove_any_pointer< T *const > | |
| Creturn_type | This templated struct lets us know about the return type from any random function pointer. This is specialized for a couple different signatures |
| Creturn_type< R &(*)(Ts...)> | |
| Creturn_type< R &(T::*)() const > | |
| Creturn_type< R &(T::*const &)() const > | |
| Creturn_type< R &(T::*const)() const > | |
| Creturn_type< R(*)(Ts...)> | |
| Creturn_type< R(T::*)() const > | |
| Creturn_type< R(T::*const &)() const > | |
| Creturn_type< R(T::*const)() const > | |
| Creturn_type< std::function< R(Ts...)> > | |
| Creturn_type< std::function< R(Ts...)> const > | |
| Creturn_type< std::function< R(Ts...)> const T::* > | |
| Creturn_type< std::function< R(Ts...)> const T::*const > | |
| Creturn_type< std::function< R(Ts...)> T::* > | |
| Creturn_type< std::function< R(Ts...)> T::*const & > | |
| Creturn_type< std::shared_ptr< R > &(T::*)() const > | |
| Creturn_type< std::shared_ptr< R > &(T::*const &)() const > | |
| Creturn_type< std::shared_ptr< R > &(T::*const)() const > | |
| Creturn_type< std::shared_ptr< R >(T::*)() const > | |
| Creturn_type< std::shared_ptr< R >(T::*const &)() const > | |
| Creturn_type< std::shared_ptr< R >(T::*const)() const > | |
| Csequence_generator | This Variadic templated struct basically works much like std::integer_sequence. It represents a compile-time sequence of integers. This is used as a parameter to the Collection function template and helps in type deduction, unpacking and transforming our tuple of random parameters back into a variadic template |
| ►NMetaTypeList | |
| Ccreate | The Variadic Class Template create takes a variable number of different types and creates a well-formed type_list consisting of those types |
| Ccreate< type_list< Elements... > > | Base case where we have consumed all the paramters in the pack and created the type_list. We just typedef it |
| Ccreate< type_list< Elements... >, Head, Tail... > | Specialization where type_list exists in the intermediate derivations |
| Ccreate< type_list<>, Head, Tail... > | Specialization where no type_list exist |
| CfrontT | The class template frontT takes type_list as template param. and typedefs the type of the first template param., templatized on type_list, in its own nested type alias |
| CfrontT< type_list< Head, Tail... > > | FrontT Template Specialization |
| Cget_index | Class Template to return the index of a certain type in a certain typelist |
| Cget_index< S, T, type_list< Head, Tail... >, typename std::enable_if< std::is_same< T, Head >::value >::type > | Class Template to return the index of a certain type in a certain typelist. Case when queried type matches front type |
| Cget_index< S, T, type_list< Head, Tail... >, typename std::enable_if<!std::is_same< T, Head >::value >::type > | Class Template to return the index of a certain type in a certain typelist. Case when queried type does not match front type |
| Cget_pack_size | Class Template get_pack_size return the current number of types in the type_list |
| Cget_pack_size< type_list< Head, Tail... > > | Unroll Templates till Base case specialization is reached and accumulate |
| Cget_pack_size< type_list<> > | Base case specialization |
| Cis_empty | Class Template is_empty Generic case |
| Cis_empty< type_list<> > | Class Template is_empty Specialization |
| Cis_meta_typelist | Variadic Class Template which takes a type and matches it if that is a type_list. Generic case results to false |
| Cis_meta_typelist< MetaTypeList::type_list< Args... > > | Template Specialization when the type indeed is a type_list |
| Cnth_elementT | This class template gives us the type of Nth element in a type_list by taking advantage of the nested alias template in frontT<T> |
| Cnth_elementT< List, 0 > | Nth_elementT Template Specialization |
| Cpop_frontT | The class template pop_frontT takes type_list as template param., extracts out the first type in type_list template param, and typedefs the rest of the parameter pack in its own nested type alias |
| Cpop_frontT< type_list< Head, Tail... > > | Pop_frontT Template Specialization |
| Cpush_backT | The class template push_backT takes an existing type_list and a new type, inserts that new type at end of the type_list and instantiate a new type_list in this process and typedefs it inside itself |
| Cpush_backT< type_list< Elements... >, NewElement > | Push_backT Template Specialization |
| Cpush_frontT | The class template push_frontT takes an existing type_list and a new type, inserts that new type at front of the type_list and instantiate a new type_list in this process and typedefs it inside itself |
| Cpush_frontT< type_list< Elements... >, NewElement > | Push_frontT Template Specialization |
| Ctype_list | The variadic class template type_list has no implementation and is empty by itself |
| ►Nsparta | Macros for handling exponential backoff |
| ►Napp | Sparta Application framework |
| CArchNodeConfigFileApplicator | Applies an architectural configuration (parameter defaults) to a virtual parameter tree. This does not support applying, only applyUnbound |
| CBacktrace | Backtrace printer. Registers a handler for certain fatal signals and dumps the backtrace if they occur |
| CBacktraceData | Backtrace without line information. Can be rendered out when needed because rendering is slow |
| CCommandLineSimulator | Command line simulator front-end class with argument parsing Works in conjunction with sparta::app::Simulation |
| ►CConfigApplicator | Base class for applying parameters or configuration files to the simulator device tree. Contains a parameter or configuration file "action" to be applied to a tree |
| CApplyFilter | Represents a filter for applying parameters based on tree location |
| CDefaultValues | Optional default values for the simulator which can be customized and provided by anyone instantiating the simulator at construction-time |
| ►CFeatureConfiguration | Collection of named feature values |
| CFeatureOptions | |
| CLoggingTrigger | Trigger for strating logging given a number of tap descriptors |
| CMetaTreeNode | |
| ►CMultiDetailOptions | Class for containing multiple levels of boost program options |
| COptAdder | Helper class for chained calls to add_options |
| Cnamed_value_parser | Parser helper for named_value_type |
| Cnamed_value_parser< int16_t > | Named_value_parser specialization for int16_t |
| Cnamed_value_parser< int32_t > | Named_value_parser specialization for int32_t |
| Cnamed_value_parser< int64_t > | Named_value_parser specialization for int64_t |
| Cnamed_value_parser< int8_t > | Named_value_parser specialization for int8_t |
| Cnamed_value_parser< uint16_t > | Named_value_parser specialization for uint16_t |
| Cnamed_value_parser< uint32_t > | Named_value_parser specialization for uint32_t |
| Cnamed_value_parser< uint64_t > | Named_value_parser specialization for uint64_t |
| Cnamed_value_parser< uint8_t > | Named_value_parser specialization for uint8_t |
| Cnamed_value_type | Helper class for populating boost program options |
| CNodeConfigFileApplicator | Applies a configuration file to a node pattern |
| CParameterApplicator | Applies a value to a parameter node pattern |
| CParameterDefaultApplicator | Applies a new default value to a parameter node pattern |
| CParameterTemplate | ParameterTemplate providing factory implementation for each data type |
| CPipelineTrigger | Trigger used to enable/disable Pipeline colletion |
| CReportConfiguration | Configuration applicator class that is used for configuring a simulator's reports. Works in conjunction with sparta::app::ReportDescriptorCollection |
| CReportDescriptor | Describes one or more report to instantiate |
| CReportDescriptorCollection | This collection of ReportDescriptors is designed to never deallocate memory once it has been allocated. References returned by the 'getDescriptorByName()' method are guaranteed to be valid for the life of this collection object |
| ►CSimulation | Simulator which builds a sparta DeviceTree |
| CSimulationController | This class is used for simulation control callbacks |
| CSimulationConfiguration | Configuration applicator class that is used for configuring a simulator. Works in conjunction with sparta::app::Simulation |
| ►Ncollection | |
| CAgedArrayCollector | An AgedArrayCollector is created by the Array class in sparta when Pipeline collection is required |
| CCollectable | Class used to either manually or auto-collect an Annotation String object in a pipeline database |
| CCollectable< DataT, collection_phase, MetaStruct::enable_if_t< std::is_base_of< sparta::PairDefinition< MetaStruct::remove_any_pointer_t< DataT > >, typename MetaStruct::remove_any_pointer_t< DataT >::SpartaPairDefinitionType >::value > > | |
| CCollectableTreeNode | An abstract type of TreeNode that has virtual calls to start collection on this node, and stop collection on this node |
| CCollector | A non-templated base class that all Collectors should inherit from |
| CDelayedCollectable | Class used to record data in pipeline collection, but recorded in a delayed fashion |
| CIterableCollector | A collector of any iterable type (std::vector, std::list, sparta::Buffer, etc) |
| CPipelineCollector | A class that facilitates all universal pipeline collection operations such as outputting finalized records, generating unique transaction Id's, maintaining heartbeat functionality, writing the location file, writing the clock file |
| CUniquePairIDGenerator | |
| ►Ncolor | |
| CColorScheme | Accessor methods for obtaining color code strings |
| ►Nlog | Diagnostic logging framework. This node generates logging messages of a specific category |
| CBasicFormatter | Formatter including only a few bits of the most relevant message information |
| Ccategories | |
| CDefaultFormatter | Formatter that writes most message information, but excludes thread/sequence |
| CDestination | Generic Logging destination stream interface which writes sparta::log::Message structures to some output [file]stream. Subclasses will implement stream I/O based on construction arguments |
| CDestinationInstance | A destination where log messages go to be written to a file or other ostream. Attempts to prevent duplicate messages from being written to the same output even if logged through mutliple taps |
| CDestinationInstance< std::ostream > | Logging Destination for an already-open ostream |
| CDestinationInstance< std::string > | Destination that opens and writes to a file with a format based on the file extension of the filename given during construction |
| CDestinationManager | Manages a set of destinations representing files or streams. All log messages will be written to at least one destination in this object |
| ►CFormatter | File writer formatting interface. Subclsases can format for different file types (e.g. raw log, html, sql, etc.) |
| CInfo | Formatter type description. Used in a table to describe various formatter sublasses |
| CMessage | Contains a logging message header and content |
| CMessageInfo | Logging Message information excluding actual message content |
| ►CMessageSource | Message source object associated with a sparta TreeNode through which messages can be sent |
| CLogObject | Temporary object for constructing a log message with a ostream-like interface. Emits a message to the message source upon destruction |
| CRawFormatter | Formatter including no meta-data from the message |
| CTap | Logging Tap. Attach to a TreeNode to intercept logging messages from any NotificationSource nodes in the subtree of that node (including the node itself) |
| CTapAddedEvent | |
| CTapDescriptor | Describes a tap |
| CTapRemovedEvent | |
| CVerboseFormatter | Formatter that writes all message information |
| ►Nmemory | Namespace containing memory interfaces, types, and storage objects |
| CBlockingMemoryIF | Pure-virtual memory interface which represents a simple, immediately accessible (blocking) address-space with meaningful read and write accees support. Partially implements DebugMemoryIF, which adds peek and poke support as well as access addr and size validation |
| ►CBlockingMemoryIFNode | Pure-virtual memory interface that builds on the BlockingMemoryIF, acting as a TreeNode in the SPARTA device tree through which clients such as tools and UIs can discover and interact with the interface. Includes SPARTA Tree notification support, and sparta::Counter representation of access statistics |
| CPostWriteAccess | Structure containing data for a Memory post-write notification |
| CReadAccess | Structure containing data for a Memory pre- or post-read notification |
| CBlockingMemoryObjectIFNode | BlockingMemoryIFNode implementation with binding to a MemoryObject instantiated separately and specified at BlockingMemoryObjectIFNode construction |
| ►CDebugMemoryIF | Memory interface which represents a simple, immediately accessible (blocking) address-space with support for peek and poke acceeses having no side effects other than changing the desired memory |
| CAccessWindow | Defines an access window within this interface. Accesses through a memory interface are constrained to this window |
| CDMIBlockingMemoryIF | Class that provides a BlockingMemoryIF over a raw pointer |
| CMemoryAccessError | Indicates that there was an issue accessing a SPARTA memory object or interface |
| CMemoryObject | Memory object with sparse storage for large memory representations. Has direct read/write interface within blocks. Checkpointable |
| CMemoryPeekError | Error while attempting to peek some memory object or interface |
| CMemoryPokeError | Error while attempting to poke some memory object or interface |
| CMemoryReadError | Error while attempting to read some memory object or interface |
| CMemoryTranslationError | Indicates that there was an issue translating an address in the SPARTA framework |
| CMemoryWriteError | Error while attempting to write some memory object or interface |
| ►CSimpleMemoryMap | Memory mapping object which maps addresses onto block-aligned destinations, each of which is a BlockingMemoryIF object. This method does not actually support memory accesses, only mapping and querying |
| CMapping | Represents a mapping between an input address and output address for use in a destination BlockingMemoryIF |
| CSimpleMemoryMapNode | Memory mapping object which implements BlockingMemoryIFNode. Supports a simple mapping of incoming addresses to addresses within a set of destination BlockingMemoryIFs |
| CTranslation | An older class used to help in encapsulate read/virtual addresses |
| CTranslationIF | Blocking translation interface with 1:1 translation unless subclassed |
| CTranslationIFNode | TranslationIF extension that builds on TranslastionIF, acting as a TreeNode in the SPARTA device tree through which clients such as tools and UIs can discover and interact with the interface |
| ►Npevents | |
| CNestedPeventCollector | Class that is capable of recording pevents as key value pairs, where a PairDefinition has been defined with the key values, and function pointers to where to get the data for the pairs |
| CPEvent | Defines the class base type for PEvents |
| CPeventCollector | Class that is capable of recording pevents as key value pairs, where a PairDefinition has been defined with the key values, and function pointers to where to get the data for the pairs |
| CPeventCollectorController | Simple class for recursively adding taps to pevents. There is probably a more efficient way than each collector having it's own tap... But I don't think there will be many taps at all, at max 10 for any run I imagine. |
| CPeventCollectorTreeNode | |
| ►Nserialization | |
| ►Ncheckpoint | |
| ►Nstorage | |
| CStringStreamStorage | Stringstream storage implementation |
| CVectorStorage | Vector of buffers storage implementation |
| CCheckpoint | Single checkpoint object interface with a tick number and an ID unique to the owning Checkpointer instance |
| CCheckpointer | Checkpointer interface. Defines an ID-based checkpointing API for tree of related checkpoints which could be stored as ordered deltas internally |
| CCheckpointError | Indicates that there was an issue operating on checkpoints within the SPARTA framework |
| CDeltaCheckpoint | Single delta checkpoint object containing all simulator state which changed since some previous DeltaCheckpoint. Can contain all simulator state if it has no previous DeltaCheckpoint. The previous delta can be referenced by getPrev() |
| CFastCheckpointer | Implements quick checkpointing through delta-checkpoint trees which store state-deltas in a compact format. State is retrieved through a sparta tree from ArchDatas associated with any TreeNodes |
| ►CPersistentFastCheckpointer | Implements a Persistent FastCheckpointer, i.e. implements an interface to save checkpoints to disk |
| CFileReadAdapter | File storage adpater for ArchData |
| CFileWriteAdapter | File storage adpater for ArchData |
| ►Nstatistics | Namespace containing methods for computing and generating statistical information using instrumentation extracted from sparta structures such as Counters |
| ►Nexpression | Namespace containing methods for parsing, building, and evaluating statistical expressions in sparta |
| ►Ngrammar | Statistical Expression Grammar |
| CExpressionGrammar | |
| CBinaryFunction | Represents a Binary function node |
| CConstant | |
| CExpression | Expression container/builder. Contains a single ExpressionNode representing the root of an expression tree. This is the object on which the parser operates to build an expression incrementally through basic operators |
| CExpressionNode | Abstract interface class for an item in an expression. Subclasses can contain other ExpressionNodes |
| CExpressionParser | Class for parsing statistical expressions based on a specific TreeNode context |
| COperation | Operation Node (e.g. +,-,*,/) |
| CReferenceVariable | Expression node for a reference to a double. Anything that cannot actually vary can be handled as a constant through Expression. If it can vary, however, it should be handled through this or SimVariable (for functions) |
| CSimVariable | Expression node for a simulation variable. Anything that cannot actually vary within a simulation can be handled as a Constant. If it can vary, however, it should be handled through this |
| CStatVariable | |
| CTernaryFunction | Represents a Ternary function node |
| CUnaryFunction | Represents a Unary function node |
| CArchiveController | Base class used by the RootArchiveNode to have some control over its data source, whether it is a live simulation, or an offline archive (no simulation) |
| CArchiveDataSeries | Wrapper around a leaf ArchiveNode's data. Owns a back pointer to the top RootArchiveNode in its tree, which it uses to synchronize the data source and data sink with every call to its data access APIs |
| CArchiveDispatcher | This class holds exactly one generic ArchiveSource, and any number of generic ArchiveSink's |
| CArchiveNode | When a simulation is configured to archive its statistics values, it will build a subset of its device tree to organize the statistics. The analogy is that a TreeNode is loosely the same as an ArchiveNode: |
| CArchiveSink | Generic statistic sink base class for report archives |
| CArchiveSource | Generic statistic source base class for report archives |
| CArchiveStream | Generic statistic stream base class for sources and sinks in the report archive system |
| CBinaryIArchive | Use a binary archive file as a source of statistics values |
| CBinaryOArchive | Use a binary archive file as a destination for statistics values |
| CLiveSimulationArchiveController | Controller used when SPARTA simulations are directly feeding data into a tempdir archive |
| COfflineArchiveController | Controller used when attaching to an archive outside of any live simulation |
| CReportStatisticsAggregator | This class is a source of statistics values used by SPARTA simulators. It takes a sparta::Report object and internally creates an archive tree that describes the report's statistics hierarchy |
| CReportStatisticsArchive | This class coordinates live SPARTA simulations (source) with binary output archives (sink) |
| CReportStatisticsHierTree | Helper class used to build up a "report statistics hierarchy tree", where the template types are: |
| CReportStreamNode | In the stream node hierarchy, this class is used wherever we encounter a sparta::Report node, which includes all subreports. This class can turn a Report node into a flattened vector of SI's, which in turn feed their data into our contiguous vector of double values, connected via SnapshotLogger's |
| CRootArchiveNode | There is one of these root node objects at the top of each report's archive. The hierarchy looks like this: |
| CSINodeHierarchy | This class serializes a sparta::Report's entire SI tree (node names, parent nodes / child nodes / etc.) into the SINodeHierarchy table in the database object you provide |
| CSIValuesBuffer | This class helps organize contiguous blocks of SI values. These values are buffered at each report update, and they are organized in the buffer so that individual SI's have their values right next to each other. To illustrate, say we had the following CSV file: |
| CStatisticInstStreamNode | In the stream node hierarchy, this class is used wherever we encounter a sparta::StatisticInstance leaf node. We make a data vector of size 1, just for our single SI, and connect them together via a SnapshotLogger |
| CStatisticsArchives | This class owns and coordinates a group of named archives |
| CStatisticsHierRootNodes | Utility class that holds onto statistics node hierarchies, accessible by a name that you choose |
| CStatisticSnapshot | User-friendly wrapper around a double reference. This is like a std::reference_wrapper that connects one StatisticInstance with somebody else's double in another data structure. It lets SI's write their double data value directly into a contiguous std::vector sitting on top of the report archive system. This is done for improved performance and overall ease of use - a single std::vector<double> vs. individual StatisticInstance's scattered all over |
| CStatisticsStreams | Wrapper around the StatisticsHierRootNodes<T> class. This class holds onto root StreamNode's that sit at the top of a report hierarchy. Say we have this hierarchy of two reports: |
| CStreamController | Stream controller interface. One of these objects will be shared between the simulation's run controller, and the root-level StreamNode's sitting at the top of each one of the simulation's report hierarchies |
| CStreamNode | When a simulation is configured to stream its statistics values for asynchronous processing, it will build a subset of its device tree to organize the statistics. The resulting hierarchy is made up of report/subreport nodes, and StatisticInstance leaves. StreamNode's represent nodes in this hierarchy, and are designed so that you can stream data out of any node, regardless of where that node lives (could be the root, could be an SI leaf, could be anywhere in the middle) |
| ►Ntracker | |
| ►Nhas_ostream_operator_impl | We need to have the capability to detect the presence of |
| Cfallback | A fallback struct which can create itself |
| Chas_ostream_operator | |
| Chas_ostream_operator | |
| CStatePool | StatePool class template is templatized on the enum type we are tracking |
| CStatePoolBase | This is the polymorphic base class for the StatePool template class |
| CStatePoolManager | This is a Singleton class which manages all the different StatePool |
| CStateSet | This is the Calculation Engine unit inside each State Tracker Unit |
| CStateTrackerDeleter | Custom Deleter of individual State Tracker Units |
| CStateTrackerUnit | This is the actual Lightweight Tracker class which does the |
| ►Ntrigger | |
| CPeventTrigger | A simple interface with 2 methods |
| ►Nutils | |
| ►Nhas_ostream_operator_impl | We need to have the capability to detect the presence of |
| Cfallback | A fallback struct which can create itself |
| Chas_ostream_operator | |
| CBitArray | Class for fast bit manipulation |
| CBoundedValue | This class allows a developer to bound a value within an upper and lower value |
| ►CEnum | Class that wraps a C++ class enum and allows conversion between POD and the enum type. Also provides strings for them |
| Citerator | |
| CUnknownNameException | |
| CValue | |
| ►CFastList | An alternative to std::list, about 70% faster |
| CNodeIterator | The internal iterator type of FastList. Use FastList<T>::[const_]iterator instead |
| Chas_ostream_operator | |
| Cis_vector | |
| Cis_vector< std::vector< T, A > > | |
| CIteratorTraits | |
| CLifeTracker | A class that will track the lifetime of the object it points to |
| CLockedValue | Provides a wrapper around a value to ensure that once the value is frozen or locked, it cannot be overwritten again |
| Cmake_lowercase | Functor for ::tolower |
| Cmake_uppercase | Functor for ::toupper |
| CModifier | Modifier instance - Associates some suffix strings (e.g. "b") with a semantic (e.g. multiply by one billion) |
| CRadixPrefix | Prefix instance - Associates some prefix strings (e.g. "0x") with a radix and a set of allowed digit characters for parsing a string following this radix |
| CRational | Class to represent a Rational number |
| CTransformedString | Function LevenshteinDistance() |
| CValidValue | Provides a wrapper around a value to ensure that the value is assigned |
| CVectorCopier | Utility for element-wise potentially-deep-copying a vector. Invoked by methods at the end of this file |
| CVectorCopier< std::shared_ptr, VT > | Specialization for shared_ptr |
| CVectorCopier< std::unique_ptr, VT > | Specialization for unique_ptr |
| C__RegisterDefintionSet | Type that holds a set of register definitions |
| ►CArchData | Contains a set of contiguous line of architectural data which can be referred to by any architected object model. When layout() is called, reserves space for each element in a registered set of ArchDataSegment instances at offsets within Lines within the ArchData |
| CLine | Line object which composes part of an entire ArchData |
| CArchDataContainer | Container class for any number of ArchData pointers owned externally |
| CArchDataSegment | |
| ►CArray | Array is essentially a fixed size vector, maintains a concept of validity of its indexes, and provides access via stl iteration and general get methods |
| CArrayIterator | An iterator struct for this array |
| CAssertContext | Creates a helper traits class for determining whehther a type has a member named getClock |
| CAssignOnceObject | Object which can only have it's value set once. Throws exception if being set more than once |
| CAsyncEvent | In a multi-threaded sim environment, this event is used to schedule an event asynchronously |
| CAudience | Class used maintain a list of sparta::Scheduleable objects; used by observation-type classes |
| CBasicHistogram | |
| CBaz | |
| Cbit_reference_to_bool | Helper type for converting _Bit_reference types into bool types for the purpose of determining how to lexically cast a string into that type |
| Cbit_reference_to_bool< typename std::_Bit_reference > | |
| CBoolEnum | The class responsible for handling State<bool> instances and converts bool instances into actual EnumTValueType instances to satisfy exisiting function signatures |
| Cbounded_int | Bounded integer type with range-checking |
| CBuffer | A data structure allowing appending at the end, beginning, or middle, but erase anywhere with collapse |
| CBus | Class that defines a Bus type |
| CBusSet | A TreeNode that represents a set of Buses |
| CCircularBuffer | A data structure allowing appending at the end, beginning, or insert in the middle, but erase anywhere with collapse |
| CClock | A representation of simulated time |
| CClockManager | Manages building a clock tree |
| CContextCounter | A container type that allows a modeler to build, store, and charge counts to a specific context |
| CCounter | Represents a counter of type counter_type (uint64_t). 2 and greater than 0 with a ceiling specified. A ceiling value that is a power of two is optimized to perform operations faster |
| CCounterBase | The base class for all Counters |
| CCycleCounter | Represents a cycle counter |
| CCycleHistogramBase | CycleHistogramBase class for uint64_t values |
| CCycleHistogramStandalone | CycleHistogramStandalone class for uint64_t values |
| CCycleHistogramTreeNode | CycleHistogramTreeNode class for uint64_t values |
| ►CDAG | |
| CCycleException | |
| CDataContainer | Used by DataInPort and SyncInPort, this class holds received data from these ports and remembers the time in which the data was set. It also maintains the validity of the data |
| CDataInPort | DataInPort receives data from sender using a DataOutPort |
| CDataOutPort | DataOutPort is used for transferring any data to another module |
| CDataView | View into a backend block of memory in an ArchData |
| CDynamicResourceTreeNode | TreeNode subclass representing a node in the device tree which creates and owns a resource. This node is created at run-time and, although it takes a parameter set at construction, is not part of the SPARTA configuration phase and is not user configurable through any sparta::ParameterSet |
| CEnumCycleHistogram | EnumCycleHistogram class for C++ Enum values |
| CEnumHistogram | EnumHistogram class for sparta::utils::Enum |
| CEvent | Event is a simple class for scheduling random events on the Scheduler |
| CEventGroup | Group a series of events together for precedence establishment |
| CEventNode | EventNode is the base class for all event types in SPARTA. Not to be used by the modeler. Its main purpose is to look for a clock and scheduler for the event |
| CEventSet | Set of Events that a unit (or sparta::TreeNode, sparta::Resource) contains and are visible through a sparta Tree |
| CExportedPort | Class that "exports" a port that's contained in the same ResourceTreeNode structure |
| CExtensionDescriptor | Descriptor class which provides basic information about an extended tree node: device tree location, extension name, and parameter name-values |
| CExtensionsParamsOnly | Helper class used to trivially extend TreeNode parameter sets (but not any additional functionality beyond that) |
| CFrontArray | Type of Array with special allocation policies to support writing to the front most valid entry in the Array, as well as reading the nth valid entry in the array |
| CFunctionManager | Singleton Function Manager class. This class contains two maps and one constant string token. These maps contain a string as key and function pointers as value. The string key is the same as the name of the free functions as defined by the users and the keys are the function pointers to those methods. One map is dedicated for HistogramTreeNodes while the other is dedicated for CycleHistogramTreeNodes. This was necessary because these two classes do not share a common polymorphic base |
| CFutureStatisticRange | Exception indicating that the range of a StatisticInstance starts or ends in the future (probably caused by to checkpointing) |
| CGlobalEvent | A type of "global" reusable event |
| CGlobalEventProxy | A helper class of GlobalEvent |
| CGlobalOrderingPoint | Used to set precedence between Scheduleable types across simulation |
| CGlobalTreeNode | TreeNode which represents some "global" namespace of the device tree, containing only RootTreeNodes, for performing searches |
| CHistogramBase | Histogram base class for uint64_t values |
| CHistogramStandalone | |
| CHistogramTreeNode | |
| CInPort | Base class for all InPort types |
| CInstrumentationNode | Base class requiring |
| CIntParameterSet | |
| Cis_sparta_enum | Detect whether template parameter is sparta::utils::Enum type |
| Cis_sparta_enum< sparta::utils::Enum< T > > | Detect whether template parameter is sparta::utils::Enum type |
| Cis_vector | Templated for determining if ValueType is std::vector for use in metaprogramming constructs. This is intended to be be consumed by enable_if |
| Cis_vector< std::vector< T > > | |
| ►CKeyValue | The type-to-type name map. Not really necessary, but useful |
| CTypeNameVisitor | Visitor class for looking up type name |
| CLineStringStream | Helper class for building a set of lines through an ostream-like interface |
| CMemoryProfiler | Utility used to periodically collect heap usage statistics throughout a simulation. Supported phases for inspection include Build, Configure, Bind, and Simulate |
| CMirrorNotificationSource | Essentially a pass through notification source that is a placeholder in a shadow tree |
| CNotificationSource | A TreeNode that generates a specific type of notification which propagates up a tree of TreeNodes (using the NotificationPropagator base class |
| ►CNotificationSourceBase | A TreeNode that generates a single specific type of notification which propagates up a tree of TreeNodes using TreeNode's builtin functionality |
| CObservationStateCallback | Callback for observation-state of a NotificationSourceBase |
| CObservationStateCallbackPrivateInterface | Controlled interface to NotificationSourceBase for regiistering and deregistering observation state change callback objects only |
| CObjectAllocator | |
| COneWayBool | Boolean with a default capable of being changed to the opposite value only. it can never set to the default even if already at the default value |
| COutPort | Base class for all OutPort types |
| CParameter | Parameter instance, templated to contain only a specific type |
| ►CParameterBase | Non-templated base class for generic parameter access and iteration |
| CParameterValueIterator | Generic value iterator for a SINGLE parameter which represents values ONLY as std::string |
| CParameterException | Exception indicating a misconfigured Parameter or invalid Parameter access |
| ►CParameterSet | Generic container of Parameters |
| CParameterSetIterator | Non-const iterator for ParameterSet |
| ►CParameterTree | Virtual Parameter Tree. This represents a tree of parameters read from some source but does not necessarily correspond to the parameters in the simulation itself or even to the simulation tree. This is meant to provide a hierarchical view into simulation parameters before they are actually applied to a real TreeNode tree |
| ►CNode | Node containing a Parameter and value to apply. Can be used to describes a value extracted from the tree when using get or tryGet. This is a copy of the value and is not in any way synchronized with the tree |
| CMatchIterator | |
| CPayloadEvent | Class to schedule a Scheduleable in the future with a payload, typed on both the data type and the scheduling phase. This is the preferred class to use in simulation, but the main API is found in sparta::PhasedPayloadEvent |
| CPhasedObject | Object having a specific phase in the sparta construction paradigm |
| CPhasedPayloadEvent | Class to schedule a Scheduleable in the future with a payload, but the class itself is not typed on the phase, but is constructed with one. The preference, however, is for the modeler to use sparta::PayloadEvent instead |
| CPhasedSingleCycleUniqueEvent | An event that can only be schedule one cycle into the future |
| CPhasedUniqueEvent | A type of Event that uniquely schedules itself on the schedule within a single time quantum. This UniqueEvent is not typed on the SchedulingPhase. It is discouraged to use this class – use UniqueEvent templatized on the SchedulingPhase |
| ►CPipe | A very simple pipe, not part of the DES paradigm |
| CPipeIterator | |
| ►CPipeline | A simple pipeline |
| CPipelineIterator | An iterator class for Pipeline class |
| CPort | The port interface used to bind port types together and defines a port behavior |
| CPortSet | A TreeNode that represents a set of ports used by a Resource |
| CPostRunValidationInfo | Information describing the type of validation being done |
| CPriorityQueue | A data structure that allows pushing/emplacing into it with a given sorter |
| Cptr_to_const_obj_ptr | Template type helper that removes a pointer, adds a const, and then re-adds the pointer. This is useful to turn "T" [T=U*] into "U const *" in places where simply using "const T" results in "U* const" |
| ►CQueue | A data structure that allows appending at the back and invalidating from the front |
| CQueueIterator | Class that alows queue elements to be accessed like a normal stl iterator. Queue iterator is a bidirectional sequential iterator isValid() method checks the validity of the iterator. This method can be used to check if the data in Queue has not yet been popped out Increment, decrement , dereferencing,less than and greater than operations are provided |
| CReadOnlyCounter | Represents a non-writable and non-observable counter with a very similar interface to sparta::Counter. The value of this counter In most cases, a normal counter should be used. However, if a value must be stored as an integer outside of counter for any reason, a ReadOnly counter can be used to wrap that value and expose it to sparta Report and statistics infrastructure |
| CRegister | An implementation of a RegisterBase |
| CRegisterBankTable | Container of register banks as a helper for RegisterSet. Instances of this class will be owned by a single RegisterSet |
| ►CRegisterBase | Base class to represents an architected register of any size that is a power of 2 and greater than 0 with a ceiling specified |
| CDefinition | Describes an architected Register |
| ►CField | Register Field with masked access to owning register |
| CDefinition | Field Definition structure |
| CPostWriteAccess | Structure containing data for a Register post-write notification |
| CReadAccess | Structure containing data for a Register pre- or post-read notification |
| CRegisterBits | |
| CRegisterProxy | Represents an interface to a pseudo-"Register" of a fixed size which indirectly references other registers (having the same group num, group idx, and size) depending on simulator state. Essentially, this hides banking and register aliasing (shared data) information from the client of this interface which is useful for presenting debugginer-visible and software-visible registers without regard for the underlying banking or aliasing |
| ►CRegisterProxyBase | |
| CDefinition | Describes a register Proxy |
| ►CRegisterSet | Holds and can create a set of Register objects having various names and groups |
| CRegisterTypeTag | |
| CResource | The is the base class for all types of resources used by the SPARTA framework |
| CResourceContainer | PhasedObject which can hold 0 or 1 Resource pointers to an associatedresource. Contains logic for setting and getting the associated Resource |
| CResourceFactory | Templated ResourceFactoryBase implementation which can be used to trivially define Resource Factories |
| CResourceFactoryBase | Factory which can create Resources as well as the Parameter sets that can be modified before actually instantiating the resources themselves. Packages providing resources to the simulator implement this interface |
| CResourceSet | Set of published ResourceFactories which can be referenced by name |
| CResourceTreeNode | TreeNode subclass representing a node in the device tree which contains a single ResourceFactory and a sparta::ParameterSet. A ResourceTreeNode is also associated with a clock |
| CReversedStatisticRange | Exception indicating that the range of a StatisticInstance was reversed when it was accessed (probably caused by checkpointing) |
| CRootTreeNode | TreeNode which represents the root ("top") of a device tree |
| ►CScheduleable | A class that defines the basic scheduling interface to the Scheduler. Not intended to be used by modelers directly, but certainly can be |
| CPrecedenceSetup | An internal class used in Scheduleble to cache a pointer to the scheduler |
| CScheduleableHandle | A light-weight reference counting handle for Scheduleables – DOES NOT delete |
| CScheduler | A class that lets you schedule events now and in the future |
| ►CScoreboard | Class used to track operand dependencies (timed) between units |
| CScoreboardParameters | |
| CScoreboardView | A ScoreboardView is a view into the master Scoreboard for operand readiness |
| CSharedData | Class that allows the writing of data this cycle, but not visable until next cycle |
| CSignalInPort | SignalInPort receives data from sender using a SignalOutPort |
| CSignalOutPort | SignalOutPort is used for transferring a simple signal to another module |
| CSimulationInfo | Contains information describing the simulation instance for the purpose of identifying the simulation and possible recreating it. This information should be written to all log files, reports, cmdline, etc |
| CSingleCycleUniqueEvent | An event that can only be schedule one cycle into the future |
| CSpartaCriticalError | Indicates something went seriously wrong and likely indicates corruption in simulator runtime state |
| CSpartaException | Used to construct and throw a standard C++ exception. Inherits from std::exception |
| CSpartaFatalError | Indicates something went seriously wrong and likely indicates unrecoverable corruption in simulator runtime state or misuse. This is the only exception that should ever be generated by a destructor since its semantics are that the simulation should terminate |
| CSpartaSharedPointer | Used for garbage collection, will delete the object it points to when all objects are finished using it |
| CSpartaSharedPointerAllocator | A memory allocator complementing SpartaSharedPointer that reuses old memory |
| CSpartaStaticInitializer | Static-initialization order controller |
| CSpartaTester | A simple testing class |
| CSpartaWeakPointer | Like in STL, create a weak pointer to a SpartaSharedPointer |
| CStartupEvent | StartupEvent is a simple class for scheduling a starting event on the Scheduler. It does not support precedence |
| ►CState | The State class for watching transition between enum states |
| CMarker | Class that will mark the state for transition |
| CMonitor | Monitor a particular State value and allow the user to determine a full state change |
| CState< T, typename std::enable_if< std::is_same< T, PhasedObject::TreePhase >::value >::type > | |
| CStateHistogram | StateHistogram class for uint64_t values |
| ►CStateTimerUnit | A high level wrapper contains the StateTimerPool and StateTimerHistogram |
| CStateTimer | The timer that user can access to start/end tracking state. A StateTimer::Handle is returned from StateTimerUnit upon allocation |
| CStatInstCalculator | |
| ►CStatisticDef | Contains a statistic definition (some useful information which can be computed) |
| CExpressionArg | Intermediate type for minimizing the number of distinct constructors that must be created for this class because any constructor can take an Expression object or a string representing an expression |
| CPendingSubStatCreationInfo | This helper class serves as a placeholder for substatistic creation |
| CStatisticInstance | Instance of either a StatisticDef or CounterBase or an Expression. Has a sample window (simulator ticks) over which it will compute the value of the contained expression/counter for that range |
| CStatisticSet | Set of StatisticDef and CounterBase-derived objects for visiblility through a sparta Tree |
| CStringManager | Manages string internment for SPARTA. This allows strings to be compared by pointer once interned |
| CSyncInPort | Class that defines an synchronized input port on modules on two different clocks |
| CSyncOutPort | Class that defines a synchronized SyncOutPort for data writes on different clocks |
| CSysCSpartaSchedulerAdapter | Class that "connects" Sparta to SystemC |
| CTag | Tag(): Simple class to provide nested sequence numbering |
| ►CTieredMap | N-Tier lookup map for sparse-representation of large memory spaces. This is essentially a M-Tree where the child lookup at each node is a simple offset computed by a rshift and mask |
| Cconst_iterator | Const for walking contents of this map if const-qualified |
| Citerator | Iterator for walking contents of this map |
| CTimeManager | Singleton which manages wall-clock time for simulations in SPARTA This is not a "timer" manager, but rather an information service and could possible become a timing interval manager |
| ►CTreeNode | Node in a composite tree representing a sparta Tree item |
| CANY_TYPE | Type for indicating that ANY notification source type should be included in a search performed by locateNotificationSources |
| Cdelegate | Temporary delegate for notificaiton invokation until the implementation is working. This will then be merged with sparta::SpartaHandler |
| CExtensionsBase | Base class used to extend TreeNode parameter sets |
| CNotificationInfo | Notification type/name information |
| Ctype_info_container | Container for std::type_info |
| CTreeNodePrivateAttorney | |
| CUniqueEvent | A type of Event that uniquely schedules itself on the schedule within a single time quantum. This class is typed on the SchedulingPhase and is the preferred type to use for UniqueEvent use, but the main API is found in PhasedUniqueEvent |
| CUnit | The is the base class for user defined blocks in simulation |
| CValidationCheckCallback | Delegate for Parameter validation |
| CVirtualGlobalTreeNode | Virtual global node for all device trees in a single simulation. This node acts a potential notification observation point for every node in the simulation regardless hierarchy |
| CWeightedContextCounter | This is an example context counter subclass used to show how users may supply their own "aggregated value calculation" method via the REGISTER_CONTEXT_COUNTER_AGGREGATE_FCN macro |
| ►Nsparta_simdb | |
| CDatabaseTester | |
| CBoolValue | This is the internal enum class which holds the enum values for bool instances. This enum has the same layout as any other enum which is expected to be templatized on sparta::State |
| CCircleExtensions | |
| ►CConsumer | |
| CConsumerParameterSet | |
| CContextCounterInfo | |
| CExampleSimulator | ExampleSimulator which builds the model and configures it |
| CFILEIstream | |
| CFILEOstream | |
| CPrecedence | Specify the default event scheduling precedence between pipeline stages |
| CProducer | |
| CProducerParameterSet | |
| CSkeletonSimulator | SkeletonSimulator which builds the model and configures it |
| Csparta_traits | |
| CUniquePairGenerator | A class which provides every new instantiation of the Templated class Collectable with a new unique value. This value is used by all the instantiations of a certain type of a Collectable as its own unique PairId which differentiates itself from other Collectable instatiations templated on some other type of class |
1.9.8