Data Structures

Here are the data structures with brief descriptions:

[detail level 12345]

►Nsprockit
Cserializable_ptr_type
►NSST
►NCore
►NEnvironment
CEnvironmentConfigGroup
CEnvironmentConfiguration
►NInterprocess
CCircularBuffer
CIPCTunnel	Tunneling class between two processes, connected by shared memory
CSSTMutex
►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::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
CSpinlock
CUnboundedQueue
CConfigGraphOutput
CConfigGraphOutputException
CDotConfigGraphOutput
CJSONConfigGraphOutput
CMemPool	Simple Memory Pool class
CPythonConfigGraphOutput
CXMLConfigGraphOutput
►NInterfaces
►CSimpleMem	Simplified, generic interface to Memory models
CHandler	Event Handler class with user-data argument
CHandler< classT, void >	Event Handler class without user-data
CHandlerBase	Functor classes for Clock handling
CRequest	Represents both memory requests and responses
►CSimpleNetwork	Generic network interface
CHandler	Event Handler class with user-data argument
CHandler< classT, void >	Event Handler class without user-data
CHandlerBase	Functor classes for handling of callbacks
CNetworkInspector	Class used to inspect network requests going through the network
CRequest	Represents both network sends and receives
CStringEvent	Simple event to pass strings between components
CTestEvent	Test Event Useful for early-testing of components
►NPartition
CSimplePartitioner
CSSTLinearPartition	Performs a linear partition scheme of an SST simulation configuration
CSSTPartitioner	Base class for Partitioning graphs
CSSTRoundRobinPartition
CSSTSelfPartition	Self partitioner actually does nothing
CSSTSinglePartition	Single partitioner is a virtual partitioner used for serial jobs
►NRNG
CMarsagliaRNG	Implements a random number generator using the Marsaglia method
CMersenneRNG	Implements a Mersenne-based RNG for use in the SST core or components
CSSTConstantDistribution	Implements a distribution which always returns a constant value (provided by the user)
CSSTDiscreteDistribution	Creates a discrete distribution for use within SST
CSSTExponentialDistribution	Creates an exponential distribution for use within SST
CSSTGaussianDistribution	Creates a Gaussian (normal) distribution for which to sample
CSSTPoissonDistribution	Creates an Poisson distribution for use within SST
CSSTRandom	Implements the base class for random number generators for the SST core
CSSTRandomDistribution	Base class of statistical distributions in SST
CSSTUniformDistribution	Creates a Uniform distribution for use within SST
CXORShiftRNG	Implements a lightweight RNG based on XOR-shift operations
►NStatistics
CAccumulatorStatistic	Allows the online gathering of statistical information about a single quantity
CHistogramStatistic	Holder of data grouped into pre-determined width bins.
Cis_type_same
Cis_type_same< T, T >
CNullStatistic	An empty statistic place holder
CStatistic	Forms the template defined base class for statistics gathering within SST.
CStatisticBase	Forms the base class for statistics gathering within SST.
CStatisticFieldInfo	The class for representing Statistic Output Fields
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
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
Cless_time	Comparator class to use with STL container classes
Cless_time_priority	Comparator class to use with STL container classes
Cless_time_priority_order	To use with STL container classes
Cpq_less_time_priority	To use with STL priority queues, that order in reverse
Cpq_less_time_priority_order	To use with STL priority queues, that order in reverse
CActivityQueue	Base Class for a queue of Activities
CBaseComponent	Main component object for the simulation
CBaseComponentElementInfo
CBaseElementInfo
CBaseParamsElementInfo
CChangeSet
Cchar_delimiter
CcheckForELI_CustomCreateFunctionforComponent
CcheckForELI_CustomCreateFunctionforSubComponent
CcheckForELI_getParamsFunction
CcheckForELI_getPortsFunction
CcheckForELI_getStatisticsFunction
CcheckForELI_getSubComponentSlotsFunction
►CClock	A Clock class
CHandler	Event Handler class with user-data argument
CHandler< classT, void >	Event Handler class without user-data
CHandlerBase	Functor classes for Clock handling
CComponent	Main component object for the simulation
CComponentDoc
CComponentDocOldELI
CComponentElementInfo
►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
CConfigLink	Represents the configuration of a generic Link
CConfigStatGroup
CConfigStatOutput
Cdecimal_fixedpoint	Class that implements a decimal fixed-point number
CElementInfoComponent	Describes a Component and its associated information
CElementInfoEvent	Describes an Event
CElementInfoGenerator	Describes a Generator
CElementInfoIntrospector	Describes an Introspector
CElementInfoModule	Describes a Module
CElementInfoParam	Describes Parameters to a Component
CElementInfoPartitioner	Describes a Partitioner
CElementInfoPort	Describes Ports that the Component can use
CElementInfoPort2	Describes Ports that the Component can use
CElementInfoStatistic	Describes Statistics used by a Component
CElementInfoSubComponent
CElementInfoSubComponentSlot
CElementLibraryDatabase
CElementLibraryInfo	Describes all the parts of the Element Library
CElemLoader	Class to load Element Libraries
CEmptyRankSync
CEmptyThreadSync
Cescaped_list_separator
►CEvent	Base class for Events - Items sent across links to communicate between components
CHandler	Event Handler class with user-data argument
CHandler< classT, void >	Event Handler class with no user-data
CHandlerBase	Functor classes for Event handling
CExit	Exit Event Action
CFactory	Class for instantiating Components, Links and the like out of element libraries
CInitQueue	ActivityQueue for use during the init() phase
CLibraryInfo
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)
CLoaderData	This structure exists so that we don't need to have any libtool-specific code (and therefore need the libtool headers) in factory.h
CModule	Module is a tag class used with the loadModule function
CModuleDoc
CModuleDocOldELI
CModuleDocWithComponent
CModuleDocWithoutComponent
CModuleElementInfo
CNewRankSync
CNewThreadSync
CNullEvent	Null Event
►COneShot	A OneShot Event class
CHandler	Event Handler class with user-data argument
CHandler< classT, void >	Event Handler class without user-data
CHandlerBase	Functor classes for OneShot handling
COutput	Output object provides consistant method for outputing data to stdout, stderr and/or sst debug file
CParams	Parameter store
CPartitionComponent
CPartitionerDoc
CPartitionerDocOldELI
CPartitionerElementInfo
CPartitionGraph
CPartitionLink
CPollingLinkQueue	A link queue which is used for polling only
CPythonModuleDoc
CPythonModuleDocOldELI
CPythonModuleElementInfo
CRankInfo
CRankSyncParallelSkip
CRankSyncSerialSkip
►CRegionInfo
CBulkMergeInfo
CChangeSetMergeInfo
CRegionMergeInfo
CSelfLink	Self Links are links from a component to itself
CSharedRegion
CSharedRegionImpl
CSharedRegionInitializedMerger
CSharedRegionManager
CSharedRegionManagerImpl
CSharedRegionMerger	Utility class to define how to merge multiple pieces of shared memory regions Useful in the multi-MPI-rank, "Global Shared" model
CSimulation	Main control class for a SST Simulation
CSimulatorHeartbeat	An optional heartbeat to show progress in a simulation
CSparseVectorMap
CSparseVectorMap< keyT, keyT >
CSST_ELI_element_version_extraction
CSSTElementPythonModule	Base class for python modules in element libraries
CSSTElementPythonModuleOldELI
CSSTInfoConfig	The SSTInfo Configuration class
CSSTInfoElement_BaseInfo
CSSTInfoElement_ComponentInfo	The SSTInfo representation of ElementInfoComponent object
CSSTInfoElement_EventInfo	The SSTInfo representation of ElementInfoEvent object
CSSTInfoElement_GeneratorInfo	The SSTInfo representation of ElementInfoGenerator object
CSSTInfoElement_LibraryInfo	The SSTInfo representation of ElementLibraryInfo object
CSSTInfoElement_ModuleInfo	The SSTInfo representation of ElementInfoModule object
CSSTInfoElement_Outputter
CSSTInfoElement_ParamInfo	The SSTInfo representation of ElementInfoParam object
CSSTInfoElement_PartitionerInfo	The SSTInfo representation of ElementInfoPartitioner object
CSSTInfoElement_PortInfo	The SSTInfo representation of ElementInfoPort object
CSSTInfoElement_StatisticInfo	The SSTInfo representation of StatisticInfo object
CSSTInfoElement_SubComponentInfo	The SSTInfo representation of ElementInfoSubComponent object
CSSTInfoElement_SubCompSlotInfo	The SSTInfo representation of SubComponentSlotINfo object
CsstLongOpts_s
CSSTModelDescription	Base class for Model Generation
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
CSubComponentDoc
CSubComponentDocOldELI
CSubComponentElementInfo
CSubComponentSlotInfo
CSubComponentSlotInfo_impl
CSyncBase	SyncBase defines the API for Sync objects, which are used to synchronize between MPI ranks in a simulation
CSyncManager
►CSyncQueue	Internal API
CHeader
CThreadSync
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 unitialized queue
CUnitAlgebra	Performs Unit math in full precision
CUnits	Helper class internal to UnitAlgebra
CComponentHolder
CComponentPy_t
CLinkPy_t
Clt__advise
Clt__handle
Clt__interface_id
Clt_dlvtable
Clt_interface_data
CModuleLoaderPy_t
COverallOutputter
CPyComponent
CPySubComponent
CSimThreadInfo_t
Cslist
CStatGroupPy_t
CStatOutputPy_t
Csymlist_chain