Draft:E4S Software Stack

The Extreme-scale Scientific Software Stack, or E4S, is a community initiative that provides open-source software packages for scientific applications on high-performance computing (HPC) platforms. It includes from-source builds and containers of various HPC software packages. E4S allows contributions from teams around the world and enables collaborative integration of open-source products. It also targets scalable next-generation computing platforms. The software is based on the Spack package manager and includes Exascale Computing Project (ECP) software technologies (ST) and related software tested for compatibility and portability across multiple architectures. It aims to distinguish between usability, quality, and community goals for software development kit (SDK), deployment, and testing purposes. The ECP software stack, E4S Release 0.2, is a subset of the full ECP ST software stack and demonstrates the target approach for future delivery. It includes some ECP ST software products that are supported by Spack packages but are not yet interoperable. This release is mainly focused on demonstrating the ST software stack approach, and not all ECP ST software products were included.

Interoperability and Software Delivery
To achieve software interoperability, E4S uses a dual-pronged approach consisting of Spack and SDKs. It also allows the use of containers and being able to deploy packages on bare metal systems. Spack serves as a package manager for deploying systems using E4S recipes. Alternatively, it is possible to download a container and image from e4s.io and deploy a container based on the chosen image. Spack is also used to manage different versions of products, interoperability, and access to runtimes and compilers. It is tested for both interoperability and portability. Spack uses Python to assist with the process of installing libraries and simulations and optimize their performance. It also allows users to build code configurations, ensures that all installed software runs correctly, and streamlines file management. Spack can additionally install numerous variants of the same build using different message-passing interface (MPI) implementations, different options, and different compilers. E4S uses the Spack package manager for software delivery since it provides the ability to distinguish between versions of software packages that are interoperable and those that are not. Writing package recipes for Spack consists of a single file containing a templated recipe for other builds of the same package, meaning recipe authors can differentiate between different versions by using a specification language developed by Todd Gamblin. It simplifies the installation of software packages by handling the complexity of connecting them with a consistent set of dependencies. Spack does this by creating different configurations for each software package, installing them in unique directories, and using RPATH linking so that each package knows where to find its dependencies. Spack helps ensure compatibility between program modules by guaranteeing one configuration of each library per dependency graph. It enables users to specify dependencies without needing to understand the dependency graph structure, as well as offer an optional concretization feature that fills in missing configuration details based on user/site preference. E4S facilitates the testing and use of an abundance of reusable HPC software packages through the use of Spack as a meta-build tool, along with supplying containers of pre-built binaries for Singularity, CharlieCloud, Docker, and Shifter. An ECP ST Software Development Kit is a group of related software tools (called packages) that can be used together to enhance user experience, provide consistent practices, and promote collaboration among teams that create similar or related capabilities. The Extreme-Scale Scientific Software Development Kit (xSDK) is featured in the initial version (0.2) of E4S. SDKs help to reduce the complexity of delivery by utilizing hierarchical build targets and distributing software integration responsibilities.

Objectives and Challenges
The objectives of composing a modular, interoperable, and deployable software stack include lowering the barrier to using ST products and enabling facilities to install all or parts of it, allowing for interoperability between the ST products, along with uniform application programming interfaces, and establishing an open, hierarchical software architecture that allows for collaboration between agencies and software institutions. These objectives also come with challenges, such as the large, diverse group of ST products, the difference in project management styles, the lack of initial drivers, and the complicated software ecosystem. The E4S Software Stack provides a complete HPC software stack that does not significantly increase the number of products in the HPC ecosystem. It provides a way of building, installing, and testing the software, and also improves the stability of the ST stack. Users can get E4S on the web page, e4s.io, by downloading the containers and accessing the docker hub and the other build cache.

Features
The E4S software stack offers a range of open-source libraries and tools for high-performance computing applications, including:


 * High-performance numerical libraries


 * Productivity tools and frameworks


 * Performance analysis and profiling tools


 * Machine learning libraries and frameworks


 * Data management and visualization tools


 * Support for multiple programming languages


 * Distributed-memory parallel computation support through MPI, and shared-memory parallel computation support

Programming Languages
The E4S software stack includes support for a variety of programming languages.

Most of the packages in the E4S software stack are written in C++, including packages such as Spack and Kokkos.

Other programming languages are also supported in the E4S software stack. Python is a language for scientific computing and data analysis, and many E4S packages have Python bindings, including packages like PyTorch and TensorFlow.

In addition to C++ and Python, Fortran is also supported in some packages in the E4S software stack. For example, PETSc is a package for solving partial differential equations, and it has optional implementations of some computational kernels in Fortran.

Other programming languages with bindings to E4S packages include C and Matlab.

Software Licenses
The E4S software stack consists of various packages, each with their own specific software license. Most of the packages in the E4S stack are open-source and licensed under the Apache License, Version 2.0. However, there are some packages that use other open-source licenses, such as the BSD-3-Clause license and the GNU Lesser General Public License (LGPL). Additionally, some packages use proprietary licenses, such as the Intel Math Kernel Library (MKL).

The E4S software stack also includes various dependencies, which have their own licensing terms. For example, the BLAS and LAPACK libraries, which are required dependencies for some packages in the E4S stack, are typically licensed under the BSD-3-Clause license.