Implementing an on-the-fly garbage collector for Java

Abstract

Java uses garbage collection (GC) for the automatic reclamation of computer memory no longer required by a running application. GC implementations for Java Virtual Machines (JVM) are typically designed for single processor machines, and do not necessarily perform well for a server program with many threads running on a multiprocessor. We designed and implemented an on-the-fly GC, based on the algorithm of Doligez, Leroy and Gonthier [13,12] (DLG), for Java in this environment. An on-the-fly collector, a collector that does not stop the program threads, allows all processors to be utilized during collection and provides uniform response times. We extended and adapted DLG for Java (e.g., adding support for weak references) and for modern multiprocessors without sequential consistency, and added performance improvements (e.g., to keep track of the objects remaining to be traced). We compared the performance of our implementation with stop-the-world mark-sweep GC. Our measurements show that the performance advantage for our collector increases as the number of threads increase and that it provides uniformly low response times.

Space overhead bounds for dynamic memory management with partial compaction

“…We continued this investigation with a study of a specific widely used memory allocator: the segregated free list allocator (used for example in [2,6,8]). Fixing a specific allocator allows a more accurate analysis and yields better bounds.…”

“…It is possible that a program can cause more overhead to a given specific allocator. One very common memory allocator is the segregated free list allocator, and in particular, the one that is block-oriented (e.g., [2,6,8]). In this section we study limits of this specific allocator and prove tighter lower bounds based on its specific behavior.…”

“…An allocation request is serviced from the appropriate list. Segregated free lists are typically implemented in a block oriented manner [2,6,8]. The heap is partitioned into blocks (typically, of a page size, i.e., 4KB) and each block may only contain objects of one size.…”

Packer: An innovative space-time-efficient parallel garbage collection algorithm based on virtual spaces

“…Conventional garbage collectors utilize Mark-Sweep algorithms [14,15,16] to manage the whole heap. When the heap has no more free space, GC is triggered and the collectors start to trace the heap.…”

Verifying a Concurrent Garbage Collector Using a Rely-Guarantee Methodology

“…Many on-the-fly algorithms are inherently racy, and some algorithms never require application threads (called mutators) to wait for the collector thread, which detects and frees unused memory. This paper focuses on an emblematic algorithm in this landscape [5,3,4], where no locks are required -i.e. it is lock-free.…”