Results 1 
9 of
9
Architecture Independent Massive Parallelization of DivideandConquer Algorithms
 Mathematics of Program Construction, Lecture Notes in Computer Science 947
, 1995
"... . We present a strategy to develop, in a functional setting, correct, efficient and portable DivideandConquer (DC) programs for massively parallel architectures. Starting from an operational DC program, mapping sequences to sequences, we apply a set of semantics preserving transformation rules, wh ..."
Abstract

Cited by 9 (1 self)
 Add to MetaCart
. We present a strategy to develop, in a functional setting, correct, efficient and portable DivideandConquer (DC) programs for massively parallel architectures. Starting from an operational DC program, mapping sequences to sequences, we apply a set of semantics preserving transformation rules, which transform the parallel control structure of DC into a sequential control flow, thereby making the implicit data parallelism in a DC scheme explicit. In the next phase of our strategy, the parallel architecture is fully expressed, where `architecture dependent' higherorder functions are introduced. Then  due to the rising communication complexities on particular architectures  topology dependent communication patterns are optimized in order to reduce the overall communication costs. The advantages of this approach are manifold and are demonstrated with a set of nontrivial examples. 1 Introduction It is wellknown that the main problems in exploiting the power of modern parallel sys...
From Transformations to Methodology in Parallel Program Development: A Case Study
 Microprocessing and Microprogramming
, 1996
"... The BirdMeertens formalism (BMF) of higherorder functions over lists is a mathematical framework supporting formal derivation of algorithms from functional specifications. This paper reports results of a case study on the systematic use of BMF in the process of parallel program development. We dev ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
The BirdMeertens formalism (BMF) of higherorder functions over lists is a mathematical framework supporting formal derivation of algorithms from functional specifications. This paper reports results of a case study on the systematic use of BMF in the process of parallel program development. We develop a parallel program for polynomial multiplication, starting with a straightforward mathematical specification and arriving at the target processor topology together with a program for each processor of it. The development process is based on formal transformations; design decisions concerning data partitioning, processor interconnections, etc. are governed by formal type analysis and performance estimation rather than made ad hoc. The parallel target implementation is parameterized for an arbitrary number of processors; for the particular number, the target program is both time and costoptimal. We compare our results with systolic solutions to polynomial multiplication.
An overview of the Adl language project
, 1995
"... The purpose of the Adl project is to demonstrate the efficient implementation of data parallel functional programming, firstly on the TMC CM5 but ultimately on other parallel machines. We have designed a small polymorphic nonrecursive language (Adl), which emphasizes highlevel operations (second ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
The purpose of the Adl project is to demonstrate the efficient implementation of data parallel functional programming, firstly on the TMC CM5 but ultimately on other parallel machines. We have designed a small polymorphic nonrecursive language (Adl), which emphasizes highlevel operations (secondorder combinators) on aggregate structures. The Adl project incorporates the formal description of Adl semantics, translation and optimization, and the design of an abstract dataparallel machine which describes not only the CM5 but also other distributed memory multicomputers and hence encourages architectureindependent code generation. An executable natural semantic description of translation to the BirdMeertens Formalism (BMF) has been completed; similar techniques are being used with an optimizer. We also describe an implementation of the abstract machine for the CM5 implementation. 1 Introduction Exploitation of parallelism in applications is a very attractive concept, but there is...
Formal Derivation of Parallel Program for 2Dimensional Maximum Segment Sum Problem
 In Annual European Conference on Parallel Processing, LNCS 1123
, 1996
"... . It has been attracting much attention to make use of list homomorphisms in parallel programming because they ideally suit the divideandconquer parallel paradigm. However, they have been usually treated rather informally and adhoc in the development of efficient parallel programs. This paper rep ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
. It has been attracting much attention to make use of list homomorphisms in parallel programming because they ideally suit the divideandconquer parallel paradigm. However, they have been usually treated rather informally and adhoc 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 2dimensional 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...
Vectorising a NonStrict DataParallel Functional Language
"... The role of a vectorising compiler for an imperative language is to transform the forloops of a program into the vector instructions of a dataparallel machine. In a functional language, constant complexity map is the essence of dataparallelism, where a function is applied to every element of a da ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
The role of a vectorising compiler for an imperative language is to transform the forloops of a program into the vector instructions of a dataparallel machine. In a functional language, constant complexity map is the essence of dataparallelism, where a function is applied to every element of a datastructure all at the same time. As map can be considered to be an abstraction of an imperative forloop, the goal of vectorising a functional language is to transform map expressions into vector operations. This paper presents a vectorisation process in terms of transformations to programs expressed in an extended calculus. Of particular interest is the way in which algebraic datatypes are transformed into a form that is susceptible to the synchronous parallel evaluation on a dataparallel machine. Results are presented for a vectorising Haskell compiler that generates code for the CPP DAP, a massively parallel SIMD machine. 1 Liberation from the von Neumann bottleneck Backus [3] ide...
Descriptive Simplicity in Parallel Computing
, 1997
"... 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. ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
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.
An introduction to the theories of bulk data types
, 1994
"... This note summarises my understanding to date of two closelyrelated theories for dealing with “bulk ” data types: the BirdMeertens 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 formalism ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
This note summarises my understanding to date of two closelyrelated theories for dealing with “bulk ” data types: the BirdMeertens 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 higherorder 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 smallscale theory leads to potentially largescale 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
Constructing List Homomorphisms for Parallelism
"... List homomorphisms are functions which can be efficiently computed in parallel since they suit the divideandconquer paradigm ideally. We propose a simple approach to testing whether a function is a homomorphism and, if so, determining how it can be parallelized. The approach is based on analyzing ..."
Abstract
 Add to MetaCart
List homomorphisms are functions which can be efficiently computed in parallel since they suit the divideandconquer paradigm ideally. We propose a simple approach to testing whether a function is a homomorphism and, if so, determining how it can be parallelized. The approach is based on analyzing two inherently sequential representations of functions based on cons and snoclists. For some interesting functions which are not homomorphisms, e.g. the maximum segment sum problem, our method provides a systematic way of embedding into a homomorphism.