Programming Models and Runtimes

The ECP software team is developing key enhancements to message passing interface (MPI) and OpenMP, addressing in particular the important design and implementation challenges of combining massive inter-node and intra-node concurrency into an application. They are also developing a diverse collection of products that further address next- generation node architectures to improve realized performance, ease of expression and performance portability.

Exascale MPI / MPICH

Objective: Enhance the MPI standard and the MPICH implementation of MPI for the exascale task-based programming model

Efficient communication among the compute elements within high performance computing systems is essential for simulation performance. The Message Passing Interface (MPI) is a community standard developed by the MPI Forum for programming these systems and handling the communication needed. MPI is the de facto programming model for large-scale scientific computing and is available on all the large systems; most of DOE’s parallel scientific applications running on pre-exascale systems use MPI.

Principal Investigators: Pavan Balaji, Argonne National Laboratory

Legion

Objective: Develop/ enhance this task-based programming model

The complexity of the exascale systems that will be delivered, from processors with many cores to accelerators and heterogeneous memory, makes it challenging for scientists to achieve high performance from their simulations. Legion provides a data-centric programming system that allows scientists to describe the properties of their program data and dependencies, along with a runtime that extracts tasks and executes them using knowledge of the exascale systems to improve performance.

Principal Investigators: Pat McCormick, Los Alamos National Laboratory

PaRSEC

Objective: Develop/ enhance this task-based programming model

One diffi culty associated with programming exascale systems is expressing the tasks comprising a scientific simulation and then mapping them to the heterogenous computational resources on that system, while achieving high performance. PaRSEC supports the development of domain-specific languages and tools to simplify and improve the productivity of scientists when using a task-based system and provides a low-level runtime.

Principal Investigators: George Bosilca, University of Tennessee – Knoxville

Pagoda: UPC++/GASNet

Objective: Develop/enhance a Partitioned Global Address Space (PGAS) programming model

A computation being performed on one part of a large system often needs to access or provide data to another part of the system in order to complete a scientific simulation. The Partitioned Global Address Space (PGAS) model provides the appearance of shared memory accessible to all the compute nodes while implementing this shared memory behind the scenes using physical memory local to the nodes and primitives, such as remote direct memory access.

Principal Investigators: Erich Strohmaier, Lawrence Berkeley National Laboratory

SICM

Objective: Develop an interface and library for accessing a complex memory hierarchy

Exascale systems will have complex, heterogenous memories that need to be effectively managed either directly by the programmer or by the runtime in order to achieve high performance. Natively supporting each memory technology is challenging, as each has its own separate programming interface. The SICM project addresses the emerging complexity of exascale memory hierarchies by providing a portable, simplified interface to complex memory.

Principal Investigators: Mike Lang, Los Alamos National Laboratory

OMPI-X

Objective: Enhance the MPI standard and the Open MPI implementation of MPI for exascale

The Message Passing Interface (MPI) is a community standard for inter-process communication and is used by the majority of DOE’s parallel scientific applications running on pre-exascale systems. The MPI standard can be implemented on all the large systems. The OMPI-X project ensures that the MPI standard and its specific implementation in Open MPI meet the needs of the ECP community in terms of performance, scalability, and capabilities.

Principal Investigators: David Bernholdt, Oak Ridge National Laboratory

Kokkos/RAJA

Objective: Develop abstractions for node-level performance portability

Exascale systems are characterized by computer chips with a large number of cores, a smaller amount of memory, and a range of various architectures, which can result in decreased productivity for library and application developers who need to write specialized software for each system. The Kokkos/RAJA project provides high-level abstractions, expressing the necessary parallel constructs that are then mapped onto a runtime to achieve portable performance across current and future architectures.

Principal Investigators: Christian Trott, Sandia National Laboratories

Argo

Objective: Optimize existing low-level system software components to improve performance and scalability and improve functionality of exascale applications and runtime systems

The operating system provides necessary functionality to libraries and applications, such as allocating memory and spawning processes, and manages the resources on the nodes in an exascale system. The Argo project is building portable, open-source system software that improves performance and scalability and provides increased functionality to exascale libraries, applications, and runtime systems, with a focus on resource management, memory management, and power management.

Principal Investigators: Pete Beckman, Argonne National Laboratory