Data Structures

Here are the data structures with brief descriptions:

[detail level 12345]

►Nsprockit
Cserializable_ptr_type
►NSST
►NCore
►NEnvironment
CEnvironmentConfigGroup
CEnvironmentConfiguration
►NInterprocess
CCircularBuffer
CInternalSharedData
CIPCTunnel	Tunneling class between two processes, connected by shared memory
CMMAPChild_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
CMMAPParent	Class supports an IPC tunnel between two or more processes, via an mmap'd file
CSHMChild	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
CSHMParent	Class supports an IPC tunnel between two or more processes via posix shared memory This class creates the tunnel for the parent/master process
CSSTMutex
CTunnelDef	This class defines a shared-memory region between a master process and one or more child processes Region has three data structures:
►NSerialization
►Npvt
Craw_ptr_wrapper
Cser_array_wrapper
Cser_buffer_accessor
Cser_buffer_overrun
Cser_packer
Cser_sizer
Cser_unpacker
Cneed_delete_statics
Cserializable
Cserializable_builder
Cserializable_builder_impl
Cserializable_factory
Cserializable_type
Cserialize	Base serialize class
Cserialize< bool >	Version of serialize that works for bool
Cserialize< pvt::raw_ptr_wrapper< TPtr > >	Version of serialize that works for copying raw pointers (only copying the value of the pointer
Cserialize< 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
Cserialize< 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
Cserialize< pvt::ser_array_wrapper< void, IntType > >	Version of serialize that works for statically allocated arrays of void*
Cserialize< serializable * >
Cserialize< SST::SparseVectorMap< keyT, classT > >
Cserialize< std::deque< T > >
Cserialize< std::list< T > >
Cserialize< std::map< Key, Value > >
Cserialize< std::pair< U, V > >	Version of serialize that works for std::pair
Cserialize< std::set< T > >
Cserialize< std::string >
Cserialize< std::unordered_map< Key, Value > >
Cserialize< std::unordered_set< T > >
Cserialize< std::vector< T > >
Cserialize< T *, typename std::enable_if< std::is_base_of< SST::Core::Serialization::serializable, T >::value >::type >
Cserialize< 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
Cserialize< T, typename std::enable_if< std::is_base_of< SST::Core::Serialization::serializable, T >::value >::type >
Cserialize< 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
Cserialize< 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
Cserialize< 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
Cserializer	This class is basically a wrapper for objects to declare the order in which their members should be ser/des
Cstatics
►NThreadSafe
CBarrier
CBoundedQueue
CEmptySpinlock
CSpinlock
CUnboundedQueue
CConfigGraphOutput
CConfigGraphOutputException
CDotConfigGraphOutput
CJSONConfigGraphOutput
CMemPoolAccessor
CMemPoolItem
CPythonConfigGraphOutput
CSSTJSONModelDefinition
CSSTPythonModelDefinition
CSSTXmlModelDefinition
CXMLConfigGraphOutput
►NCoreTest
►NMessageMesh
CEnclosingComponent
CMessageEvent
CMessagePort
CPortInterface
CPortSlot
CRouteInterface
CRouteMessage
►NCoreTestClockerComponent
CcoreTestClockerComponent
►NCoreTestComponent
CcoreTestComponent
CcoreTestComponentBase
CcoreTestComponentBase2
CcoreTestComponentEvent
CcoreTestLinks
►NCoreTestDistribComponent
CcoreTestDistribComponent
►NCoreTestLookupTableComponent
CcoreTestLookupTableComponent
►NCoreTestMemPoolTest
CMemPoolTestComponent
CMemPoolTestEvent1
CMemPoolTestEvent2
CMemPoolTestEvent3
CMemPoolTestEvent4
CMemPoolTestPerformanceEvent
►NCoreTestMessageGeneratorComponent
CcoreTestMessage
CcoreTestMessageGeneratorComponent
►NCoreTestModule
CCoreTestModuleExample
►NCoreTestParamComponent
CcoreTestParamComponent
►NCoreTestPerfComponent
CcoreTestPerfComponent
CcoreTestPerfComponentBase
CcoreTestPerfComponentBase2
►NCoreTestRNGComponent
CcoreTestRNGComponent
►NCoreTestSerialization
CcoreTestSerialization
►NCoreTestSharedObjectsComponent
CcoreTestSharedObjectsComponent
CsetItem
►NCoreTestStatisticsComponent
CStatisticsComponentFloat
CStatisticsComponentInt
►NCoreTestSubComponent
CSubCompInterface
CSubComponentLoader
CSubCompReceiver
CSubCompSender
CSubCompSendRecvInterface
CSubCompSlot
CSubCompSlotInterface
►NELI
CAllocator
CBuilder
CBuilderDatabase
CBuilderInfoImpl
CBuilderInfoImpl< void >
CBuilderLibrary
CBuilderLibraryDatabase
CBuilderLoader
CCachedAllocator
CcheckForELI_getSimpleInfoFunction
CCtorList
CCtorList< Base, void >
CDataBase
CDerivedBuilder
CElementsBuilder
CElementsBuilder< Base, std::tuple< Args... > >
CElementsInfo
CExtendedCtor	Implements a constructor for a derived base as usually happens with subcomponents, e.g
CForceExport
CGetAttributes
CGetAttributes< T, typename MethodDetect< decltype(T::ELI_getAttributes())>::type >
CGetParams
CGetParams< T, typename MethodDetect< decltype(T::ELI_getParams())>::type >
CInfoDatabase
CInfoLibrary
CInfoLibraryDatabase
CInfoLoader
CInfoPorts
CInfoPorts< T, typename MethodDetect< decltype(T::ELI_getPorts())>::type >
CInfoProfilePoints
CInfoProfilePoints< T, typename MethodDetect< decltype(T::ELI_getProfilePoints())>::type >
CInfoStats
CInfoStats< T, typename MethodDetect< decltype(T::ELI_getStatistics())>::type >
CInfoSubs
CInfoSubs< T, typename MethodDetect< decltype(T::ELI_getSubComponentSlots())>::type >
CInstantiateBuilder
CInstantiateBuilderInfo
Cis_tuple_constructible
Cis_tuple_constructible< T, std::tuple< Args... > >
CLibraryLoader
CLoadedLibraries
CMethodDetect
CNoValidConstructorsForDerivedType
CNoValidConstructorsForDerivedType< 0 >
CProvidesAttributes
CProvidesCategory
CProvidesDefaultInfo
CProvidesInterface
CProvidesParams
CProvidesPorts
CProvidesProfilePoints
CProvidesSimpleInfo
CProvidesStats
CProvidesSubComponentSlots
CSimpleInfoPlaceHolder
CSingleCtor
►NIMPL
►NPartition
CSimplePartitioner
CSSTLinearPartition	Performs a linear partition scheme of an SST simulation configuration
CSSTRoundRobinPartition
CSSTSelfPartition	Self partitioner actually does nothing
CSSTSinglePartition	Single partitioner is a virtual partitioner used for serial jobs
CPool
CTimeVortexBinnedMap
CTimeVortexBinnedMap_ts
CTimeVortexBinnedMapBase	Primary Event Queue
CTimeVortexPQ
CTimeVortexPQ_ts
CTimeVortexPQBase	Primary Event Queue
►NInterfaces
►CSimpleMem	Simplified, generic interface to Memory models
CRequest	Represents both memory requests and responses
►CSimpleNetwork	Generic network interface
CNetworkInspector	Class used to inspect network requests going through the network
CRequest	Represents both network sends and receives
►CStandardMem	Generic interface to Memory models
CCustomData
CCustomReq
CCustomResp
CFlushAddr
CFlushResp	Response to a flush request
CInvNotify	Notifies endpoint that an address has been invalidated from the L1
CLoadLink	Conditional atomic update
CMoveData	Move: move data from one address to another Returns a WriteResp
CRead	Read request
CReadLock	Locked atomic update -> guaranteed success A ReadLock must be followed by a WriteUnlock
CReadResp	Response to a Read
CRequest	Base class for StandardMem commands
CRequestConverter
CRequestHandler
CStoreConditional
CWrite	Request to write data
CWriteResp	Response to a Write
CWriteUnlock
CStringEvent	Simple event to pass strings between components
CTestEvent	Test Event Useful for early-testing of components
►NPartition
CSSTPartitioner	Base class for Partitioning graphs
►NProfile
CClockHandlerProfileTool
CClockHandlerProfileToolCount	Profile tool that will count the number of times a handler is called
CClockHandlerProfileToolTime	Profile tool that will count the number of times a handler is called
CClockHandlerProfileToolTimeHighResolution
CClockHandlerProfileToolTimeSteady
►CComponentCodeSegmentProfileTool
CProfilePoint
CComponentCodeSegmentProfileToolCount	Profile tool that will count the number of times a handler is called
CComponentCodeSegmentProfileToolTime	Profile tool that will count the number of times a handler is called
CComponentCodeSegmentProfileToolTimeHighResolution
CComponentCodeSegmentProfileToolTimeSteady
CComponentProfileTool
CEventHandlerProfileTool
CEventHandlerProfileToolCount	Profile tool that will count the number of times a handler is called
CEventHandlerProfileToolTime	Profile tool that will count the number of times a handler is called
CEventHandlerProfileToolTimeHighResolution
CEventHandlerProfileToolTimeSteady
CProfileTool	ProfileTool is a class loadable through the factory which allows dynamic addition of profiling capabililites to profile points
CSyncProfileTool
CSyncProfileToolCount	Profile tool that will count the number of times a handler is called
CSyncProfileToolTime	Profile tool that will count the number of times a handler is called
CSyncProfileToolTimeHighResolution
CSyncProfileToolTimeSteady
►NRNG
CConstantDistribution	Implements a distribution which always returns a constant value (provided by the user)
CDiscreteDistribution	Creates a discrete distribution for use within SST
CExponentialDistribution	Creates an exponential distribution for use within SST
CGaussianDistribution	Creates a Gaussian (normal) distribution for which to sample
CMarsagliaRNG	Implements a random number generator using the Marsaglia method
CMersenneRNG	Implements a Mersenne-based RNG for use in the SST core or components
CPoissonDistribution	Creates an Poisson distribution for use within SST
CRandom	Implements the base class for random number generators for the SST core
CRandomDistribution	Base class of statistical distributions in SST
CUniformDistribution	Creates a Uniform distribution for use within SST
CXORShiftRNG	Implements a lightweight RNG based on XOR-shift operations
►NShared
CSharedArray	SharedArray class
CSharedArray< bool >	SharedArray class
CSharedMap	SharedMap class
CSharedObject
CSharedObjectChangeSet	This is the base class for holding data on changes made to the shared data on each rank
CSharedObjectData	Base class for holding SharedObject data
CSharedObjectDataManager
CSharedSet	SharedSet class
►NStatistics
CAccumulatorStatistic	Allows the online gathering of statistical information about a single quantity
CHistogramStatistic	Holder of data grouped into pre-determined width bins
CImplementsStatFields
CNullStatistic	An empty statistic place holder
CNullStatistic< void >
CNullStatisticBase
CNullStatisticBase< std::tuple< Args... >, false >
CNullStatisticBase< T, false >
CNullStatisticBase< T, true >
CStatistic	Forms the template defined base class for statistics gathering within SST
CStatistic< void >	Void Statistic has special meaning in that it does not collect fields in the usual way through the addData function
CStatisticBase	Forms the base class for statistics gathering within SST
CStatisticCollector	Base type that creates the virtual addData(...) interface Used for distinguishing fundamental types (collected by value) and composite struct types (collected by reference)
CStatisticCollector< std::tuple< Args... >, false >
CStatisticCollector< T, true >
CStatisticFieldInfo	The class for representing Statistic Output Fields
CStatisticFieldsOutput
CStatisticFieldType
CStatisticFieldTypeBase
CStatisticGroup
CStatisticInfo
CStatisticOutput	Forms the base class for statistics output generation within the SST core
CStatisticOutputConsole	The class for statistics output to the console
CStatisticOutputCSV	The class for statistics output to a comma separated file
CStatisticOutputHDF5	The class for statistics output to a comma separated file
CStatisticOutputJSON	The class for statistics output to a JSON formatted file
CStatisticOutputTextBase
CStatisticOutputTxt	The class for statistics output to a text file
CStatisticProcessingEngine	An SST core component that handles timing and event processing informing all registered Statistics to generate their outputs at desired rates
CUniqueCountStatistic	Creates a Statistic which counts unique values provided to it
CAction	An Action is a schedulable Activity which is not an Event
►CActivity	Base class for all Activities in the SST Event Queue
Cgreater	Class to use as the greater than operator for STL functions or sorting algorithms (used if you want to sort opposite the natural soring order)
Cless	Class to use as the less than operator for STL functions or sorting algorithms
CActivityQueue	Base Class for a queue of Activities
Cbad_filtered_key_error	Exception that is thrown by SparseVectorMap::filter() if the filtering object returns an object that returns a different value from the key() function than what was passed into the filter
CBaseComponent	Main component object for the simulation
Cchar_delimiter
CClock	A Clock class
CClockHandlerMetaData
CComponent	Main component object for the simulation
CComponentExtension	ComponentExtension is a class that can be loaded using loadComponentExtension<T>(...)
►CComponentInfo
CEqualsID
CEqualsName
CHashID
CHashName
CComponentInfoMap
CConfig	Class to contain SST Simulation Configuration variables
CConfigComponent	Represents the configuration of a generic component
CConfigGraph	A Configuration Graph A graph representing Components and Links
CConfigHelper
CConfigLink	Represents the configuration of a generic Link
CConfigStatGroup
CConfigStatistic
CConfigStatOutput
Cdecimal_fixedpoint	Class that implements a decimal fixed-point number
CElementInfoAttribute
CElementInfoParam	Describes Parameters to a Component
CElementInfoPort	Describes Ports that the Component can use
CElementInfoProfilePoint
CElementInfoStatistic	Describes Statistics used by a Component
CElementInfoSubComponentSlot
CElemLoader	Class to load Element Libraries
CEmptyEvent	Empty Event
CEmptyRankSync
CEmptyThreadSync
Cescaped_list_separator
CEvent	Base class for Events - Items sent across links to communicate between components
CEventHandlerMetaData
CExit	Exit Event Action
CFactory	Class for instantiating Components, Links and the like out of element libraries
CHandlerMetaData	Just a tag class for the various metadata that will need to be stored in the simulation object to allow ProfileTools to get the data they need
CHandlerProfileToolAPI
CInitQueue	ActivityQueue for use during the init() phase
CLink	Link between two components
CLinkMap	Maps port names to the Links that are connected to it
CLinkPair	Defines a pair of links (to define a connected link)
CLinkSendProfileToolList
CModule	Module is a tag class used with the loadModule function
CNameCheck
CNullEvent	Null Event
COneShot	A OneShot Event class
COutput	Output object provides consistent method for outputting data to stdout, stderr and/or sst debug file
CParams	Parameter store
CPartitionComponent
CPartitionGraph
CPartitionLink
CPollingLinkQueue	A link queue which is used for polling only
CPyStatistic
CRankInfo
CRankSync
CRankSyncParallelSkip
CRankSyncSerialSkip
CSelfLink	Self Links are links from a component to itself
CSimulation	Main control class for a SST Simulation
CSimulation_impl	Main control class for a SST Simulation
CSimulatorHeartbeat	An optional heartbeat to show progress in a simulation
CSparseVectorMap	Class that stores data in a vector, but can access the data similar to a map
CSparseVectorMap< keyT, classT * >	Class that stores data in a vector, but can access the data similar to a map
CSparseVectorMap< keyT, keyT >	Templated version of SparseVectorMap where the data and key are the same (actually more like a set than a map in this case)
CSST_ELI_element_version_extraction
CSSTElementPythonModule	Base class for python modules in element libraries
CSSTElementPythonModuleCode	Class to represent the code that needs to be added to create the python module struture for the library
CSSTHandler	Handler class with user-data argument
CSSTHandler< returnT, argT, classT, void >	Event Handler class with no user-data
CSSTHandlerBase	Handlers with 1 handler defined argument to callback from caller
CSSTHandlerBase< void, argT >
CSSTHandlerBaseNoArgs	Handlers with no arguments to callback from caller
CSSTHandlerBaseNoArgs< void >
►CSSTHandlerBaseProfile	Functor classes for Event handling
CHandlerProfileToolList
CSSTHandlerNoArgs	Event Handler class with user-data argument
CSSTHandlerNoArgs< returnT, classT, void >	Event Handler class with no user-data
CSSTInfoConfig	The SSTInfo Configuration class
CSSTLibraryInfo	The SSTInfo representation of ElementLibraryInfo object
CsstLongOpts_s
CSSTModelDescription	Base class for Model Generation
CStatGroupPy_t
CStatisticPy_t
CStatOutputPy_t
CStopAction	Action which causes the Simulation to end
CSubComponent	SubComponent is a class loadable through the factory which allows dynamic functionality to be added to a Component
CSubComponentSlotInfo	Used to load SubComponents when multiple SubComponents are loaded into a single slot (will also also work when a single SubComponent is loaded)
CSyncManager
CSyncProfileToolList
►CSyncQueue	Internal API
CHeader
CThreadSync
CThreadSyncDirectSkip
CThreadSyncQueue	Base Class for a queue of Activities
CThreadSyncSimpleSkip
CTimeConverter	A class to convert between a component's view of time and the core's view of time
CTimeLord	Class for creating and managing TimeConverter objects
CTimeVortex	Primary Event Queue
CTokenizer
CTraceFunction
CUninitializedQueue	Always uninitialized queue
CUnitAlgebra	Performs Unit math in full precision
CUnits	Helper class internal to UnitAlgebra
CComponentHolder
CComponentPy_t
CLinkPy_t
CModuleLoaderPy_t
COverallOutputter
CPyComponent
CPySubComponent
CSimThreadInfo_t
Csst_eli_fake_deprecated_class
CUnitAlgebraPy_t