Data Structures
Here are the data structures with brief descriptions:
[detail level 12345]
  sprockit | |
   serializable_ptr_type | |
| SST | |
| Core | |
| Environment | |
 EnvironmentConfigGroup | |
| EnvironmentConfiguration | |
| Interprocess | |
| CircularBuffer | |
| IPCTunnel | Tunneling class between two processes, connected by shared memory |
| MMAPChild_Pin3 | Class supports an IPC tunnel between two or more processes, via an mmap'd file This class attaches to an existing tunnel for a child process using PinCRT |
| MMAPParent | Class supports an IPC tunnel between two or more processes, via an mmap'd file |
| SHMChild | Class supports an IPC tunnel between two or more processes, via posix shared memory This class attaches to an existing tunnel for a child process |
| SHMParent | Class supports an IPC tunnel between two or more processes via posix shared memory This class creates the tunnel for the parent/master process |
| SSTMutex | |
| InternalSharedData | |
| TunnelDef | This class defines a shared-memory region between a master process and one or more child processes Region has three data structures: |
| Serialization | |
| pvt | |
| ser_array_wrapper | |
| raw_ptr_wrapper | |
| ser_buffer_overrun | |
| ser_buffer_accessor | |
| ser_packer | |
| ser_sizer | |
| ser_unpacker | |
| serializable | |
| serializable_type | |
| serializable_builder | |
| serializable_builder_impl | |
| serializable_factory | |
| serialize | Base serialize class |
| serialize< T, typename std::enable_if< std::is_fundamental< T >::value||std::is_enum< T >::value >::type > | Version of serialize that works for fundamental types and enums |
| serialize< bool > | Version of serialize that works for bool |
| serialize< T *, typename std::enable_if< std::is_fundamental< T >::value||std::is_enum< T >::value >::type > | Version of serialize that works for pointers to fundamental types and enums |
| serialize< std::pair< U, V > > | Version of serialize that works for std::pair |
| serialize< T[N], typename std::enable_if< std::is_fundamental< T >::value||std::is_enum< T >::value >::type > | Version of serialize that works for statically allocated arrays of fundamental types and enums |
| serialize< T[N], typename std::enable_if<!std::is_fundamental< T >::value &&!std::is_enum< T >::value >::type > | Version of serialize that works for statically allocated arrays of non base types |
| serialize< pvt::ser_array_wrapper< T, IntType >, typename std::enable_if< std::is_fundamental< T >::value||std::is_enum< T >::value >::type > | Version of serialize that works for dynamically allocated arrays of fundamental types and enums |
| serialize< pvt::ser_array_wrapper< T, IntType >, typename std::enable_if<!std::is_fundamental< T >::value &&!std::is_enum< T >::value >::type > | Version of serialize that works for dynamically allocated arrays of non base types |
| serialize< pvt::ser_array_wrapper< void, IntType > > | Version of serialize that works for statically allocated arrays of void* |
| serialize< pvt::raw_ptr_wrapper< TPtr > > | Version of serialize that works for copying raw pointers (only copying the value of the pointer |
| serialize< std::deque< T > > | |
| serialize< std::list< T > > | |
| serialize< std::map< Key, Value > > | |
| serialize< serializable * > | |
| serialize< T *, typename std::enable_if< std::is_base_of< SST::Core::Serialization::serializable, T >::value >::type > | |
| serialize< T, typename std::enable_if< std::is_base_of< SST::Core::Serialization::serializable, T >::value >::type > | |
| serialize< std::set< T > > | |
| serialize< std::string > | |
| serialize< std::vector< T > > | |
| serializer | This class is basically a wrapper for objects to declare the order in which their members should be ser/des |
| statics | |
| need_delete_statics | |
| serialize< SST::SparseVectorMap< keyT, classT > > | |
| ThreadSafe | |
| Barrier | |
| Spinlock | |
| BoundedQueue | |
| UnboundedQueue | |
| DotConfigGraphOutput | |
| JSONConfigGraphOutput | |
| PythonConfigGraphOutput | |
| XMLConfigGraphOutput | |
| ConfigGraphOutputException | |
| ConfigGraphOutput | |
| MemPool | Simple Memory Pool class |
| ELI | |
| ProvidesCategory | |
| ProvidesDefaultInfo | |
| Builder | |
| BuilderLibrary | |
| BuilderLibraryDatabase | |
| BuilderLoader | |
| InstantiateBuilder | |
| Allocator | |
| CachedAllocator | |
| DerivedBuilder | |
| is_tuple_constructible | |
| is_tuple_constructible< T, std::tuple< Args...> > | |
| BuilderDatabase | |
| ElementsBuilder | |
| ElementsBuilder< Base, std::tuple< Args...> > | |
| ExtendedCtor | Implements a constructor for a derived base as usually happens with subcomponents, e.g |
| SingleCtor | |
| CtorList | |
| NoValidConstructorsForDerivedType | |
| NoValidConstructorsForDerivedType< 0 > | |
| CtorList< Base, void > | |
| DataBase | |
| BuilderInfoImpl | |
| BuilderInfoImpl< void > | |
| InstantiateBuilderInfo | |
| InfoLibrary | |
| InfoLibraryDatabase | |
| InfoLoader | |
| ElementsInfo | |
| InfoDatabase | |
| MethodDetect | |
| LibraryLoader | |
| LoadedLibraries | |
| ProvidesInterface | |
| GetParams | |
| GetParams< T, typename MethodDetect< decltype(T::ELI_getParams())>::type > | |
| ProvidesParams | |
| InfoPorts | |
| InfoPorts< T, typename MethodDetect< decltype(T::ELI_getPorts())>::type > | |
| ProvidesPorts | |
| InfoStats | |
| InfoStats< T, typename MethodDetect< decltype(T::ELI_getStatistics())>::type > | |
| ProvidesStats | |
| InfoSubs | |
| InfoSubs< T, typename MethodDetect< decltype(T::ELI_getSubComponentSlots())>::type > | |
| ProvidesSubComponentSlots | |
| IMPL | |
| Partition | |
| SSTLinearPartition | Performs a linear partition scheme of an SST simulation configuration |
| SSTRoundRobinPartition | |
| SSTSelfPartition | Self partitioner actually does nothing |
| SimplePartitioner | |
| SSTSinglePartition | Single partitioner is a virtual partitioner used for serial jobs |
| TimeVortexPQ | Primary Event Queue |
| Interfaces | |
| SimpleMem | Simplified, generic interface to Memory models |
| Handler | Event Handler class with user-data argument |
| Handler< classT, void > | Event Handler class without user-data |
| HandlerBase | Functor classes for Clock handling |
| Request | Represents both memory requests and responses |
| SimpleNetwork | Generic network interface |
| Handler | Event Handler class with user-data argument |
| Handler< classT, void > | Event Handler class without user-data |
| HandlerBase | Functor classes for handling of callbacks |
| NetworkInspector | Class used to inspect network requests going through the network |
| Request | Represents both network sends and receives |
| StringEvent | Simple event to pass strings between components |
| TestEvent | Test Event Useful for early-testing of components |
| Partition | |
| SSTPartitioner | Base class for Partitioning graphs |
| RNG | |
| SSTConstantDistribution | Implements a distribution which always returns a constant value (provided by the user) |
| SSTDiscreteDistribution | Creates a discrete distribution for use within SST |
| SSTRandomDistribution | Base class of statistical distributions in SST |
| SSTExponentialDistribution | Creates an exponential distribution for use within SST |
| SSTGaussianDistribution | Creates a Gaussian (normal) distribution for which to sample |
| MarsagliaRNG | Implements a random number generator using the Marsaglia method |
| MersenneRNG | Implements a Mersenne-based RNG for use in the SST core or components |
| SSTPoissonDistribution | Creates an Poisson distribution for use within SST |
| SSTRandom | Implements the base class for random number generators for the SST core |
| SSTUniformDistribution | Creates a Uniform distribution for use within SST |
| XORShiftRNG | Implements a lightweight RNG based on XOR-shift operations |
| Statistics | |
| Statistic | Forms the template defined base class for statistics gathering within SST |
| AccumulatorStatistic | Allows the online gathering of statistical information about a single quantity |
| StatisticInfo | |
| StatisticBase | Forms the base class for statistics gathering within SST |
| StatisticCollector | Base type that creates the virtual addData(...) interface Used for distinguishing fundamental types (collected by value) and composite struct types (collected by reference) |
| StatisticCollector< T, true > | |
| StatisticCollector< std::tuple< Args...>, false > | |
| Statistic< void > | Void Statistic has special meaning in that it does not collect fields in the usual way through the addData function |
| ImplementsStatFields | |
| StatisticProcessingEngine | An SST core component that handles timing and event processing informing all registered Statistics to generate their outputs at desired rates |
| StatisticFieldTypeBase | |
| StatisticFieldType | |
| StatisticFieldInfo | The class for representing Statistic Output Fields |
| StatisticGroup | |
| HistogramStatistic | Holder of data grouped into pre-determined width bins |
| NullStatisticBase | |
| NullStatisticBase< T, true > | |
| NullStatisticBase< std::tuple< Args...>, false > | |
| NullStatisticBase< T, false > | |
| NullStatistic | An empty statistic place holder |
| NullStatistic< void > | |
| StatisticOutput | Forms the base class for statistics output generation within the SST core |
| StatisticFieldsOutput | |
| StatisticOutputConsole | The class for statistics output to the console |
| StatisticOutputCSV | The class for statistics output to a comma separated file |
| StatisticOutputHDF5 | The class for statistics output to a comma separated file |
| StatisticOutputJSON | The class for statistics output to a JSON formatted file |
| StatisticOutputTxt | The class for statistics output to a text file |
| UniqueCountStatistic | Creates a Statistic which counts unique values provided to it |
| Action | An Action is a schedulable Activity which is not an Event |
| Activity | Base class for all Activities in the SST Event Queue |
| less_time | Comparator class to use with STL container classes |
| less_time_priority | Comparator class to use with STL container classes |
| less_time_priority_order | To use with STL container classes |
| pq_less_time_priority | To use with STL priority queues, that order in reverse |
| pq_less_time_priority_order | To use with STL priority queues, that order in reverse |
| ActivityQueue | Base Class for a queue of Activities |
| BaseComponent | Main component object for the simulation |
| SubComponentSlotInfo | Used to load SubComponents when multiple SubComponents are loaded into a single slot (will also also work when a single SubComponent is loaded) |
| Clock | A Clock class |
| Handler | Event Handler class with user-data argument |
| Handler< classT, void > | Event Handler class without user-data |
| HandlerBase | Functor classes for Clock handling |
| Component | Main component object for the simulation |
| ComponentExtension | ComponentExtension is a class that can be loaded using loadComponentExtension<T>(...) |
| ComponentInfo | |
| EqualsID | |
| EqualsName | |
| HashID | |
| HashName | |
| ComponentInfoMap | |
| sstLongOpts_s | |
| Config | Class to contain SST Simulation Configuration variables |
| ConfigLink | Represents the configuration of a generic Link |
| ConfigStatGroup | |
| ConfigStatOutput | |
| ConfigComponent | Represents the configuration of a generic component |
| ConfigGraph | A Configuration Graph A graph representing Components and Links |
| PartitionComponent | |
| PartitionLink | |
| PartitionGraph | |
| decimal_fixedpoint | Class that implements a decimal fixed-point number |
| LoaderData | This structure exists so that we don't need to have any libtool-specific code (and therefore need the libtool headers) in factory.h |
| ElemLoader | Class to load Element Libraries |
| SST_ELI_element_version_extraction | |
| ElementInfoStatistic | Describes Statistics used by a Component |
| ElementInfoParam | Describes Parameters to a Component |
| ElementInfoPort | Describes Ports that the Component can use |
| ElementInfoPort2 | Describes Ports that the Component can use |
| ElementInfoSubComponentSlot | |
| Event | Base class for Events - Items sent across links to communicate between components |
| Handler | Event Handler class with user-data argument |
| Handler< classT, void > | Event Handler class with no user-data |
| HandlerBase | Functor classes for Event handling |
| NullEvent | Null Event |
| Exit | Exit Event Action |
| Factory | Class for instantiating Components, Links and the like out of element libraries |
| SimulatorHeartbeat | An optional heartbeat to show progress in a simulation |
| InitQueue | ActivityQueue for use during the init() phase |
| Link | Link between two components |
| SelfLink | Self Links are links from a component to itself |
| LinkMap | Maps port names to the Links that are connected to it |
| LinkPair | Defines a pair of links (to define a connected link) |
| SSTElementPythonModuleCode | Class to represent the code that needs to be added to create the python module struture for the library |
| SSTElementPythonModule | Base class for python modules in element libraries |
| SSTModelDescription | Base class for Model Generation |
| Module | Module is a tag class used with the loadModule function |
| OneShot | A OneShot Event class |
| Handler | Event Handler class with user-data argument |
| Handler< classT, void > | Event Handler class without user-data |
| HandlerBase | Functor classes for OneShot handling |
| Output | Output object provides consistent method for outputting data to stdout, stderr and/or sst debug file |
| TraceFunction | |
| Params | Parameter store |
| PollingLinkQueue | A link queue which is used for polling only |
| RankInfo | |
| RankSyncParallelSkip | |
| RankSyncSerialSkip | |
| SharedRegionMerger | Utility class to define how to merge multiple pieces of shared memory regions Useful in the multi-MPI-rank, "Global Shared" model |
| SharedRegionInitializedMerger | |
| SharedRegionManager | |
| SharedRegion | |
| ChangeSet | |
| RegionInfo | |
| BulkMergeInfo | |
| ChangeSetMergeInfo | |
| RegionMergeInfo | |
| SharedRegionImpl | |
| SharedRegionManagerImpl | |
| Simulation | Main control class for a SST Simulation |
| SparseVectorMap | |
| SparseVectorMap< keyT, keyT > | |
| SSTInfoConfig | The SSTInfo Configuration class |
| SSTLibraryInfo | The SSTInfo representation of ElementLibraryInfo object |
| StopAction | Action which causes the Simulation to end |
| char_delimiter | |
| escaped_list_separator | |
| Tokenizer | |
| SubComponent | SubComponent is a class loadable through the factory which allows dynamic functionality to be added to a Component |
| SyncBase | SyncBase defines the API for Sync objects, which are used to synchronize between MPI ranks in a simulation |
| EmptyRankSync | |
| EmptyThreadSync | |
| NewRankSync | |
| NewThreadSync | |
| SyncManager | |
| SyncQueue | Internal API |
| Header | |
| ThreadSync | |
| ThreadSyncQueue | Base Class for a queue of Activities |
| ThreadSyncSimpleSkip | |
| TimeConverter | A class to convert between a component's view of time and the core's view of time |
| TimeLord | Class for creating and managing TimeConverter objects |
| TimeVortex | Primary Event Queue |
| UninitializedQueue | Always uninitialized queue |
| Units | Helper class internal to UnitAlgebra |
| UnitAlgebra | Performs Unit math in full precision |
| ComponentHolder | |
| ComponentPy_t | |
| emptyModuleDef | |
| LinkPy_t | |
| lt__advise | |
| lt__handle | |
| lt__interface_id | |
| lt_dlvtable | |
| lt_interface_data | |
| ModuleLoaderPy_t | |
| OverallOutputter | |
| PyComponent | |
| PySubComponent | |
| SimThreadInfo_t | |
| slist | |
| sstModuleDef | |
| StatGroupPy_t | |
| StatOutputPy_t | |
| symlist_chain |
