This paper describes a new garbage collection scheme for large persistent object stores that makes efficient use of the disk and main memory. The heap is divided into partitions that are collected independently using information about inter-partition references. We present efficient techniques to maintain this information stably using auxiliary data structures in memory and the log. The result is a scheme that truly preserves the localized and scalable nature of partitioned collection. Remembering

A new garbage collection algorithm for distributed object systems, called DMOS (Distributed Mature Object Space), is presented. It is derived from two previous algorithms, MOS (Mature Object Space), sometimes called the train algorithm, and PMOS (Persistent Mature Object Space). The contribution of DMOS is that it provides the following unique combination of properties for a distributed collector: safety, completeness, non-disruptiveness, incrementality, and scalability. Furthermore, the DMOS collector is non-blocking and does not use global tracing. 1 Introduction Automatic storage management is an essential property of high level programming systems providing an error-free abstraction with which the programmer may manipulate space without regard to the inessential details of physical storage. The abstraction holds only until the store becomes full. Thus it is important for the storage management system to distinguish useful data from garbage, so that the space occupied by the garbag...

This paper presents the design of a new store layer for PJama. PJama is a platform that provides orthogonal persistence for Java. Based on experience with a prototype, PJama0, a new architecture has been devised to permit incremental store management and to allow a number of object management regimes to co-exist in one store. It uses a plug-in model for composing a Java Virtual Machine (JVM) with the persistent store and a descriptor abstraction to limit the impact of changes in JVMs on store management. Its anticipated advantages over the current scheme include flexibility, adaptability, scalability, and maintainability.

We describe an eficient server-based algorithm for garbage collecting object-oriented databases in a client/server environment. The algorithm is incremen-tal and runs concurrently with client transactions. Un-like previous algorithms, it does not hold any locks on data and does not require callbacks to clients. It is fault tolerant, but performs very little logging. The algorithm has been designed to be integrated into existing OODB systems, and therefore it works with standard implemen-tation techniques such as two-phase locking and write-ahead-logging. In addition, it supports client-server per-formance optimizations such as client caching and flexible management of client buffers. We describe an implemen-tation of the algorithm in the EXODUS storage manager and present results from an initial performance study. 1

We examine the costs and benefits of a variety of copying garbage collection (GC) mechanisms across multiple architectures and programming languages. Our study covers both low-level object representation and copying issues as well as the mechanisms needed to support more advanced techniques such as generational collection, large object spaces, and type-segregated areas. Our experiments are made possible by a novel performance analysis tool, Oscar. Oscar allows us to capture snapshots of programming language heaps that may then be used to replay garbage collections. The replay program is self-contained and written in C, which makes it easy to port to other architectures and to analyze with standard performance analysis tools. Furthermore, it is possible to study additional programming languages simply by instrumenting existing implementations to capture heap snapshots. In general, we found that careful implementation of GC mechanisms can have a significant benefit. For a simple collecto...

. Larchant-RDOSS is a distributed shared memory that persists on reliable storage across process lifetimes. Memory management is automatic: caching of data and of locks, coherence, collecting objects unreachable from the persistent root, writing reachable objects to disk, and reducing store fragmentation. Memory management is based on a novel garbage collection algorithm, that (i) approximates a global trace by a series of partial traces within dynamically determined subsets of the memory, (ii) causes no extra I/O or locking traffic, and (iii) needs no extra synchronization between the collector and the application processes. This results in a simple programming model, and expected minimal added application latency. The algorithm is designed for the most unfavorable environment (uncontrolled programming language, reference by pointers, non-coherent shared memory) and should work well also in more favorable settings. 1 Introduction The Reliable Distributed Object Storage System (Larcha...

Caching and persistence support efficient, convenient and transparent distributed data sharing. The most natural model of persistence is persistence by reachability, managed automatically by a garbage collector (GC). We propose a very general model of such a system (based on distributed shared memory) and a scalable, asynchronous distributed GC algorithm. Within this model, we show sufficient and widely applicable correctness conditions for the interactions between applications, store, memory, coherence, and GC.

We describe an efficient server-based algorithm for garbage collecting object-oriented databases in a workstation/server environment. The algorithm is incremental and runs concurrently with client transactions, however, it does not hold any locks on data and does not require callbacks to clients. It is fault tolerant, but performs very little logging. The algorithm has been designed to be integrated into existing OODB systems, and therefore it works with standard implementation techniques such as two-phase locking and write-ahead-logging. In addition, it supports client-server performance optimizations such as client caching and flexible management of client buffers. We describe an implementation of the algorithm in the EXODUS storage manager and present results from an initial performance study of the implementation. These results demonstrate that the introduction of the garbage collector adds minimal overhead to client operations. 1 Introduction A primary strength of Object Oriented...

We describe the PerDiS persistent distributed store and its garbage collection algorithm. The PerDiS store behaves like an object-oriented persistent shared memory, and is accessed transactionally. Applications get direct access to persistent data in their own memory, and use the usual C/C++ pointer dereferencing and assignment to navigate and modify the object graph. PerDiS provides persistence by reachability based on the Larchant algorithm. We focus on the issues of implementation for large-scale sharing. The main problems we face involve concurrency, ordering and consistency. We also address performance/modularity trade-offs. 1 Introduction This article describes the integration of the Larchant distributed garbage collection algorithm [8] into PerDiS, a persistent distributed store. PerDiS [16, 22] is a Long Term Research ESPRIT project, aiming at the design and implementation of a large-scale PERsistent DIstributed Store, for cooperative engineering applications. Persistence is b...

PMOS is an incremental garbage collector designed specifically to reclaim space in a persistent object store. It is complete in that it will, after a finite number of invocations, reclaim all unreachable storage. PMOS imposes minimum constraints on the order of collection and offers techniques to reduce the I/O traffic induced by the collector. Here we present the first implementation of the PMOS collector called PMOS#1. The collector has been incorporated into the stable heap layer of the generic persistent object store used to support a number of languages including Napier88. Our main design goals are to maintain the independence of the language from the store and to retain the existing store interface. The implementation has been completed and tested using a Napier88 system. The main results of this work show that the PMOS collector is implementable in a persistent store and that it can be built without requiring changes to the language interpreter. Initial performance ...