. This paper reports on some experiments with the implementation of a concurrent version of a graph reduction system -red + on an nCUBE/2 system of up to 32 processing sites. They primarily concern basic concepts of workload partitioning and balancing, the relationship between relative performance gains and the computational complexities of the investigated programs, resource management and suitable system topologies. All programs used for these experiments realize divide and conquer algorithms and have been run with varying (sizes of) data sets and system parameters (configurations). 1 Introduction Running complex application programs non-sequentially in multiprocessor systems is known to be a formidable organizational problem. It relates to a programming paradigm suitable for exposing problem-inherent concurrency, to the orderly cooperation of all processes participating in the computation, and to a process management discipline which ensures a stable overall system behav...

The relationship between the generalised computational model of Term Graph Rewriting Systems (TGRS) and Object-Oriented Programming (OOP) is explored and exploited by extending the TGRS model with records where access to parameters is done by naming rather than position. Records are then used as the basis for expressing object-oriented techniques such as object encapsulation and (various forms of) inheritance. The effect is that TGRS with records can now be used as an implementation model for a variety of (concurrent) object-oriented (functional, logic or otherwise) languages but also as a common formalism for comparing various related techniques (such as different forms of inheritance or approaches for providing solutions to problems caused by the combination of concurrency and interaction between objects). Keywords: Object-Oriented Programming; Concurency and Parallelism; Programming Language Extensions; Rewriting Systems. Object-Oriented Term Graph Rewriting George A. Papadopoulos...

This paper assesses the costs of maintaining a virtual shared heap in our parallel graph reducer (GUM), which implements a parallel functional language. GUM performs automatic and dynamic resource management for both work and data. We introduce extensions to the original design of GUM, aiming at a more flexible memory management and communication mechanism to deal with high-latency systems. We then present measurements of running GUM on a Beowulf cluster, evaluating the overhead of dynamic distributed memory management and the effectiveness of the new memory management and communication mechanisms. c IEEE; "CCGrid 2002", Berlin, May 2002.

This copy of the thesis has been supplied on the condition that anyone who consults it is understood to recognise that the copyright rests with its author and that no quotation from the thesis and no information derived from it may be published without the prior written consent of the author or the university (as may be appropriate). I hereby declare that the work presented in this the-sis was carried out by myself at Heriot-Watt University, Edinburgh, except where due acknowledgement is made, and has not been submitted for any other degree.

this paper we try to bridge the gap between the two formalisms by showing how concurrent logic languages can be implemented using graph rewriting. In particular, we develop techniques for mapping a wide class of CLLs including Parlog, GHC, Strand, Janus and a restricted subset of the Concurrent Prolog family onto Dactl, a compiler target language based on graph rewriting. We discuss the problems found in the process and the adopted solutions. The paper contributes to related research by: # examining the potential of graph reduction as a suitable model for implementing CLLs in terms of expressiveness and efficiency

A clustered architecture has been designed to exploit divide and conquer parallelism in functional programs. The programming methodology developed for the machine is based on explicit annotations and program transformations. It has been successfully applied to a number of algorithms resulting in a benchmark of small and medium size parallel functional programs. Sophisticated compilation techniques are used such as strictness analysis on non-flat domains and RISC and VLIW code generation. Parallel jobs are distributed by an efficient hierarchical scheduler. A special processor for graph reduction has been designed as a basic building block for the machine. A prototype of a single cluster machine has been constructed with stock hardware. This paper describes the experience with the project and its current state. 1 Introduction Functional programming is founded on the lambda calculus, which is a mathematical theory that provides a sound basis for work on reduction machines [5]. This is p...

Machine (PAM, [LKI89], [Kuc89], [Loo90]). This machine was designed and implemented as a software prototype at the RheinischWestf älische Technische Hochschule (RWTH) Aachen. A machine performing graph reduction evaluates a functional expression according to a set of given function definitions. In pure functional languages multiple occurrences of subexpressions need to be evaluated just once. Therefore the subtrees representing the common subexpressions can be identified and the abstract syntax tree of the functional expression is transformed to a graph. During the evaluation the machine holds the expression together with bookkeeping information in its memory. Since a graph reduction machine uses graphs as the main data structure, it is a very suitable application for a graph-grammar model. Several other projects have designed and implemented parallel graph reduction machines for example ALICE ([DCFHR87]), or GRIP ([HamPey90],[PCSH87]). So there is a broad application area of monitorin...

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

This paper presents Haskell# , a parallel functional language based on coordination. Haskell# supports lazy stream communication and facilities, at coordination level, to the specification of data parallel programs. Haskell# supports a clean and complete, semantic and syntactic, separation between coordination and computation levels of programming, with several benefits to parallel program engineering. The implementation of some well-known applications in Haskell# is presented, demonstrating its expressiveness, allowing for elegant, simple, and concise specification of any static pattern of parallel, concurrent or distributed computation.

The ability for multiple threads to enter the same graph node without contention and conflict is a necessary component of the graph reduction of functional languages since graph components may be shared. Shared closures, however, compound the difficulty of priority management.