Section: Scientific Foundations
Adaptive Parallel and Distributed Algorithms Design
Participants : PierreFrançois Dutot, Thierry Gautier, Guillaume Huard, Bruno Raffin, JeanLouis Roch, Denis Trystram, Frédéric Wagner.
This theme deals with the analysis and the design of algorithmic schemes that control (statically or dynamically) the grain of interactive applications.
The classical approach consists in setting in advance the number of processors for an application, the execution being limited to the use of these processors. This approach is restricted to a constant number of identical resources and for regular computations. To deal with irregularity (data and/or computations on the one hand; heterogeneous and/or dynamical resources on the other hand), an alternate approach consists in adapting the potential parallelism degree to the one suited to the resources. Two cases are distinguished:

in the classical bottomup approach, the application provides fine grain tasks; then those tasks are clustered to obtain a minimal parallel degree.

the topdown approach (Cilk, Hood, Athapascan) is based on a workstealing scheduling driven by idle resources. A local sequential depthfirst execution of tasks is favored when recursive parallelism is available.
Ideally, a good parallel execution can be viewed as a flow of computations flowing through resources with no control overhead. To minimize control overhead, the application has to be adapted: a parallel algorithm on p resources is not efficient on q<p resources. On one processor, the scheduler should execute a sequential algorithm instead of emulating a parallel one. Then, the scheduler should adapt to resource availability by changing its underlying algorithm. This first way of adapting granularity is implemented by Kaapi (default workstealing schedule based on workfirst principle); an implementation of Athapascan, the parallel programming interface developed by the APACHE project, is available on top of Kaapi.
However, this adaptation is restrictive. More generally, the algorithm should adapt itself at runtime to improve its performance by decreasing the overheads induced by parallelism, namely the arithmetic operations and communications. This motivates the development of new parallel algorithmic schemes that enable the scheduler to control the distribution between computation and communication (grain) in the application to find the good balance between parallelism and synchronizations. MOAIS has exhibited several techniques to manage adaptivity from an algorithmic point of view:

amortization of the number of global synchronizations required in an iteration (for the evaluation of a stopping criterion);

adaptive deployment of an application based on online discovery and performance measurements of communication links;

generic recursive cascading of two kind of algorithms: a sequential one, to provide efficient executions on the local resource, and a parallel one that enables an idle resource to extract parallelism to dynamically suit the degree of parallelism to the available resources.
The generic underlying approach consists in finding a good mix of various algorithms, what is often called a "polyalgorithm". Particular instances of this approach are Atlas library (performance benchmark are used to decide at compile time the best block size and instruction interleaving for sequential matrix product) and FFTW library (at run time, the best recursive splitting of the FFT butterfly scheme is precomputed by dynamic programming). Both cases rely on prebenchmarking of the algorithms. Our approach is more general in the sense that it also enables to tune the granularity at any time during execution. The objective is to develop processor oblivious algorithms: similarly to cache oblivious algorithms, we define a parallel algorithm as processoroblivious if no program variable that depends on architecture parameters, such as the number or processors or their respective speeds, needs to be tuned to minimize the algorithm runtime.
We have applied this technique to develop processor oblivious algorithms for several applications with provable performance: iterated and prefix sum (partial sums) computations, stream computations (cipher and hdvideo transformation), 3D image reconstruction (based on the concurrent usage of multicore and GPU), loop computations with early termination. Finally, to validate these novel parallel computation schemes, we developed a tool named KRASH. This tool is able to generate dynamic CPU load in a reproducible way on manycores machines. Thus, by providing the same experimental conditions to several parallel applications, it enables users to evaluate the efficiency of resource uses for each approach.
This adaptation technique is now integrated in softwares that we are developing with external partners within contracts. In particular, in partnership with STM within the Minalogic SCEPTRE contract (completed in Q4 2009), we have developed a specific optimized C interface, dedicated to stream computation for multiprocessor system on chips (MPSoC); this interface is named AWS (Adaptive WorkStealing).
Besides, we developed a parallel implementation of the C++ Standard Template Library STL on top of Kaapi; this library, named KaSTL, provides adaptive parallel algorithms for distributed containers (such as transform, foreach and findif on vectors). By optimizing the workstealing to our adaptive algorithm scheme, a new nonblocking (waitfree) implementation of Kaapi has been designed. A first prototype of this C library, named XKaapi, will be delivered to STM in Q4 2009. The benchmarks experimented on SMPs and NUMAs architectures provides good performances with respect to concurrent libraries MCSTL, PaSTL, Intel TBB, and Cilk++, while improving the grain where parallelism can be exploited.
Extensions concern the development of algorithms that are both cache and processor oblivious. The processor algorithms proposed for prefix sums and segmentation of an array are cache oblivious too. We are currently working on sorting and mesh partitioning within a collaboration with the CEA.