Parallel graph rewriting on loosely coupled machine architectures

Abstract

Graph rewriting models are very suited to serve as the basic computational model for functional languages and their implementation. Graphs are used to share computations which is needed to make efficient implementations of functional languages on sequential hardware possible. When graphs are rewritten (reduced) on parallel loosely coupled machine architectures, subgraphs have to be copied from one processor to another such that sharing is lost. In this paper we introduce the notion of lazy copying. With lazy copying it is possible to duplicate a graph without duplicating work. Lazy copying can be combined with simple mmotations which control the order of reduction. In principle, only interleaved execution of the individual reduction steps is possible. However, a condition is deduced under which parallel execution is allowed. When only certain combinations of lazy copying and annotations are used it is guarantied that this so-called non-interference condition is fulfilled. Abbreviations for these combinations are introduced. Now complex process behavlours, such as process communication on a loosely coupled parallel machine architecture, can be modelled. This also includes a special case: modelling mnltlprocessing on a single processor. Arbitrary process topologies can be created. Synchronous and asyncbronons process communication can be modelled. The implementation of the language Concurrent Clean, which is based on the proposed graph rewriting model, has shown that complicated parallel algorithms which can go far beyond divide-and-conquar like applications can be expressed. 1 I n t r o d u c t i o n Ideally, a computational model of a language is a formal model as close as possible to both its semantics and its implementation, still it models only the essential aspects of them. In the following paragraphs it is explained why Graph Rewriting Systems (GRS*s) are suited to serve as a computational model of functional languages and their implementations. After that, GRS's are extended in order to deal with parallel evaluation. Graph rewriting systems and functional languages Our prime interests are functional languages and their implementation on sequential and parallel hardware. Traditionally. the pure lambda calculus (Church (1932/3). Barendregt (1984)) is considered to be a suitable model for these languages. However, in our opinion, some important aspects of functional languages and the way they are usually implemented, cannot be modelled with this calculus. In particular, the calculus itself lacks pattern matching and the notion of sharing of computations. Patterns contain in'tportant information for strictness analyTers (Ntcker (1988)). Sharing of computations is essential to obtain efficient implementations on traditional hardware (Fasel & Keller (1986)). Graph Rewriting systems are based on pattern matching and sharing. We believe that compared to the X-calculus graph rewriting systems (Barendregt et al. (1987a,b)) are better suited to serve as computational model for functional languages. In the past we have...

Graph rewriting semantics for functional programming languages

“…This way o f copying is called lazy copying. Lazy copying can be used to model communication channels, a s p r oposed in Eekelen et al (1991). Together with a mechanism for creating parallel reduction processes, the lazy copying formalism provides a speci cation method for arbitrary process topologies with various kinds of communication links.…”

“…Defer attributes are also allowed to appear in the right-hand side of a rewrite rule. In Eekelen et al (1991) these attributes are used to de ne primitives for s pecifying communication for various kinds of p a rallelism, varying from simple divide-and-conquer parallelism to complicated, non-hierarchical process structures.…”

Concurrent clean

“…With the same two a n notations the programmer can specify that, when communication takes pla c e , a v alue has to be communicated or that the e x p ression to compute the value has to be shipped. Communication between processes takes place implicitly on demand via the concept of lazy copying (Eekelen et al (1991), Barendsen and Smetsers (1992)).…”

“…Communication involves the copying of graphs. In Concurrent Clean the concept of lazy copying is used (Eekelen et al (1991), Barendsen and Smetsers (1992)). When during t h e c o p ying a subgraph i s encountered that is a l ready b e i ng reduced by another reduction process, this subgraph is not copied at that moment.…”