What is the Large Object Heap (LOH) in .NET, and how do you find and fix LOH fragmentation and churn?

1. Why a separate heap at all

Compaction cost is proportional to bytes copied. Moving a 50 MB array to close a gap costs far more than the gap is worth. So the GC treats large objects differently: allocate them in their own space, collect them with Gen 2 (large objects are assumed long-lived), and avoid moving them.

The assumption "large objects live long" is exactly what churn violates.

2. The threshold, in bytes

Array layout on 64-bit:

+------------------+------------------+------------------+-------------------------+
| object header 8B | MethodTable* 8B  | length 8B        | elements ...            |
+------------------+------------------+------------------+-------------------------+

new byte[84_976] → 24 + 84,976 = 85,000 bytes → LOH. One element fewer stays in Gen 0.

3. Fragmentation, visually

LOH after some churn:
[ A 1MB ][ free 300KB ][ B 1MB ][ free 300KB ][ C 2MB ][ free 400KB ]

Request: new byte[500_000]
 -> no single free block is big enough
 -> the GC takes a new region / grows the LOH
 -> 1 MB free but unusable; process memory grows

Pooling keeps the same buffers alive and reused, so holes aren't created in the first place.

4. MemoryStream growth is a churn generator

Writing 10 MB into a default MemoryStream:

capacity: 256 → 512 → ... → 128 KB (LOH) → 256 KB → 512 KB → 1 MB → 2 MB → 4 MB → 8 MB → 16 MB

Every step above 85 KB is a new LOH array; the previous one becomes garbage. Then ToArray() copies 10 MB again. Total LOH allocation is roughly 3x the payload. RecyclableMemoryStream uses pooled blocks and pooled large buffers to avoid this.

5. ArrayPool<T> details that matter

byte[] buffer = ArrayPool<byte>.Shared.Rent(1_000_000);
try
{
    int read = await source.ReadAsync(buffer.AsMemory(0, 1_000_000), ct);
    await destination.WriteAsync(buffer.AsMemory(0, read), ct);
}
finally
{
    ArrayPool<byte>.Shared.Return(buffer, clearArray: containsSensitiveData);
}

• Rent may return a larger array (rounded up to a bucket size); always slice.
• The shared pool is per-core/thread-local with buckets; very large requests beyond its limits are just allocated.
• The shared pool trims under memory pressure (it registers for Gen 2 callbacks), so pooled buffers don't hold memory forever.
• Never use a buffer after returning it; never return it twice.

6. Compaction and thresholds

using System.Runtime;

// After a known bulk import that fragmented the LOH:
GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect(); // blocking Gen 2 that compacts the LOH; the setting resets to Default

runtimeconfig.json:

{
  "configProperties": {
    "System.GC.LOHThreshold": 120000
  }
}

Raising the threshold puts objects between 85,000 and 120,000 bytes into the SOH, where they can be compacted and collected in young GCs. It also means they're copied when compacted. Only do this when measurements show many short-lived objects in that range.

7. Reading LOH numbers in-process

GCMemoryInfo info = GC.GetGCMemoryInfo();
GCGenerationInfo loh = info.GenerationInfo[3]; // 0,1,2 = SOH gens, 3 = LOH, 4 = POH
Console.WriteLine($"LOH: {loh.SizeAfterBytes:N0} bytes, fragmented {loh.FragmentationAfterBytes:N0}");

The indices 3 and 4 are runtime bookkeeping; logically LOH and POH belong to Gen 2.

8. Version notes

9. Try it yourself

1. Run the code example and compare total allocated MB, Gen 2 GCs and LOH size for new byte[] vs ArrayPool.
2. Allocate new byte[84_975] and new byte[84_976], then call GC.GetGeneration on each: one reports 0, the other 2.
3. Write 10 MB into a MemoryStream and count Gen 2 GCs; repeat with RecyclableMemoryStream.
4. Create fragmentation: allocate alternating 1 MB arrays, keep every other one, then try a 1.5 MB allocation and watch GenerationInfo[3].FragmentationAfterBytes.
5. Use dotnet-dump collect and dumpheap -stat -min 85000 on a running sample to list large objects.
6. Capture a gc-collect trace and count GCs with reason AllocLarge before and after your fix.

using System.Buffers;

const int Size = 1024 * 1024; // 1 MB: LOH sized

Measure("new byte[] per call", () =>
{
    byte[] buffer = new byte[Size];
    return Fill(buffer);
});

Measure("ArrayPool rent/return", () =>
{
    byte[] buffer = ArrayPool<byte>.Shared.Rent(Size);
    try { return Fill(buffer.AsSpan(0, Size)); }
    finally { ArrayPool<byte>.Shared.Return(buffer); }
});

static int Fill(Span<byte> span)
{
    span[0] = 1; span[^1] = 2;
    return span[0] + span[^1];
}

static void Measure(string name, Func<int> work)
{
    GC.Collect(); // demo only
    int gen2 = GC.CollectionCount(2);
    long before = GC.GetTotalAllocatedBytes();
    long sum = 0;
    for (int i = 0; i < 2_000; i++) sum += work();
    long allocated = GC.GetTotalAllocatedBytes() - before;

    GCGenerationInfo loh = GC.GetGCMemoryInfo().GenerationInfo[3];
    Console.WriteLine($"{name,-22} allocated {allocated / (1024 * 1024),6:N0} MB, Gen 2 GCs {GC.CollectionCount(2) - gen2,4}, " +
                      $"LOH size after {loh.SizeAfterBytes / (1024 * 1024):N0} MB, sum {sum}");
}