We describe a new method for determining when an object can be garbage collected. The method does not require marking live objects. Instead, each object X is dynamically associated with a stack frame , such that is collectable when pops. Because could havebeendead earlier, our method is conservative. Our results demonstrate that the method nonetheless identifies a large percentage of collectable objects. The method has been implemented in Sun's Java tm Virtual Machine interpreter, and results are presented based on this implementation.

We present a new distributed garbage collection algorithm that is able to reorganise diffusion trees and to support mobile objects. It has a modular design comprising three components: a reliable transport mechanism, a referencecounting based distributed garbage collector for non-mobile objects, and an extra layer that provides mobility. The algorithm is formalised by an abstract machine and is proved to be correct. The safety property ensures that an object may not be reclaimed as long as it is referred to locally or remotely. The liveness property guarantees that unreachable objects will eventually be reclaimed. The mobility property certifies that messages are always forwarded towards more recent mobile object positions. 1 Introduction Distributed object systems provide programmers with the capability to refer to remote objects and to activate remote computations (generally called remote method invocation) [27, 28]. In this context, distributed garbage collection is a valuable tec...

Distributed reference counting is a general purpose technique, which may be used, e.g., to detect termination of distributed programs or to implement distributed garbage collection. We present a distributed reference counting algorithm and a mechanical proof of correctness carried out using the proof assistant Coq. The algorithm is formalised by an abstract machine, and its correctness has two dierent facets. The safety property ensures that if there exists a reference to a resource, then its reference counter will be strictly positive. Liveness guarantees that if all references to a resource are deleted, its reference counter will eventually become null. 1 Introduction Reference counting is a general purpose technique that is able to count the number of references to a given resource. Collins [5] was the rst to use it in order to determine when list cells were no longer needed. Operating systems rely on this technique in order to decide when les may be deleted or when le...

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.

We have recently defined a new algorithm for distributed garbage collection based on reference-counting [20, 24]. At the heart of the algorithm, we find tree rerooting, a mechanism able to reduce third-party dependencies by reorganising diffusion trees. In reality, the algorithm describes a spectrum of algorithms according to the policy used to manage messages. In this paper, we present the implementation of the algorithm and evaluate its performance. We have implemented two policies, which are extremes of the spectrum, respectively using and not using tree rerooting. In addition, two different strategies for managing action queues have been implemented. The conclusions of our experimentations are the following. Tree rerooting offers more parallelism during distributed gc activity; we explain this phenomenon by the length reduction of causality chains in the distributed gc. Grouping messages per destination dramatically reduces the number of messages, but requires a more complex implementation as messages have to be sorted per destination. Speed up of 100% has been observed on some benchmarks.

We propose an effective methodology in which a distributed garbage collector may be derived from a distributed termination algorithm and a centralized garbage collector in a manner that preserves interesting properties of the original collector, such as completeness. To illustrate our technique we show how two distributed termination algorithms, credit recovery and task balancing, may be suitably described; and then map four centralized garbage collectors—reference counting, mark/scan, a generational scheme, and the Mature Object Space collector (MOS)—onto this description. The advantage of our approach is that, by separating the issues of distribution and collection, we alleviate the difficulty of inventing, understanding, and comparing distributed garbage collection techniques. 1

Managed runtime environments (MREs) employ garbage collection (GC) for automatic memory management. However, GC induces pressure on the virtual memory (VM) manager, since it may touch pages that are not related to the working set of the application. Paging due to GC can significantly hurt performance, even when the application’s working set fits into physical memory. We present a feedback-directed heap resizing mechanism to avoid GC-induced paging, using information from the operating system (OS). We avoid costly GCs when there is physical memory available, and trade off GC for paging when memory is constrained Our mechanism is simple and uses allocation stall events during GC alone to trigger heap resizing, without user participation or OS kernel modification. Our system enables significant performance improvements when real memory is restricted and similar to, or better performance than, the current state-of-the-art MRE, when memory is unconstrained. 1.

Abstract. Automatic distributed garbage collection (GC) gives abstraction to grid application development, promoting code quality and improving resource management. Unreachability of active objects or actors from the root set is not a sufficient condition to collect actor garbage, making passive object GC algorithms unsafe when directly used on actor systems. In practical actor languages, all actors have references to the root set since they can interact with users, e.g., through standard input or output streams. Based on this observation, we introduce pseudo roots: a dynamic set of actors that can be viewed as the root set. Pseudo roots use protected (undeletable) references to ensure that no actors are erroneously collected even with messages in transit. Following this idea, we introduce a new direction of actor GC, and demonstrate it by developing a distributed GC framework. The framework can thus be used for automatic life time management of mobile reactive processes with unordered asynchronous communication. This report is an extended version of [42]. It provides more information about how we built a distributed garbage collector with the help of the pseudo root approach. It also shows experimental results for local GC. 1

ProcessBase is a programming environment designed to support flexible and compliant application development. The Distributed ProcessBase system is a variant on this environment, designed for a distributed context. The three distributed object cache implementations that are described in this document form the basis for experimentation into DMOS-based distributed garbage collectors. The three implementations differ in their approach to coherency maintenance over objects in the cache. Analysis includes the messaging cost, dereference costs and addressing complexity for each implementation. 1

A multi-tasking virtual machine (MVM) executes multiple programs in isolation, within a single operating system process. The goal of a MVM is to improve startup time, overall system throughput, and performance, by effective reuse and sharing of system resources across programs (tasks). However, multitasking also mandates a memory management system capable of offering a guarantee of isolation with respect to garbage collection costs, accounting of memory usage, and timely reclamation of heap resources upon task termination. To this end, we investigate and evaluate, novel task-aware extensions to a state-of-the-art MVM garbage collector (GC). Our task-aware GC exploits the generational garbage collection hypothesis, in the context of multiple tasks, to provide performance isolation by maintaining task-private young generations. Task aware GC facilitates concurrent per-task allocation and promotion, and minimizes synchronization and scanning overhead. In addition, we efficiently track per-task heap usage to enable GC-free reclamation upon task termination. Moreover, we couple these techniques with a light-weight synchronization mechanism that enables pertask minor collection, concurrently with allocation by other tasks. We empirically evaluate the efficiency, scalability, and throughput that our task-aware GC system enables. Categories and Subject Descriptors D.3.4 [Programming Languages]: Processors—Memory management (garbage collection)