Garbage Collection

​

Available Collectors

​

G1 Garbage Collector

​

Architecture

“A G1CollectedHeap is an implementation of a java heap for HotSpot. It uses the Garbage First heap organization and algorithm, which may combine concurrent marking with parallel, incremental compaction of heap subsets that will yield large amounts of garbage.”

​

Region-Based Heap

• Eden regions - Young generation allocation targets
• Survivor regions - Objects that survived one GC
• Old regions - Long-lived objects
• Humongous regions - Large objects (> 50% of region size)

​

Key Components

// From g1CollectedHeap.hpp:
class G1CollectedHeap : public CollectedHeap {
  G1ConcurrentMark*      _concurrent_mark;
  G1HeapRegionManager*   _hrm;
  G1CollectionSet*       _collection_set;
  G1RemSet*              _rem_set;
  G1ConcurrentRefine*    _concurrent_refine;
  G1Allocator*           _allocator;
  // ...
};

​

Collection Phases

​

Card Tables and Remembered Sets

• Heap divided into 512-byte cards
• Modified cards tracked in per-region remembered sets
• Concurrent refinement threads process cards asynchronously
• Reduces young GC scanning to only relevant old regions

​

Z Garbage Collector

​

Design Goals

class ZCollectedHeap : public CollectedHeap {
  ZHeap             _heap;
  ZDriverMinor*     _driver_minor;  // Generational ZGC support
  ZDriverMajor*     _driver_major;
  ZDirector*        _director;      // Adaptive heuristics
  ZRuntimeWorkers   _runtime_workers;
  // ...
};

• Sub-millisecond pause times - Maximum 1ms pauses
• Terabyte+ heaps - Scales to multi-TB heap sizes
• Minimal throughput overhead - < 15% vs. Parallel GC

​

Colored Pointers

64-bit pointer layout:
+------------------------+-------+
| Object Address (42bit) | Metadata (4bit) | Unused (18bit) |
+------------------------+-------+
     ↑                        ↑
  Actual address         Marking/Relocation/Remapped bits

• Marked0/Marked1 - Concurrent marking state
• Remapped - Whether pointer has been updated
• Finalizable - Object has finalizer

​

Load Barriers

// User code:
Object obj = field.value;

// With load barrier:
Object obj = load_barrier(field.value);
  // Barrier checks pointer metadata
  // Heals pointer if needed (marking/relocation)
  // Returns correct reference

​

Collection Phases

1. Pause Mark Start (< 1ms) - Scan thread roots
2. Concurrent Mark - Traverse object graph
3. Pause Mark End (< 1ms) - Finalize marking
4. Concurrent Reference Processing - Process weak references
5. Concurrent Relocation Preparation - Select pages to relocate
6. Pause Relocate Start (< 1ms) - Relocate roots
7. Concurrent Relocation - Move objects, remap references

​

Generational ZGC

• Young generation for recently allocated objects
• Old generation for long-lived objects
• Reduces marking overhead for stable heaps
• Further improves throughput

​

Shenandoah Collector

​

Architecture

class ShenandoahHeap : public CollectedHeap {
  ShenandoahMode*             _mode;            // GC mode (satb/iu/passive)
  ShenandoahController*       _controller;
  ShenandoahConcurrentMark*   _concurrent_mark;
  ShenandoahFreeSet*          _free_set;
  ShenandoahPacer*            _pacer;           // Allocation pacing
  ShenandoahVerifier*         _verifier;
  // ...
};

​

Forwarding Pointers

• Brooks pointers - Indirection pointer at object start
• Objects have a forwarding pointer field
• During relocation, pointers updated to new location
• Read barriers check and follow forwarding pointers

​

Liveness Data

// Used for buffering per-region liveness data.
// uint16_t provides tradeoff between static/dynamic footprint
// and cache pressure during marking.
typedef uint16_t ShenandoahLiveData;
#define SHENANDOAH_LIVEDATA_MAX ((ShenandoahLiveData)-1)

​

Collection Modes

​

Evacuation and Pacing

• Concurrent Evacuation - Moves objects while application runs
• Allocation Pacing - Throttles allocation when GC can’t keep up
• Generational Support - Young and old generations (ShenandoahYoungGeneration, ShenandoahOldGeneration)

​

Serial Collector

• Single-CPU systems
• Small heaps (< 100MB)
• Batch jobs where pause time doesn’t matter
• Minimal memory footprint required

1. Mark live objects from roots
2. Compute forwarding addresses
3. Update all references
4. Move objects to compacted locations

​

Parallel Collector

• Young generation - Parallel Scavenge
• Old generation - Parallel Mark-Compact

• Maximum throughput prioritized over latency
• Adaptive sizing based on throughput/pause goals
• Excellent for batch processing and computations

• Longer pause times than G1/ZGC/Shenandoah
• Better throughput on multi-core systems
• Simpler than region-based collectors

​

Epsilon Collector

• Performance testing and benchmarking
• Ultra-short-lived applications
• Measuring GC overhead
• Testing GC interface contracts

​

Shared GC Infrastructure

​

Barrier Sets

• CardTableBarrierSet - Card marking for generational collectors
• G1BarrierSet - SATB and card marking for G1
• ShenandoahBarrierSet - Brooks pointer barriers
• ZBarrierSet - Load barriers for ZGC

​

Work Queues

typedef OverflowTaskQueue<ScannerTask, mtGC>  G1ScannerTasksQueue;
typedef GenericTaskQueueSet<G1ScannerTasksQueue, mtGC> G1ScannerTasksQueueSet;

​

Reference Processing

• Discovered during marking
• Processed at end of GC cycle
• Notifications enqueued for application
• Implemented in referenceProcessor.hpp

​

Selecting a Collector

​

Next Steps