Abstract not found

We describe a replicating garbage collector for a persistent heap. The garbage collector cooperates with a transaction manager to provide safe and efficient transactional storage management. Clients read and write the heap in primary memory and can commit or abort their write operations. When write operations are committed they are preserved in stable storage and survive system failures. Clients can freely access the heap during garbage collection because the collector concurrently builds a compact replica of the heap. A log captures client write operations and is used to support both the transaction manager and the replicating garbage collector. Our implementation is the first to provide concurrent and compacting garbage collection of a persistent heap. Measurements show that concurrent replicating collection produces significantly shorter pause times than stop-and-copy collection. For small transactions, throughput is limited by the logging bandwidth of the underlying log manager. The results suggest that replicating garbage collection offers a flexible and efficient way to provide automatic storage management in transaction systems, object-oriented databases and persistent programming environments.

The main-memory management of an object cache that provides an orthogonally persistent platform for Java is described. Features of the architecture include: two levels of buffering between the disk and virtual machine, a consistent representation of transient and active objects, an efficient residency checking algorithm in the presence of multiple threads of execution, and well developed object-cache management technology. We present some of the challenges of providing persistence for the Java virtual machine, which may be typical of any attempt at an industrial-strength orthogonally persistent programming system. Some of these might have been avoided by sacrificing persistence independence, but that is far too valuable to sacrifice. We report on some detailed investigations of pinning and cache replacement techniques applicable in this context. The information available for eviction-victim selection is inevitably limited by imprecise information about the state of the machine and the ...

We describe the design of a transaction facility for a language that supports higher-order functions. We factor transactions into four separable features: persistence, undoability, locking, and threads. Then, relying on function composition, we show how we can put them together again. Our "Tinkertoy" approach towards building transactions enables us to construct a model of concurrent, nested, multi-threaded transactions, as well as other non-traditional models where not all features of transactions are present. Key to our approach is the use of higher-order functions to make transactions first-class. Not only do we get clean composability of transactional features, but also we avoid the need to introduce special control and block-structured constructs as done in more traditional transactional systems. We implemented our design in Standard ML of New Jersey. This research is sponsored in part by the Wright Laboratory, Aeronautical Systems Center, Air Force Materiel Command, USAF, and the...