Ming-Dong Feng

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.

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

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.

BaLinda suite of languages and implementations

The BaLinda suite of parallel languages, currently consisting of BaLinda Lisp, BaLinda Pascal, and BaLinda Fortran, aim at providing a pragmatic parallel programming model. They incorporate the Linda tuplespace and support both mandatory and speculative parallelism. They have been implemented on a network of transputers and SUN workstations. A number of examples of parallel programming applications in BaLinda languages are presented to show that the languages are worthwhile additions to the family of parallel languages. A distributed Linda tuplespace implementation and dynamic load balancing strategies for BaLinda languages are also presented, and their performances are evaluated, demonstrating an efficient, reliable, and portable way to realize BaLinda suite of languages on distributed parallel machines.

BaLinda Lisp: Design and implementation

BaLinda Lisp is a parallel Lisp dialect employing a shared memory model of parallel processing together with a subset of the Linda tuple space operators. Also included in the design is speculative processing. The aim is to have shared memory multiprocessing with the tuple space acting as the main data structure through which synchronization is done. The result is a flexible programming language. In this paper, we shall describe the design philosophy of BaLinda Lisp, discuss its implementation on three multiprocessing platforms, give examples of programs written in BaLinda Lisp and discuss future work on the language.

A TRANSPUTER-BASED PARALLEL LISP IMPLEMENTATION

Transputers are commonly used in low cost computation-intensive applications, such as image processing and signal analysis. Symbolic processing and AI applications on transputers require a different programming environment. This paper reports the effort made to implement BaLinda Lisp, a parallel Lisp dialect, on transputer arrays. BaLinda Lisp supports the FUTURE construct to initiate parallel execution threads, speculative constructs to spawn parallel tasks for results that may be required, 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. The implementation strategies are described in this paper, focusing on how to support the novel features of BaLinda Lisp. The advantages and disadvantages inherent in the transputer architecture that affect the design of the interpreter are also discussed.

Use of active objects in BaLinda K for system programming

An active object is a function that returns a pointer to its environment when an execution thread is attached to it. This facility of BaLinda K, a parallel Lisp dialect with an imperative appearance, is shown to be useful for constructing I/O interfaces and execution control mechanisms, and has potential as a tool for system program implementation.

Breadth-first search in the Eight Queens Problem

The Eight Queens Problem is a familiar example in programming and algorithm textbooks . Usually, the given solution applies depth-first search with backtracking, and stops afte r finding one solution . When we attempted to reformulate the problem by applyin g breadth-first search, in order to find all solutions without backtracking, we were only abl e to find one published example, written in a Miranda-like functional language[1] .

Speculative processing mechanisms in a parallel Lisp machine: BIDDLE

In a system supporting parallel execution, speculative processing can be used to increase the amount of parallelism. The authors propose a speculative execution scheme for the data-driven Lisp machine BIDDLE. Execution priorities are assigned to instructions according to their nested position in conditional statements. These priorities are updated dynamically during execution as results of Boolean guards of conditional execution are returned. The authors describe the ways to maintain the environment and handle side effects and tuplespace in the speculative context. Each speculative branch is given a separate environment. Any side-effects made are merged into the environment of the calling instruction when the speculation is confirmed, and removed if they are unwanted. It is also demonstrated that infinite data structures can be supported by this scheme.<<ETX>>