Limits of parallel marking garbage collection

@inproceedings{Siebert2008LimitsOP,
  title={Limits of parallel marking garbage collection},
  author={Fridtjof Siebert},
  booktitle={ISMM '08},
  year={2008}
}
More and more, parallel multicore systems will be used even in low-end devices such as embedded controllers that require realtime guarantees. When garbage collection is used in these systems, parallel or concurrent garbage collection brings important performance advantages. In the context of realtime systems, it has to be shown that a parallel garbage collector implementation not only performs well in most cases, but guarantees on its performance in the worst case are required. 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.

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.

Hard real-time garbage collection for a Java chip multi-processor

A hard real-time garbage collector for a Java chip multi-processor that provides non-disruptive and analyzable behavior, and a hardware unit that enables transparent, preemptible copying of objects, which eliminates the need to block tasks while copying objects.

A study of thread-local garbage collection for multi-core systems

This thesis evaluates a novel thread-local heap garbage collector for Java, that is designed to improve the effectiveness of this thread-independent garbage collection.

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.

Using Transactional Memory to Synchronize an Adaptive Garbage Collector in Real-Time Java

  • M. T. Higuera-Toledano
  • Computer Science
    2011 14th IEEE International Symposium on Object/Component/Service-Oriented Real-Time Distributed Computing Workshops
  • 2011
Hardware Transactional Memory is proposed to use TM to synchronize the concurrent/parallel execution of the Garbage Collector and Java applications, within the context of an embedded real-time environment.

Research on Algorithm of Parallel Garbage Collection Based on LISP 2 for Multi-core System

A parallel copying garbage collector designed for shared-memory multi-core systems or multiprocessor systems in the base of classical LISP2 algorithm that overcomes the earlier parallel copying collector's drawback.

Iterative data-parallel mark&sweep on a GPU

A parallel mark-and-sweep collector to collect GPU memory on the GPU and tune its performance to achieve a speedup of a factor of up-to 11 over a sequential collector on the same GPU.

Garbage collection optimization for non uniform memory access architectures

This research evaluates the new NUMA-aware garbage collector using seven benchmarks of an established real-world DaCapo benchmark suite and designs and implements a runtime technique, which involves heuristics from dynamic collection behavior to calculate an optimal number of garbage collector threads for each collection cycle.

The Garbage Collection Handbook: The art of automatic memory management

The Garbage Collection Handbook: The Art of Automatic Memory Management brings together a wealth of knowledge gathered by automatic memory management researchers and developers over the past fifty years and addresses new challenges to garbage collection made by recent advances in hardware and software.

References

SHOWING 1-10 OF 29 REFERENCES

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.

On bounding time and space for multiprocessor garbage collection

The first multiprocessor garbage collection algorithm with provable bounds on time and space is presented, and it is proved that the algorithm requires at most 2(R(l + 2/k) + N + 5PD) memory locations.

List Processing in Real Time on a Serial Computer

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.

List processing in real time on a serial computer

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.

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.

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.

Controlling fragmentation and space consumption in the metronome, a real-time garbage collector for Java

This paper presents a more detailed analysis of fragmentation than in previous work, and shows how the collector is able to bound fragmentation to acceptable limits, and bound both the time for collection and consequently the space overhead required much more tightly.

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.

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

Measurements indicate that VCGC can substantially reduce worst-case pause latencies as well as reduce overall memory usage, and remark that the degrees of freedom on the rates of marking and sweeping enable exploration of a range of resource tradeoffs, but makes "optimal" tuning for even a small set of applications difficult.

A Scalable Mark-Sweep Garbage Collector on Large-Scale Shared-Memory Machines

This work describes implementation of a mark-sweep garbage collector for shared-memory machines and reports its performance, and observed that the implementation detail affects the performance heavily.