What is the difference between background GC and the older concurrent GC in .NET, and how do GC latency modes affect pauses?

1. Timeline of a background GC with a foreground GC

app threads   ====|p|=====================|g0|=========================|p|=====
BGC thread         [start][  concurrent mark ......... ][final mark][  sweep  ]
foreground                                |g0|
 p = short pause    g0 = foreground (blocking) Gen 0 GC during the BGC

With the legacy concurrent GC, the g0 would not be allowed: a thread that ran out of Gen 0 space would wait until the concurrent Gen 2 finished.

2. How concurrent marking stays correct

While the background thread marks, the application keeps writing references. If the app stores a reference to an unmarked object into an already-scanned object, the GC could miss it. The runtime records modified memory using write watch (implemented in software via the write barrier in modern .NET). In the final pause, the GC re-scans modified pages/cards so nothing live is missed.

That is also why background GC has a small ongoing cost: the write barrier variant used while a BGC is in progress does extra work.

3. Why background GC can't compact

Compaction moves objects and rewrites references. Doing that while app threads run would need read barriers (check-and-forward on every reference load) or a stop-the-world phase. .NET chose not to put read barriers on every load for performance, so concurrent work is limited to marking and sweeping. When fragmentation matters, the GC decides to do a blocking compacting Gen 2 instead.

4. Background GC with Server GC

• Each heap has a background GC thread in addition to its foreground GC thread.
• Foreground ephemeral GCs during a BGC run in parallel across heaps.
• With DATAS (.NET 9+), the number of heaps, and therefore GC threads, adapts to load.

5. No-GC regions in detail

const long budget = 32 * 1024 * 1024;
if (GC.TryStartNoGCRegion(budget))
{
    try
    {
        RunMatchingBurst();   // must allocate less than the budget
    }
    finally
    {
        if (GCSettings.LatencyMode == GCLatencyMode.NoGCRegion)
            GC.EndNoGCRegion();
    }
}

• TryStartNoGCRegion may perform a GC first to make the space available.
• There is a maximum budget (related to ephemeral space size); large values throw ArgumentOutOfRangeException.
• Exceeding the budget silently ends the region (a GC can then occur); EndNoGCRegion would then throw, hence the check.
• .NET 8+ adds GC.RegisterNoGCRegionCallback to be notified if the budget is exhausted.
• You cannot set GCSettings.LatencyMode = NoGCRegion directly.

6. Seeing GC types in traces

In-process: GC.GetGCMemoryInfo(GCKind.Background), GCKind.FullBlocking, GCKind.Ephemeral return the most recent GC of each kind, with pause durations and whether it compacted.

7. Version notes

8. Try it yourself

1. Run the code example and confirm the default mode is Interactive.
2. Run with DOTNET_gcConcurrent=0 and confirm Batch; compare GC.GetGCMemoryInfo(GCKind.Background).Index (stays 0).
3. Allocate and retain ~500 MB of small objects in a loop while timing a separate thread's iterations; compare max iteration latency with concurrent on and off.
4. Try GC.TryStartNoGCRegion with a budget smaller than what you allocate and observe the mode change and the exception if you call EndNoGCRegion unconditionally.
5. Capture dotnet-trace collect --profile gc-collect under load and find ForegroundGC entries occurring inside a BackgroundGC in PerfView.

using System.Runtime;

Console.WriteLine($"Default latency mode: {GCSettings.LatencyMode}");  // Interactive with background GC

// Critical period: avoid blocking full GCs where possible
GCLatencyMode previous = GCSettings.LatencyMode;
GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency;
try
{
    ProcessMarketOpen();
}
finally
{
    GCSettings.LatencyMode = previous;
}

// Very short burst with a bounded allocation budget
if (GC.TryStartNoGCRegion(16 * 1024 * 1024))
{
    try
    {
        var batch = new byte[64][];
        for (int i = 0; i < batch.Length; i++) batch[i] = new byte[64 * 1024];
        Console.WriteLine($"Allocated in no-GC region, mode: {GCSettings.LatencyMode}");
    }
    finally
    {
        if (GCSettings.LatencyMode == GCLatencyMode.NoGCRegion)
            GC.EndNoGCRegion();
    }
}

GCMemoryInfo bg = GC.GetGCMemoryInfo(GCKind.Background);
Console.WriteLine(bg.Index == 0 ? "No background GC yet" : $"Last background GC #{bg.Index}, gen {bg.Generation}");

static void ProcessMarketOpen()
{
    for (int i = 0; i < 1_000_000; i++) _ = new byte[128];
}