Parallel computers have been successfully deployed in many scientific and numerical application areas, although their use in non-numerical and database applications has been scarce. In this report, we first survey the architectural advancements beginning to make general-purpose parallel computing cost-effective, the requirements for non-numerical (or symbolic) applications, and the previous attempts to develop parallel databases. The central theme of the Bulk Synchronous Parallel model is to provide a high level abstraction of parallel computing hardware whilst providing a realisation of a parallel programming model that enables architecture independent programs to deliver scalable performance on diverse hardware platforms. Therefore, the primary objective of this report is to investigate the feasibility of developing a portable, scalable, parallel object database, based on the Bulk Synchronous Parallel model of computation. In particular, we devise a way of providing high-level abstra...

Skeletons are well-suited to structure parallel programming. They allow the easy use of some well-known parallel programming paradigms to construct portable, efficient programs. Much research has been focused on the use of skeletons in functional programming languages, because they can be expressed elegantly as higher order functions. On the other hand, little attention has been paid to an elementary weakness of skeletons: how to implement them. In this paper we will show that functional languages with some low level constructs for parallelism can be used to efficiently implement a range of high level skeletons. We will construct skeletons for data parallelism, for parallel I/O, and for stream processing. Our experiments demonstrate that no performance penalty needs to be paid, compared to more restrictive solutions. 1. Introduction The development of efficient parallel programs is an important non-trivial problem that programmers and compiler writers have to deal with. The use of fun...

: Traditionally a vectorising compiler matches the iterative constructs of a program against a set of predefined templates. If a loop contains no dependency cycles then a map template can be used; other simple dependencies can often be expressed in terms of fold or scan templates. This paper addresses the template matching problem within the context of functional programming. A small collection of program identities are used to specify vectorisable for-loops. By incorporating these program identities within a monad, all well-typed for-loops in which the body of the loop is expressed using the vectorisation monad can be vectorised. This technique enables the elimination of template matching from a vectorising compiler, and the proof of the safety of vectorisation can be performed by a type inference mechanism. Keywords: Data parallelism; monads; vectorisation; Bird-Meertens formalism; program transformation; category theory; imperative functional programming; non-strict semantics; Has...

The essence of data-parallelism is a O(1) map function. A data-parallel interpretation of map is the application of a function to every element of a parallel data structure at the same time. This model is at odds with a version of map over lists. Although list map can be interpreted as applying a function to every element of a list, in a non-strict functional language the function applications only occur to those elements of the list required by a subsequent computation. We reconcile these opposing views of map using a three tiered model: (1) a non-strict data-parallel evaluation mechanism based upon `aims' [5] is used that combines the "only evaluate what is required" philosophy of non-strict evaluation, with the "evaluate everything synchronously, and in parallel" mechanism of a data-parallel paradigm; (2) program transformations inspired by the map distributivity law are used to vectorize functional programs that contain map; (3) the resulting vectorized programs are compiled into ...

It has long been known that some of the most common uses of for and while-loops in imperative programs can easily be expressed using the standard higher-order functions fold and map. With this correspondence as a starting point, we derive parallel implementations of various iterative constructs, each having a better complexity than their sequential counterparts, and explore the use of monads to guarantee the soundness of the parallel implementation. As an aid to the presentation of the material, we use the proposed syntax for parallel Haskell [27] (figure 1) as a vehicle in which imperative functional programs will be expressed. Surprisingly, incorporating imperative features into a purely functional language has become an active area of research within the functional programming community [30, 24, 36, 20]. One of the techniques gaining widespread acceptance as a model for imperative functional programming is monads [38, 37, 26]. Typically monads are used to guarantee single threadedn...

The role of a vectorising compiler for an imperative language is to transform the for-loops of a program into the vector instructions of a data-parallel machine. In a functional language, constant complexity map is the essence of data-parallelism, where a function is applied to every element of a data-structure all at the same time. As map can be considered to be an abstraction of an imperative for-loop, 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 data-types are transformed into a form that is susceptible to the synchronous parallel evaluation on a data-parallel 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...

This is the final report on the GRASP project, carried out under SERC grants GR/F34671 and GR/F98444, at Glasgow University 1 2 . The project supported two Principal Investigators (Simon Peyton Jones and Phil Wadler), and three Research Assistants (Kevin Hammond, Cordelia Hall and Will Partain). Four research students have worked in close association with the project. 1 Summary The purpose of GRASP was to help get the technology of functional programming out of the lab and into the hands of practitioners, by producing robust and usable compilers and profilers for these languages, on both sequential and parallel systems. The main achievements of the project are as follows: ffl We have played a key role in the development of a common international non-strict functional language, Haskell (Hudak et al. [1992]). This standardisation effort has led directly to a considerable focussing of the international research community in these languages. More details about Haskell are given in Sect...

A data-parallel style of programming is one method of utilising the enormous computing power available on today's parallel machines. It is becoming clear that the dataparallel paradigm is not tied to a particular "flavour" of parallel architecture, be it Single Instruction Multiple Data-stream (SIMD) or Multiple Instruction Multiple Data-stream (MIMD). The purpose of this paper is to give an introduction to the basic techniques that form the building blocks of a data-parallel paradigm. The combinatorial search problem of finding the shortest path between two nodes in a graph is investigated, and two parallel solutions are presented. The first is based upon the scan algorithm that forms the heart of many data-parallel applications; the second uses a technique from the parallel solution of a computational fluid dynamics problem. The examples demonstrate that a parallel solution to a given problem may not necessarily bear any resemblance to a sequential solution---although the parallel te...