Managing cross-generation object references efficiently is critical for generational collectors. When a minor garbage collection occurs, the virtual machine must identify objects in the Young Generation that are still referenced by objects residing in the Old Generation. Scanning the entire Old Generation every cycle wouldd severely degrade throughput. To resolve this performance bottleneck, HotSpot maintains a remembered set, which is physically implemented using a card table.

Conssider a scenario where an Old Generation instance holds a reference to a Young Generation instance:

public class PersistentEntity {
    TemporaryItem tempReference;
}

public class TemporaryItem {}

During a Young Generation collection, the JVM cannot safely ignore PersistentEntity. The card table divides the heap into fixed-size memory pages (traditionally 512 bytes per card). Any Old Generation reference pointing toward the Young Generation updates the corresponding card's state. The remembered set stores metadata about these cards, allowing the collector to scan only relevant memory segments rather than traversing the entire tenured space. This relationship mirrors how a concrete implementation satisfies an interface—the card table provides the underlying storage mechanism for the remembered set abstraction.

Core Architecture and Memory Layout

The G1 collector utilizes a copying algorithm explicitly optimized for multi-core environments and expansive memory footprints. Unlike traditional collectors that pre-define rigid boundaries between generations, G1 partitions the heap into multiple equal-sized physical units called regions. By default, a large heap divides into 2048 regions, each sized at 2 MB. These sizes are configurable between 1 MB and 32 MB, always adhering to powers of two.

Logically, these regions dynamically map to three categories:

• Young Generation: Contains Eden spaces and Survivor spaces.
• Old Generation: Stores long-lived objects surviving multiple collection cycles.
• Humongous Objects: Reserved for exceptionally large allocations that span one or more contiguous regions.

Generation assignment remains fluid. As the application executes, regions transition states based on real-time allocation patterns and usage metrics. The initial Young Generation allocation typically consumes around 5% of the total heap, adjustable via configuration directives. Region allocation during runtime determines whether a block becomes young, old, or humongous territory based on immediate workload demands.

Collection Lifecycle and Phases

G1's primary collection cycle mirrors concurrent marking strategies but optimizes strictly for predictable stop-the-world pauses:

1. Initial Mark: A brief STW phase that traces direct references from GC roots to immediate children. Similar to other collectors, this step identifies entry points into the object graph.
2. Concurrent Mark: Executes alongside user threads. Traverses the object graph to mark all reachable instances. Continuations and modifications are tracked to maintain consistency throughout the traversal.
3. Final Remark: Another STW window that reconciles changes made during the concurrent phase. It corrects anomalies like missed pointers or over-counted objects discovered after the background scan.
4. Selective Reclaim: The collector evaluates each region's garbage-to-live ratio and estimates cleanup duration. Regions requiring less time to process are prioritized. This predictive mechanism ensures compliance with configured pause targets. Unreclaimed fragmentation temporarily becomes floating garbage, deferred to subsequent cycles.

Collection Trigger Mechanisms

G1 employs distinct collection types based on heap dynamics and latency goals:

• Young GC: Activation depends on pause time forecasting rather than strict capacity thresholds. If expanding Eden can accommodate new allocations within the latency budget, growth proceeds. Once the forecast breaches the target, Young GC initiates.
• Mixed GC: Triggered when the Old Generation occupancy surpasses a defined heap percentage. This phase consolidates Young, Old, and Humongous regions. The collector filters out regions where live object density exceeds the recycling efficiency threshold, skipping those deemed too expensive to compact.
• Full GC: Acts as a fallback when the copying algorithm encounters severe allocation failures or insufficient survivor space during Mixed GC. Execution switches to a single-threaded, complete STW operation involving marking, scavenging, and defragmentation. This mirrors catastrophic concurrent mode failures observed in older architectures.

Configuration Directives

Fine-tuning requires precise parameter adjustments. Below are essential flags governing collector behavior:

Parameter	Description
-XX:+UseG1GC	Enables the G1 collector.
-XX:ParallelGCThreads	Dictates thread count for parallel collection tasks.
-XX:G1HeapRegionSize	Sets region size (1MB–32MB, power-of-two). Defaults to dividing heap into 2048 blocks.
-XX:MaxGCPauseMillis	Defines acceptable pause duration (default 200ms).
-XX:G1NewSizePercent / -XX:G1MaxNewSizePercent	Bounds Young Generation memory footprint relative to total heap.
-XX:TargetSurvivorRatio	Percentage threshold triggering promotion to Old Generation. If combined age-weighted objects exceed this value in Survivors, older cohorts transfer upward.
-XX:MaxTenuringThreshold	Maximum survival count before forced promotion (default 15).
-XX:InitiatingHeapOccupancyPercent	Old Generation occupancy trigger for Mixed GC initiation (default 45%).
-XX:G1MixedGCLiveThresholdPercent	Minimum live object percentage required to justify region reclamation during Mixed GC (default 85%).
-XX:G1MixedGCCountTarget	Maximum consecutive reclaim cycles allowed before pausing to yield CPU time back to the application. Prevents excessive single-run interruptions.
-XX:G1HeapWastePercent	Threshold defining acceptable empty region ratio post-collection (default 5%). Reaches this cap halts further Mixed GC operations.

Historical heap sizing guidelines traditionally suggest legacy parallel collectors for sub-4 GB footprints, hybrid generational approaches for 4–8 GB workloads, and G1 for distributions exceeding 8 GB where consistent throughput and bounded latency converge. The internal memory topology follows a modular region grid, executing cycles through sequential phase progression without predefined static generation demarcations.