Response:
SST as a framework for DES is not focused on a specific problem or domain.

SST supports distributed computation using MPI.

Response:

• elements are a collection of componenets
• components are connected to links via ports
• composition (implemented as "project driver file") which specifies links between components.
• events, which are transmitted via links between components
• subcomponents - shares common base class with Component​. Do not need to communicate with component via links. Cannot exist by themselves
• modules - self-contained functionality (no access to Component class functionality​. Do not need to communicate with component via links. Cannot exist by themselves. [citation: slide 50]
• clock, to progress ticks

Response: A Python script that specifies components, subComponents, and links.
Also can specify parameters per component and subComponent.

Reference: https://sst-simulator.org/SSTPages/SSTUserPythonFileFormat/

Response: a collection of components in a single .so file. Example from sst-info:

ELEMENT 1 = switch ()
Num Components = 1
      Component 0: SwitchComponent
      CATEGORY: UNCATEGORIZED COMPONENT

Response: A Python class that connects two SST components.
Each component has a port.

#!/usr/bin/env python3
import sst
compA = sst.Component("Comp A", "dummy.Component")
compB = sst.Component("Comp B", "dummy.Component")
link = sst.Link("mylink")

link.connect((compA, "myPort", "10ns"), (compB, "myPort", "10ns"))
      

In a C++ component, poll or interrupt with EventHandler​

Reference: https://sst-simulator.org/SSTPages/SSTUserPythonFileFormat/#links

Response: A C++ file and .h header that performs the simulation.
SST Components have ports and send events over links to communicate with other components​.
SST Components can load SubComponents and Modules for additional functionality.

Related questions

• what is an SST subComponent?
• what is an SST link?

Response: A C++ file and .h header that can be used for supplemental functionality.

Why use a subComponent?:

• modularity of functionality between components
• enables common interfaces to other components

Example:

#!/usr/bin/env python3
import sst

core = sst.Component(“core”, “miranda.BaseCPU”)​
core.addParams({ “clock” : “2.4GHz” })​
gen = core.setSubComponent(“generator”, “miranda.STREAMBenchGenerator”)​

cache = sst.Component(“L1”, “memHierarchy.Cache”)​

mctrl = sst.Component(“memctrl”, “memHierarchy.MemController”)
memory = mctrl.setSubComponent(“backend”, “memHierarchy.simpleMem”)​
      

Response: A C++ file and .h header that can be used for supplemental functionality.
Modules don't access base class API. Statistics are not available. Ports are not available. Modules are considered user facing. Can be specified in Python as a parameter.

Why use a Module:

• modularity of functionality between components
• enables common interfaces to other components

Response: Purpose is to enable decomposition of complicated components. Component extensions cannot be run independently. Status: stable but not official; may have bugs. Component extensions are in Beta and will eventually be made official; intent is for long-term support.

Response: A unit of communication sent between two SST components over a link.

Examples of standardized interfaces:
https://github.com/sstsimulator/sst-core/tree/master/src/sst/core/interfaces

Response:

• a "project driver file" as a Python script (.py)
• at least one Component written as C++ source code
• a .h header for the component.

Response: SST Core maintains a database of registered libraries.
The list of registered elements can be queried using
sst-info

Response:

• Polled: Register a clock handler to poll the link
• Interrupt: Register an event handler to be called when an event arrives
• Both: Receive events on interrupt, send events on clock

Abbreviation: ELI = Element Library Information

Response: sst-register

Description from slide 19; see also slide 20

1. Birth
• Create graph of components using Python configuration file
• Partition graph and assign components to MPI ranks
• Instantiate components
• Connect components via links
• Initialize components using their init() functions
• Setup components using their setup() functions
2. Life
• Send events
• Manage clock and event handlers
3. Death
• Finalize components using their finish() functions
• Output statistics
• Cleanup simulation, delete components

Response: (from slide 20, also slide 13)

1. Graph construction:
   • define components and links
   • partition components to MPI ranks
2. Construction: call component constructors and parse parameters. See slide 14
3. initialize. See slide 15
   • Components send “init” events to each other over links. Discover neighbors, negotiate parameters, initialize data structures, etc.
   • Multiple rounds of communication until no more “init” events are sent
4. setup ("pre-time")
   • Each component does its final setup and schedules initial events
5. run
   • Actual simulation (time begins)
   • Continues until a set time, or all components agree to finish
6. Complete
• “Post-time” phase analogous to initialization phase​
• Components can send “init” events to each other over links​
• Multiple rounds, until no more “init” events are sent
7. finalize
• Simulation complete
• Write statistics, free memory

Response: the component-link graph from the Python driver file is partitioned and sent to MPI nodes

See slides 21-23

Response: By default SST tries to partition to load balance and cut long-latency links​

General Partitioners​

• linear: Partitions components by dividing Component ID space into roughly equal portions. Components with sequential IDs will be placed close together.​
• roundrobin: Partitions components using a simple round robin scheme based on ComponentID. Sequential IDs will be placed on different ranks.​
• simple: Simple partitioning scheme which attempts to partition on high latency links while balancing number of components per rank.​
• zoltan: zoltan parallel partitioner.​

Special Partitioners​

• single: Allocates all components to rank 0. Automatically selected for serial jobs.​
• self: Used when partitioning is already specified in the configuration file.

Response: Partitioning can be specified in the python input file​
Use setRank(mpi_rank, thread) on a component​.
User must set rank/thread pairs for all components in system, partial partitions not supported

Must set the partitioner to be ”self”​. Can be done on command-line: --partitioner=self​ or can be done in python file: sst.setProgramOption(”partitioner", ”self")​

Response:

1. install SST Core
2. register one or more components
3. sst driver_config.py

Related questions:

• how to launch a parallel SST simulation?

Response: Components distributed among MPI ranks/threads.
Link latency controls synchronization rate​ Two ranks​:

mpirun –np 2 sst demo1.py​

sst –n 2 demo1.py​
      

mpirun –np 2 sst –n 2 demo1.py
      

Response: Components and SubComponents define statistics​

sst.setStatisticOutput(“sst.statoutputcsv”)​
sst.setStatisticOutputOptions({ “filepath” : “stats.csv” })​
sst.setStatisticLoadLevel(5)​
sst.enableAllStatisticsForAllComponents()​
      

Response: according to ELI guide the elementinfo.h lists the macros. However, there are many more.

The full list can be grep'd in the sst-core directory using

        grep -R "#define SST_ELI" * | cut -d" " -f2 | sed 's/(.*//'g | sort | uniq
      

• SST_ELI_DOCUMENT_PARAMS
• SST_ELI_DOCUMENT_PORTS - Used by: Components, SubComponents​. Macro takes a list of ports available on the element​.
  Each port is defined as { “name”, “description”, vector of supported events }​
  name and description are string literals ​
• SST_ELI_DOCUMENT_STATISTICS - Used by: Components, SubComponents​. Macro takes a list of statistics that the element can produce​; for example
  { “name”, “description”, “units”, enable level }​.
  name, description, and units are string literals​.
  enable level is an integer between 1 and 7
• SST_ELI_DOCUMENT_SUBCOMPONENT_SLOTS - sst-core/src/sst/core/eli/subcompSlotInfo.h
  Used by: Components, SubComponent​. Macro takes a list of available SubComponentSlots.
  Each slot is defined as { “slotname”, “description”, “name of superclass” }​ name of superclass should be the fully qualified name of the class that defines the slot’s API.
  The superclass inherits from SubComponent, and any subcomponent attached to this slot must inherit from the specified superclass.​
  Example: SST::ElementLibrary::SubComponentClass
• SST_ELI_DOCUMENT_PARAMS - Used by: Components, SubComponents, Modules​. Each parameter is defined as { “name”, “description”, “default value” }​
  If default value is entered as NULL, then there is no default and the parameter is required.​
  If default value is an empty string, then it is optional, with no default
• SST_ELI_ELEMENT_VERSION(major, minor, tertiary) - Required for all element types​. major, minor and tertiary are integers​
• SST_ELI_REGISTER_COMPONENT(class, “library”, “name”, version, “description”, category)​
• SST_ELI_REGISTER_CUSTOM_STATISTIC
• SST_ELI_REGISTER_DERIVED
• SST_ELI_REGISTER_EXTERN
• SST_ELI_REGISTER_MODULE(class, “library”, “name”, version, “description”, interface)​
• SST_ELI_REGISTER_MODULE_API(class, constructor_args)​
• SST_ELI_REGISTER_MODULE_DERIVED
• SST_ELI_REGISTER_MODULE_DERIVED_API(class, base,constructor_args)​
• SST_ELI_REGISTER_PARTITIONER(class, “library”, “name” , version, “description”)​
• SST_ELI_REGISTER_PYTHON_MODULE(class, “library”, version)​
• SST_ELI_REGISTER_SUBCOMPONENT_API(class, constructor_args)​ - sst-core/src/sst/core/subcomponent.h
• SST_ELI_REGISTER_SUBCOMPONENT_DERIVED(class, “library”, “name”, version, “description”, interface)​ - sst-core/src/sst/core/subcomponent.h
• SST_ELI_REGISTER_SUBCOMPONENT_DERIVED_API(class, base,constructor_args)​ - sst-core/src/sst/core/subcomponent.h

Definitions of arguments:​

• class: Name of class to register. Must not be quoted, as template expansion uses it.​
• base: Name of base class API is derived from. Must not be quoted, as template expansion uses it.​
• library: Library name. String literal. ​
• name: Name used to reference the component, full name is library.name. String literal.​
• Example: if library = “merlin” and name = ”hr_router”, then full name is “merlin.hr_router”​
• version: Version number of component defined using SST_ELI_ELEMENT_VERSION macro​
• description: Brief description of the component. String literal.​
• category (Components only): Component category as defined in elibase.h. ​
• interface (SubComponents and Modules only): Fully qualified class name of the SubComponent/Module that this class inherits from. Must not be qutoted. The interface must be registered as an API using one of the registration commands listed above.​
• constructor_args (SubComponent and Module APIs only): types of parameters to be passed to constructor of elements derived from these APIs​

Response:

• SST::Simulation - sst/core/simulation.h​; Base of the simulation
• SST::Event - sst/core/event.h; Base class for data to send over a SST::Link​
  Inherit from this to create your own Event​
  Provides base class for Event::Handler​
• SST::Component
• SST::Link - sst/core/link.h​; Standard mechanism to send/receive data from another component.​
Created via SST::Component::configureLink()
• SST::Param - sst/core/param.h​; Holds parameters from ConfigGraph​. Handed to Component in constructor
• SST::Output​ - sst/core/output.h​; Utility class to bundle output from SST
• SST::UnitAlgebra​
• SST::RNG::SSTRandom