Quaff: efficient C++ design for parallel skeletons

Abstract

We present Quaff, a new skeleton-based parallel programming library. Its main originality is to rely on C++ template meta-programming techniques to achieve high efficiency. In particular, by performing most of skeleton instantiation and optimization at compile-time, Quaff can keep the overhead traditionally associated to object-oriented implementations of skeleton-based parallel programming libraries very small. This is not done at the expense of expressivity. This is demonstrated in this paper by several applications, including a full-fledged, realistic real-time vision application.

Introduction

Modern parallel programming on MIMD machines is usually carried out using message-passing libraries. These libraries, such as PVM or MPI, provide a standardized, platform independent way to build parallel applications. However, manipulating such low level frameworks is difficult and error prone. Deadlocks and other common undesired behaviors make parallel software development very slow compared to classic, sequential one. Algorithmic skeletons [5], [6] have been proposed as a solution to these problems. They are typical parallel patterns that can be implemented once on a given platform. Building parallel software using algorithmic skeletons boils down to combining skeletons and sequential code fragments. In practice, approaches based upon skeletons can be divided into three main classes:

• New languages embedding skeleton patterns in their syntax. This approach can offer good performances but requires the programmer to learn a new language, which can viewed as an obstacle to the adoption of this paradigm.

• Parallel compilers for an existing language. Such compilers aim at identifying parallel structures in existing sequential code and use specific parallel implementation for those structures [20].

• High-level libraries for an existing language. Such solutions are more easily accepted by developers as they allow them to reuse existing code and to work with a familiar environment.

We focus here on approaches based upon high-level libraries for an existing language. This is the way taken, for example, by the BSMLLib [17], Lithium [9], [2], eSkel [6] and Muesli [15] projects.¹ The most challenging issue, for such a library is to find a good trade-off between readability and efficiency. By readability we mean the ability to express parallelism with a minimum concern for implementation details. By efficiency we mean the ability to produce code whose performances can stay on the par with those obtained using a low-level message passing like MPI. These features are clearly in tension with each other. For example, eSkel can produce very efficient code but at the expense of a rather low-level API (with a lot of MPI-specific idioms visible). By contrast, a library such as Muesli exposes a much more abstract and simple API but incurs a significantly higher overhead at runtime. This overhead can be mostly explained by the fact that this library uses an abstract class hierarchy to embed user-defined tasks within the skeleton structure of the application, resulting in repeated virtual function calls at run-time. This is unfortunate because, within skeleton-based parallel programming models, the overall structure of the application, i.e., the combination of parallel skeletons and user-defined sequential functions is essentially static.

The library described in this paper, named Quaff, aims at reducing the aforementioned tension. For this, it relies on C++ compilation techniques such as template meta-programming to reduce the runtime overhead of classical object-oriented implementations of skeleton-based parallel programming libraries to the strict minimum, while keeping a high-level of expressivity and readability. Quaff also enforces the re-usability of legacy code or third party libraries by limiting its impact on existing code.

This paper is organized as follows. The Quaff programming model is introduced in Section 2, with simple examples. Section 3 presents the implementation, with quaff, of a full-fledged vision application, showing its ability to handle complex, realistic situations while still producing very efficient code. Section 4 details the implementation techniques used for turning Quaff programs into optimized MPI code. Section 5 is a short review of related work and Section 6 concludes the paper.