CHAMELEON

A Task-based Programming Environment for Developing Reactive HPC Applications

1. Description

The technical design of High Performance Computing (HPC) systems is becoming increasingly complex. The Chameleon project is dedicated to the aspect of ever-increasing dynamic variability. The programming approaches widely used today are often poorly suited for highly dynamic systems and may in the future only be able to exploit part of the true potential of modern systems.

Project Chameleon developed a task-based programming environment based on the established standards MPI and OpenMP that is better prepared for systems with dynamic variability than today's widely used bulk-synchronous programming models.

In Chameleon, the dynamic performance data required for efficient task execution is provided by a monitoring or introspection component. Without negatively affecting the target application or introducing high overhead, performance metrics are determined and made available to the application itself, or to Chameleon's execution system. For example, the computational load or power consumption of the computational system components are continuously monitored and made available to the other parts of Chameleon. With such a frequent and reactive monitoring it is then possible to form better load balancing decisions not just in shared memory but also between MPI processes in distributed memory. The concept in Chameleon is based on migratable task entities that can either be executed on the local system or depending on the current load situation be migrated to a remote rank and executed there.

Funding

CHAMELEON is funded by the German Ministry of Education and Research (BMBF) (2017-2020).

Further information

Website:

http://www.chameleon-hpc.org/

GitHub:

https://github.com/chameleon-hpc/chameleon

2. Publications / How to Cite

• Jannis Klinkenberg, Philipp Samfass, Michael Bader, Christian Terboven, Matthias S. Müller. CHAMELEON: Reactive Load Balancing for Hybrid MPI+OpenMP Task-Parallel Applications, Journal of Parallel and Distributed Computing, Volume 138, 2020, Pages 55-64, ISSN 0743-7315. https://doi.org/10.1016/j.jpdc.2019.12.005

• Jannis Klinkenberg, Philipp Samfass, Michael Bader, Christian Terboven, Matthias S. Müller. (2020) Reactive Task Migration for Hybrid MPI+OpenMP Applications. In: Wyrzykowski R., Deelman E., Dongarra J., Karczewski K. (eds) Parallel Processing and Applied Mathematics. PPAM 2019. Lecture Notes in Computer Science, vol 12044. Springer, Cham. https://doi.org/10.1007/978-3-030-43222-5_6

• Philipp Samfass, Jannis Klinkenberg, and Michael Bader. Hybrid MPI+OpenMP Reactive Work Stealing in Distributed Memory in the PDE Framework sam(oa)^2. Proceedings of the 2018 IEEE International Conference on Cluster Computing (CLUSTER). September 10 - 13, 2018, Belfast, UK. https://ieeexplore.ieee.org/document/8514894

3. Building and Installing CHAMELEON

CHAMELEON can be build from source using CMake.

3.1. Prerequisites

• CMake version 2.8.12 or greater
• C++ compiler supporting the C++11 standard and OpenMP
• Fortran compiler (optional)
• MPI installation (OpenMPI, MPICH, ...)
• hwloc

3.2. Getting the source

git clone https://github.com/chameleon-hpc/chameleon.git

3.3. Building

To build CHAMELEON using CMake run:

Create build directory:

mkdir BUILD && cd ./BUILD

Run cmake to configure the build:

cmake ..

For a list of available parameters:

cmake .. -L

To configure build parameters using ccmake:

ccmake ..

To build run:

make

3.4. Installation

Installing to the default installation path usually requires root privileges. Changing the installation path can be done using -DCMAKE_INSTALL_PREFIX

cmake -DCMAKE_INSTALL_PREFIX=<install/path> ../
make
make install

3.5. Make runtime available for applications

To be able to link applications against the Chameleon runtime, you need to prepend / append a few environment variables.

# base path to install folder
export CHAMELEON_INSTALL_PATH=<install/path>

# include paths
export INCLUDE="${CHAMELEON_INSTALL_PATH}/include:${INCLUDE}"
export CPATH="${CHAMELEON_INSTALL_PATH}/include:${CPATH}"
export C_INCLUDE_PATH="${CHAMELEON_INSTALL_PATH}/include:${C_INCLUDE_PATH}"
export CPLUS_INCLUDE_PATH="${CHAMELEON_INSTALL_PATH}/include:${CPLUS_INCLUDE_PATH}"

# library paths
export LIBRARY_PATH="${CHAMELEON_INSTALL_PATH}/lib:${LIBRARY_PATH}"
export LD_LIBRARY_PATH="${CHAMELEON_INSTALL_PATH}/lib:${LD_LIBRARY_PATH}"