The process of writing large parallel programs is complicated by the need to specify both the parallel behaviour of the program and the algorithm that is to be used to compute its result. This paper introduces evaluation strategies, lazy higher-order functions that control the parallel evaluation of non-strict functional languages. Using evaluation strategies, it is possible to achieve a clean separation between algorithmic and behavioural code. The result is enhanced clarity and shorter parallel programs. Evaluation strategies are a very general concept: this paper shows how they can be used to model a wide range of commonly used programming paradigms, including divideand -conquer, pipeline parallelism, producer/consumer parallelism, and data-oriented parallelism. Because they are based on unrestricted higher-order functions, they can also capture irregular parallel structures. Evaluation strategies are not just of theoretical interest: they have evolved out of our experience in parallelising several large-scale applications, where they have proved invaluable in helping to manage the complexities of parallel behaviour. These applications are described in detail here. The largest application we have studied to date, Lolita, is a 60,000 line natural language parser. Initial results show that for these applications we can achieve acceptable parallel performance, while incurring minimal overhead for using evaluation strategies.

Abstract not found

Machine [Ber90] than a traditional graph reduction machine. 6 Results A translator has been developed which will convert "programs" in an extended -Calculus to the process notation. Several different translations from -Calculus to processes have been implemented. The process networks are converted to the sublanguage which makes heavy use of agent definitions. This form is then converted to Dactl. The mapping from process notation to Dactl does not handle non-trivial processes with output guards (only inaction may follow an output guard). This enables us to express the new translation directly, but the ß-Calculus translations of Milner cannot be translated directly. A Form of the Lazy- -Calculus translation modified in a manner inspired by [Hon91] has been produced. The translation is extended to handle constants. This has been called PiLazy: [[x]] u = x!u:() [[k]] u = u?v : v!k:() [[x:M ]] u = u?d: ( d!a:() j a?x: u?v: [[M ]] v )na [[M @L N ]] u = ( [[M ]] v j v!d:() j d?a: (a!t...

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...

Honda and Tokoro provide a formal system for communicating systems developed from Milner’s π–calculus. Unlike other formalisms, their work is based on asynchronous communication primitives. This paper proposes some minor but practically significant extensions to a model based on asynchronous communication and shows how the resulting system may be mapped very directly onto a graph rewriting system. While the model based on asynchronous communication permits the most direct translation, a related model using synchronous communication may be implemented in a similar

ion Lawrence A. Crowl Oregon State University and Thomas J. LeBlanc University of Rochester Parallel programming involves finding the potential parallelism in an application and mapping it to the architecture at hand. Since a typical application has more potential parallelism than any single architecture can exploit effectively, programmers usually limit their focus to the parallelism that the available control constructs express easily and that the given architecture exploits efficiently. This approach produces programs that exhibit much less parallelism than exists in the application, and whose performance depends critically on the underlying hardware and software. We argue for an alternative approach based on control abstraction. Control abstraction is the process by which programmers define new control constructs, specifying constraints on statement ordering separately from an implementation of that ordering. With control abstraction programmers can define and use a rich variety o...

We report work in progress on the implementation of languages that integrate concurrent and functional programming styles. A translation scheme is presented for mapping such languages into process networks using a simple notation based on communication between named processes. The translation of functional code is sequential, but parallelism arises from use of concurrency constructs in the source language. Early implementation experiments have used graph rewriting techniques, although work on a more direct implementation is in progress. 1 Introduction and Background This paper reports work done at ECRC in close collaboration with Bent Thomsen and Lone Leth. The work has focussed on techniques for implementing the Facile language [GPM89] which enhances the --calculus with primitives for process spawning and channel-based communication in the style of CCS [Mil80]. Recent work by Milner using the ß--calculus [MPW89] and its polyadic form [Mil91] shows that a --expression may be translate...

In this paper ' we investigate the problem of parallel evaluation of functional programs. We have developed a novel approach to deal with sharing in graph reduction. Share nodes are introduced to explicitly handle sharing. By using share nodes, we have a garbage collection method that is on-the-fly (real time), parallel. distributed. and incremental. In our parallel graph reducer, copying can be done in parallel to make an exponential growth of program tree nodes. Since each node represents a simple operation, the growth of program trees is a natural distri-bution of computation work. Load balancing becomes very easy and can be done automatically. A simulator is implemented to simulate a tree structured parallel com-puter to run our graph reducer. Examples such as parallel matrix addition and multiplication are tested. 1.

ing out and studying those patterns of computation as useful objects in their own right leads to further insights into the nature of computation. The list operators studied later in these notes follow this approach. ffl Functional programs are usually an order of magnitude more concise than their imperative counterparts. Besides being shorter, they can be much more readable. The functional community like to cite studies that show the number of bugs per line is more or less constant, independent of the level of the language in use. Higher-level languages encode more concept per line, and therefore have relatively fewer bugs. ffl Functional programs are often more akin to formal specifications than their conventional counterparts. A good notation goes a long way towards solving the problem[47]. ffl Lazy evaluation permits a new approach to some algorithms. It is a simple but powerful idea that can remove the need for explicit backtracking, and can allow the programmer to manipulate in...

In this paper, we present a new parallel and multi-threaded implementation of functional programs. The execution is based on a new parallel evaluation scheme of functional languages named P 3 . The implementation consists of two phases: the first one statically tansforms the program in order to increase the granularity of parallelism ; the second phase translates the transformed program in an intermediate multi-threaded, distributed and compilable language. At the first stage, we use a new approach, named GRANIT, of implicit granularity management. It consists of three kinds of grouping: the gathering of the functions of the program into functional packets, each of these must be executed, a priori, sequentially ; the abstract grouping of the data into windows: for each packet, one computes by abstract execution its window i.e. the part of the data really necessary for its execution ; and the association of the packets with their windows. The concrete grouping of the data is achieved ...