GUM is a portable, parallel implementation of the Haskell functional language. Despite sustained research interest in parallel functional programming, GUM is one of the first such systems to be made publicly available. GUM is message-based, and portability is facilitated by using the PVM communications harness that is available on many multi-processors. As a result, GUM is available for both shared-memory (Sun SPARCserver multiprocessors) and distributed-memory (networks of workstations) architectures. The high message-latency of distributed machines is ameliorated by sending messages asynchronously, and by sending large packets of related data in each message. Initial performance figures demonstrate absolute speedups relative to the best sequential compiler technology. To improve the performance of a parallel Haskell program GUM provides tools for monitoring and visualising the behaviour of threads and of processors during execution.

Programming parallel computers remains a difficult task. An ideal programming environment should enable the user to concentrate on the problem solving activity at a convenient level of abstraction, while managing the intricate low-level details without sacrificing performance. This thesis investigates a model of parallel programming based on the BirdMeertens Formalism (BMF). This is a set of higher-order functions, many of which are implicitly parallel. Programs are expressed in terms of functions borrowed from BMF. A parallel implementation is defined for each of these functions for a particular topology, and the associated execution costs are derived. The topologies which have been considered include the hypercube, 2-D torus, tree and the linear array. An analyser estimates the costs associated with different implementations of a given program and selects a cost-effective one for a given topology. All the analysis is performed at compile-time which has the advantage of reducing run-...

. We discuss why existing implementations of functional languages on MIMD-machines with distributed memory are slow. This is done by comparing the behavior of a functional program with a corresponding Occam program. The main reason is that functional languages give insufficient means to control parallelism and communication. Our approach is to support data parallelism by providing a set of primitives on arrays which allow the user to control the parallelism and communication on a high level, disabling problems like deadlocks. Only one unique version of an array may be referenced at a time. This restriction allows arrays to be updated in place and enables the user to control the space requirements of the program. The uniqueness of arrays is checked by the compiler. Experimental results demonstrate the efficiency of our data parallel functional language. 1 Introduction MIMD machines with distributed memory offer high computation power at relatively low costs. On the other hand, the corr...

John Hughes [10] argues that the ability to decompose a problem into parts, depends upon the ability to `glue' those parts together. A functional programming language such as Haskell [9] provides the user with two powerful kinds of glue: higher order functions and lazy evaluation. Although many data parallel extensions to functional languages exist--- Connection Machine Lisp [16], Paralation Lisp [15], Parallel EuLisp [13], and Tuple [21], they all lack the special glue of a lazy language. This paper describes two data parallel extensions to the lazy functional language Haskell: pods and pod comprehensions. These enable parallel algorithms to be expressed by decomposing a problem into smaller sequential parts, which are then glued together in parallel. We contrast an implementation of a text searching algorithm and an LL(1) parser [7], and show that the parallelism within both can be expressed in terms of the same higher order parallel map and scan functions. In the first example, we...

Parallel graph reducers such as GUM use dynamic techniques to manage resources during execution. One important aspect of the dynamic behaviour is the distribution of work. The load balancing mechanism, which controls this aspect, should be flexible, to adjust the distribution of work to hardware characteristics as well as dynamic program characteristics, and scalable, to achieve high utilisation of all processors even on massively parallel machines.

This paper presents a practical evaluation and comparison of three stateof -the-art parallel functional languages. The evaluation is based on implementations of three typical symbolic computation programs, with performance measured on a Beowulf-class parallel architecture.

A new technique for the management of runtime structures in distributed implementations is presented. Instead of storing the runtime stacks of parallel processes as linked lists of function blocks in a heap structure, the local stacks of several parallel processes, which are executed on the same processor element, are stored in an interleaved manner on a single physical stack, called the meshed stack. The technique originated from the stack organisation in the well known Warren Abstract Machine (WAM) for logic languages, where the runtime information of several alternative computation branches is stored on a single stack.

The research presented in this thesis is about the design and implementation of Naira, a parallel, parallelising compiler for a rich, purely functional programming language. The source language of the compiler is a subset of Haskell 1.2. The front end of Naira is written entirely in the Haskell subset being compiled. Naira has been successfully parallelised and it is the largest successfully parallelised Haskell program having achieved good absolute speedups on a network of SUN workstations. Having the same basic structure as other production compilers of functional languages, Naira's parallelisation technology should carry forward to other functional language compilers. The back end of Naira is written in C and generates parallel code in the C language which is envisioned to be run on distributed-memory machines. The code generator is based on a novel compilation scheme specified using a restricted form of Milner's ß-calculus which achieves asynchronous communication. We present the f...

This report outlines a parallel abstract machine for the implementation of a lazy functional core language. The evaluation transformer model of reduction [1] is used to control the evaluation process. An evaluator space containing parameterised evaluators for structured and polymorphic types is introduced. Using this framework it is possible to handle runtime information about evaluators for arbitrary structured types as well as evaluation transformers for functions over polymorphic types. Institut fr Informatik Fachbereich Mathematik und Informatik Freie Universitt Berlin Takustrae 9 D-14109 Berlin horn@inf.fu-berlin.de http://www.inf.fu-berlin.de/~horn/ 2 3 1 Introduction Because of their referential transparency, pure functional languages are especially well suited for implementation on parallel machines. Since they do not allow side effects, subexpressions can be evaluated in arbitrary order or in parallel. Lazy functional languages with lazy evaluation retain this p...

To support high level coordination, parallel functional languages need eective and automatic work distribution mechanisms. Many implementations distribute potential work, i.e. sparks or closures, but there is good evidence that the performance of certain classes of program can be improved if current work, or threads, are also distributed.