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

  title={An on-the-fly reference-counting garbage collector for java},
  author={Yossi Levanoni and Erez Petrank},
  journal={ACM Trans. Program. Lang. Syst.},
Reference-counting is traditionally considered unsuitable for multiprocessor systems. According to conventional wisdom, the update of reference slots and reference-counts requires atomic or synchronized operations. In this work we demonstrate this is not the case by presenting 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). A second novelty of… 

Dusty caches for reference counting garbage collection

A new cache write-back policy is described that can substantially decrease the reference-counting traffic to RAM, and a cache design is investigated that takes advantage of temporally silent stores, by remebering the first-fetched value of a cache subblock, so that the subblock need not be written back to RAM unless a different value is present.

A fully concurrent garbage collector for functional programs on multicore processors

This paper presents a concurrent garbage collection method for functional programs running on a multicore processor, a concurrent extension of the bitmap-marking non-moving collector with Yuasa's snapshot-at-the-beginning strategy that achieves both efficient allocation and unobtrusive collection in an multicore system.

An efficient on-the-fly cycle collection

A new concurrent cycle collector is proposed, one that runs concurrently with the program threads, imposing negligible pauses (of around 1ms) on a multiprocessor, and eliminates the theoretical termination problem that appeared in the earlier concurrent cycle collection.

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.

Simple concurrent garbage collection almost without synchronization

We present two simple mark and sweep algorithms, A and B, for concurrent garbage collection by a single collector running concurrently with a number of mutators that concurrently modify shared data.

Concurrent deferred reference counting with constant-time overhead

The approach combines ideas from referencing counting and hazard pointers in a novel way to implement concurrent reference counting with wait-free, constant-time overhead and is significantly safer than manual techniques since objects are reclaimed automatically.

A reference-counting garbage collection algorithmfor cyclical functional programming

A novel algorithm is presented that combines both approaches to obtain reasonably efficient local mark-and-scan phases with a marking invariant that is rather cheap to maintain and is well-suited to a functional programming technique for cyclic data.

Stopless: a real-time garbage collector for multiprocessors

Stopless is the first collector that provides real-time responsiveness while preserving lock-freedom, supporting atomic operations, controlling fragmentation by compaction, and supporting modern parallel platforms.

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.

Yama: a scalable generational garbage collector for Java in multiprocessor systems

An on-the-fly generational garbage collector called Yama is proposed for multiprocessor systems and has an extremely low pause time in both the young and the old generation, which results in better response times for the user programs.



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.

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.

Static Analysis for Optimizing Reference Counting

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.

Java without the coffee breaks: a nonintrusive multiprocessor garbage collector

The Recycler is a fully concurrent pure reference counting garbage collector that is implemented in the Jalapeño Java virtual machine running on shared memory multiprocessors and achieves a maximum measured mutator delay of only 2.6 milliseconds for the authors' benchmarks.

Portable, unobtrusive garbage collection for multiprocessor systems

A new concurrent mark-and-sweep garbage collection algorithm that supports multiprocessor environments where the registers of running processes are not readily accessible, without imposing any overhead on the elementary operations of loading a register or reading or initializing a field.

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 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

Real-time concurrent collection on stock multiprocessors

A copying garbage-collection algorithm that is efficient, real-time, concurrent, runs on commercial uniprocessor and shared-memory multiprocessors, and requires no change to compilers is designed and implemented.