This paper reports our experiences with a mostly-concurrent incremental garbage collector, implemented in the context of a high performance virtual machine for the Java ™ programming language. The garbage collector is based on the “mostly parallel ” collection algorithm of Boehm et al., and can

By combining existing type systems with standard typebased compilation techniques, we describe how to write strongly typed programs that include a function that acts as a tracing garbage collector for the program. Since the garbage collector is an explicit function, we do not need to provide a

. This paper describes the design and the evaluation of Complementary Garbage Collector that is a fundamental algorithm for the parallel and incremental garbage collector. Our algorithm is a combination of two types of fundamental algorithms, incremental update and snapshot-at-beginning, which

A conservative garbage collector can typically be used with conventionally compiled programs written in C or C++. But two safety issues must be considered. First, the source code must not hide pointers from the garbage collector. This primarily requires stricter adherence to existing restrictions

Abstract. We give an algebraic characterisation of reachability and non-reachability in modal Kleene algebras. By this we derive a general algorithm for garbage collectors and present some further algebraic opti-misations. The given approach is fully expressible in first-order logic and hence

We analyze the performance of several copying garbage collection algorithms in a large address space offered by modern architectures. In particular, we describe the design and implementation of the RealOF garbage collector, an algorithm explicitly designed to exploit the features of 64-bit

Even if garbage collectors are widely used in modern software platforms, performance models tend to ignore their presence. This paper uses benchmark experiments to show that the impact of garbage collection might be significant and to suggest possible approaches leading to incorporation of garbage

Based on an experiment comparing two garbage collection algorithms on a large, long running Lisp program, we find that a simple, two generation, stop-andcopy collector is equal or superior to a complex, multigeneration incremental collector in every measured area except paging performance

This paper describes a new way of solving the storage reclamation problem for a system such as Lisp that allocates storage automatically from a heap, and does not require the programmer to give any indication that particular items are no longer useful or accessible. A reference count scheme for reclaiming non-self-referential structures, and a linearizing, compacting, copying scheme to reorganize all storage at the users discretion are proposed. The algorithms are designed to work well in systems which use multiple levels of storage, and large virtual address space. They depend on the fact that most cells are referenced exactly once, and that reference counts need only be accurate when storage is about to be reclaimed. A transaction file stores changes to reference counts, and a multiple reference table stores the count for items which are referenced more than once.

Garbage collectors are notoriously hard to verify, due to their low-level interaction with the underlying system and the general dif-ficulty in reasoning about reachability in graphs. Several papers have presented verified collectors, but either the proofs were hand-written or the collectors were