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

@inproceedings{Levanoni2006AnOR,
  title={An on-the-fly reference-counting garbage collector for java},
  author={Yossi Levanoni and Erez Petrank},
  booktitle={TOPL},
  year={2006}
}
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
Reference counting is a garbage-collection technique that maintains a per-object count of the number of pointers to that object. When the count reaches zero, the object must be dead and can be
A fully concurrent garbage collector for functional programs on multicore processors
TLDR
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
TLDR
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
TLDR
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.
The space cost of lazy reference counting
TLDR
If each reference count operation is constrained to take constant time, then the overall space requirements can be increased by a factor of Ω(R) in the worst case, where R is the ratio between the size of the largest and smallest allocated object.
A study of concurrent real-time garbage collectors
TLDR
This paper proposes two additional algorithms for concurrent real-time garbage collection: CLOVER and CHICKEN, both of which obtain reduced complexity over the first collector STOPLESS, but need to trade a benefit for it.
Concurrent deferred reference counting with constant-time overhead
TLDR
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
TLDR
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.
Efficient Concurrent Mark-Sweep Cycle Collection
Since 1960, reference counting has been a popular means of garbage collection. Reference counters achieve low pause times by using local data to determine liveness, but the use of this local data
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 78 REFERENCES
Implementing an on-the-fly garbage collector for Java
TLDR
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
TLDR
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
TLDR
This work presents a compile-time analysis for higher-order functional languages that determines whether the lifetime of a reference exceeds the Lifetime of the environment in which the reference was created.
An on-the-fly mark and sweep garbage collector based on sliding views
TLDR
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.
An on-the-fly mark and sweep garbage collector based on sliding views
TLDR
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
TLDR
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
TLDR
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
TLDR
This work proposes three designs for combining two on-the-fly collectors so that the reference counting collector collects the young generation or the old generation or both, and implements these algorithms with the Jikes JVM and compared them against the concurrentreference counting collector supplied with theJikes package.
Real-time garbage collection on general-purpose machines
  • T. Yuasa
  • Computer Science
    J. Syst. Softw.
  • 1990
TLDR
Although the algorithm does not support compaction of the whole data space, it efficiently supports partial compaction such as array relocation, and reduces the execution overhead to a great extent.
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
...
1
2
3
4
5
...