A study of concurrent real-time garbage collectors

  title={A study of concurrent real-time garbage collectors},
  author={Filip Pizlo and Erez Petrank and Bjarne Steensgaard},
  booktitle={ACM-SIGPLAN Symposium on Programming Language Design and Implementation},
Concurrent garbage collection is highly attractive for real-time systems, because offloading the collection effort from the executing threads allows faster response, allowing for extremely short deadlines at the microseconds level. [] Key Method Both collectors obtain reduced complexity over the first collector STOPLESS, but need to trade a benefit for it. We study the algorithmic strengths and weaknesses of CLOVER and CHICKEN and compare them to STOPLESS. Finally, we have implemented all three collectors on…

Figures and Tables from this paper

Concurrent, parallel, real-time garbage-collection

This paper explains how the single-CPU real-time GC of the Java implementation JamaicaVM was changed to make it a hard real- time garbage collector that is parallel and concurrent.

A Study of Lock-Free Based Concurrent Garbage Collectors for Multicore Platform

  • Hao WuZ. Ji
  • Computer Science
  • 2014
This paper presents a lock-free solution for constructing a highly concurrent garbage collector that adopts CAS/MCAS synchronization primitives to guarantee that the programs will never be blocked by the collector thread while the garbage collection process is ongoing.

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.

Parallel Real-Time Garbage Collection

Two implementations, Metronome-TS and JamaicaVM will be presented in more detail since these two represent two typical instances of the time-based and work-based approaches of running the garbage collector.

Nonblocking real-time garbage collection

An interruptible copy unit is presented that implements nonblocking object copy and can be interrupted after a single word move, and is evaluated as a real-time garbage collector that uses the proposed techniques on a Java processor.

A lock-free, concurrent, and incremental stack scanning mechanism for garbage collectors

This work proposes the first concurrent, incremental, and lock-free stack scanning mechanism for garbage collectors, that allows high responsiveness and support for programs that employ fine-grain synchronization to avoid locks.

Adaptive optimization of the Sun Java™ real-time system garbage collector

A framework for dynamically adapting the StartupMemoryThreshold for achieving the optimal balance between the application's throughput and pause time is presented, which was integrated into the beta release of Java RTS 2.2.

A lock-free, concurrent, and incremental stack scanning for garbage collectors

This work proposes the first concurrent, incremental, and lock-free stack scanning for garbage collectors, allowing high responsiveness and support for programs that employ fine-synchronization to avoid locks.

Blade: A Data Center Garbage Collector

This work describes Blade, an API between the collector and application developer that allows developers to leverage existing failure recovery mechanisms in distributed systems to coordinate collection and bound the latency impact, and implements it for the Go programming language.

Tracing garbage collection on highly parallel platforms

This paper investigates the scalability of parallel heap tracing, which stands at the core of the garbage collection activity, and proposes and implements a prototype of garbage collection techniques that attempt to ameliorate the object-graph shape problem.



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.

A parallel, real-time garbage collector

This paper presents the extensions necessary for a practical implementation of a parallel, real-time garbage collector: reducing excessive interleaving, handling stacks and global variables, reducing double allocation, and special treatment of large and small objects.

A real-time garbage collector with low overhead and consistent utilization

Now that the use of garbage collection in languages like Java is becoming widely accepted due to the safety and software engineering benefits it provides, there is significant interest in applying

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

A parallel, incremental, mostly concurrent garbage collector for servers

This work designed and implemented a collector facing these demands building on the mostly concurrent garbage collector proposed by Boehm et al.

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.

Time-triggered garbage collection: robust and adaptive real-time GC scheduling for embedded systems

Time-triggered GC allows a more high-level view on GC scheduling; it looks at the GC cycle level rather than at the individual work increments, which makes it possible to schedule GC as any other thread.

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.

The pauseless GC algorithm

The Pauseless GC algorithm is presented, the supporting hardware features that enable it, and data on the overhead, efficiency, and pause times when running a sustained workload is presented.