Functional programming and parallel graph rewriting

1997

A methodology is developed for mapping a wide class of concurrent logic languages (CLLs) onto Dactl, a compiler target language based on generalized graph rewriting. We show how features particular to the generalized graph rewriting model (such as non-root overwrites and sharing) can be used to implement CLLs. We identify problems in the mapping of a concurrent logic program to an equivalent set of rewrite rules and provide solutions. We also show some important optimizations and compilation techniques that can be adopted in the process. Finally, we take advantage of the underlying graph reduction model to enhance a concurrent logic program with some capabilities found usually only in functional languages such as lazy evaluation, sharing of computation and higher order programming.

Lean is an experimental language for specifying computations in terms of graph rewriting. It is based on an alternative to Term Rewriting Systems (TRS) in which the terms are replaced by graphs. Such a Graph Rewriting System (GRS) consists of a set of graph rewrite rules which specify how a graph may be rewritten. Besides supporting functional programming, Lean also describes imperative constructs and allows the manipulation of cyclic graphs. Programs may exhibit non-determinism as well as parallelism. In particular, Lean can serve as an intermediate language between declarative languages and machine architectures, both sequential and parallel. This paper is a revised version of Barendregt et al. (1987b) which was presented at the ESPRIT, PARLE conference in Eindhoven, The Netherlands, June 1987.

Lecture Notes in Computer Science

Lean is an experimental language for specifying computations in terms of graph rewriting. It is based on an alternative to Term Rewriting Systems (TRS) in which the terms are replaced by graphs. Such a Graph Rewriting System (GRS) consists of a set of graph rewrite rules which specify how a graph may be rewritten. Besides supporting functional programming, Lean also describes imperative constructs and allows the manipulation of cyclic graphs. Programs may exhibit non-determinism as well as parallelism. In particular, Lean can serve as an intermediate language between declarative languages and machine architectures, both sequential and parallel.

1992

The seminar emphasized four issues: o sta.tic program analysis o extensions for progra.mmer control of pa.ra.llelism o functional+logic languages and constraints o implementa.tion of functiona.l la.ngua.ges There were two formal discussion sessions, which a.ddressed the problems of input/output in functional la.nguages, and the utility of static program analysis. It is gratifying that the first Dagstuhl seminar in this area. (Functional Languages: Optimization for Parallelism) had stimulated many developments which were reported a.t this one. A particular feature of this seminar was the la.rge number of prototypes which were demonstrated a.nd which vividly illustrated the issues raised in discussions and presentations. Static Program Analysis Static program analysis has been thoroughly investigated for optimising sequential implementations, but parallel ones offer new problems. Discovering properties of synchronisation, for example, requires richer domains than those used in the sequential setting, lea.ding to a combinatorial explosion in cost. Current sequential analyses operate at or beyond the limits of today s algorithm technology. The most expensive aspect is computing xpoints, which requires a convergence test am] therefore a decision procedure for equality of abstract values. New work reported here helps reduce the need for convergence tests. and, using the algebraic properties of the operators in the resulting straightline code, partial evaluation ca.n be used to generate very efficient parallel code with a high degree of processor utilization. This is exempli ed by the well-known problem of parallel evaluation of expressions (and, more generally, straight-line code) over a semi-ring. In this context, partial evaluation is evaluation over the induced polynomial semi-ring that can be executed in parallel by tree contraction.

1996

1994

Parallel functional programming has a relatively long history. Burge was one of the first to suggest the basic technique of evaluating function arguments in parallel, with the possibility of functions absorbing unevaluated arguments and perhaps also exploiting speculative evaluation 22]. Berkling also considered the application of functional languages to parallel processing 17].

Journal of Programming Languages, 1997

A generalized computational model based on graph rewriting is presented along with Dactl, an associated compiler target (intermediate) language. An illustration of the capability of graph rewriting to model a variety of computational formalisms is presented by showing how some examples written originally in a number of languages can be described as graph rewriting transformations using Dactl notation. This is followed by a formal presentation of the Dactl model before giving a formal definition of the syntax and semantics of the language. Some implementation issues are also discussed.

Lecture Notes in Computer Science, 2001

We identify a set of programming constructs ensuring that a programming language based on graph transformation is computationally complete. These constructs are (1) nondeterministic application of a set of graph transformation rules, (2) sequential composition and (3) iteration. This language is minimal in that omitting either sequential composition or iteration results in a computationally incomplete language. By computational completeness we refer to the ability to compute every computable partial function on labelled graphs. Our completeness proof is based on graph transformation programs which encode arbitrary graphs as strings, simulate Turing machines on these strings, and decode the resulting strings back into graphs.

Theoretical Computer Science, 2001

A framework is presented for designing parallel programming languages whose semantics is functional and where communications are explicit. To this end, Brookes and Geva's generalized concrete data structures are specialized with a notion of explicit data layout to yield a CCC of distributed structures called arrays. Arrays' symmetric replicated structures, suggested by the data-parallel SPMD paradigm, are found to be incompatible with sum types. We then outline a functional language with explicitly distributed (monomorphic) concrete types, including higher-order, sum and recursive ones. In this language, programs can be as large as the network and can observe communication events in other programs. Such exibility is missing from current data-parallel languages and amounts to a fusion with their so-called annotations, directives or meta-languages.