Distributed symbolic computations involve the existence of remote references allowing an object, local to a processor, to designate another object located on another processor. To reclaim inaccessible objects is the non trivial task of a distributed Garbage Collector (GC). We present in this paper a new distributed GC algorithm which (i) is faulttolerant, (ii ) is largely independent of how a processor garbage collects its own data space, (iii ) does not need centralized control nor global stop-the-world synchronization, (iv) allows for multiple concurrent active GCs, (v) does not require to migrate objects from processor to processor and (vi) eventually reclaims all inaccessible objects including distributed cycles. These results are mainly obtained through the concept of a group of processors (or processes). Processors of a same group cooperate together to a GC inside this group; this GC is conservative with respect to the outside of the group. A processor contributes to the glob...

In this report we present a fault-tolerant and efficient algorithm for distributed garbage collection and prove its correctness. The algorithm is a generalization of reference counting; it maintains a set of identifiers for processes with references to an object. The set is maintained with pair-wise communication between processes, so no global synchronization is required. The primary cost for maintaining the set is one remote procedure call when an object reference is transferred to a new process for the first time. The distributed collector collaborates with the local collector in detecting garbage; any local collector may be used, so long as it can be extended to provide notification when an object is collected. In fact, the distributed collector could be used without a local collector; in that case, the programmer would insert explicit dispose commands to release an object. The algorithm was designed and implemented as part of the Modula-3 network objects system, but it should be s...

The overall goal of the Emerald garbage collection scheme is to provide an efficient "on-thefly " garbage collection in a distributed object-based system that collects all garbage, and that is robust to partial failures. The first goal is to collect all garbage in the entire distributed system; we say that the collection is comprehensive in contrast to conservative collectors that only collect most garbage. Comprehensiveness is achieved by employing a system-wide mark-and-sweep collection based on concurrently running collectors, one on each node. The second goal of our collector is to be robust to partial failures. When facing node failures the collector will progress in the available parts of the system and, when necessary, wait for temporarily unavailable nodes to become available again. The scheme is being implemented on a network of VAXstations at DIKU. The full scheme employs two concurrent mark-and-sweep collectors on each node in the distributed system, one for comprehensivenes...

Abstract. This paper presents a new algorithm for distributed garbage collection and outlines its implementation within the Network Objects system. The algorithm is based on a reference listing scheme augmented by partial tracing in order to collect distributed garbage cycles. Our collector is designed to be exible thereby allowing e ciency, expediency and fault-tolerance to be traded against completeness. Processes may be dynamically organised into groups, according to appropriate heuristics, in order to reclaim distributed garbage cycles. Unlike previous groupbased algorithms, multiple concurrent distributed garbage collections that span groups are supported: when two collections meet they may either merge, overlap or retreat. The algorithm places no overhead on local collectors and suspends local mutators only brie y. Partial tracing of the distributed graph involves only objects thought tobe part of a garbage cycle: no collaboration with other processes is required.

This paper introduces an algorithm that performs garbage collection in distributed systems of active objects (i.e., objects having their own threads of control). The proposed garbage collector is made of a set of local garbage collectors, one per node, loosely coupled to a global garbage collector. The novelties of the proposed garbage collector come from the fact that local garbage collectors need not be synchronized with each other for detecting garbage objects, and that faulty communication channels are tolerated. The paper describes the proposed garbage collector, together with its implementation and performance for a concurrent object-oriented language running on a local area network of workstations.

With the increasing use of active object systems, agents and concurrent object oriented languages like Java, the problem of garbage collection (GC) of unused resources has become more complex. Since active objects are autonomous computational agents, unlike passive object systems the criterion for identifying garbage in active objects cannot be based solely on reachability from a root set. This has led to development of specialized algorithms for GC of active objects. We reduce the problem of GC of active objects to that of passive objects by providing a transformation of the active object reference graph to a passive object reference graph so that if a garbage collector for a passive object system is applied to the transformed graph, precisely those objects are collected which correspond to garbage objects in the original active object reference graph. The transformation technique enables us to reuse the algorithms already developed for passive objects systems. We provide a proof of correctness of the transformation and discuss its cost. An advantage of the transformation is that it can prove valuable for mixed systems of active and passive objects by providing a common approach to GC.

Garbage collection is a valuable service which provides error-free and automatic management of system resources. A substantial amount of work has been done in the area of garbage collection in uniprocessor and distributed systems. Garbage collection techniques and algorithms have also been proposed for actor systems, but traditionally, algorithms developed for non-actor systems are considered unsuitable for actors as they do not take into account the "processing-power" inherently present in each actor. This thesis presents a transformation of the actor-reference graph into a passive object graph with the property that if a garbage collector for a general object-oriented system is run on the transformed graph,only those objects are collected which correspond to garbage actors in the original graph. A proof of correctness of the transformation is given and the costs associated therewith are discussed. The transformation enables us to reuse many algorithms already developed for other systems, to find garbage actors. This is of increased importance for distributed systems because garbage collection in such systems still faces a number of challenging issues prompting the need for investigation of new algorithms.

In this paper, a garbage collection scheme to work in an object oriented, distributed, persistent environment is described. An experimental prototype has been implemented to demonstrate the feasibility of such a scheme. The scheme can be considered incremental. The garbage identification and collection processes at the different processing nodes are totally autonomous and independant, without a need for communication or synchronization between nodes. The scheme is considered as part of the more general object reorganization in the system to achieve stronger locality of reference at the different nodes 1 . 1 ntroduction In object oriented environments the problem of storage reclamation is more serious than in traditional systems. Object oriented programming encourages building dynamic complex structures with large number of connections among the components of these structures which makes it difficult to determine the nonreachable(garbage) objects manually. Automatic storage r...

Printed on QMS- PS-810 turbo PostScript printer. Bibliography made by BibTEX. Illustration made by idraw. D.I.K.U. / Dist. Lab.

EZ is a system that integrates traditional operating systems and programming languages into a very high-level, persistent, string processing language. This paper describes the design and initial implementation of a distributed memory manager that distributes EZ's virtual address space transparently among a network of homogeneous computers. The design adapts the techniques used in recent implementations of shared virtual memory for use in EZ's persistent environment. Unlike most implementations of shared virtual memory, control information is distributed and migrates. This memory manager works in concert with a distributed mark-and-sweep garbage collector, which is also concurrent and real-time. This collector trades time for space and minimal disruption of mutators, which reduces communication costs. Introduction A system that integrates language and operating system concepts into a single system offers a different perspective on some time-honored features of traditional operating s...