The PEPPHER Composition Tool is a research prototype developed at
Linköping University (Sweden),
as part of the EU FP7 project PEPPHER (2010-2012).
The main functionality of the current version of the composition tool
is to compose C/C++ based applications for heterogeneous multi-/manycore systems
from application-level building blocks (components)
that are written and annotated using the
PEPPHER component 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 open-source StarPU runtime system) to do
the composition at runtime (i.e. dynamic composition). Besides dynamic composition, it supports user-guided static composition.
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.
void sort(float *arr, int size);Besides function declaration, an interface has an assosiated XML descriptor which models extra information about the interface. This includes information about:
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)
{
...
}
Like component interfaces, each PEPPHER component implementation has an associated XML descriptor describing this implementation's meta-data.
The descriptor specifies:
This work was funded by EU FP7 project PEPPHER during 2010-2012 period.
Its current development is partly funded by SeRC-OpCoReS and Vetenskapsrådet.