. An SPMD parallel implementation schema for divide-and-conquer specifications is proposed and derived by formal refinement (transformation) of the specification. The specification is in the form of a mutually recursive functional definition. In a first phase, a parallel functional program schema is constructed which consists of a communication tree and a functional program that is shared by all nodes of the tree. The fact that this phase proceeds by semanticspreserving transformations in the Bird-Meertens formalism of higher-order functions guarantees the correctness of the resulting functional implementation. A second phase yields an imperative distributed message-passing implementation of this schema. The derivation process is illustrated with an example: a twodimensional numerical integration algorithm. 1. Introduction One of the main problems in exploiting modern multiprocessor systems is how to develop correct and efficient programs for them. We address this problem using the ap...

The purpose of the Adl project is to demonstrate the efficient implementation of data parallel functional programming, firstly on the TMC CM-5 but ultimately on other parallel machines. We have designed a small polymorphic non-recursive language (Adl), which emphasizes high-level operations (second-order combinators) on aggregate structures. The Adl project incorporates the formal description of Adl semantics, translation and optimization, and the design of an abstract data-parallel machine which describes not only the CM-5 but also other distributed memory multicomputers and hence encourages architecture-independent code generation. An executable natural semantic description of translation to the Bird-Meertens Formalism (BMF) has been completed; similar techniques are being used with an optimizer. We also describe an implementation of the abstract machine for the CM-5 implementation. 1 Introduction Exploitation of parallelism in applications is a very attractive concept, but there is...

. It has been attracting much attention to make use of list homomorphisms in parallel programming because they ideally suit the divide-and-conquer parallel paradigm. However, they have been usually treated rather informally and ad-hoc in the development of efficient parallel programs. This paper reports a case study on systematic and formal development of a new parallel program for the 2-dimensional maximum segment problem. We show how a straightforward, and "obviously" correct, but quite inefficient solution to the problem can be successfully turned into a semantically equivalent "almost list homomorphism" based on two transformations, namely tupling and fusion, which are defined according to the specific recursive structures of list homomorphisms. 1 Introduction It has been attracting wide attention to make use of list homomorphisms in parallel programming. List homomorphisms are those functions on finite lists that promote through list concatenation --- that is, function h for whic...

While tree contraction algorithms play an important role in e#cient tree computation in parallel, it is di#cult to develop such algorithms due to the strict conditions imposed on contracting operators. In this paper, we propose a systematic method of deriving e#cient tree contraction algorithms from recursive functions on trees in any shape. We identify a general recursive form that can be parallelized to obtain e#cient tree contraction algorithms, and present a derivation strategy for transforming general recursive functions to parallelizable form. We illustrate our approach by deriving a novel parallel algorithm for the maximum connected-set sum problem on arbitrary trees, the tree-version of the famous maximum segment sum problem.

This note summarises my understanding to date of two closely-related theories for dealing with “bulk ” data types: the Bird-Meertens formalism (henceforth abbreviated to BMF) and its extension in categorical data types (CDT). I've been led to this study for two reasons: as interesting formalisms for program derivation in their own right, and as a possible basis for defining useful operations for shared abstract data types. In this note I cover all the essential ideas I've found so far, and include a bibliography of the theories. Overview specifications using a small number of higher-order constructs. Functions are expressed as combinations of functions over data structures, avoiding the explicit use of recursion. This both simplifies proofs of correctness and allows the possibility for efficient (possibly parallel) implementation of the combination operators over a range of data types. A small-scale theory leads to potentially large-scale applications. The theory does not, however, start from a standpoint of immediate mechanisation. To do so, in Bird and Meertens ' view, would severely limit the many ways in which an

and there currently exist a wide selection of parallel programming languages and environments. This thesis presents and examines the Hierarchical Skeleton Model (HSM), a model of parallel programming that combines ease of use, portability and flexibility.

A supercomputer implementation of a functional data parallel language

Trees are useful data structures, but to design e#cient parallel programs over trees is known to be more di#cult than to do over lists. Although several important tree skeletons have been proposed to simplify parallel programming on trees, few studies have been reported on how to systematically use them in solving practical problems; it is neither clear how to make a good combination of skeletons to solve a given problem, nor obvious how to find suitable operators used in a single skeleton. In this paper, we report our first attempt to resolve these problems, proposing two important transformations, the tree di#usion transformation and the tree context preservation transformation. The tree di#usion transformation allows one to use familiar recursive definitions to develop his parallel programs, while the tree context preservation transformation shows how to derive associative operators that are required when using tree skeletons. We illustrate our approach by deriving an e#cient parallel program for solving a nontrivial problem called the party planning problem, the tree version of the famous maximum-weight-sum problem.