This paper presents the design and implementation of a "quasi real-time" garbage collector for Concurrent Caml Light, an implementation of ML with threads. This two-generation system combines a fast, asynchronous copying collector on the young generation with a nondisruptive concurrent marking collector on the old generation. This design crucially relies on the ML compiletime distinction between mutable and immutable objects. 1 Introduction This paper presents the design and implementation of a garbage collector for Concurrent Caml Light, an implementation of the ML language that provides multiple threads of control executing concurrently in a shared address space. Garbage collection --- the automatic reclamation of unused memory space --- is one of the most problematic components of run-time systems for multi-threaded languages. The naive "stop-the-world" approach, where all threads synchronously stop executing the user's program to perform garbage collection, is clearly inadequate,...

We have designed and implemented a copying garbage-collection algorithm that is efficient, real-time, concurrent, runs on commerial uniprocessors and shared-memory multiprocessors, and requires no change to compilers. The algorithm uses standard virtual-memory hardware to detect references to "from space" objects and to synchronize the collector and mutator threads. We have implemented and measured a prototype running on SRC's 5-processor Firefly. It will be straightforward to merge our techniques with generational collection. An incremental, non-concurrent version could be implemented easily on many versions of Unix. Introduction This paper presents the first copying garbage-collection algorithm that is efficient, real-time, concurrent, runs on stock commercial uniprocessors and multiprocessors, and requires no change to compilers. A collection algorithm is efficient if the amortized cost to allocate, access, and collect an object is small compared to the cost of initializing the o...

this paper. associated with a relocating collector is saved; other costs remain, however, such as the costs of updating all pointers and foregoing some compiler optimizations.

We describe and prove the correctness of a new concurrent mark-and-sweep garbage collection algorithm. This algorithm derives from the classical on-the-fly algorithm from Dijkstra et al. [9]. A distinguishing feature of our algorithm is that it supports multiprocessor environments where the registers of running processes are not readily accessible, without imposing any overhead on the elementary operations of loading a register or reading or initializing a field. Furthermore our collector never blocks running mutator processes except possibly on requests for free memory; in particular, updating a field or creating or marking or sweeping a heap object does not involve system-dependent synchronization primitives such as locks. We also provide support for process creation and deletion, and for managing an extensible heap of variable-sized objects. 1 Introduction Concurrent garbage collection has a well-deserved reputation for being a tough problem. This is evidenced by the discrepancies...

Weighted Reference Counting is a low communication distributed storage reclamation scheme for loosely-couple multiprocessors. The algorithm we present herein extends weighted reference counting to allow the collection of cyclic data structures. To do so, the algorithm identifies candidate objects that may be part of cycles and performs a tricolour mark-scan on their subgraph in a lazy manner to discover whether the subgraph is still in use. The algorithm is concurrent in the sense that multiple useful computation processes and garbage collection processes can be performed simultaneously. Keywords: Memory management, Distributed memory, Reference counting, Garbage collection. Introduction Computation on distributed systems involving several processors is already a reality. In a distributed multiprocessor system each processor is responsible for allocating and reclaiming structures residing in its local memory; interprocessor communication is far less efficient than local memory access...

Absfrucf-We advocate a stepwise method of deriving high perfor-mance implementation of a set of operations. This method is based on the ability to organize the data into a multilevel data structure so as to provide an efficient implementation of all the operations. Typically, for such data organization the performance may deteriorate over a period of time and that can be corrected by reorganizing the data. This data reorganization is done by the introduction of maintenance processes. For a particular example we consider the multilevel data organiza-tion and the different models of maintenance processes possible. The various models of maintenance processes provide varying amounts of concurrency by varying the degree of atomicity in different operations. Performance behavior for the different models are derived and we sketch a correctness proof for the developed implementation. Simula-tion studies of the performance for this example confirm that the per-formance improves as we move from coarse grained concurrency to finer grained Concurrency. Zndex Terms-Maintenance processes, multilevel data structures, performance, program correctness, weaklstrong invariants. I.

. This paper describes the design and the evaluation of Complementary Garbage Collector that is a fundamental algorithm for the parallel and incremental garbage collector. Our algorithm is a combination of two types of fundamental algorithms, incremental update and snapshot-at-beginning, which are complementary to each other. The algorithm has the advantages of both types: great efficiency of the garbage collection and ease of consistent implementation. This algorithm can be substituted for the snapshot-at-beginning algorithm widely used in several types of parallel and incremental garbage collectors. Measurements of this algorithm in a parallel and an incremental mark-sweep GC indicate that it improves the efficiency of the collection making it equivalent to the stop garbage collector. Consequently, the execution time of the list processing is shortened and the range of non-stop processing is extended. Keywords: real-time garbage collection, parallel garbage collection, incremental ...

Abstract-We present a state reduction method that effectively reduces a two-dimensional Markov model to a one-dimensional Markov model for the performance analysis of a class of concurrent data structure maintenance policies. The reduced model allows the derivation of a closed form expression for the average service time per operation and facilitates the identification of priority allocation functions under which a) the system is stable and b) the service time per operation is minimized. The applicability of the model is exemplified with a binary tree data structure and the conditions under which concurrent maintenance strategies are better than a conventional incremental maintenance strategy are determined. Index Terms-Client-server computational models, data structures concurrent maintenance policies, Markov models, performance evaluation, state reduction. I.

This paper deals with compacting garbage collection in real-time programs, i.e., programs that have to satisfy strict real-time requirements. Real-time programs are used to control physical processes, e.g., the motion of a robot. The required response time may be extremely short, but a response time of a few milliseconds is probably enough in most applications. In a real-time program, the maximum time required by the elementary operations (e.g., object allocation and object access) must be small. Memory reclamation must consequently be performed without causing long and unpredictable delays. It implies that garbage collection has to execute more in parallel, i.e., more interleaved with the program, than in non-real-time programs (so-called

Distributed systems present a new challenge to garbage collection design. Garbage collection schemes for linked, heterogeneous data-structures distributed over a network are reviewed for the first time. As distributed garbage collectors evolved from single address space collectors, these are classified first. The classification is extended to distributed collectors taking into account the additional issues of distribution: locality; latency and synchronisation. Categories and Subject Descriptors: C.2.4 [Computer-Communications Networks]: Distributed Systems; D.1.3 [Programming Techniques]: Concurrent Programming, Distributed programming, parallel programming; D.4.2 [Operating Systems]: Storage management; D.4.3: File systems management. Additional key words and phrases: memory management, automatic storage reclamation, garbage collection, reference counting, distributed systems, distributed memories, distributed file systems, network communication. Contents 1 Introduction 3 2 Taxonom...