COST Quick Reference Guide
The Common Open Source Tools project, or COST is a stack of tools and combines all Baseline Configuration Team (BCT) mandated packages and are built in a similar way on every HPC system in the program. This allows users of the HPC systems to have a common environment on every machine in the program to develop software or have their jobs run in a similar fashion, independent of the machine.
Change Log
| Date | Change |
| 26 August 2016 | Added: BOOST C++, CMake, Git, Parallel netCDF Removed: BLAS, GotoBLAS2 |
Packages and libraries included:
How to use the COST software and libraries
- Initial module setup
module load costinit
- View what software is available
module avail(then look towards the top of the module listing)
- Load the desired module (python as an example)
module load python/gnu
- After loading the module, the software package or library will be added to your path.
Module name format for COST applications is
<application>/<compiler>/<version>
for serial libraries and applications and
<application>-mpi/<compiler>/<MPI Stack>/<version>
for MPI libraries and applications. For example, to load the COST version of Python:
module load costinit
module load python/gnu/2.7.9
When loading modules, the <version> tag can be left off. This will
load the newest version of the software, should more than one version exist. For example,
to load the COST version of Python without using <version>:
module load costinit
module load python/gnu
More information about the module command can be found at
https://www.afrl.hpc.mil/docs/modulesUserGuide.html and
http://modules.sourceforge.net/.
Compiler Support
The COST stack consists of Open Source Software, most of which was written with the Gnu Compiler Collection (GCC) in mind. Because of this, the COST stack is built using primarily GCC on all HPC and Utility systems and GCC is the primary supported compiler for the COST application stack.
Other compilers that are OSS-friendly will be considered on an as-needed and best-effort support basis. At this time, the PGI and Cray Compiler suites are not supported.
Software Explanation
ARPACK
Description
ARPACK is a collection of Fortran77 subroutines designed to solve large scale eigenvalue problems.
The package is designed to compute a few eigenvalues and corresponding eigenvectors of a general n by n matrix A. It is most appropriate for large sparse or structured matrices A where structured means that a matrix-vector product w <- Av requires order n rather than the usual order n2 floating point operations. This software is based upon an algorithmic variant of the Arnoldi process called the Implicitly Restarted Arnoldi Method (IRAM). When the matrix A is symmetric it reduces to a variant of the Lanczos process called the Implicitly Restarted Lanczos Method (IRLM). These variants may be viewed as a synthesis of the Arnoldi/Lanczos process with the Implicitly Shifted QR technique that is suitable for large scale problems. For many standard problems, a matrix factorization is not required. Only the action of the matrix on a vector is needed.
Usage
module load arpack/<compiler>/<version>
Examples:
module load arpack/gnu/96
Vendor Links
http://www.caam.rice.edu/software/ARPACK
BOOST C++
Description
Boost is a set of libraries for the C++ programming language that provide support for tasks and structures such as linear algebra, pseudorandom number generation, multithreading, image processing, regular expressions, and unit testing. It contains over eighty individual libraries
COST provides both the serial (thread-enabled) and MPI versions of BOOST C++
Usage
module load boost/<compiler>/<version>
-or-
module load boost-mpi/<compiler>/<MPI stack>/<version>
Examples:
module load boost/gnu/1.58.0
-or-
module load boost-mpi/gnu/sgimpt/1.58.0
Vendor Links
CMake
Description
CMake is an open-source, cross-platform family of tools designed to build, test and package software. CMake is used to control the software compilation process using simple platform and compiler independent configuration files, and generate native makefiles and workspaces that can be used in the compiler environment of your choice. The suite of CMake tools were created by Kitware in response to the need for a powerful, cross-platform build environment for open-source projects such as ITK and VTK.
Usage
module load cmake/<compiler>/<version>
Examples:
module load cmake/gnu/3.2.3
Vendor Links
FFTW
Description
FFTW is a C subroutine library for computing the discrete Fourier transform (DFT) in one or more dimensions, of arbitrary input size, and of both real and complex data (as well as of even/odd data, i.e. the discrete cosine/sine transforms or DCT/DST).
COST provides both the serial (thread-enabled) and MPI versions of FFTW
Usage
module load fftw3/<compiler>/<version>
-or-
module load fftw3-mpi/<compiler>/<MPI stack>/<version>
Examples:
module load fftw3/gnu/3.3.4
-or-
module load fftw3-mpi/gnu/sgimpt/3.4.4
Vendor Links
Git
Description
Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.
Usage
module load git/<compiler>/<version>
Examples:
module load git/gnu/2.4.4
Vendor Links
Gnuplot
Description
Gnuplot is a portable command-line driven graphing utility for Linux, OS/2, MS Windows, OSX, VMS, and many other platforms. The source code is copyrighted but freely distributed (i.e., you don't have to pay for it). It was originally created to allow scientists and students to visualize mathematical functions and data interactively, but has grown to support many non-interactive uses such as web scripting. It is also used as a plotting engine by third-party applications like Octave. Gnuplot has been supported and under active development since 1986.
Usage
module load gnuplot/<compiler>/<version>
Examples:
module load gnuplot/gnu/5.0.0
Vendor Links
GSL
Description
The GNU Scientific Library (GSL) is a numerical library for C and C++ programmers. It is free software under the GNU General Public License.
The library provides a wide range of mathematical routines such as random number generators, special functions and least-squares fitting. There are over 1000 functions in total with an extensive test suite.
The complete range of subject areas covered by the library includes,
| Complex Numbers | Roots of Polynomials | Special Functions |
| Vectors and Matrices | Permutations | Sorting |
| BLAS Support | Linear Algebra | Eigensystems |
| Fast Fourier Transforms | Quadrature | Random Numbers |
| Quasi-Random Sequences | Random Distributions | Statistics |
| Histograms | N-Tuples | Monte Carlo Integration |
| Simulated Annealing | Differential Equations | Interpolation |
| Numerical Differentiation | Chebyshev Approximation | Series Acceleration |
| Discrete Hankel Transforms | Root-Finding | Minimization |
| Least-Squares Fitting | Physical Constants | IEEE Floating-Point |
| Discrete Wavelet Transforms | Basis splines | Running Statistics |
| Sparse Matrices and Linear |
Usage
module load gsl/<compiler>/<version>
Examples:
module load gsl/gnu/1.16
Vendor Links
http://www.gnu.org/software/gsl
HDF5 & HDF5-parallel
Description
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.
NOTE: Due to changes in SGI's MPT compilers, the GCC-built
version of HDF5-parallel is not supported when using sgimpt as an MPI stack.
On SGI systems, users are encouraged to use the hdf5-mpi/intel/sgimpt
or hdf5-mpi/gcc/intelmpi modules.
Usage
module load hdf5/<compiler>/<version>
-or-
module load hdf5-mpi/<compiler>/<MPI stack><version>
Examples:
module load hdf5/gnu/1.8.15
-or-
module load hdf5-mpi/gnu/intelmpi/1.8.15
Vendor Links
IPython
Description
IPython provides a rich architecture for interactive computing with:
- Powerful interactive shells (terminal and Qt-based).
- A browser-based notebook with support for code, text, mathematical expressions, inline plots and other rich media.
- Support for interactive data visualization and use of GUI toolkits.
- Flexible, embeddable interpreters to load into your own projects.
- Easy to use, high performance tools for parallel computing.
NOTE: Due to security concerns, any functions that require IPython's webserver (Notebook and Terminal) or ZeroMQ/PyZMQ (Parallel) modules and libraries are disabled.
Usage
module load python/<compiler>/<version>
-and-
module load ipython/<compiler>/<version>
Examples:
module load python/gnu/2.7.9
-and-
module load ipython/gnu/3.0.0
Vendor Links
LAPACK
Description
LAPACK is written in Fortran 90 and provides routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems. The associated matrix factorizations (LU, Cholesky, QR, SVD, Schur, and generalized Schur) are also provided, as are related computations such as reordering of the Schur factorizations and estimating condition numbers. Dense and banded matrices are handled, but not general sparse matrices. In all areas, similar functionality is provided for real and complex matrices, in both single and double precision.
Basic Linear Algebra Subroutine (BLAS) is a de facto application programming interface standard for publishing libraries to perform basic linear algebra operations such as vector and matrix multiplication.
Usage
module load lapack/<compiler>/<version>
Examples:
module load lapack/gnu/3.5.0
Vendor Links
Matplotlib
Description
Matplotlib is a python 2D plotting library which produces publication quality figures in a variety of hardcopy formats and interactive environments across platforms. Matplotlib can be used in python scripts, the python and ipython shell (ala MATLAB® or Mathematica®), web application servers, and six graphical user interface toolkits.
Usage
module load python/<compiler>/<version>
module load matplotlib/<compiler>/<version>
Examples:
module load python/gnu/2.7.9
module load matplotlib/gnu/1.4.3
Vendor Links
MPI4Py
Description
This package is constructed on top of the MPI-1/2 specifications and provides an object oriented interface which closely follows MPI-2 C++ bindings. It supports point-to-point (sends, receives) and collective (broadcasts, scatters, gathers) communications of any picklable Python object, as well as optimized communications of Python object exposing the single-segment buffer interface (NumPy arrays, builtin bytes/string/array objects).
Usage
module load python/<compiler>/<version>
-and-
module load mpi4py/<compiler>/<MPI Stack>/<version>
Examples:
module load python/gnu/2.7.9
-and-
module load mpi4py/gnu/sgimpt/1.3.1
Vendor Links
NCL & NCAR Graphics
Description
NCL/NCAR Graphics is comprised of:
- a library containing over two dozen Fortran/C utilities for drawing contours, maps, vectors, streamlines, weather maps, surfaces, histograms, X/Y plots, annotations, and more
- an ANSI/ISO standard version of GKS, with both C and FORTRAN callable entries
- a math library containing a collection of C and Fortran interpolators and approximators for one-dimensional, two-dimensional, and three-dimensional data
- applications for displaying, editing, and manipulating graphical output
- map databases
- hundreds of FORTRAN and C examples
- demo programs
- compilation scripts
Usage
module load ncl_ncarg/<compiler>/<version>
Examples:
module load ncl_ncarg/gnu/6.3.0
Vendor Links
http://www.ncl.ucar.edu/overview.shtml
NetCDF-C
Description
NetCDF (network Common Data Form) is a set of interfaces for array-oriented data access and a freely distributed collection of data access libraries for C. The netCDF libraries support a machine-independent format for representing scientific data. Together, the interfaces, libraries, and format support the creation, access, and sharing of scientific data.
NetCDF is available in C, C++, and FORTRAN library sets. As each library set is versioned differently from the developer, they are available as different modules.
Usage
module load netcdf-c/<compiler>/<version>
Examples:
module load netcdf-c/gnu/4.3.31
Vendor Links
http://www.unidata.ucar.edu/software/netcdf/
NetCDF-CXX
Description
NetCDF (network Common Data Form) is a set of interfaces for array-oriented data access and a freely distributed collection of data access libraries for C++. The netCDF libraries support a machine-independent format for representing scientific data. Together, the interfaces, libraries, and format support the creation, access, and sharing of scientific data.
NetCDF is available in C, C++, and FORTRAN library sets. As each library set is versioned differently from the developer, they are available as different modules.
Usage
module load netcdf-cxx/<compiler>/<version>
Examples:
module load netcdf-cxx/gnu/4.2
Vendor Links
http://www.unidata.ucar.edu/software/netcdf/
NetCDF-FORTRAN
Description
NetCDF (network Common Data Form) is a set of interfaces for array-oriented data access and a freely distributed collection of data access libraries for FORTRAN. The netCDF libraries support a machine-independent format for representing scientific data. Together, the interfaces, libraries, and format support the creation, access, and sharing of scientific data.
NetCDF is available in C, C++, and FORTRAN library sets. As each library set is versioned differently from the developer, they are available as different modules.
Usage
module load netcdf-fortran/<compiler>/<version>
Examples:
module load netcdf-fortran/gnu/4.4.2
Vendor Links
http://www.unidata.ucar.edu/software/netcdf/
NumPy
Description
NumPy is the fundamental package for scientific computing with Python. It contains among other things:
- a powerful N-dimensional array object
- sophisticated (broadcasting) functions
- tools for integrating C/C++ and Fortran code
- useful linear algebra, Fourier transform, and random number capabilities
Usage
module load python/<compiler>/<version>
-and-
module load numpy/<compiler>/<version>
Examples:
module load python/gnu/2.7.9
-and-
module load numpy/gnu/1.9.2
Vendor Links
Octave
Description
GNU Octave is a high-level interpreted language, primarily intended for numerical computations. It provides capabilities for the numerical solution of linear and nonlinear problems, and for performing other numerical experiments. It also provides extensive graphics capabilities for data visualization and manipulation. Octave is normally used through its interactive command line interface, but it can also be used to write non-interactive programs. The Octave language is quite similar to Matlab so that most programs are easily portable.
Usage
module load octave/<compiler>/<version>
Examples:
module load octave/gnu/4.0
Vendor Links
http://www.gnu.org/software/octave
PAPI
Description
PAPI provides the tool designer and application engineer with a consistent interface and methodology for use of the performance counter hardware found in most major microprocessors. PAPI enables software engineers to see, in near real time, the relation between software performance and processor events.
COST provides both the serial and MPI versions of PAPI.
Usage
module load papi/<compiler>/<version>
-or-
module load papi-mpi/<compiler>/<MPI stack>/<version>
Examples:
module load papi/gnu/5.4.1
-or-
module load papi-mpi/gnu/sgimpt/5.4.1
Vendor Links
Parallel netCDF
Description
PnetCDF is a library providing high-performance parallel I/O while still maintaining file-format compatibility with Unidata's NetCDF, specifically the formats of CDF-1 and CDF-2. Although NetCDF supports parallel I/O starting from version 4, the files must be in HDF5 format. PnetCDF is currently the only choice for carrying out parallel I/O on files that are in classic formats (CDF-1 and 2).
In addition, PnetCDF supports the CDF-5 file format, an extension of CDF-2, that supports more data types and allows users to define large dimensions, attributes, and variables (>2B elements).
NetCDF gives scientific programmers a self-describing and portable means for storing data. However, prior to version 4, netCDF does so in a serial manner. By making some small changes to the netCDF APIs, PnetCDF can use MPI-IO to achieve high-performance parallel I/O.
Usage
module load pnetcdf-mpi/<compiler>/<MPI stack>/<version>
Examples:
module load pnetcdf-mpi/gnu/sgimpt/0.96
Vendor Links
https://trac.mcs.anl.gov/projects/parallel-netcdf
PARPACK
Description
PARPACK is a collection of parallel Fortran77 subroutines designed to solve large scale eigenvalue problems. The package is designed to compute a few eigenvalues and corresponding eigenvectors of a general n by n matrix A. It is most appropriate for large sparse or structured matrices A where structured means that a matrix-vector product w <- Av requires order n rather than the usual order n2 floating point operations. This software is based upon an algorithmic variant of the Arnoldi process called the Implicitly Restarted Arnoldi Method (IRAM). When the matrix A is symmetric it reduces to a variant of the Lanczos process called the Implicitly Restarted Lanczos Method (IRLM). These variants may be viewed as a synthesis of the Arnoldi/Lanczos process with the Implicitly Shifted QR technique that is suitable for large scale problems. For many standard problems, a matrix factorization is not required. Only the action of the matrix on a vector is needed.
Usage
module load parpack/<compiler>/<MPI stack>/<version>
Examples:
module load parpack/gnu/sgimpt/0.96
Vendor Links
http://www.caam.rice.edu/software/ARPACK
PETSc & PETSc MPI
Description
PETSc is a suite of data structures and routines for the scalable (parallel) solution of scientific applications modeled by partial differential equations. It supports MPI, shared memory pthreads, and NVIDIA GPUs, as well as hybrid MPI-shared memory pthreads or MPI-GPU parallelism.
COST provides both the serial and MPI versions of PAPI. Debug versions are also available
Usage
module load petsc/<compiler>/<version>
-or-
module load petsc-debug/<compiler>/<version>
-or-
module load petsc-mpi/<compiler>/<MPI stack>/<version>
-or-
module load petsc-mpi-debug/<compiler>/<MPI stack>/<version>
Examples:
module load petsc/gnu/3.6.3
-or-
module load petsc-debug/gnu/3.6.3
-or-
module load petsc-mpi/gnu/sgimpt/3.6.3
-or-
module load petsc-mpi-debug/gnu/sgimpt/3.6.3
Vendor Links
PyMPI
Description
This package builds on traditional Python by enabling users to write distributed, parallel programs based on MPI message passing primitives. General python objects can be messaged between processors.
Usage
module load pympi/<compiler>/<version>
Examples:
module load pympi/gnu/sgimpt/2.50b
Vendor Links
Python
Description
Python is an interpreted, interactive, object-oriented programming language.
It is often compared to Tcl, Perl, Scheme or Java.
Python combines remarkable power with very clear syntax. It has modules, classes,
exceptions, very high level dynamic data types, and dynamic typing. There are
interfaces to many system calls and libraries, as well as to various windowing
systems (X11, Motif, Tk, Mac, MFC). New built-in modules are easily written in C
or C++. Python is also usable as an extension language for applications that need
a programmable interface.
Usage
module load python/<compiler>/<version>
Examples:
module load python/gnu/2.7.9>
Vendor Links
ScaLAPACK
Description
ScaLAPACK is a library of high-performance linear algebra routines for parallel distributed memory machines. ScaLAPACK solves dense and banded linear systems, least squares problems, eigenvalue problems, and singular value problems.
Usage
module load scalapack/<compiler>/<version>
Examples:
module load scalapack/gnu/2.0.2
Vendor Links
http://www.netlib.org/scalapack
SCALASCA
Description
Scalasca is a software tool that supports the performance optimization of parallel programs by measuring and analyzing their runtime behavior. The analysis identifies potential performance bottlenecks - in particular those concerning communication and synchronization - and offers guidance in exploring their causes.
COST provides both the serial and MPI versions of SCALASCA
Usage
module load scalasca/<compiler>/<version>
-or-
module load scalasca/<compiler>/<MPI stack></version>
Examples:
module load scalasca/gnu/2.2.1
-or-
module load scalasca-mpi/gnu/sgimpt/2.2.1
Vendor Links
SciPy
Description
SciPy is open-source software for mathematics, science, and engineering. It is also the name of a very popular conference on scientific programming with Python. The SciPy library depends on NumPy, which provides convenient and fast N-dimensional array manipulation. The SciPy library is built to work with NumPy arrays, and provides efficient numerical routines such as routines for numerical integration and optimization
Usage
module load python/<compiler>/<version>
-and-
module load scipy/<compiler>/<version>
Examples:
module load python/gnu/2.7.9
-and-
module load module load scipy/gnu/0.15.1
Vendor Links
SuperLU
Description
SuperLU is a general purpose library for the direct solution of large, sparse, nonsymmetric systems of linear equations on high performance machines. The library is written in C and is callable from either C or Fortran. The library routines will perform an LU decomposition with partial pivoting and triangular system solves through forward and back substitution. The LU factorization routines can handle non-square matrices but the triangular solves are performed only for square matrices. The matrix columns may be preordered (before factorization) either through library or user supplied routines. This preordering for sparsity is completely separate from the factorization. Working precision iterative refinement subroutines are provided for improved backward stability. Routines are also provided to equilibrate the system, estimate the condition number, calculate the relative backward error, and estimate error bounds for the refined solutions.
Usage
module load superlu/<compiler>/<version>
Examples:
module load superlu/gnu/4.3
Vendor Links
http://crd-legacy.lbl.gov/~xiaoye/SuperLU
TAU
Description
TAU (Tuning and Analysis Utilities) is capable of gathering performance information through instrumentation of functions, methods, basic blocks, and statements. All C++ language features are supported including templates and namespaces. The API also provides selection of profiling groups for organizing and controlling instrumentation. The instrumentation can be inserted in the source code using an automatic instrumentor tool based on the Program Database Toolkit (PDT), dynamically using DyninstAPI, at runtime in the Java Virtual Machine, or manually using the instrumentation API.
TAU's profile visualization tool, paraprof, provides graphical displays of all the performance analysis results, in aggregate and single node/context/thread forms. The user can quickly identify sources of performance bottlenecks in the application using the graphical interface. In addition, TAU can generate event traces that can be displayed with the Vampir, Paraver or JumpShot trace visualization tools.
COST provides both the serial and MPI versions of TAU.
Usage
module load tau/<compiler>/<version>
-or-
module load tau-mpi/<compiler>/<MPI stack>/<version>
Examples:
module load tau/gnu/2.24.1
-or-
tau-mpi/gnu/sgimpt/2.24.1
Vendor Links
http://www.cs.uoregon.edu/research/tau/home.php
Valgrind
Description
class="indent"Valgrind is an instrumentation framework for building dynamic analysis tools. There are Valgrind tools that can automatically detect many memory management and threading bugs, and profile your programs in detail. You can also use Valgrind to build new tools.
COST provides both the serial and MPI versions of Valgrind.
Usage
module load valgrind/<compiler>/<version>
-or-
module load valgrind-mpi/<compiler>/<MPi stack>/<version>
Examples:
module load valgrind/gnu/3.10.1
-or-
module load valgrind-mpi/gnu/sgimpt/3.10.1
Vendor Links
XDMF
Description
The need for a standardized method to exchange scientific data between High Performance Computing codes and tools lead to the development of the eXtensible Data Model and Format (XDMF). Uses for XDMF range from a standard format used by HPC codes to take advantage of widely used visualization programs like ParaView, to a mechanism for performing coupled calculations using multiple, previously stand alone codes.
COST provides both the serial and MPI versions of XDMF.
Usage
module load xdmf/<compiler>/<version>
-or-
module load xdmf-mpi/<compiler>/<MPi stack>/<version>
Examples:
module load xdmf/gnu/v3
-or-
module load xdmf-mpi/gnu/sgimpt/v3
Vendor Links
http://www.xdmf.org/index.php/Main_Page