Home » SSTDocumentation » Adding Additional External Components For SST 15.0.x

Adding Additional External Components For SST 15.0.x

Adding Additional External Components For SST 15.0.x

Overview

These instructions are intended to walk the user through a detailed set of steps to build and install the optional external components used by SST. It is intended for users with intermediate knowledge in the operation of Unix/Linux/OSX environments.

NOTE: The following instructions assume the user has completed the basic build steps for SST outlined in Detailed Build and Installation Instructions for SST.

The SST Release Notes identify what operating systems, compiler and external component combinations have been tested and proven to work with SST.

NOTE: Using combinations other than what is identified in the Release Notes may cause build failures and/or unexpected results.

A detailed list of elements provided with the SST distribution are available at SST Element Summary and SST Element Release Matrix.

If you encounter difficulties, go to the SST Support page.

NOTE: Building SST and its External Components can sometimes be error prone due to the sheer number of combinations of operating systems, compiler versions and external required components. It is STRONGLY recommended that users closely follow these instructions.

General Build and Install Information

Refer to Detailed SST Build and Install Instructions for more information on system requirements, special instructions, example directories and additional tasks for users.

Optional External Components Installation

SST allows for a number of optional external packages. Some notes and hints for using these are included here.

Note: Some the external packages may require files from the SST-Elements 15.0.x distribution. SST-Elements 15.0.x should have already been downloaded and extracted before compiling and installing these dependent external packages. See Detailed Build and Installation Instructions for SST for more information.

Optional External Components FOR SST-Core

These are optional external components for the SST-Core. They may provide additional features.

HDF5 1.10.5

OPTIONAL EXTERNAL COMPONENT FOR SST-CORE - Used for HDF Formatting for SST Statistics

General Infomation:

HDF5 is a data model, library, and file format for storing and managing data. It supports an unlimited variety of datatypes, and is designed for flexible and efficient I/O and for high volume and complex data. HDF5 is portable and is extensible, allowing applications to evolve in their use of HDF5. The HDF5 Technology suite includes tools and applications for managing, manipulating, viewing, and analyzing data in the HDF5 format.
For more info see HDF5
SST 15.0.x is tested against version 1.10.5 of HDF5.

Where to find:

HDF5 1.10.5 is downloadable from here

Build Instructions:

1. Assuming that the tarfile has been downloaded to $HOME/scratch/src, unarchive hdf5-1.10.5.tar.gz

$ cd $HOME/scratch/src
$ tar xfz hdf5-1.10..5.tar.gz
$ cd hdf5-1.10.5

2. Set the home directory environment variable of the HDF5 installation.

$ export HDF5_HOME=$HOME/local/packages/HDF5

3. Configure the build and installation of HDF5

$ ./configure --prefix=$HDF5_HOME --enable-cxx

4. Build and Install HDF5

$ make
$ make check
$ make install
$ make check-install

5. Configure SST-Core to use HDF5

$ cd <to SST-Core base directory>
$ ./configure <all other SST configure options> --with-hdf5=$HDF5_HOME
$ make install

Optional External Components FOR SST-Elements

These are optional external components for the SST-Elements. They may provide additional features for elements or they may be required to allow an element to be built.

DRAMsim3

OPTIONAL EXTERNAL COMPONENT

General Infomation:

DRAMsim3 models the timing paramaters and memory controller behavior for several DRAM protocols such as DDR3, DDR4, LPDDR3, LPDDR4, GDDR5, GDDR6, HBM, HMC, STT-MRAM. It is implemented in C++ as an objected oriented model that includes a parameterized DRAM bank model, DRAM controllers, command queues and system-level interfaces to interact with a CPU simulator (GEM5, ZSim) or trace workloads. It is designed to be accurate, portable and parallel.
Please refer to DRAMsim3 for more details.
SST 15.0.x is tested against tag 1.0.0 of DRAMsim3.
NOTE: DRAMsim3 requires CMake version 3 or greater

Where to find:

DRAMsim3 is downloadable from here

Build Instructions:

1. Assuming that the tarfile has been downloaded to $HOME/scratch/src, unarchive dramsim3.tar.gz

$ cd $HOME/scratch/src
$ tar xfz dramsim3-1.0.0.tar.gz
$ cd dramsim3-1.0.0

2. Set the home directory environment variable of the DRAMsim3 installation.

$ export DRAMSIM3_HOME=$HOME/local/packages/dramsim3

3. Build the DRAMsim3 library

$ mkdir build
$ cd build
$ cmake ..
$ make -j4
$ cd ..

4. Install DRAMsim3 library

$ cp -r . $DRAMSIM3_HOME

5. Configure SST-Elements to use DRAMsim3

$ cd <to SST-Elements base directory>
$ ./configure <all other SST configure options> --with-dramsim3=$DRAMSIM3_HOME
$ make install

Intel Pin Tool 3.31-98869

OPTIONAL EXTERNAL COMPONENT - Required for Ariel Element

General Infomation:

Pin is a dynamic binary instrumentation framework for the IA-32 and x86-64 instruction-set architectures that enables the creation of dynamic program analysis tools. Some tools built with Pin are Intel Parallel Inspector, Intel Parallel Amplifier and Intel Parallel Advisor. The tools created using Pin, called Pintools, can be used to perform program analysis on user space applications in Linux and Windows. As a dynamic binary instrumentation tool, instrumentation is performed at run time on the compiled binary files. Thus, it requires no recompiling of source code and can support instrumenting programs that dynamically generate code.
For more information see Intel Pin
SST 15.0.x is tested against version 3.31-98869 of PinTool.

Where to find:

Intel Pin Downloads
- NOTE: PIN Version 3 is supported on Linux; all compilers are supported.
- NOTE: PIN Version 3 is not supported on OSX.
- Ensure that version 3.31-98869 is the downloaded version.

Build Instructions:

- Instructions specific to Linux Operating Systems.

1. Assuming that the tarfile has been downloaded to $HOME/scratch/src, unarchive pin

$ cd $HOME/scratch/src
$ tar xfz pin-external-3.31-98869-gfa6f126a8-gcc-linux.tar.gz

2. Set the home directory environment variable of the PinTool installation.

$ export PIN_HOME=$HOME/local/packages/pin-external-3.31-98869-gfa6f126a8-gcc-linux
$ export INTEL_PIN_DIRECTORY=$PIN_HOME

3. Configure SST-Elements to use PinTool.

$ cd <to SST-Elements base directory>
$ ./configure <all other SST-Elements configure options> --with-pin=$PIN_HOME
$ make install

Goblin HMCSim

OPTIONAL EXTERNAL COMPONENT - Used by MemHierarchy Element for optional enhanced features

General Infomation:

The Goblin HMC-Sim is a Hybrid Memory Cube Functional Simulation Environment.
For more information see Goblin HMCSim
SST 15.0.x is tested against version SST-8.0.0-release of Goblin HMCSim.

Where to find:

Goblin HMCSim is available here

Build Instructions:

1. Assuming that the zipfile has been downloaded to $HOME/scratch/src, unzip gc64-hmcsim-sst-8.0.0-release.zip

$ cd $HOME/scratch/src
$ unzip gc64-hmcsim-sst-8.0.0-release.zip
$ cd gc64-hmcsim-sst-8.0.0-release

2. Set the home directory environment variable of the Goblin HMCSim installation.

$ export GOBLINHMCSIM_HOME=$HOME/local/packages/GoblinHMCSim

3. Build Goblin HMCSim

$ make

4. Install Goblin HMCSim library

$ ln -s `pwd` $GOBLINHMCSIM_HOME

5. Configure SST-Elements to use Goblin HMCSim

$ cd <to SST-Elements base directory>
$ ./configure <all other SST configure options> --with-goblin-hmcsim=$GOBLINHMCSIM_HOME
$ make install

Ramulator

OPTIONAL EXTERNAL COMPONENT - Used by MemHierarchy Element for optional enhanced features

General Infomation:

Ramulator is a fast and cycle-accurate DRAM simulator that supports a wide array of commercial, as well as academic, DRAM standards.
For more information see Ramulator
SST 15.0.x is tested against Ramulator SHA .

Where to find:

Ramulator is available here.
Required patches for ramulator are available here
- 2 Patches for SHA: 7d2e723 are required.

Build Instructions:

1. Ramulator must be cloned using Git, and a specific SHA must be used.

$ cd $HOME/scratch/src
$ git clone https://github.com/CMU-SAFARI/ramulator.git
$ cd ramulator
$ git checkout 7d2e72306c6079768e11a1867eb67b60cee34a1c

2. Apply patches to the Ramulator source.

$ patch -p1 -i ramulator_sha_7d2e723_gcc48Patch.patch
$ patch -p1 -i ramulator_sha_7d2e723_libPatch.patch

3. Set the home directory environment variable of the Ramulator installation.

$ export RAMULATOR_HOME=$HOME/local/packages/ramulator

4. Build Ramulator

- Instructions specific to Linux Operating Systems.

$ make CXX=g++ libramulator.so

- Instructions specific to Mac OSX Operating Systems.

$ make libramulator.a

5. Install Ramulator library

$ ln -s `pwd` $RAMULATOR_HOME

6. Configure SST-Elements to use Ramulator

$ cd <to SST-Elements base directory>
$ ./configure <all other SST configure options> --with-ramulator=$RAMULATOR_HOME
$ make install

Ramulator 2

OPTIONAL EXTERNAL COMPONENT - Used by MemHierarchy Element for optional enhanced features

General Infomation:

Ramulator 2.0 is a modern, modular, extensible, and fast cycle-accurate DRAM simulator. It provides support for agile implementation and evaluation of new memory system designs (e.g., new DRAM standards, emerging RowHammer mitigation techniques).
For more information see Ramulator2
SST 15.0.x is tested against Ramulator SHA a6ee92f.

Where to find:

Ramulator is available here.

Build Instructions:

NOTE: Ramulator 2 requires a minimum GCC version of 8.0.

1. Select a location for Ramulator 2.

$ cd $HOME/local/packages

2. Clone the Ramulator 2 repository

$ git clone https://github.com/CMU-SAFARI/ramulator2.git
$ cd ramulator2
$ export RAMULATOR2_HOME=`pwd`

3. Select commit a6ee92f

$ git reset --hard a6ee92f

4. Install a copy of sst_frontend.cpp from the SST Elements source code. NOTE: These instructions assume that the SST Elements source code is located at $HOME/mysst/sst-elements

$ cp $HOME/mysst/sst-elements/src/sst/elements/memHierarchy/membackend/ramulator2/sst_frontend.cpp $RAMULATOR2_HOME/impl/external_wrapper/

4. Patch Ramulator 2 to reference the added sst_frontend.cpp

$ cd $RAMULATOR2_HOME
$ sed -i.bak '20impl/external_wrapper/sst_frontend.cpp' ./src/frontend/CMakeLists.txt

6. Configure Ramulator 2 build

$ mkdir build
$ cd build
$ cmake ..

5. Build Ramulator 2 NOTE: “-j” option without a limiting argument can cause modestly equipped systems to degrade in performance during the build to the point of unusability. Consider providing a reasonable numeric argument to -j to restrict the number of parallel jobs in the Ramulator 2 build.

$ make -j <number of parallel jobs>

6. Finalize Ramulator 2 setup

$ cp ./ramulator2 ../ramulator2
$ cd ..
$ export PATH=$PATH:$PWD
$ export LD_LIBRARY_PATH=LD_LIBRARY_PATH:$PWD
$ export RAMULATOR2_HOME=`pwd`

7. Configure SST-Elements to use Ramulator

$ cd <to SST-Elements base directory>
$ ./configure <all other SST configure options> --with-ramulator2=$RAMULATOR2_HOME
$ make install

CrossSim

CrossSim is a GPU-accelerated, Python-based crossbar simulator designed to model analog in-memory computing for neural networks and linear algebra applications.

NOTE: CrossSim requires a Python minimum version of 3.8.

Local user installation of CrossSim requires the creation of a Python virutal environment. CrossSim will install to this environment, therefore, in order to use CrossSim with SST, the virtual environment must be loaded. Additionally, CrossSim has dependencies on SciPy and NumPy.

1. Confirm that Python version is >= 3.8

$ python3 --version

2. Create a Python virtual environment. CrossSim will be installed here.

$ python -m venv $HOME/crosssim-venv
$ export CROSSSIM_VENV_DIR=$HOME/crosssim-venv

3. Load/initialize the Python virtual environment. NOTE: This action must be performed each time CrossSim is used with SST.

$ source $CROSSSIM_VENV_DIR/bin/activate

4. Assuming that $HOME/scratch/src is created, fetch CrossSim and unarchive it.

$ cd $HOME/scratch/src
$ wget https://github.com/sandialabs/cross-sim/archive/refs/tags/v3.1.1.tar.gz
$ tar xfz v3.1.1.tar.gz
$ cd cross-sim-3.1.1

4. Build and install CrossSim and its prerequisites NOTE: Confirm that the Python environment is activated prior to issuing this command.

$ pip install scipy numpy
$ pip install .

5. Finalize CrossSim install

CrossSim will be automatically detected by SST if the CrossSim Python virtual environment is activated.

GPGPUSIM

OPTIONAL EXTERNAL COMPONENT - Used by Balar Element for simulation

- Instructions specific to Linux Operating Systems.

General Infomation:

GPGPU-Sim, a cycle-level simulator modeling contemporary graphics processing units (GPUs) running GPU computing workloads written in CUDA or OpenCL.
For more information see GPGPUSIM

NOTE Balar and GPGPUSim have recently undergone substantial updates. As of SST 14, some of the changes are still in flight. Please refer to the [Balar README](https://github.com/sstsimulator/sst-elements/src/sst/elements/balar/README.md] and/or the balar documentation pages for the latest installation instructions. Once the instructions are finalized, they will be replicated here.

MUSL Compiler

OPTIONAL EXTERNAL COMPONENT - Used by Vanadis Element for compiling code for simulations

- Instructions specific to Linux Operating Systems.

General Infomation:

musl.cc - Your source for static cross and native musl-based toolchains.
For more information see musl.cc
SST 15.0.x is tested using (the musl.cc) mipsel-linux-musl-gcc compiler.
NOTE: musl.cc downloads are not version controlled.
- Per the musl.cc website - “versions may be bumped up or down without notice if bugs are discovered.”
- Vanadis is heavily dependant on the MUSL compiler, there may be situations (outside of the SST Team’s control) that the compiler has changed causing Vanadis to exhibit unexpected behavior.

Where to find:

The musl compiler suite is available here look for mipsel-linux-musl-cross.tgz

Installation Instructions:

1. The musl compiler must be must be download and extracted and then added to the PATH

$ cd $HOME/scratch/src
$ wget https://musl.cc/mipsel-linux-musl-cross.tgz
$ tar xf  mipsel-linux-musl-cross.tgz
$ export PATH=$PWD/mipsel-linux-musl-cross/bin:$PATH

SST-STONNE

OPTIONAL EXTERNAL COMPONENT for DNN accelerators

SST-STONNE is a cycle-level microarchitectural simulator for flexible DNN inference accelerators. This library is developed and maintained by a third-party here. More information is available on the SST Community page.

Installation Instructions:

1. Clone the SST-STONNE element.

git clone https://github.com/stonne-simulator/sst-elements-with-stonne

2. Copy the stonne element into your official SST-Elements source code. Assuming that your SST-Elements resides at $SST_ELEMENTS_HOME:

cp -r $HOME/scratch/src/sst-elements-with-stonne/src/sst/elements/sstStonne $SST_ELEMENTS_HOME/src/sst/elements

3. Build and install SST-Elements as usual. You will need to run ./autogen.sh prior to configuring and building.

cd $SST_ELEMENTS_HOME
./autogen.sh
./configure <CONFIGURE_OPTIONS>
make
make install

Using STONNE

sstStonne must be instantiated in the SST Python Configuration file, along with the memory hierarchy elements that will be used to model the memory hierarchy. The following examples, along with scripts to generate memory initialization files and calcuate memory address locations are provided. After running the generation script, remember to update the SST input script with the memory address locations and memory initialization file for each kernel to be launched.

Run a convolution operation:
- SST Input File: sst-elements/src/sst/elements/sstStonne/tests/sst_stonne_conv.py
- Memory Initialization: sst-elements/src/sst/elements/sstStonne/tests/gen_conv.py
Run a dense GEMM operation:
- SST Input File: sst-elements/src/sst/elements/sstStonne/tests/sst_stonne_gemm.py
- Memory Initialization: sst-elements/src/sst/elements/sstStonne/tests/gen_gemm.py
Run a sparse-sparse GEMM operation where the matrices are encoded using a bitmap format:
- SST Input File: sst-elements/src/sst/elements/sstStonne/tests/sst_stonne_bitmapSpMSpM.py
- Memory Initialization: sst-elements/src/sst/elements/sstStonne/tests/gen_bitmapSpMSpM.py
Run a sparse-dense GEMM operation where the sparse matrix is encoded using a CSR format:
- SST Input File: sst-elements/src/sst/elements/sstStonne/tests/sst_stonne_csrSpMM.py
- Memory Initialization: sst-elements/src/sst/elements/sstStonne/tests/gen_csrSpMM.py