Abstract. Automatic storage reclamation via reference counting has important advantages, but has always suffered from a major weakness due to its inability to reclaim cyclic data structures. We describe a novel cycle collection algorithm that is both concurrent — it is capable of collecting garbage even in the presence of simultaneous mutation — and localized — it never needs to perform a global search of the entire data space. We describe our algorithm in detail and present a proof of correctness. We have implemented our algorithm in the Jalapeño Java virtual machine as part of the Recycler, a concurrent multiprocessor reference counting garbage collector that achieves maximum mutator pause times of only 6 milliseconds. We present measurements of the behavior of the cycle collection algorithm over a set of eight benchmarks that demonstrate the effectiveness of the algorithm at finding garbage cycles, handling concurrent mutation, and eliminating global tracing. 1

Abstract. This paper presents an algorithm for distributed garbage collection and outlines its implementation within the Network Objects system. The algorithm is based on a reference listing scheme, which is augmented by partial tracing in order to collect distributed garbage cycles. Processes may be dynamically organised into groups, according to appropriate heuristics, to reclaim distributed garbage cycles. 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 to be part of a garbage cycle: no collaboration with other processes is required. The algorithm o ers considerable exibility, allowing expediency and fault-tolerance to be traded against completeness.

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 report outlines a parallel abstract machine for the implementation of a lazy functional core language. The evaluation transformer model of reduction [1] is used to control the evaluation process. An evaluator space containing parameterised evaluators for structured and polymorphic types is introduced. Using this framework it is possible to handle runtime information about evaluators for arbitrary structured types as well as evaluation transformers for functions over polymorphic types. Institut fr Informatik Fachbereich Mathematik und Informatik Freie Universitt Berlin Takustrae 9 D-14109 Berlin horn@inf.fu-berlin.de http://www.inf.fu-berlin.de/~horn/ 2 3 1 Introduction Because of their referential transparency, pure functional languages are especially well suited for implementation on parallel machines. Since they do not allow side effects, subexpressions can be evaluated in arbitrary order or in parallel. Lazy functional languages with lazy evaluation retain this p...

Systems that store objects at a large number of sites require fault-tolerant and timely garbage collection. A popular technique is to trace each site independently using inter-site references as roots. However, this fails to collect cyclic garbage spread across sites. We present an algorithm that collects cyclic garbage by involving only the sites containing it. Our algorithm is based on finding objects highly likely to be cyclic garbage and tracing backward from them to check if they are reachable from any root. We present efficient techniques that make conducting such traces practical. The algorithm collects all distributed cyclic garbage, is safe in the presence of concurrent mutations, and has low space and time overhead. 1 Introduction Emerging distributed systems will use objects stored at a large number of sites. The scale of such systems poses new challenges to reclaiming the storage of objects unreachable by applications. Such objects are known as garbage. A simple way to col...

We show how abstract requirements of garbage collection can be captured using temporal logic. The temporal logic specification can then be used as a basis for process algebra specifications which can involve varying amounts of parallelism. We present two simple CCS specifications as an example, followed by a more complex specification of the cyclic reference counting algorithm. The verification of such algorithms is then briefly discussed. Keywords: Concurrency, garbage collection, temporal logic, CCS. 1 Introduction The memorymanagement of simple static programming languages, such as Fortran, can be handled entirely by the compiler. The location of all variables can be fully determined at compile-time and no run-time support for memory management is necessary. However, such languages impose considerable restrictions on programming style, for example, recursive procedure calls are disallowed. High-level languages that allow recursion, on the other hand, demand some run-time support. T...

The Java RMI collector is arguably the most widely used distributed garbage collector. Its distributed reference listing algorithm was introduced by Birrell in the context of Network Objects, where the description was informal and heavily biased toward implementation. In this paper, we formalise this algorithm in an implementation-independent manner, which allows us to clarify weaknesses of the initial presentation. In particular, we discover cases critical to the correctness of the algorithm that are not accounted for by Birrell. We use our formalisation to derive an invariant-based proof of correctness of the algorithm that avoids notoriously difficult temporal reasoning. Furthermore, we offer a novel graphical representation of the state transition diagram, which we use to provide intuitive explanations of the algorithm and to investigate its tolerance to faults in a systematic manner. Finally, we examine how the algorithm may be optimised, either by placing constraints on message channels or by tightening the coupling between application program and distributed garbage collector.

We present a distributed cyclic reference counting algorithm which incorporates both, the correct management of cyclic data structures and the improvement of lazy mark-scan. The algorithm allows processors to run local mark-scan simultaneously without any need of synchronisation between phases of different local mark-scans either on the same processor or on different processors. 1 Introduction In distributed memory multiprocessors, each processor is responsible for reclaiming unused structures residing in its local memory (distributed garbage collection). As in the case of uni-processors, the algorithms are usually based on (global) mark-scan or on reference counting [5]. A number of algorithms use (global) mark-scan in distributed architectures [11, 1, 12]. The major disadvantage of these methods is that, as in the sequential case, the application is suspended during the garbage collection phase. One attempt [21] to improve this uses dual processors on each local memory and transfers...

The lack of collecting cyclic garbage is generally considered the major weakness of reference counting. Reference counted systems handle this problem by incorporating either a global tracing collector, or a ”partial ” tracing collector that considers only the cycle candidates but needs several traces on them. In particular, the latter has become a preferred one as it has better scalability and locality (no need to scan the entire heap). This paper presents a new ”lightweight ” cyclic reference counting algorithm, which is based on partial tracing and deals with the cycle problem in a simpler and more efficient way. By exploiting the lightweight hypothesis that considers a single sub-graph, instead of individual cycles, as the basic unit of cycle collection, the algorithm can detect garbage cycles in a single trace. In addition, we propose a technique for eliminating redundant scans over garbage objects, thus improving the efficiency of the algorithm. The pseudocode and its correctness proof are also presented. Finally, an implementation based on Jikes Research Virtual Machine is provided to demonstrate the effectiveness of the new algorithm. Categories and Subject Descriptors D.3.4 [Programming Languages]: Processors—Memory management (garbage collection)

We present a novel algorithm for Garbage Collection (GC) in Distributed Shared Memory (dsm) systems. A Remote Reference Counting (RRC) algorithm reduces the network traffic overhead (and the memory and computation overheads), essentially eliminating all communication when there is no active collection, and minimizing it when the collection process is turned on. RRC works correctly for asynchronous environments where messages may experience arbitrary delays on the way to their destinations. It also tolerates arbitrary duplication of messages and is thus a suitable "add-on" for fault-tolerant communication protocols. It does not suffer from problems such as weight underflow (which arise in reference counting techniques). In addition, when applied in granularity of pages (which is the most relevant in page-based dsm systems), the memory overhead is not inflated when the average allocation size is small, and the memory reorganization required due to the GC operations is simpli...