An efficient on-the-fly cycle collection

  title={An efficient on-the-fly cycle collection},
  author={Harel Paz and David F. Bacon and Elliot K. Kolodner and Erez Petrank and V. T. Rajan},
A reference-counting garbage collector cannot reclaim unreachable cyclic structures of objects. Therefore, reference-counting collectors either use a backup tracing collector infrequently, or employ a cycle collector to reclaim cyclic structures. We propose a new concurrent cycle collector, one that runs concurrently with the program threads, imposing negligible pauses (of around 1ms) on a multiprocessor. Our new collector combines a state-of-the-art cycle collector [Bacon and Rajan 2001] with… 

Figures and Tables from this paper

Efficient Concurrent Mark-Sweep Cycle Collection

MSCD is responded to with MSCD, a concurrent tracing algorithm that takes advantage of information available within a reference counted environment and outperforms alternatives such as trial deletion and backup tracing by up to a factor of two.

A simple and efficient algorithm for cycle collection

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.

A Single-Trace Cycle Collection for Reference Counting Systems

A novel cycle collection algorithm which can detect garbage cycles in a single trace over cycle candidates is presented and the algorithm and the correctness proof are described in detail.

A Lightweight Cyclic Reference Counting Algorithm

A "lightweight" cycle detector, which is based on the partial tracing approach but collects garbage cycles in a simpler and more efficient way.

TR-CS-09-02 Efficient Concurrent Mark-Sweep Cycle Collection

It is shown that MSCD works with state of the art reference counting collectors — which allow large numbers of heap mutations to be ignored — without affecting the correctness or completeness of the algorithm.

Concurrent, parallel garbage collection in linear time

A new concurrent garbage collection algorithm based on two types of reference, strong and weak, to link the graph of objects, which is linear in total time and can run in parallel with a live system without "stopping the world".

Efficient memory management for servers

The ageoriented collector is introduced, which exploits the generational hypothesis best when used with reference counting, to obtain highly efficient collection and a new onthe-fly cycle collection algorithm to accompany the reference-counting sliding-views collector.

Compiler optimizations for nondeferred reference: counting garbage collection

This paper presents a series of optimizations that target the stack and substantially enhance the throughput of nondeferred RC collection, including a new static analysis and optimization called RC subsumption that significantly reduces the overhead of maintaining the stack contribution to reference counts.

Soft real-time garbage collection for dynamic dispatch languages

This work investigates various schemes for the efficient implementation of soft real-time multi-generation garbage collection algorithms within dynamic dispatch languages and describes the implementation of a production uniprocessor collector for Haskell, and evaluates its performance against implementations of existing algorithms.

High Performance Reference Counting and Conservative Garbage Collection

This thesis is that reference counting and conservative garbage collection can perform as well or better than the best performing garbage collectors.



Efficient Onthe-Fly Cycle Collection

An improved on-the-fly cycle collector is presented by combining techniques developed in that paper with the sliding views collectors, which improves over the efficiency of the original collector significantly, making the cycle collection solution usable in practice.

Concurrent Cycle Collection in Reference Counted Systems

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.

An on-the-fly reference-counting garbage collector for java

A novel reference-counting algorithm suitable for a multiprocessor system that does not require any synchronized operation in its write barrier (not even a compare-and-swap type of synchronization) and allows eliminating a large fraction of thereference-count updates, thus, drastically reducing the reference- Counting traditional overhead.

Integrating generations with advanced reference counting garbage collectors

It turns out that a modern reference counting collector may benefit from the use of generations, and a new collector appropriate for running on a multiprocessor is designed.

An on-the-fly mark and sweep garbage collector based on sliding views

A novel mark and sweep on-the-fly algorithm based on the sliding views mechanism of Levanoni and Petrank that outperforms the Jikes concurrent collector by up to 60% and may be used as a backup collector for the LeVanoni-Petrank reference counting collector.

A generational on-the-fly garbage collector for Java

Comparing the incorporation of generations into an on-the-fly collector with and without generations, it turns out that the generational collector performs better for most applications.

Age-Oriented Concurrent Garbage Collection

A new collection approach is proposed, denoted age-oriented collection, for exploiting the generational hypothesis to obtain better efficiency, particularly useful when reference counting is used to collect the old generation, yielding a highly efficient and non-obtrusive on-the-fly collector.

Implementing an on-the-fly garbage collector for Java

Measurements show that the performance advantage for the collector increases as the number of threads increase and that it provides uniformly low response times, compared with stop-the-world mark-sweep GC.

A generational mostly-concurrent garbage collector

This paper reports the experiences with a mostly-concurrent incremental garbage collector, implemented in the context of a high performance virtual machine for the Java#8482; programming language, which minimises maximum garbage collection pause times, while having only a small impact on the average garbage collectionpause time and overall execution time.

An efficient, incremental, automatic garbage collector

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