| Csparta::__RegisterDefintionSet< RegisterT > | Type that holds a set of register definitions |
| Csparta::memory::DebugMemoryIF::AccessWindow | Defines an access window within this interface. Accesses through a memory interface are constrained to this window |
| CMetaStruct::add_pointer< T > | This templated struct takes a type and gives back a nested typedef of a pointer to that type |
| CMetaStruct::add_pointer< const T * > | |
| CMetaStruct::add_pointer< const T *const > | |
| CMetaStruct::add_pointer< T * > | |
| CMetaStruct::add_pointer< T *const > | |
| Csparta::TreeNode::ANY_TYPE | Type for indicating that ANY notification source type should be included in a search performed by locateNotificationSources |
| Csparta::app::ConfigApplicator::ApplyFilter | Represents a filter for applying parameters based on tree location |
| ►Csparta::ArchData | Contains a set of contiguous line of architectural data which can be referred to by any architected object model. When layout() is called, reserves space for each element in a registered set of ArchDataSegment instances at offsets within Lines within the ArchData |
| Csparta::memory::MemoryObject | Memory object with sparse storage for large memory representations. Has direct read/write interface within blocks. Checkpointable |
| ►Csparta::ArchDataContainer | Container class for any number of ArchData pointers owned externally |
| ►Csparta::TreeNode | Node in a composite tree representing a sparta Tree item |
| Ccore_example::SimpleDL1 | |
| Csparta::Baz | |
| Csparta::Bus | Class that defines a Bus type |
| Csparta::BusSet | A TreeNode that represents a set of Buses |
| Csparta::Clock | A representation of simulated time |
| Csparta::CycleHistogramTreeNode | CycleHistogramTreeNode class for uint64_t values |
| Csparta::DynamicResourceTreeNode< ResourceT, ParamsT > | 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 |
| Csparta::EnumCycleHistogram< EnumType > | EnumCycleHistogram class for C++ Enum values |
| Csparta::EnumHistogram< EnumType > | EnumHistogram class for sparta::utils::Enum |
| ►Csparta::EventNode | EventNode is the base class for all event types in SPARTA. Not to be used by the modeler. Its main purpose is to look for a clock and scheduler for the event |
| Csparta::Event< SchedulingPhase::Tick > | |
| Csparta::PhasedPayloadEvent< sparta::GlobalEventProxy > | |
| Csparta::PhasedPayloadEvent< bool > | |
| Csparta::PhasedPayloadEvent< sparta::SpartaSharedPointer > | |
| Csparta::PhasedPayloadEvent< ScoreboardViewUpdate > | |
| Csparta::PhasedPayloadEvent< DurationData > | |
| ►Csparta::Event< sched_phase_T > | Event is a simple class for scheduling random events on the Scheduler |
| Csparta::AsyncEvent< sched_phase_T > | In a multi-threaded sim environment, this event is used to schedule an event asynchronously |
| ►Csparta::PhasedPayloadEvent< DataT > | 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 |
| Csparta::PayloadEvent< bool, sparta::SchedulingPhase::Trigger > | |
| Csparta::PayloadEvent< sparta::SpartaSharedPointer > | |
| Csparta::PayloadEvent< ScoreboardViewUpdate, sparta::SchedulingPhase::Update > | |
| Csparta::PayloadEvent< DataT, SchedulingPhase::Collection > | |
| Csparta::PayloadEvent< DurationData, SchedulingPhase::Collection > | |
| Csparta::PayloadEvent< DataT, sched_phase_T > | 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 |
| ►Csparta::PhasedSingleCycleUniqueEvent | An event that can only be schedule one cycle into the future |
| Csparta::SingleCycleUniqueEvent< sched_phase_T > | An event that can only be schedule one cycle into the future |
| ►Csparta::PhasedUniqueEvent | A type of Event that uniquely schedules itself on the schedule within a single time quantum. This UniqueEvent is not typed on the SchedulingPhase. It is discouraged to use this class – use UniqueEvent templatized on the SchedulingPhase |
| Csparta::UniqueEvent< SchedulingPhase::Update > | |
| Csparta::UniqueEvent< SchedulingPhase::PostTick > | |
| Csparta::UniqueEvent< sched_phase_T > | 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 |
| Csparta::EventSet | Set of Events that a unit (or sparta::TreeNode, sparta::Resource) contains and are visible through a sparta Tree |
| Csparta::GlobalTreeNode | TreeNode which represents some "global" namespace of the device tree, containing only RootTreeNodes, for performing searches |
| Csparta::HistogramTreeNode | |
| ►Csparta::InstrumentationNode | Base class requiring |
| ►Csparta::CounterBase | The base class for all Counters |
| Csparta::Counter | Represents a counter of type counter_type (uint64_t). 2 and greater than 0 with a ceiling specified. A ceiling value that is a power of two is optimized to perform operations faster |
| Csparta::CycleCounter | Represents a cycle counter |
| Csparta::ReadOnlyCounter | Represents a non-writable and non-observable counter with a very similar interface to sparta::Counter. The value of this counter In most cases, a normal counter should be used. However, if a value must be stored as an integer outside of counter for any reason, a ReadOnly counter can be used to wrap that value and expose it to sparta Report and statistics infrastructure |
| ►Csparta::StatisticDef | Contains a statistic definition (some useful information which can be computed) |
| Csparta::ContextCounter< sparta::Counter > | |
| ►Csparta::ContextCounter< CounterT > | A container type that allows a modeler to build, store, and charge counts to a specific context |
| Csparta::WeightedContextCounter< sparta::Counter > | |
| Csparta::WeightedContextCounter< CounterT > | 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 |
| ►Csparta::NotificationSourceBase | A TreeNode that generates a single specific type of notification which propagates up a tree of TreeNodes using TreeNode's builtin functionality |
| ►Csparta::NotificationSource< sparta::log::Message > | |
| Csparta::log::MessageSource | Message source object associated with a sparta TreeNode through which messages can be sent |
| Csparta::NotificationSource< PostWriteAccess > | |
| Csparta::NotificationSource< ReadAccess > | |
| Csparta::NotificationSource< TreeNode > | |
| Csparta::MirrorNotificationSource< NotificationDataT > | Essentially a pass through notification source that is a placeholder in a shadow tree |
| Csparta::NotificationSource< NotificationDataT > | A TreeNode that generates a specific type of notification which propagates up a tree of TreeNodes (using the NotificationPropagator base class |
| ►Csparta::ParameterBase | Non-templated base class for generic parameter access and iteration |
| Csparta::Parameter< ValueType > | Parameter instance, templated to contain only a specific type |
| ►Csparta::ParameterSet | Generic container of Parameters |
| CConsumer::ConsumerParameterSet | |
| CProducerParameterSet | |
| Ccore_example::BIU::BIUParameterSet | Parameters for BIU model |
| Ccore_example::CPU::CPUParameterSet | Parameters for CPU model |
| Ccore_example::Core::CoreParameterSet | Parameters for Core model |
| Ccore_example::Decode::DecodeParameterSet | Parameters for Decode model |
| Ccore_example::Dispatch::DispatchParameterSet | Parameters for Dispatch model |
| Ccore_example::Execute::ExecuteParameterSet | Parameters for Execute model |
| Ccore_example::Fetch::FetchParameterSet | Parameters for Fetch model |
| Ccore_example::FlushManager::FlushManagerParameters | |
| Ccore_example::LSU::LSUParameterSet | Parameters for LSU model |
| Ccore_example::MSS::MSSParameterSet | Parameters for MSS model |
| Ccore_example::Preloader::PreloaderParameterSet | |
| Ccore_example::ROB::ROBParameterSet | Parameters for ROB model |
| Ccore_example::Rename::RenameParameterSet | Parameters for Rename model |
| Ccore_example::SimpleTLB::TLBParameterSet | |
| Csparta::IntParameterSet | |
| Csparta::Scoreboard::ScoreboardParameters | |
| ►Csparta::Port | The port interface used to bind port types together and defines a port behavior |
| Csparta::ExportedPort | Class that "exports" a port that's contained in the same ResourceTreeNode structure |
| ►Csparta::InPort | Base class for all InPort types |
| Csparta::DataInPort< uint32_t > | |
| Csparta::DataInPort< InstQueue::value_type > | |
| Csparta::DataInPort< InstGroup > | |
| Csparta::DataInPort< FlushManager::FlushingCriteria > | |
| Csparta::DataInPort< uint64_t > | |
| Csparta::DataInPort< FlushingCriteria > | |
| Csparta::DataInPort< sparta::SpartaSharedPointer > | |
| Csparta::DataInPort< FlushCriteria > | |
| Csparta::DataInPort< bool > | |
| Csparta::SyncInPort< bool > | |
| Csparta::SyncInPort< sparta::SpartaSharedPointer > | |
| Csparta::DataInPort< DataT > | DataInPort receives data from sender using a DataOutPort |
| Csparta::SignalInPort | SignalInPort receives data from sender using a SignalOutPort |
| Csparta::SyncInPort< DataT > | Class that defines an synchronized input port on modules on two different clocks |
| ►Csparta::OutPort | Base class for all OutPort types |
| Csparta::DataOutPort< uint32_t > | |
| Csparta::DataOutPort< sparta::SpartaSharedPointer > | |
| Csparta::DataOutPort< InstGroup > | |
| Csparta::DataOutPort< InstQueue::value_type > | |
| Csparta::DataOutPort< FlushingCriteria > | |
| Csparta::DataOutPort< uint64_t > | |
| Csparta::DataOutPort< FlushManager::FlushingCriteria > | |
| Csparta::SyncOutPort< sparta::SpartaSharedPointer > | |
| Csparta::SyncOutPort< bool > | |
| Csparta::DataOutPort< DataT > | DataOutPort is used for transferring any data to another module |
| Csparta::SignalOutPort | SignalOutPort is used for transferring a simple signal to another module |
| Csparta::SyncOutPort< DataT > | Class that defines a synchronized SyncOutPort for data writes on different clocks |
| Csparta::PortSet | A TreeNode that represents a set of ports used by a Resource |
| ►Csparta::RegisterBase | Base class to represents an architected register of any size that is a power of 2 and greater than 0 with a ceiling specified |
| Csparta::Register | An implementation of a RegisterBase |
| Csparta::RegisterBase::Field | Register Field with masked access to owning register |
| Csparta::RegisterSet | Holds and can create a set of Register objects having various names and groups |
| Csparta::ResourceTreeNode | TreeNode subclass representing a node in the device tree which contains a single ResourceFactory and a sparta::ParameterSet. A ResourceTreeNode is also associated with a clock |
| ►Csparta::RootTreeNode | TreeNode which represents the root ("top") of a device tree |
| Csparta::Scheduler | A class that lets you schedule events now and in the future |
| Csparta::app::MetaTreeNode | |
| Csparta::StateHistogram< StateEnumType > | StateHistogram class for uint64_t values |
| Csparta::StateTimerUnit | A high level wrapper contains the StateTimerPool and StateTimerHistogram |
| Csparta::StatisticSet | Set of StatisticDef and CounterBase-derived objects for visiblility through a sparta Tree |
| Csparta::VirtualGlobalTreeNode | Virtual global node for all device trees in a single simulation. This node acts a potential notification observation point for every node in the simulation regardless hierarchy |
| ►Csparta::collection::CollectableTreeNode | An abstract type of TreeNode that has virtual calls to start collection on this node, and stop collection on this node |
| Csparta::collection::Collectable< sparta::SpartaSharedPointer > | |
| Csparta::collection::Collectable< uint64_t > | |
| Csparta::collection::Collectable< bool > | |
| Csparta::collection::IterableCollector< std::list< sparta::SpartaSharedPointer > > | |
| ►Csparta::collection::Collectable< DataT, collection_phase, typename > | Class used to either manually or auto-collect an Annotation String object in a pipeline database |
| Csparta::collection::DelayedCollectable< DataT > | Class used to record data in pipeline collection, but recorded in a delayed fashion |
| Csparta::collection::Collectable< 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 > > | |
| Csparta::collection::IterableCollector< IterableType, collection_phase, sparse_array_type > | A collector of any iterable type (std::vector, std::list, sparta::Buffer, etc) |
| ►Csparta::memory::BlockingMemoryIFNode | 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 |
| Csparta::memory::BlockingMemoryObjectIFNode | BlockingMemoryIFNode implementation with binding to a MemoryObject instantiated separately and specified at BlockingMemoryObjectIFNode construction |
| Csparta::memory::SimpleMemoryMapNode | Memory mapping object which implements BlockingMemoryIFNode. Supports a simple mapping of incoming addresses to addresses within a set of destination BlockingMemoryIFs |
| Csparta::memory::TranslationIFNode | 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 |
| ►Csparta::ArchDataSegment | |
| Csparta::DataView | View into a backend block of memory in an ArchData |
| ►Csparta::statistics::ArchiveController | 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) |
| Csparta::statistics::LiveSimulationArchiveController | Controller used when SPARTA simulations are directly feeding data into a tempdir archive |
| Csparta::statistics::OfflineArchiveController | Controller used when attaching to an archive outside of any live simulation |
| Csparta::statistics::ArchiveDataSeries | 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 |
| Csparta::statistics::ArchiveDispatcher | This class holds exactly one generic ArchiveSource, and any number of generic ArchiveSink's |
| ►Csparta::statistics::ArchiveNode | 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: |
| Csparta::statistics::RootArchiveNode | There is one of these root node objects at the top of each report's archive. The hierarchy looks like this: |
| ►Csparta::statistics::ArchiveStream | Generic statistic stream base class for sources and sinks in the report archive system |
| ►Csparta::statistics::ArchiveSink | Generic statistic sink base class for report archives |
| Csparta::statistics::BinaryOArchive | Use a binary archive file as a destination for statistics values |
| ►Csparta::statistics::ArchiveSource | Generic statistic source base class for report archives |
| Csparta::statistics::BinaryIArchive | Use a binary archive file as a source of statistics values |
| Csparta::statistics::ReportStatisticsAggregator | 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 |
| ►Csparta::Array< DataT, ArrayT > | 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 |
| Csparta::FrontArray< DataT, ArrayT > | 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 |
| Csparta::Array< DataT, ArrayType::AGED > | |
| Csparta::AssertContext | Creates a helper traits class for determining whehther a type has a member named getClock |
| Csparta::AssignOnceObject< T > | Object which can only have it's value set once. Throws exception if being set more than once |
| Csparta::Audience | Class used maintain a list of sparta::Scheduleable objects; used by observation-type classes |
| Csparta::app::Backtrace | Backtrace printer. Registers a handler for certain fatal signals and dumps the backtrace if they occur |
| Csparta::app::BacktraceData | Backtrace without line information. Can be rendered out when needed because rendering is slow |
| ►CBaseAllocator | |
| Csparta::SpartaSharedPointerAllocator< core_example::LSU::MemoryAccessInfo > | |
| Csparta::SpartaSharedPointerAllocator< core_example::LSU::LoadStoreInstInfo > | |
| Csparta::SpartaSharedPointerAllocator< PointerT > | A memory allocator complementing SpartaSharedPointer that reuses old memory |
| Cboost::program_options::basic_parsed_options< charT > | |
| ►Csparta::cache::BasicCacheItem | |
| Ccore_example::SimpleCacheLine | |
| Ccore_example::SimpleTLBEntry | |
| Csparta::BasicHistogram< BucketT, ASSERT_ON_UNDERFLOW > | |
| Csparta::bit_reference_to_bool< T > | Helper type for converting _Bit_reference types into bool types for the purpose of determining how to lexically cast a string into that type |
| Csparta::bit_reference_to_bool< typename std::_Bit_reference > | |
| Csparta::utils::BitArray | Class for fast bit manipulation |
| Csparta::BoolEnum | The class responsible for handling State<bool> instances and converts bool instances into actual EnumTValueType instances to satisfy exisiting function signatures |
| 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 |
| Csparta::bounded_int< T, min_bound, max_bound > | Bounded integer type with range-checking |
| Csparta::utils::BoundedValue< T > | This class allows a developer to bound a value within an upper and lower value |
| Csparta::Buffer< DataT > | A data structure allowing appending at the end, beginning, or middle, but erase anywhere with collapse |
| Csparta::Buffer< LoadStoreInstInfoPtr > | |
| Csparta::log::categories | |
| ►Csparta::serialization::checkpoint::Checkpoint | Single checkpoint object interface with a tick number and an ID unique to the owning Checkpointer instance |
| Csparta::serialization::checkpoint::DeltaCheckpoint< StorageT > | 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() |
| ►Csparta::serialization::checkpoint::Checkpointer | Checkpointer interface. Defines an ID-based checkpointing API for tree of related checkpoints which could be stored as ordered deltas internally |
| ►Csparta::serialization::checkpoint::FastCheckpointer | 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 |
| Csparta::serialization::checkpoint::PersistentFastCheckpointer | Implements a Persistent FastCheckpointer, i.e. implements an interface to save checkpoints to disk |
| Csparta::CircularBuffer< DataT > | A data structure allowing appending at the end, beginning, or insert in the middle, but erase anywhere with collapse |
| Csparta::ClockManager | Manages building a clock tree |
| ►Csparta::collection::Collector | A non-templated base class that all Collectors should inherit from |
| Csparta::collection::PipelineCollector | 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 |
| Csparta::color::ColorScheme | Accessor methods for obtaining color code strings |
| Csparta::app::CommandLineSimulator | Command line simulator front-end class with argument parsing Works in conjunction with sparta::app::Simulation |
| ►Csparta::app::ConfigApplicator | 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 |
| Csparta::app::ArchNodeConfigFileApplicator | Applies an architectural configuration (parameter defaults) to a virtual parameter tree. This does not support applying, only applyUnbound |
| Csparta::app::NodeConfigFileApplicator | Applies a configuration file to a node pattern |
| Csparta::app::ParameterApplicator | Applies a value to a parameter node pattern |
| Csparta::app::ParameterDefaultApplicator | Applies a new default value to a parameter node pattern |
| Csparta::TieredMap< KeyT, ValT >::const_iterator | Const for walking contents of this map if const-qualified |
| CContextCounterInfo | |
| Ccore_example::CPUFactories | |
| ►Ccore_example::CPUTopology | |
| Ccore_example::CoreTopology_1 | CoreTopology_1 topology class |
| CMetaTypeList::create<... > | The Variadic Class Template create takes a variable number of different types and creates a well-formed type_list consisting of those types |
| CMetaTypeList::create< type_list< Elements... > > | Base case where we have consumed all the paramters in the pack and created the type_list. We just typedef it |
| ►CMetaTypeList::create< type_list< Elements..., Head >, Tail... > | |
| CMetaTypeList::create< type_list< Elements... >, Head, Tail... > | Specialization where type_list exists in the intermediate derivations |
| ►CMetaTypeList::create< type_list< Head >, Tail... > | |
| CMetaTypeList::create< type_list<>, Head, Tail... > | Specialization where no type_list exist |
| ►Csparta::CycleHistogramBase | CycleHistogramBase class for uint64_t values |
| Csparta::CycleHistogramStandalone | CycleHistogramStandalone class for uint64_t values |
| Csparta::CycleHistogramTreeNode | CycleHistogramTreeNode class for uint64_t values |
| Csparta::EnumCycleHistogram< EnumType > | EnumCycleHistogram class for C++ Enum values |
| Csparta::DAG | |
| Csparta_simdb::DatabaseTester | |
| ►Csparta::DataContainer< DataT > | 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 |
| Csparta::DataInPort< uint32_t > | |
| Csparta::DataInPort< InstQueue::value_type > | |
| Csparta::DataInPort< InstGroup > | |
| Csparta::DataInPort< FlushManager::FlushingCriteria > | |
| Csparta::DataInPort< uint64_t > | |
| Csparta::DataInPort< FlushingCriteria > | |
| Csparta::DataInPort< sparta::SpartaSharedPointer > | |
| Csparta::DataInPort< FlushCriteria > | |
| Csparta::DataInPort< bool > | |
| Csparta::SyncInPort< bool > | |
| Csparta::SyncInPort< sparta::SpartaSharedPointer > | |
| Csparta::DataInPort< DataT > | DataInPort receives data from sender using a DataOutPort |
| Csparta::SyncInPort< DataT > | Class that defines an synchronized input port on modules on two different clocks |
| ►Csparta::DataContainer< bool > | |
| Csparta::SignalInPort | SignalInPort receives data from sender using a SignalOutPort |
| Csparta::DataContainer< FlushCriteria > | |
| Csparta::DataContainer< FlushingCriteria > | |
| Csparta::DataContainer< FlushManager::FlushingCriteria > | |
| Csparta::DataContainer< InstGroup > | |
| Csparta::DataContainer< InstQueue::value_type > | |
| Csparta::DataContainer< sparta::SpartaSharedPointer > | |
| Csparta::DataContainer< uint32_t > | |
| Csparta::DataContainer< uint64_t > | |
| ►Csparta::memory::DebugMemoryIF | 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 |
| ►Csparta::memory::BlockingMemoryIF | 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 |
| Csparta::memory::BlockingMemoryIFNode | 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 |
| Csparta::memory::DMIBlockingMemoryIF | Class that provides a BlockingMemoryIF over a raw pointer |
| Csparta::app::DefaultValues | Optional default values for the simulator which can be customized and provided by anyone instantiating the simulator at construction-time |
| Csparta::RegisterBase::Definition | Describes an architected Register |
| Csparta::RegisterBase::Field::Definition | Field Definition structure |
| Csparta::RegisterProxyBase::Definition | Describes a register Proxy |
| Csparta::TreeNode::delegate | Temporary delegate for notificaiton invokation until the implementation is working. This will then be merged with sparta::SpartaHandler |
| ►Csparta::log::Destination | 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 |
| Csparta::log::DestinationInstance< DestType > | 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 |
| Csparta::log::DestinationInstance< std::ostream > | Logging Destination for an already-open ostream |
| Csparta::log::DestinationInstance< std::string > | Destination that opens and writes to a file with a format based on the file extension of the filename given during construction |
| Csparta::log::DestinationManager | Manages a set of destinations representing files or streams. All log messages will be written to at least one destination in this object |
| Csparta::utils::Enum< EnumType > | Class that wraps a C++ class enum and allows conversion between POD and the enum type. Also provides strings for them |
| Ccore_example::ExampleInst | Example instruction that flows through the example/CoreModel |
| ►Cstd::exception | |
| ►Csparta::SpartaException | Used to construct and throw a standard C++ exception. Inherits from std::exception |
| Csparta::DAG::CycleException | |
| Csparta::FutureStatisticRange | Exception indicating that the range of a StatisticInstance starts or ends in the future (probably caused by to checkpointing) |
| Csparta::ParameterException | Exception indicating a misconfigured Parameter or invalid Parameter access |
| Csparta::ReversedStatisticRange | Exception indicating that the range of a StatisticInstance was reversed when it was accessed (probably caused by checkpointing) |
| Csparta::SpartaCriticalError | Indicates something went seriously wrong and likely indicates corruption in simulator runtime state |
| Csparta::SpartaFatalError | Indicates something went seriously wrong and likely indicates unrecoverable corruption in simulator runtime state or misuse. This is the only exception that should ever be generated by a destructor since its semantics are that the simulation should terminate |
| ►Csparta::memory::MemoryAccessError | Indicates that there was an issue accessing a SPARTA memory object or interface |
| Csparta::memory::MemoryPeekError | Error while attempting to peek some memory object or interface |
| Csparta::memory::MemoryPokeError | Error while attempting to poke some memory object or interface |
| Csparta::memory::MemoryReadError | Error while attempting to read some memory object or interface |
| Csparta::memory::MemoryWriteError | Error while attempting to write some memory object or interface |
| Csparta::memory::MemoryTranslationError | Indicates that there was an issue translating an address in the SPARTA framework |
| Csparta::serialization::checkpoint::CheckpointError | Indicates that there was an issue operating on checkpoints within the SPARTA framework |
| Csparta::utils::Enum< EnumType >::UnknownNameException | |
| Csparta::statistics::expression::Expression | 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 |
| Csparta::StatisticDef::ExpressionArg | 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 |
| ►Csparta::statistics::expression::ExpressionNode | Abstract interface class for an item in an expression. Subclasses can contain other ExpressionNodes |
| Csparta::statistics::expression::BinaryFunction< RetT, ArgT > | Represents a Binary function node |
| Csparta::statistics::expression::Constant | |
| Csparta::statistics::expression::Operation | Operation Node (e.g. +,-,*,/) |
| Csparta::statistics::expression::ReferenceVariable | 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) |
| Csparta::statistics::expression::SimVariable | 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 |
| Csparta::statistics::expression::StatVariable | |
| Csparta::statistics::expression::TernaryFunction< RetT, ArgT > | Represents a Ternary function node |
| Csparta::statistics::expression::UnaryFunction< RetT, ArgT, fxn_t > | Represents a Unary function node |
| Csparta::statistics::expression::ExpressionParser | Class for parsing statistical expressions based on a specific TreeNode context |
| Csparta::ExtensionDescriptor | Descriptor class which provides basic information about an extended tree node: device tree location, extension name, and parameter name-values |
| ►Csparta::TreeNode::ExtensionsBase | Base class used to extend TreeNode parameter sets |
| ►Csparta::ExtensionsParamsOnly | Helper class used to trivially extend TreeNode parameter sets (but not any additional functionality beyond that) |
| CCircleExtensions | |
| Csparta::tracker::has_ostream_operator_impl::fallback | A fallback struct which can create itself |
| Csparta::utils::has_ostream_operator_impl::fallback | A fallback struct which can create itself |
| ►Cstd::false_type | |
| CMetaStruct::is_any_pointer< typename > | 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 |
| CMetaStruct::is_bool< typename > | Templated struct for detecting Boolean Type |
| CMetaStruct::is_char_pointer< typename > | Templated struct for detecting char pointer type |
| CMetaStruct::is_pair< typename > | 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 |
| CMetaStruct::is_sparta_enum< T > | Detect whether template parameter is sparta::utils::Enum type. Case when it is not a sparta::utils::Enum type |
| CMetaStruct::is_stl_container< typename > | This templated struct takes a type and tells us whether that type is a STL container |
| CMetaStruct::is_string< typename > | Templated struct for detecting String Type |
| CMetaTypeList::is_empty< typename > | Class Template is_empty Generic case |
| CMetaTypeList::is_meta_typelist<... > | Variadic Class Template which takes a type and matches it if that is a type_list. Generic case results to false |
| Csparta::is_sparta_enum< T > | Detect whether template parameter is sparta::utils::Enum type |
| Csparta::utils::is_vector< T > | |
| Csparta::utils::FastList< DataT > | An alternative to std::list, about 70% faster |
| Csparta::utils::FastList< PayloadDeliveringProxy * > | |
| Csparta::app::FeatureConfiguration | Collection of named feature values |
| Csparta::app::FeatureConfiguration::FeatureOptions | |
| CFILEIstream | |
| CFILEOstream | |
| Csparta::serialization::checkpoint::PersistentFastCheckpointer::FileReadAdapter | File storage adpater for ArchData |
| Csparta::serialization::checkpoint::PersistentFastCheckpointer::FileWriteAdapter | File storage adpater for ArchData |
| ►Csparta::log::Formatter | File writer formatting interface. Subclsases can format for different file types (e.g. raw log, html, sql, etc.) |
| Csparta::log::BasicFormatter | Formatter including only a few bits of the most relevant message information |
| Csparta::log::DefaultFormatter | Formatter that writes most message information, but excludes thread/sequence |
| Csparta::log::RawFormatter | Formatter including no meta-data from the message |
| Csparta::log::VerboseFormatter | Formatter that writes all message information |
| CMetaTypeList::frontT< typename > | 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 |
| ►CMetaTypeList::frontT< List > | |
| CMetaTypeList::nth_elementT< List, 0 > | Nth_elementT Template Specialization |
| CMetaTypeList::frontT< type_list< Head, Tail... > > | FrontT Template Specialization |
| Csparta::FunctionManager | Singleton Function Manager class. This class contains two maps and one constant string token. These maps contain a string as key and function pointers as value. The string key is the same as the name of the free functions as defined by the users and the keys are the function pointers to those methods. One map is dedicated for HistogramTreeNodes while the other is dedicated for CycleHistogramTreeNodes. This was necessary because these two classes do not share a common polymorphic base |
| CMetaStruct::generate_sequence< N, S > | This is the generic template |
| CMetaStruct::generate_sequence< 0, S... > | This is the specialization which kicks in when the first template parameter is 0 |
| CMetaTypeList::get_index< size_t,... > | Class Template to return the index of a certain type in a certain typelist |
| CMetaTypeList::get_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 |
| ►CMetaTypeList::get_index< S, T, type_list< Tail... > > | |
| CMetaTypeList::get_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 |
| CMetaTypeList::get_pack_size<... > | Class Template get_pack_size return the current number of types in the type_list |
| CMetaTypeList::get_pack_size< type_list< Head, Tail... > > | Unroll Templates till Base case specialization is reached and accumulate |
| CMetaTypeList::get_pack_size< type_list<> > | Base case specialization |
| Csparta::GlobalEvent< sched_phase_T > | A type of "global" reusable event |
| Csparta::GlobalEvent< SchedulingPhase::Update > | |
| Csparta::GlobalEventProxy | A helper class of GlobalEvent |
| Csparta::GlobalOrderingPoint | Used to set precedence between Scheduleable types across simulation |
| ►Cboost::spirit::qi::grammar | |
| Csparta::statistics::expression::grammar::ExpressionGrammar | |
| ►Csparta::tracker::has_ostream_operator_impl::has_ostream_operator< T > | |
| Csparta::tracker::has_ostream_operator< T > | |
| ►Csparta::utils::has_ostream_operator_impl::has_ostream_operator< T > | |
| Csparta::utils::has_ostream_operator< T > | |
| Chashtuple::hash< TT > | Base struct for types which have std::hash() defined |
| Chashtuple::hash< std::tuple< TT... > > | Template specialization where the template parameter |
| ►Csparta::HistogramBase | Histogram base class for uint64_t values |
| Csparta::HistogramStandalone | |
| Csparta::HistogramTreeNode | |
| Csparta::log::Formatter::Info | Formatter type description. Used in a table to describe various formatter sublasses |
| CMetaStruct::is_stl< T > | |
| Csparta::is_vector< T > | Templated for determining if ValueType is std::vector for use in metaprogramming constructs. This is intended to be be consumed by enable_if |
| Csparta::is_vector< std::vector< T > > | |
| Csparta::TieredMap< KeyT, ValT >::iterator | Iterator for walking contents of this map |
| Csparta::utils::Enum< EnumType >::iterator | |
| Csparta::utils::IteratorTraits< category, T > | |
| ►Csparta::utils::IteratorTraits< std::bidirectional_iterator_tag, value_type > | |
| Csparta::Queue< DataT >::QueueIterator< is_const_iterator > | 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 |
| ►Csparta::utils::IteratorTraits< std::forward_iterator_tag, DataT > | |
| Csparta::Pipeline< DataT, EventT >::PipelineIterator< is_const_iterator > | An iterator class for Pipeline class |
| ►Csparta::utils::IteratorTraits< std::forward_iterator_tag, value_type > | |
| Csparta::Array< DataT, ArrayT >::ArrayIterator< is_const_iterator > | An iterator struct for this array |
| Csparta::Pipe< DataT >::PipeIterator< is_const_iterator > | |
| Csparta::utils::FastList< DataT >::NodeIterator< is_const > | The internal iterator type of FastList. Use FastList<T>::[const_]iterator instead |
| Csparta::KeyValue | The type-to-type name map. Not really necessary, but useful |
| CMetaStruct::last_index_type< size_t,... > | 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 |
| CMetaStruct::last_index_type< 0, T > | Base case when we have just the last item of the parameter pack |
| ►CMetaStruct::last_index_type< N - 1, Args... > | |
| CMetaStruct::last_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 |
| Csparta::ArchData::Line | Line object which composes part of an entire ArchData |
| Csparta::LineStringStream | Helper class for building a set of lines through an ostream-like interface |
| Ccore_example::LSU::LoadStoreInstInfo | |
| Csparta::utils::LockedValue< T > | Provides a wrapper around a value to ensure that once the value is frozen or locked, it cannot be overwritten again |
| Csparta::log::MessageSource::LogObject | Temporary object for constructing a log message with a ostream-like interface. Emits a message to the message source upon destruction |
| Csparta::utils::make_lowercase | Functor for ::tolower |
| Csparta::utils::make_uppercase | Functor for ::toupper |
| Csparta::memory::SimpleMemoryMap::Mapping | Represents a mapping between an input address and output address for use in a destination BlockingMemoryIF |
| Csparta::State< EnumT, MetaDataT, MAX_MARKERS >::Marker | Class that will mark the state for transition |
| CMetaStruct::matches_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 |
| CMetaStruct::matches_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 |
| Csparta::ParameterTree::Node::MatchIterator | |
| Ccore_example::LSU::MemoryAccessInfo | |
| Csparta::MemoryProfiler | Utility used to periodically collect heap usage statistics throughout a simulation. Supported phases for inspection include Build, Configure, Bind, and Simulate |
| Csparta::log::Message | Contains a logging message header and content |
| Csparta::log::MessageInfo | Logging Message information excluding actual message content |
| Csparta::utils::Modifier | Modifier instance - Associates some suffix strings (e.g. "b") with a semantic (e.g. multiply by one billion) |
| Csparta::State< EnumT, MetaDataT, MAX_MARKERS >::Monitor | Monitor a particular State value and allow the user to determine a full state change |
| Csparta::app::MultiDetailOptions | Class for containing multiple levels of boost program options |
| Csparta::app::named_value_parser< ArgT > | Parser helper for named_value_type |
| Csparta::app::named_value_parser< int16_t > | Named_value_parser specialization for int16_t |
| Csparta::app::named_value_parser< int32_t > | Named_value_parser specialization for int32_t |
| Csparta::app::named_value_parser< int64_t > | Named_value_parser specialization for int64_t |
| Csparta::app::named_value_parser< int8_t > | Named_value_parser specialization for int8_t |
| Csparta::app::named_value_parser< uint16_t > | Named_value_parser specialization for uint16_t |
| Csparta::app::named_value_parser< uint32_t > | Named_value_parser specialization for uint32_t |
| Csparta::app::named_value_parser< uint64_t > | Named_value_parser specialization for uint64_t |
| Csparta::app::named_value_parser< uint8_t > | Named_value_parser specialization for uint8_t |
| Csparta::ParameterTree::Node | 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 |
| Csparta::TreeNode::NotificationInfo | Notification type/name information |
| CMetaTypeList::nth_elementT< List, N > | 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> |
| Csparta::ObjectAllocator< ObjT > | |
| Csparta::ObjectAllocator< TickQuantum > | |
| Csparta::NotificationSourceBase::ObservationStateCallback | Callback for observation-state of a NotificationSourceBase |
| Csparta::NotificationSourceBase::ObservationStateCallbackPrivateInterface | Controlled interface to NotificationSourceBase for regiistering and deregistering observation state change callback objects only |
| Csparta::OneWayBool< Default > | 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 |
| Csparta::OneWayBool< false > | |
| Csparta::app::MultiDetailOptions::OptAdder | Helper class for chained calls to add_options |
| ►Csparta::PairCollector | |
| Csparta::collection::Collectable< 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 > > | |
| Csparta::pevents::NestedPeventCollector< DataT > | 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 |
| Csparta::pevents::PeventCollector< CollectedEntityType > | 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 |
| ►Csparta::PairCollectorTreeNode | |
| ►Csparta::pevents::PeventCollectorTreeNode | |
| Csparta::pevents::NestedPeventCollector< DataT > | 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 |
| Csparta::pevents::PeventCollector< CollectedEntityType > | 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 |
| ►Csparta::PairDefinition | |
| Ccore_example::ExampleInstPairDef | Pair Definition class of the Example instruction that flows through the example/CoreModel |
| Ccore_example::LSU::LoadStoreInstInfoPairDef | Pair Definition class of the load store instruction that flows through the example/CoreModel |
| Ccore_example::LSU::MemoryAccessInfoPairDef | Pair Definition class of the Memory Access Information that flows through the example/CoreModel |
| CMetaStruct::parameter_pack_length< Args > | This Variadic templated struct contains a nested value which stores the length of any parameter pack it gets templatized on |
| Csparta::ParameterSet::ParameterSetIterator< T > | Non-const iterator for ParameterSet |
| Csparta::app::ParameterTemplate | ParameterTemplate providing factory implementation for each data type |
| Csparta::ParameterTree | Virtual Parameter Tree. This represents a tree of parameters read from some source but does not necessarily correspond to the parameters in the simulation itself or even to the simulation tree. This is meant to provide a hierarchical view into simulation parameters before they are actually applied to a real TreeNode tree |
| Csparta::ParameterBase::ParameterValueIterator | Generic value iterator for a SINGLE parameter which represents values ONLY as std::string |
| CMetaStruct::peek_last_type<... > | |
| CMetaStruct::peek_last_type< Tail > | |
| ►CMetaStruct::peek_last_type< Tail... > | |
| CMetaStruct::peek_last_type< Head, Tail... > | |
| Csparta::StatisticDef::PendingSubStatCreationInfo | This helper class serves as a placeholder for substatistic creation |
| Csparta::pevents::PEvent< CustomAttrs > | Defines the class base type for PEvents |
| Csparta::pevents::PeventCollectorController | 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. |
| ►Csparta::PhasedObject | Object having a specific phase in the sparta construction paradigm |
| ►Csparta::ResourceContainer | PhasedObject which can hold 0 or 1 Resource pointers to an associatedresource. Contains logic for setting and getting the associated Resource |
| Csparta::TreeNode | Node in a composite tree representing a sparta Tree item |
| Csparta::Pipe< DataT > | A very simple pipe, not part of the DES paradigm |
| Csparta::Pipe< MemoryAccessInfoPtr > | |
| Csparta::Pipeline< DataT, EventT > | A simple pipeline |
| Csparta::Pipeline< MemoryAccessInfoPtr > | |
| CMetaTypeList::pop_frontT< typename > | 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 |
| CMetaTypeList::pop_frontT< type_list< Head, Tail... > > | Pop_frontT Template Specialization |
| Ccore_example::CPUTopology::PortConnectionInfo | Structure to represent a port binding between units in device tree |
| Csparta::PostRunValidationInfo | Information describing the type of validation being done |
| Csparta::memory::BlockingMemoryIFNode::PostWriteAccess | Structure containing data for a Memory post-write notification |
| Csparta::RegisterBase::PostWriteAccess | Structure containing data for a Register post-write notification |
| CPrecedence | Specify the default event scheduling precedence between pipeline stages |
| Csparta::Scheduleable::PrecedenceSetup | An internal class used in Scheduleble to cache a pointer to the scheduler |
| ►Csparta::cache::PreloadableIF | |
| Ccore_example::SimpleDL1 | |
| ►Csparta::cache::PreloadDumpableIF | |
| Ccore_example::SimpleDL1 | |
| ►Csparta::cache::PreloaderIF | |
| Ccore_example::Preloader | Implement a PreloaderIF with appropriate knowledge of how to preload yaml files into the lsu's L1 cache |
| Csparta::PriorityQueue< DataT, SortingAlgorithmT, bounded_cnt > | A data structure that allows pushing/emplacing into it with a given sorter |
| Csparta::ptr_to_const_obj_ptr< T, ConstT > | 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" |
| CMetaTypeList::push_backT< typename, typename > | 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 |
| CMetaTypeList::push_backT< type_list< Elements... >, NewElement > | Push_backT Template Specialization |
| CMetaTypeList::push_frontT< typename, typename > | 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 |
| CMetaTypeList::push_frontT< type_list< Elements... >, NewElement > | Push_frontT Template Specialization |
| Csparta::Queue< DataT > | A data structure that allows appending at the back and invalidating from the front |
| Csparta::Queue< ExampleInstPtr > | |
| Csparta::utils::RadixPrefix | 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 |
| Csparta::utils::Rational< T > | Class to represent a Rational number |
| Csparta::utils::Rational< uint32_t > | |
| Csparta::memory::BlockingMemoryIFNode::ReadAccess | Structure containing data for a Memory pre- or post-read notification |
| Csparta::RegisterBase::ReadAccess | Structure containing data for a Register pre- or post-read notification |
| Csparta::RegisterBankTable< RegisterT > | Container of register banks as a helper for RegisterSet. Instances of this class will be owned by a single RegisterSet |
| Csparta::RegisterBankTable< RegisterBase > | |
| Csparta::RegisterBankTable< sparta::RegisterBase > | |
| Csparta::RegisterBits | |
| ►Csparta::RegisterProxyBase | |
| Csparta::RegisterProxy | Represents an interface to a pseudo-"Register" of a fixed size which indirectly references other registers (having the same group num, group idx, and size) depending on simulator state. Essentially, this hides banking and register aliasing (shared data) information from the client of this interface which is useful for presenting debugginer-visible and software-visible registers without regard for the underlying banking or aliasing |
| Csparta::RegisterSet::RegisterTypeTag< RegisterT > | |
| CMetaStruct::remove_any_pointer< T > | 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 |
| CMetaStruct::remove_any_pointer< const T * > | |
| CMetaStruct::remove_any_pointer< const T *const > | |
| CMetaStruct::remove_any_pointer< std::shared_ptr< T > & > | |
| CMetaStruct::remove_any_pointer< std::shared_ptr< T > > | |
| CMetaStruct::remove_any_pointer< std::shared_ptr< T > const & > | |
| CMetaStruct::remove_any_pointer< std::shared_ptr< T > const > | |
| CMetaStruct::remove_any_pointer< std::unique_ptr< T > & > | |
| CMetaStruct::remove_any_pointer< std::unique_ptr< T > > | |
| CMetaStruct::remove_any_pointer< std::unique_ptr< T > const & > | |
| CMetaStruct::remove_any_pointer< std::unique_ptr< T > const > | |
| CMetaStruct::remove_any_pointer< std::weak_ptr< T > & > | |
| CMetaStruct::remove_any_pointer< std::weak_ptr< T > > | |
| CMetaStruct::remove_any_pointer< std::weak_ptr< T > const & > | |
| CMetaStruct::remove_any_pointer< std::weak_ptr< T > const > | |
| CMetaStruct::remove_any_pointer< T * > | |
| CMetaStruct::remove_any_pointer< T *const > | |
| Csparta::app::ReportConfiguration | Configuration applicator class that is used for configuring a simulator's reports. Works in conjunction with sparta::app::ReportDescriptorCollection |
| Csparta::app::ReportDescriptor | Describes one or more report to instantiate |
| Csparta::app::ReportDescriptorCollection | 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 |
| Csparta::statistics::ReportStatisticsArchive | This class coordinates live SPARTA simulations (source) with binary output archives (sink) |
| Csparta::statistics::ReportStatisticsHierTree< NodeT, LeafNodeT > | Helper class used to build up a "report statistics hierarchy tree", where the template types are: |
| ►Csparta::Resource | The is the base class for all types of resources used by the SPARTA framework |
| Ccore_example::Preloader | Implement a PreloaderIF with appropriate knowledge of how to preload yaml files into the lsu's L1 cache |
| ►Csparta::Unit | The is the base class for user defined blocks in simulation |
| CConsumer | |
| CProducer | |
| Ccore_example::BIU | |
| Ccore_example::CPU | |
| Ccore_example::Core | |
| Ccore_example::Decode | |
| Ccore_example::Dispatch | |
| Ccore_example::Execute | |
| Ccore_example::Fetch | |
| Ccore_example::FlushManager | Class used by performance models for signaling a flushing event across blocks |
| Ccore_example::LSU | |
| Ccore_example::MSS | |
| Ccore_example::ROB | |
| Ccore_example::Rename | |
| Ccore_example::SimpleTLB | |
| Csparta::Scoreboard | Class used to track operand dependencies (timed) between units |
| ►Csparta::ResourceFactoryBase | Factory which can create Resources as well as the Parameter sets that can be modified before actually instantiating the resources themselves. Packages providing resources to the simulator implement this interface |
| ►Csparta::ResourceFactory< CPU, CPU::CPUParameterSet > | |
| Ccore_example::CPUFactory | |
| Csparta::ResourceFactory< core_example::Core, core_example::Core::CoreParameterSet > | |
| Csparta::ResourceFactory< core_example::Fetch, core_example::Fetch::FetchParameterSet > | |
| Csparta::ResourceFactory< core_example::Decode, core_example::Decode::DecodeParameterSet > | |
| Csparta::ResourceFactory< core_example::Rename, core_example::Rename::RenameParameterSet > | |
| Csparta::ResourceFactory< core_example::Dispatch, core_example::Dispatch::DispatchParameterSet > | |
| Csparta::ResourceFactory< core_example::Execute, core_example::Execute::ExecuteParameterSet > | |
| Csparta::ResourceFactory< core_example::LSU, core_example::LSU::LSUParameterSet > | |
| Csparta::ResourceFactory< core_example::SimpleTLB, core_example::SimpleTLB::TLBParameterSet > | |
| Csparta::ResourceFactory< core_example::BIU, core_example::BIU::BIUParameterSet > | |
| Csparta::ResourceFactory< core_example::MSS, core_example::MSS::MSSParameterSet > | |
| Csparta::ResourceFactory< core_example::ROB, core_example::ROB::ROBParameterSet > | |
| Csparta::ResourceFactory< core_example::FlushManager, core_example::FlushManager::FlushManagerParameters > | |
| Csparta::ResourceFactory< core_example::Preloader, core_example::Preloader::PreloaderParameterSet > | |
| Csparta::ResourceFactory< ResourceT, ParamsT > | Templated ResourceFactoryBase implementation which can be used to trivially define Resource Factories |
| Csparta::ResourceSet | Set of published ResourceFactories which can be referenced by name |
| CMetaStruct::return_type< T > | This templated struct lets us know about the return type from any random function pointer. This is specialized for a couple different signatures |
| CMetaStruct::return_type< R &(*)(Ts...)> | |
| CMetaStruct::return_type< R &(T::*)() const > | |
| CMetaStruct::return_type< R &(T::*const &)() const > | |
| CMetaStruct::return_type< R &(T::*const)() const > | |
| CMetaStruct::return_type< R(*)(Ts...)> | |
| CMetaStruct::return_type< R(T::*)() const > | |
| CMetaStruct::return_type< R(T::*const &)() const > | |
| CMetaStruct::return_type< R(T::*const)() const > | |
| CMetaStruct::return_type< std::function< R(Ts...)> > | |
| CMetaStruct::return_type< std::function< R(Ts...)> const > | |
| CMetaStruct::return_type< std::function< R(Ts...)> const T::* > | |
| CMetaStruct::return_type< std::function< R(Ts...)> const T::*const > | |
| CMetaStruct::return_type< std::function< R(Ts...)> T::* > | |
| CMetaStruct::return_type< std::function< R(Ts...)> T::*const & > | |
| CMetaStruct::return_type< std::shared_ptr< R > &(T::*)() const > | |
| CMetaStruct::return_type< std::shared_ptr< R > &(T::*const &)() const > | |
| CMetaStruct::return_type< std::shared_ptr< R > &(T::*const)() const > | |
| CMetaStruct::return_type< std::shared_ptr< R >(T::*)() const > | |
| CMetaStruct::return_type< std::shared_ptr< R >(T::*const &)() const > | |
| CMetaStruct::return_type< std::shared_ptr< R >(T::*const)() const > | |
| ►Csc_core::sc_module | |
| Csparta::SysCSpartaSchedulerAdapter | Class that "connects" Sparta to SystemC |
| ►Csparta::Scheduleable | A class that defines the basic scheduling interface to the Scheduler. Not intended to be used by modelers directly, but certainly can be |
| Csparta::Event< SchedulingPhase::Tick > | |
| Csparta::Event< sched_phase_T > | Event is a simple class for scheduling random events on the Scheduler |
| Csparta::PhasedUniqueEvent | A type of Event that uniquely schedules itself on the schedule within a single time quantum. This UniqueEvent is not typed on the SchedulingPhase. It is discouraged to use this class – use UniqueEvent templatized on the SchedulingPhase |
| Csparta::Scheduler::TickQuantum::ScheduleableGroup | |
| Csparta::ScheduleableHandle | A light-weight reference counting handle for Scheduleables – DOES NOT delete |
| Csparta::ScoreboardView | A ScoreboardView is a view into the master Scoreboard for operand readiness |
| CMetaStruct::sequence_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 |
| ►Cstd::shared_ptr | |
| Csparta::utils::LifeTracker< SpartaHandler > | |
| Csparta::utils::LifeTracker< TrackedObjectT > | A class that will track the lifetime of the object it points to |
| Csparta::SharedData< DataT, manual_update > | Class that allows the writing of data this cycle, but not visable until next cycle |
| Csparta::SharedData< Status > | |
| ►Csparta::cache::SimpleCache2 | |
| Ccore_example::SimpleDL1 | |
| Ccore_example::SimpleTLB | |
| ►Csparta::memory::SimpleMemoryMap | 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 |
| Csparta::memory::SimpleMemoryMapNode | Memory mapping object which implements BlockingMemoryIFNode. Supports a simple mapping of incoming addresses to addresses within a set of destination BlockingMemoryIFs |
| ►Csparta::app::Simulation | Simulator which builds a sparta DeviceTree |
| CExampleSimulator | ExampleSimulator which builds the model and configures it |
| CSkeletonSimulator | SkeletonSimulator which builds the model and configures it |
| Csparta::app::SimulationConfiguration | Configuration applicator class that is used for configuring a simulator. Works in conjunction with sparta::app::Simulation |
| Csparta::app::Simulation::SimulationController | This class is used for simulation control callbacks |
| Csparta::SimulationInfo | Contains information describing the simulation instance for the purpose of identifying the simulation and possible recreating it. This information should be written to all log files, reports, cmdline, etc |
| Csparta::statistics::SINodeHierarchy | 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 |
| Csparta::statistics::SIValuesBuffer | 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: |
| Csparta_traits< T > | |
| Csparta::SpartaSharedPointer< PointerT > | Used for garbage collection, will delete the object it points to when all objects are finished using it |
| Csparta::SpartaSharedPointer< ExampleInst > | |
| Csparta::SpartaSharedPointer< MemoryAccessInfo > | |
| Csparta::SpartaStaticInitializer | Static-initialization order controller |
| Csparta::SpartaTester | A simple testing class |
| Csparta::SpartaWeakPointer< PointerT > | Like in STL, create a weak pointer to a SpartaSharedPointer |
| Csparta::StartupEvent | StartupEvent is a simple class for scheduling a starting event on the Scheduler. It does not support precedence |
| Csparta::State< EnumT, MetaDataT, MAX_MARKERS > | The State class for watching transition between enum states |
| Csparta::State< CacheState > | |
| Csparta::State< IssuePriority > | |
| Csparta::State< IssueState > | |
| Csparta::State< MMUState > | |
| Csparta::State< sparta::PhasedObject::TreePhase > | |
| Csparta::State< Status > | |
| Csparta::State< T, typename std::enable_if< std::is_same< T, PhasedObject::TreePhase >::value >::type > | |
| ►Csparta::tracker::StatePoolBase | This is the polymorphic base class for the StatePool template class |
| Csparta::tracker::StatePool< T > | StatePool class template is templatized on the enum type we are tracking |
| Csparta::tracker::StatePoolManager | This is a Singleton class which manages all the different StatePool |
| Csparta::tracker::StateSet< EnumT > | This is the Calculation Engine unit inside each State Tracker Unit |
| Csparta::StateTimerUnit::StateTimer | The timer that user can access to start/end tracking state. A StateTimer::Handle is returned from StateTimerUnit upon allocation |
| Csparta::tracker::StateTrackerDeleter< T > | Custom Deleter of individual State Tracker Units |
| Csparta::tracker::StateTrackerUnit< EnumT > | This is the actual Lightweight Tracker class which does the |
| ►Cboost::static_visitor | |
| Csparta::KeyValue::TypeNameVisitor | Visitor class for looking up type name |
| Ccore_example::ExampleInst::StaticInfo | |
| Csparta::StatInstCalculator | |
| Csparta::StatisticInstance | Instance of either a StatisticDef or CounterBase or an Expression. Has a sample window (simulator ticks) over which it will compute the value of the contained expression/counter for that range |
| Csparta::statistics::StatisticsHierRootNodes< StorageT > | Utility class that holds onto statistics node hierarchies, accessible by a name that you choose |
| ►Csparta::statistics::StatisticsHierRootNodes< RootArchiveNode > | |
| Csparta::statistics::StatisticsArchives | This class owns and coordinates a group of named archives |
| Csparta::statistics::StatisticsHierRootNodes< sparta::statistics::StreamNode > | |
| Csparta::statistics::StatisticSnapshot | 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 |
| Csparta::statistics::StatisticsStreams | 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: |
| Csparta::statistics::StreamController | 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 |
| ►Csparta::statistics::StreamNode | 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) |
| Csparta::statistics::ReportStreamNode | 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 |
| Csparta::statistics::StatisticInstStreamNode | 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 |
| Csparta::StringManager | Manages string internment for SPARTA. This allows strings to be compared by pointer once interned |
| Csparta::serialization::checkpoint::storage::StringStreamStorage | Stringstream storage implementation |
| Csparta::Tag | Tag(): Simple class to provide nested sequence numbering |
| Csparta::log::Tap | Logging Tap. Attach to a TreeNode to intercept logging messages from any NotificationSource nodes in the subtree of that node (including the node itself) |
| Csparta::log::TapAddedEvent | |
| Csparta::log::TapDescriptor | Describes a tap |
| Csparta::log::TapRemovedEvent | |
| Csparta::TieredMap< KeyT, ValT > | 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 |
| Csparta::TieredMap< line_idx_type, Line * > | |
| Csparta::TimeManager | Singleton which manages wall-clock time for simulations in SPARTA This is not a "timer" manager, but rather an information service and could possible become a timing interval manager |
| Csparta::utils::TransformedString< AppliedTransform > | Function LevenshteinDistance() |
| Csparta::memory::Translation | An older class used to help in encapsulate read/virtual addresses |
| ►Csparta::memory::TranslationIF | Blocking translation interface with 1:1 translation unless subclassed |
| Csparta::memory::TranslationIFNode | 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 |
| Csparta::TreeNodePrivateAttorney | |
| ►Ctrigger::Triggerable | |
| Csparta::app::LoggingTrigger | Trigger for strating logging given a number of tap descriptors |
| Csparta::app::PipelineTrigger | Trigger used to enable/disable Pipeline colletion |
| ►CTriggerable | |
| Csparta::trigger::PeventTrigger | A simple interface with 2 methods |
| ►Cstd::true_type | |
| CMetaStruct::is_any_pointer< T * > | |
| CMetaStruct::is_any_pointer< T *const > | |
| CMetaStruct::is_any_pointer< const T * > | |
| CMetaStruct::is_any_pointer< const T *const > | |
| CMetaStruct::is_any_pointer< std::shared_ptr< T > & > | |
| CMetaStruct::is_any_pointer< std::shared_ptr< T > > | |
| CMetaStruct::is_any_pointer< std::shared_ptr< T > const & > | |
| CMetaStruct::is_any_pointer< std::shared_ptr< T > const > | |
| CMetaStruct::is_any_pointer< std::unique_ptr< T > & > | |
| CMetaStruct::is_any_pointer< std::unique_ptr< T > > | |
| CMetaStruct::is_any_pointer< std::unique_ptr< T > const & > | |
| CMetaStruct::is_any_pointer< std::unique_ptr< T > const > | |
| CMetaStruct::is_any_pointer< std::weak_ptr< T > & > | |
| CMetaStruct::is_any_pointer< std::weak_ptr< T > > | |
| CMetaStruct::is_any_pointer< std::weak_ptr< T > const & > | |
| CMetaStruct::is_any_pointer< std::weak_ptr< T > const > | |
| CMetaStruct::is_bool< bool & > | |
| CMetaStruct::is_bool< bool > | |
| CMetaStruct::is_bool< bool const & > | |
| CMetaStruct::is_bool< bool const > | |
| CMetaStruct::is_char_pointer< char * > | |
| CMetaStruct::is_char_pointer< char *const > | |
| CMetaStruct::is_char_pointer< const char * > | |
| CMetaStruct::is_char_pointer< const char *const > | |
| CMetaStruct::is_pair< std::pair< T, U > & > | |
| CMetaStruct::is_pair< std::pair< T, U > > | |
| CMetaStruct::is_pair< std::pair< T, U > const & > | |
| CMetaStruct::is_pair< std::pair< T, U > const > | |
| CMetaStruct::is_sparta_enum< sparta::utils::Enum< T > > | Detect whether template parameter is sparta::utils::Enum type. Case when it is a sparta::utils::Enum type |
| CMetaStruct::is_stl_container< std::array< T, N > > | |
| CMetaStruct::is_stl_container< std::deque< Args... > > | |
| CMetaStruct::is_stl_container< std::forward_list< Args... > > | |
| CMetaStruct::is_stl_container< std::list< Args... > > | |
| CMetaStruct::is_stl_container< std::map< Args... > > | |
| CMetaStruct::is_stl_container< std::multimap< Args... > > | |
| CMetaStruct::is_stl_container< std::multiset< Args... > > | |
| CMetaStruct::is_stl_container< std::priority_queue< Args... > > | |
| CMetaStruct::is_stl_container< std::queue< Args... > > | |
| CMetaStruct::is_stl_container< std::set< Args... > > | |
| CMetaStruct::is_stl_container< std::stack< Args... > > | |
| CMetaStruct::is_stl_container< std::unordered_map< Args... > > | |
| CMetaStruct::is_stl_container< std::unordered_multimap< Args... > > | |
| CMetaStruct::is_stl_container< std::unordered_multiset< Args... > > | |
| CMetaStruct::is_stl_container< std::unordered_set< Args... > > | |
| CMetaStruct::is_stl_container< std::vector< Args... > > | |
| CMetaStruct::is_string< std::string & > | |
| CMetaStruct::is_string< std::string > | |
| CMetaStruct::is_string< std::string const & > | |
| CMetaStruct::is_string< std::string const > | |
| CMetaStruct::matches_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 |
| CMetaTypeList::is_empty< type_list<> > | Class Template is_empty Specialization |
| CMetaTypeList::is_meta_typelist< MetaTypeList::type_list< Args... > > | Template Specialization when the type indeed is a type_list |
| Csparta::is_sparta_enum< sparta::utils::Enum< T > > | Detect whether template parameter is sparta::utils::Enum type |
| Csparta::utils::is_vector< std::vector< T, A > > | |
| Csparta::TreeNode::type_info_container | Container for std::type_info |
| CMetaTypeList::type_list<... > | The variadic class template type_list has no implementation and is empty by itself |
| ►Cboost::program_options::typed_value | |
| Csparta::app::named_value_type< ArgT > | Helper class for populating boost program options |
| 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 |
| Csparta::collection::UniquePairIDGenerator | |
| Ccore_example::CPUTopology::UnitInfo | Structure to represent a resource unit in device tree |
| Csparta::ValidationCheckCallback< ValueType > | Delegate for Parameter validation |
| Csparta::utils::ValidValue< T > | Provides a wrapper around a value to ensure that the value is assigned |
| Csparta::utils::ValidValue< bool > | |
| Csparta::utils::ValidValue< DataT > | |
| Csparta::utils::ValidValue< double > | |
| Csparta::utils::ValidValue< EnumTValueType > | |
| Csparta::utils::ValidValue< FlushCriteria > | |
| Csparta::utils::ValidValue< FlushingCriteria > | |
| Csparta::utils::ValidValue< FlushManager::FlushingCriteria > | |
| Csparta::utils::ValidValue< InstGroup > | |
| Csparta::utils::ValidValue< InstQueue::value_type > | |
| Csparta::utils::ValidValue< InstrumentationNode::class_t > | |
| Csparta::utils::ValidValue< InstrumentationNode::visibility_t > | |
| Csparta::utils::ValidValue< size_t > | |
| Csparta::utils::ValidValue< sparta::SpartaSharedPointer > | |
| Csparta::utils::ValidValue< StatisticDef::ValueSemantic > | |
| Csparta::utils::ValidValue< std::string > | |
| Csparta::utils::ValidValue< typename std::underlying_type< EnumT >::type > | |
| Csparta::utils::ValidValue< uint32_t > | |
| Csparta::utils::ValidValue< uint64_t > | |
| Csparta::utils::Enum< EnumType >::Value | |
| ►Cstd::vector | |
| Csparta::EventGroup | Group a series of events together for precedence establishment |
| Csparta::utils::VectorCopier< C, T > | Utility for element-wise potentially-deep-copying a vector. Invoked by methods at the end of this file |
| Csparta::utils::VectorCopier< std::shared_ptr, VT > | Specialization for shared_ptr |
| Csparta::utils::VectorCopier< std::unique_ptr, VT > | Specialization for unique_ptr |
| ►CVectorResourceCollectable | |
| Csparta::collection::AgedArrayCollector< ArrayType > | An AgedArrayCollector is created by the Array class in sparta when Pipeline collection is required |
| Csparta::serialization::checkpoint::storage::VectorStorage | Vector of buffers storage implementation |
1.9.8