Homomorphisms are functions which can be parallelized by the divide-and-conquer paradigm. A class of distributable homomorphisms (DH) is introduced and an efficient parallel implementation schema for all functions of the class is derived by transformations in the Bird-Meertens formalism. The schema can be directly mapped on the hypercube with an unlimited or an arbitrary fixed number of processors, providing provable correctness and predictable performance. The popular scan-function (parallel prefix) illustrates the presentation: the systematically derived implementation for scan coincides with the practically used "folklore" algorithm for distributed-memory machines.

Algorithmic skeletons are seen as being high-level, parallel programming language constructs encapsulating the expression of parallelism, communication, synchronisation, embedding, and costing. This report examines the classification of algorithmic skeletons, proposing one classification, and examining others which have been devised. Various algorithmic skeletons are examined, and these are categorised to form a core of algorithmic skeletons suitable for a general classification which is based on practical experience in the use of such skeletons. This categorisation is compared with others which have been proposed. Similarly, other skeleton-like approaches are briefly examined. 1 Introduction 1.1 Algorithmic Skeletons Algorithmic skeletons are envisaged as high-level, parallel programming language constructs encapsulating the expression of parallelism, communication, synchronisation and embedding, and having an associated cost complexity. Skeletons are to parallel threads as sequenti...

this paper, we study functions called list homomorphisms, which represent a particular pattern of parallelism.

Some skeleton based parallel programming models allow the programmer to use both data and stream parallel skeletons within the same program. It is known that particular skeleton nestings can be formally rewritten into different nestings that preserve the functional semantics. Indeed, the kind and possibly the amount of parallelism usefully exploitable may change while rewriting takes place. Here we discuss an original framework allowing the user (and/or the compiling tools) of a skeleton based parallel programming language to evaluate whether or not the transformation of a skeleton program is worthwhile in terms of the nal program performance. We address, in particular, the evaluation of transformations exchanging data parallel and stream parallel skeleton subtrees.

Any parallel programming language provides a model of parallelism, and one can write a program directly in the language, accepting the fixed given model. We propose an alternative methodology: the program is derived in a sequence of steps, where each step incorporates just one decision, and is based on a specific model of parallelism, called an abstract parallel machine, which is chosen to be suitable for that step. Each step is proved equivalent to the previous one. There is a family of related abstract parallel machines; each one is described by a set of parallel operations describing its behavior, and is related to similar abstract parallel machines by transformation theorems. In this paper we present the formalism for abstract parallel machines and illustrate the derivation process with two case studies.

This paper reports a case study in the development of parallel programs in the Bird-Meertens formalism (BMF), starting from divide-and-conquer algorithm specifications. The contribution of the paper is two-fold: (1) we classify divide-and-conquer algorithms and formally derive a parameterized family of parallel implementations for an important subclass of divide-and-conquer, called DH (distributable homomorphisms); (2) we systematically adjust the mathematical specification of the Fast Fourier Transform (FFT) to the DH format and thereby obtain a generic SPMD program, well suited for implementation under MPI. The target program includes the efficient FFT solutions used in practice the binary-exchange and the 2D- and 3D-transpose implementations as its special cases.