What is a Gen 2 (full) garbage collection in .NET, what triggers it, and how do you investigate frequent Gen 2 GCs?

1. The cost of a full GC

full GC cost ≈ mark(all live objects + references)
             + (if compacting) copy(live bytes) + update(all references)
             + sweep / free-list building (if not compacting)

A 4 GB heap made of a few large arrays is cheap to mark. A 1 GB heap made of 20 million small objects with many references is expensive. Object count and graph shape matter more than bytes.

2. Background GC timeline

app threads   ====||=========================================||=====
BGC thread         [initial mark]---[concurrent mark]---[final mark]---[sweep]
Gen 0/1 GCs              |g0|          |g1|        |g0|
                     ^ short pause                      ^ short pause

During a background GC, ephemeral (Gen 0/1) GCs can still run. Allocations continue, so the GC uses a write watch (software write watch tracking) to find objects modified during concurrent marking and re-checks them in the final pause.

3. When the GC chooses a blocking compacting full GC

• Fragmentation in Gen 2 is high and free lists can't satisfy allocations well.
• The process is close to GCHeapHardLimit or the container limit (the GC becomes more aggressive and compacts to avoid OOM).
• GC.Collect(2, GCCollectionMode.Forced, blocking: true, compacting: true) or GCSettings.LargeObjectHeapCompactionMode = CompactOnce followed by a blocking GC.
• Provisional decisions: an ephemeral GC can be escalated to a full GC based on tuning (seen as Gen 2 with an ephemeral-looking reason).

4. Reading GC data in-process

GCMemoryInfo full = GC.GetGCMemoryInfo(GCKind.FullBlocking);
GCMemoryInfo bgc  = GC.GetGCMemoryInfo(GCKind.Background);

Console.WriteLine($"Full blocking #{full.Index}: compacted={full.Compacted}, " +
                  $"pause={full.PauseDurations[0].TotalMilliseconds:N1} ms, " +
                  $"fragmented={full.FragmentedBytes:N0}, promoted={full.PromotedBytes:N0}");

Console.WriteLine($"Memory load {full.MemoryLoadBytes:N0} of {full.TotalAvailableMemoryBytes:N0} (high threshold {full.HighMemoryLoadThresholdBytes:N0})");

TotalAvailableMemoryBytes reflects the container limit or hard limit, which is a quick way to confirm what the GC thinks it has.

5. Latency control knobs (use with care)

6. Containers and hard limits

• With a container memory limit, the default GCHeapHardLimit is roughly 75% of that limit (configurable via GCHeapHardLimit / GCHeapHardLimitPercent).
• Approaching it, the GC becomes much more aggressive: more Gen 2 GCs, more compaction.
• GC.RefreshMemoryLimit() (.NET 8+) lets a process re-read changed limits.
• A pod that is OOM-killed with a small GC heap usually has native memory growth, which full GCs cannot fix.

7. Finding GC.Collect callers

• Search source: GC.Collect( and GCSettings.LargeObjectHeapCompactionMode.
• At runtime: collect dotnet-trace collect --profile gc-verbose (includes GC trigger stacks with the right providers) or attach a debugger with a breakpoint on System.GC.Collect.
• Libraries: older image-processing, reporting and "memory reporting" libraries are frequent offenders.

8. Version notes

9. Try it yourself

1. Run the code example and note how many Gen 2 GCs LOH churn produces, and the details of the last background and full blocking GCs.
2. Replace new byte[200_000] with ArrayPool<byte>.Shared.Rent(200_000) / Return and compare Gen 2 counts.
3. Add GC.Collect() every 100 iterations and look at the trace: the reason becomes Induced.
4. Run the app in Docker with --memory=256m, allocate and keep 150 MB, and watch Gen 2 frequency and TotalAvailableMemoryBytes.
5. Capture dotnet-trace collect --profile gc-collect and open it in PerfView GCStats; sort by pause time and find which GC type caused the longest pause.
6. Set GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency and compare the number of blocking full GCs under the same load.

using System.Runtime;

int gen2Before = GC.CollectionCount(2);

// LOH churn: many short-lived large arrays trigger Gen 2 GCs
for (int i = 0; i < 2_000; i++)
{
    byte[] big = new byte[200_000];   // >= 85,000 bytes: allocated on the LOH
    big[i % big.Length] = 1;
}

Console.WriteLine($"Gen 2 GCs caused by LOH churn: {GC.CollectionCount(2) - gen2Before}");

Print("Last background GC", GC.GetGCMemoryInfo(GCKind.Background));
Print("Last full blocking GC", GC.GetGCMemoryInfo(GCKind.FullBlocking));
Console.WriteLine($"Latency mode: {GCSettings.LatencyMode}");

static void Print(string label, GCMemoryInfo info)
{
    if (info.Index == 0) { Console.WriteLine($"{label}: none yet"); return; }
    Console.WriteLine($"{label}: #{info.Index}, gen {info.Generation}, compacted {info.Compacted}, " +
        $"pause {info.PauseDurations[0].TotalMilliseconds:N2} ms, fragmented {info.FragmentedBytes:N0} bytes");
}

dotnet-trace collect -p <pid> --profile gc-collect --duration 00:00:30
# open the .nettrace in PerfView > GCStats to see reason, type and pause per GC