ComPU ("PEPPHER") Composition Tool

The PEPPHER Composition Tool ComPU is a research prototype developed by Lu Li, Usman Dastgeer and Christoph Kessler at Linköping University (Sweden), for the EU FP7 project PEPPHER (2010-2012). Its further development since 2013 is partly funded by SeRC, project OpCoReS (Optimized Composition and Runtime Support for e-Science), and (in 2013) by Vetenskapsrådet.

ComPU builds optimized C/C++ based applications for GPU-based systems from user-defined application-level building blocks (PEPPHER components) with multiple implementation variants, which are written and annotated using the PEPPHER component model.
The composition tool generates glue code that will, at run-time, automatically select for each call to a PEPPHER component among its available implementation variants the expected fastest one, based on a performance model.

Currently, the composition tool supports component implementations written in sequential C/C++, OpenMP, CUDA and OpenCL, and for execution it uses the PEPPHER runtime system (which is built upon the open-source StarPU runtime system). The default is dynamic composition, i.e., generating multi-variant tasks for StarPU which performs context-aware composition (implementation selection and resource allocation) at runtime. Besides dynamic composition, the composition tool also supports user-guided static composition and static composition by building off-line a performance model that is inspected at runtime for fast implementation selection.

We have also designed an adaptive sampling method for off-line performance modeling and implemented it in the PEPPHER composition tool.

The PEPPHER component model is a comprehensive framework for annotating software components for heterogeneous multicore systems that are written in various programming models for CPUs and GPUs with rich metadata to expose their variation points and tuning options to an external software composition tool.
Instead of hardcoding such performance optimizations for a specific platform configuration in the application code, a composition tool will generate code for the application from its components and their implementation variants such that the composed code automatically adapts its runtime behavior (e.g., selection of implementation variants, scheduling, resource allocation, ...) for a given platform and for a given runtime context (which might comprise performance-relevant properties such as problem sizes or current load of processing units), in order to optimize program execution. This supports both code portability and performance portability.

The PEPPHER component model is generic in its design; however, it is currently realized in C/C++ so we will here discuss it with respect to C/C++.

A PEPPHER component consists of an interface and one or more implementations of that interface. Both interface and implementations are complemented with extra information (called "meta-data") in the form of XML descriptors. In this sense the PEPPHER component model is non-intrusive, as it require very little direct modification in the user code.

PEPPHER component interface

void sort(float *arr, int size);

• the access mode of each parameter (i.e., is it read, written or both inside the component);
• which parameters are considered relevant for performance modeling (e.g., in the above sorting interface, the "size" parameter defines the total number of elements of the "arr" parameter and might be considered as criterion for context-aware implementation selection while "arr" itself may be not)
• a performance model (if any) associated with the component
• ...

PEPPHER component implementations

A PEPPHER component implementation implements the functionality promised by a PEPPHER interface while keeping the same calling interface (return-type, parameter-types).

For example, for the sorting interface, we might have the following implementations:

void qs_cpu_imp(float *arr, int size)
{
   ...
}

void ms_cpu_imp(float *arr, int size)
{
   ...
}

void qs_gpu_imp(float *arr, int size)
{
   ...
}

void bs_gpu_imp(float *arr, int size)
{
   ...
}

• The interface that the implementation implements.
• A reference to the source code.
• The programming language of the implementation (e.g. C/C++, OpenMP, CUDA, OpenCL)
• Information about specific library usage and other dependences.
• Deployment information esp. for compilation, e.g. if it requires some specific compilation command such as specific include or link directives for libraries it uses internally.
• ...

• Generic components (using C++ templates)
• Performance-aware component implementation selection
• Asynchronous component calls, automatically synchronized by tracking operand data dependencies
• Smart containers (Matrix, Vector, Scalar) for passing operands (optional alternative to native data types)
• Automatic generation of annotating XML descriptor templates and implementation skeletons from a C++ header file
• Support for automatic task partitioning (enabling hybrid execution) by annotating a component as data parallel
• Reading and reifying a PDL platform specification for run-time introspection of platform properties
• Conditional implementation selection: specifying user-defined constraints on selectability in terms of the execution environment (PDL platform description) and the call context (container properties)
• Adaptive off-line sampling and tuning: a heuristic technique to build a run-time predictor of high accuracy with a reduced amount of training executions.
• Access of XPDL platform information (added 2016)

Overview Poster

• PEPPHER Composition Tool: Performance-Aware Dynamic Composition of Applications for GPU-based Systems.
  Poster presented at ACACES-2012 and the HiPEAC-2013 conference.
  Poster PDF

Online manual

• Detailed description of the composition tool prototype

Thesis

• Usman Dastgeer.
  Performance-Aware Component Composition for GPU-based Systems.
  PhD thesis, Linköping Studies in Science and Technology, Dissertation No. 1581, Linköping University, May 2014. (LiU-EP)
  (Full text: LiU-EP; Chapter 5 describes the PEPPHER composition tool.)

Research Papers

• Usman Dastgeer, Lu Li, Christoph Kessler:
  The PEPPHER Composition Tool: Performance-Aware Dynamic Composition of Applications for GPU-based Systems.
  In: Proc. 2012 Int. Workshop on Multi-Core Computing Systems (MuCoCoS 2012), Nov. 16, 2012, Salt Lake City, Utah, USA, in conjunction with Supercomputing Conference (SC12). ISBN 978-1-4673-6218-4, DOI: 10.1109/SC.Companion.2012.97, IEEE.
  Author version (PDF)

• Lu Li, Usman Dastgeer, Christoph Kessler:
  Adaptive off-line tuning for optimized composition of components for heterogeneous many-core systems.
  Proc. Seventh International Workshop on Automatic Performance Tuning (iWAPT-2012), 17 July 2012, Kobe, Japan. In: Proc. VECPAR-2012 Conference, Kobe, Japan, July 2012, Springer LNCS vol. 7851, pp. 329-345, 2013.
  Author-version (PDF)

• Usman Dastgeer and Christoph Kessler:
  Conditional component composition for GPU-based systems.
  Proc. MULTIPROG-2014 workshop at HiPEAC-2014, Vienna, Austria, Jan. 2014.
  Author version (PDF)

• Usman Dastgeer, Lu Li, Christoph Kessler:
  The PEPPHER Composition Tool: Performance-Aware Composition for GPU-based Systems.
  Computing, vol. 96 no. 12 (2014), pages 1195-1211, ISSN 0010-485X (print) Dec. 2014 / 1436-5057 (online), Nov. 2013 (DOI 10.1007/s00607-013-0371-8). Springer.

• Lu Li, Usman Dastgeer, Christoph Kessler:
  Pruning strategies in adaptive off-line tuning for optimized composition of components on heterogeneous systems.
  Parallel Computing 51:37-45, Jan. 2016 (print), DOI: 10.1016/j.parco.2015.09.003.
  - Slides (PDF)

Source code

Applications

• several applications from the RODINIA benchmark suite,
• an ODE Solver,
• a Lightfield Photography (image refocusing) application
• and several small applications/kernels (SpMxV, SGEMM, SGEMV etc.).

Ongoing work