We describe a parallel, real-time garbage collector and present experimental results that demonstrate good scalability and good real-time bounds. The collector is designed for shared-memory multiprocessors and is based on an earlier collector algorithm [2], which provided fixed bounds on the time any thread must pause for collection. However, since our earlier algorithm was designed for simple analysis, it had some impractical features. This paper presents the extensions necessary for a practical implementation: reducing excessive interleaving, handling stacks and global variables, reducing double allocation, and special treatment of large and small objects. An implementation based on the modified algorithm is evaluated on a set of 15 SML benchmarks on a Sun Enterprise 10000, a 64-way UltraSparc-II multiprocessor. To the best of our knowledge, this is the first implementation of a parallel, real-time garbage collector.The average collector speedup is 7.5 at 8 processors and 17.7 at 32 processors. Maximum pause times range from 3 ms to 5 ms. In contrast, a non-incremental collector (whether generational or not) has maximum pause times from 10 ms to 650 ms. Compared to a non-parallel, stop-copy collector, parallelism has a 39% overhead, while real-time behavior adds an additional 12% overhead. Since the collector takes about 15% of total execution time, these features have an overall time costs of 6% and 2%.

/pdf/a-parallel-real-time-garbage-collector-2rvhqewbtt.pdf

A parallel, real-time garbage collector

This paper considers the garbage collection of concurrent objects for which it is necessary to know not only “reachability,” the usual criterion for reclaiming data, but also the “state” (active or blocked) of the object. For the actor model, a more comprehensive definition than previously available is given for reclaimable actors. Two garbage collection algorithms, implementing a set of “coloring” rules, are presented and their computational complexity is analyzed. Extensions are briefly described to allow incremental, concurrent, distributed and real-time collection. It is argued that the techniques used for the actor model applies to other object-based concurrent models.

/pdf/garbage-collection-of-actors-42j7kqo9lq.pdf

Garbage collection of actors

A general strategy for automatically decomposing and dynamically distributing a functional program is discussed. The strategy is suitable for parallel execution on multiprocessor architectures with no shared memory. It borrows ideas from data flow and reduction machine research on the one hand, and from conventional compiler technology for sequential machines on the other. One of the more troublesome issues in such a system is choosing the right granularity for the parallel tasks. As a solution, the authors describe a program transformation technique based on serial combinators that offers in some sense just the right granularity for this style of computing, and that can be fine-tuned for particular multiprocessor architectures. Simulation demonstrates the success of this approach.

Distributed execution of functional programs using serial combinators

Creating more knowledgeable computer systems will require vastly increased computational resources. We are working on the development of a computer architecture (called the Apiary) to meet this need. In this paper we present an overview of the Apiary introducing important concepts and techniques such as Interest groups.Jeff Schiller has constructed a preliminary implementation of the network software for the Apiary on the CADR Distributed System at the MIT Artificial Intelligence Laboratory. Phyllis Koton has constructed a preliminary version of Portal which is a communications chip designed to facilitate the construction of Multiprocessor Network Architectures like the Apiary. However a great deal of work remains to be done in order to make the Apiary into a practical usable system.

The Apiary network architecture for knowledgeable systems

In recent years there has been a fair amount of interest both in using combinators to represent functional programs, and in using graph reduction as an underlying valuation strategy. Combining these ideas within a single framework for an “applicative architecture” is very appealing because: (1) the normally ubiquitous “environment” is eliminated, (2) the evaluation strategy becomes very simple (amenable to VLSI), and (3) there is a great potential for parallelism. We have been exploring a model of diffused combinator reduction in which the reduction process is distributed “by demand” among a network of closely-coupled processors. We have tested our ideas via simulation, with encouraging results.This research was supported in part by NSF Grant MCS-8302018 and ONR Grant N00014-84-K-0043.

Experiments in diffused combinator reduction

: The goal of this thesis is to develop a methodology for building networks of small computers capable of the same tasks now performed by single larger computers. Such networks promise to be both easier to scale and more economical in many instances. The mu calculus, a simple syntactic formalism for representing message-passing computations, is presented and augmented to serve as the semantic basis for programs running on the network. The augmented version includes cells, tokens, and semaphores, as well as primitives for side-effect-free computation. Tokens, a novel construct, allow certain simple communication and synchronization tasks without involving fully general side effects. The network implementation presented supports object references, keeping track of them by using a new concept, the reference tree. A reference tree is a group of neighboring processors in the network that share knowledge of a common object. Also discussed are mechanisms for handling side effects on objects and strategy issues involved in allocating computations to processors. (Author)

Robert H Halstead

Papers

Multiple-processor implementations of message-passing systems