Chung-Kwong Yuen

SilkRoad: a multithreaded runtime system with software distributed shared memory for SMP clusters

Constructing multithreaded parallel systems with software distributed shared memory (DSM) is an attractive trend in cluster computing. Distributed Cilk (Cilk 5.1) is a multithreaded runtime system for SMP clusters with support for the divide-and-conquer programming paradigm. However, it lacks support for user-level shared memory. We describe SilkRoad, an extension of Distributed Cilk which implements the lazy release consistency (LRC) memory model. In the SilkRoad runtime system, system control information is kept consistent by means of a backing store, just as it is in the original Distributed Cilk, while the users cluster wide shared data is kept consistent by LRC. LRC enables SilkRoad programmers to define and use shared variables between the threads running on different nodes in a cluster This greatly enlarges the scope of supported programming paradigms in Cilk. Besides testing its performance, we also compared SilkRoad with TreadMarks, an LRC software DSM system for clusters with no support of multithreading. The results show that with the hybrid memory model of dag-consistency and LRC, multithreaded SilkRoad programs written in a divide-and-conquer fashion with good data locality can achieve comparable performance with the corresponding multiple-process TreadMarks programs.

tmPVM-task migratable PVM

In this paper we introduce an implementation of PVM that exploits the homogeneity of an MPP network with user-level task migration. The target machine is the Fujitsu AP3000. It is basically a network of Sun workstations connected by a high-speed network. Furthermore, we explore the possibility of allowing the PVM host configuration to expand dynamically so as to include idle nodes into the virtual machine. The result is tmPVM, which allows the virtual machine to re-distribute workload dynamically with low overhead.

Distributed Linda Tuplespace Algorithms and Implementations

Linda, a general purpose coordination language, has been used to make a language parallel. Based on a logically shared tuplespace, Linda poses difficulties to be efficiently implemented on a distributed multiprocessor system. This paper reports our approach to solve the problem: processors are divided into groups, and each group has a group manager to provide a local view of global tuplespace, and handles the tuplespace operations incurred by processors within the group. To maintain the consistency and correctness of the Linda tuplespace operations, we propose the algorithms of a group manager. We also implement the algorithms on a network of transputers, and show the experiment results.

Dynamic load balancing on a distributed system

We consider the problem of load balancing on loosely coupled multiprocessor systems. During run time, a task may create subtasks, which are dynamically distributed by the load balancer. Different load-balancing strategies (receiver-initiated, sender-initiated and mixture of both) are studied and evaluated on transputers. We test three commonly used benchmark problems (fibonacci function, N-queen and 15-puzzle) to observe the effect of load balancing. Our experiments involve up to 18 Transputers, and we observe speed improvements from 12 to 16 times over a sequential program. The mixed strategy was the best in most cases. We also find that the longer a problem takes to solve using sequential implementation, the more likely it is to benefit from parallel execution. The load balancing algorithms presented here are applicable to any distributed systems where processor interconnection is modifiable.<<ETX>>

BIDDLE: a dataflow architecture for Lisp

Machine architectural support for the high-speed execution of Lisp has been the subject of considerable research interest. This paper presents an update on the design of BIDDLE (Bidirectional Data-Driven Lisp Engine), a multiprocessor Lisp machine based on the dataflow architecture. Some issues previously not discussed in detail in earlier publications are emphasized, namely environment maintenance, storage management, and execution characteristics.<<ETX>>

BaLinda Lisp: a parallel list-processing language

The authors describe BaLinda (Biddle and Linda) Lisp, a parallel execution Lisp dialect designed to take advantage of the architectural capabilities of Biddle (bidirectional data driven Lisp engine). The Future construct is used to initiate parallel execution threads, which may communicate through Linda-like commands operating on a tuple space. These features provide good support for parallel execution, and blend together well with notational consistency and simplicity. Unstructured task initiation and termination commands are avoided, while mandatory and speculative parallelisms (lazy versus eager executions) are both supported.<<ETX>>

BIDDLE: a bidirectional data driven Lisp engine

The authors propose BIDDLE, a direct execution architecture for Lisp based on both data- and demand-driven principles. A priority queuing mechanism is used to control the parallelism and the workload of the processing elements. Also introduced is a novel mechanism whereby the sequential semantics of Lisp can be enforced in such a way as not to reduce the parallelism too drastically. BIDDLE is, therefore, aimed at achieving a balance between eager and lazy evaluation, sequential semantics, and parallelism. At present, BIDDLE exists only on paper and is a long way from hard ware implementation.<<ETX>>

A transputer-based parallel Lisp implementation

This paper reports the effort made to implement BaLinda Lisp, a parallel Lisp dialecL on Uansputer arrays. BaLinda lisp supports the FUTURE construct to initiate parallel execution threads, speculative constructs to spawn parallel tasks for nxmlts that may be requittxl, and tuple space operations to enforce the proper communication, synchronization, mutual exclusion and shared variable access for parallel tasks. A suite of application programs has been tested on the resulting interpreter and some performance results are presented. The results demonstrate that the interpreter achieves realistic parallelism and provides a high speed symbolic processing environment on transputers.

A MODEL OF SPECULATIVE PARALLELISM

Speculative parallelism is the parallelism that one finds when parallel tasks are spawned in the hope that they will later be of use. While this aggressive form of parallelism promises high levels ...

Which model of programming for LISP: sequential, functional or mixed?

This article reviews models of programming applicable to Lisp, and argues that both the sequential model and the functional model have developed in directions of excessive complexity. For future developments, a mixed model based on old-style Lisp, but augmented with new parallel constructs, can provide a simpler tool for handling practical programming tasks.