Very concurrent mark-&-sweep garbage collection without fine-grain synchronization

@inproceedings{Huelsbergen1998VeryCM,
  title={Very concurrent mark-\&-sweep garbage collection without fine-grain synchronization},
  author={Lorenz Huelsbergen and Phil Winterbottom},
  booktitle={ISMM '98},
  year={1998}
}
We describe a new incremental algorithm for the concurrent reclamation of a program's allocated, yet unreachable, data. Our algorithm is a variant of mark-&-sweep collection that---unlike prior designs---runs mutator, marker, and sweeper threads concurrently without explicit fine-grain synchronization on shared-memory multiprocessors. A global, but infrequent, synchronization coordinates the per-object coloring marks used by the three threads; fine-grain synchronization is achieved without… 

Figures and Tables from this paper

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.
A Flexible , Efficient Concurrent Garbage Collector for Speculative Thread Processors
TLDR
A novel garbage collector for Java to be used for processors with speculative threads support like the Hydra chip multiprocessor (CMP) is introduced, augmented Dijkstra’s classical on-the-fly mark and sweep collector to take advantage of the CMP's thread-level speculation and low-latency interprocessor communication.
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.
Scalable real-time parallel garbage collection for symmetric multiprocessors
TLDR
This thesis describes the first parallel, real-time garbage collection algorithm using an abstract symmetric multiprocessor model and proves space and time bounds guaranteeing that every application pause is constant and that the collector takes bounded space.
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.
A multithreaded concurrent garbage collector parallelizing the new instruction in Java
  • D. Lo, W. Srisa-an, J. Chang
  • Computer Science
    Proceedings 16th International Parallel and Distributed Processing Symposium
  • 2002
TLDR
A new multithreaded concurrent generational garbage collector (MCGC) based on mark-sweep with the assistance of reference counting is proposed that can take advantage of multiple CPUs in an SMP system and the merits or light weight processes.
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.
Lightweight and block-level concurrent sweeping for javascript garbage collection
TLDR
A lightweight, block-level concurrent sweeping mechanism for a mark-and-sweep garbage collector that is implemented in JavaScript Core engine embedded in the WebKit browser and evaluated on an ARM-based mobile system to show that memory utilization of the system is significantly improved without performance degradation.
Concurrent garbage collection using hardware-assisted profiling
In the presence of on-chip multithreading, a Virtual Machine (VM) implementation can readily take advantage of service threads for enhancing performance by performing tasks such as profile collection
A performance comparison between stop-the-world and multithreaded concurrent generational garbage collection for Java
  • C. Lo, W. Srisa-an, J.M. Chang
  • Computer Science
    Conference Proceedings of the IEEE International Performance, Computing, and Communications Conference (Cat. No.02CH37326)
  • 2002
TLDR
In this paper, the performance evaluation of a new multithreaded concurrent generational garbage collector (MCGC) based on mark-sweep with the assistance of reference counting is reported and results indicate that the MCGC improves the garbage collection pause time up to 96.75% over the traditional stop-the-world mark-Sweep garbage collector.
...
...

References

SHOWING 1-10 OF 44 REFERENCES
A concurrent copying garbage collector for languages that distinguish (im)mutable data
TLDR
Measurements of this collector in a Standard ML compiler on a shared-memory computer indicate that it eliminates perceptible garbage-collection pauses by reclaiming storage in parallel with the computation proper.
Mark DURING Sweep rather than Mark THEN Sweep
TLDR
On-the-fly GC schemes were introduced to permit an application and a collector to run concurrently and that concurrency may lessen the GC penalty incurred by the application.
List processing in real time on a serial computer
TLDR
A real-time list processing system is presented which continuously reclaims garbage, including directed cycles, while linearizing and compacting the accessible cells into contiguous locations to avoid fragmenting the free storage pool.
Mostly parallel garbage collection
TLDR
A method for adapting garbage collectors designed to run sequentially with the client, so that they may run concurrently with it, has been used to construct a mostly parallel trace-and-sweep collector that exhibits very short pause times.
Implementation of multilisp: Lisp on a multiprocessor
TLDR
Multilisp is an extension of Lisp (more specifically, of the Lisp dialect Scheme) with additional operators and additional semantics to deal with parallel execution with novel techniques used for task scheduling and garbage collection.
Real-time replication garbage collection
TLDR
The first copying garbage collector is implemented that permits continuous unimpeded mutator access to the original objects during copying and uses a mutation log to bring the replicas up-to-date with changes made by the mutator.
Uniprocessor Garbage Collection Techniques
We survey basic garbage collection algorithms, and variations such as incremental and generational collection. The basic algorithms include reference counting, mark-sweep, mark-compact, copying, and
A concurrent, generational garbage collector for a multithreaded implementation of ML
TLDR
This paper presents the design and implementation of a “quasi real-time” garbage collector for Concurrent Caml Light, an implementation of ML with threads that crucially relies on the ML compile-time distinction between mutable and immutable objects.
A real-time garbage collector based on the lifetimes of objects
TLDR
This work presents a garbage collection algorithm that makes storage for short-lived objects cheaper than storage for long-livedObjects, that operates in real time, increases locality of reference, for better virtual memory performance, and works well with multiple processors and a large address space.
A LISP garbage-collector for virtual-memory computer systems
TLDR
A garbage-collection algorithm for list-processing systems which operate within very large virtual memo, ies is described, which is more the compaction of active storage than the discovery of free storage.
...
...