What is GC pressure in .NET, how do you measure it, and how do you reduce it (including GC.AddMemoryPressure for native memory)?

1. Why each driver costs what it costs

Gen 0 GCs per second   ≈ allocation rate / Gen 0 budget
cost per young GC      ≈ roots + dirty cards + survivors copied
Gen 2 inflow           ≈ allocation rate × Gen 0 survival × Gen 1 survival
full GC cost           ≈ live objects + references in the whole heap

This is why you can have:

• a service allocating 1 GB/s at 2% time in GC (almost nothing survives), and
• a service allocating 50 MB/s at 15% (a huge, reference-heavy live heap with frequent Gen 2 GCs).

2. Graph shape matters: references cost marking work

// 1 million objects, 1 million references to mark and possibly update
List<Point> points;           // class Point { double X, Y; }

// 1 object, no references inside: marking is trivial
Point[] points;               // struct Point { double X, Y; }

For large long-lived datasets (lookup tables, in-memory indexes), arrays of structs, FrozenDictionary, or storing integer IDs instead of object references reduce full GC cost and card-marking work.

3. Reading GC pressure in-process

GCMemoryInfo info = GC.GetGCMemoryInfo();
Console.WriteLine($"Pause time %: {info.PauseTimePercentage:N2}");
Console.WriteLine($"Heap: {info.HeapSizeBytes / 1_048_576} MB, fragmented {info.FragmentedBytes / 1_048_576} MB");
Console.WriteLine($"Promoted last GC: {info.PromotedBytes / 1024} KB");
Console.WriteLine($"Total allocated: {GC.GetTotalAllocatedBytes() / 1_048_576} MB");
Console.WriteLine($"Total pause: {GC.GetTotalPauseDuration().TotalMilliseconds:N0} ms");

Exporting these per process to your metrics system makes regressions visible after deploys.

4. ObjectPool done right

var provider = new DefaultObjectPoolProvider();
ObjectPool<StringBuilder> pool = provider.CreateStringBuilderPool(initialCapacity: 256, maximumRetainedCapacity: 4096);

StringBuilder sb = pool.Get();
try
{
    sb.Append("order:").Append(orderId);
    return sb.ToString();
}
finally
{
    pool.Return(sb);   // the policy clears it and drops oversized builders
}

Pool expensive or large objects. Pooled objects live in Gen 2; references from them to new objects dirty cards. Pooling tiny objects usually costs more than it saves.

5. How AddMemoryPressure influences the GC

The runtime tracks added and removed pressure. When added pressure grows significantly relative to the managed heap and to what has been removed, the GC may trigger collections itself so that wrappers owning native memory get finalised or noticed sooner. Consequences:

• Unbalanced Add without Remove → the GC thinks memory is permanently high → excessive GCs.
• Many tiny calls → overhead for no benefit.
• It doesn't free anything by itself: the native memory is released only by your Dispose/SafeHandle.

6. GCConserveMemory in practice

• Range 0 (default) to 9; higher means the GC compacts Gen 2 more readily when fragmentation is high.
• Useful for memory-dense deployments (many pods per node) where a few percent more GC CPU is acceptable.
• Set via System.GC.ConserveMemory in runtimeconfig.json or DOTNET_GCConserveMemory (hex).

7. Version notes

8. Try it yourself

1. Run the code example; compare allocated MB and GC pause time for the LINQ and span tokenisers.
2. Put both tokenisers in BenchmarkDotNet with [MemoryDiagnoser].
3. Build a 1-million-element List<PointClass> and PointStruct[], keep them alive, run GC.Collect() several times, and compare GC.GetTotalPauseDuration() deltas.
4. Allocate 200 MB of native memory per wrapper in a loop without Dispose or AddMemoryPressure, and watch working set; then add AddMemoryPressure plus a finaliser-backed SafeHandle and compare.
5. Call AddMemoryPressure without RemoveMemoryPressure repeatedly and watch GC counts climb.
6. Export PauseTimePercentage and allocation rate from a sample API to dotnet-counters or OpenTelemetry and compare before/after an optimisation.

using System.Diagnostics;
using System.Runtime.InteropServices;

string text = string.Join(' ', Enumerable.Range(0, 2_000).Select(i => $"word{i % 50}"));

Run("Split + LINQ", () => text.Split(' ').Where(w => w.EndsWith('7')).Select(w => w.Length).Sum());
Run("Span tokeniser", () =>
{
    int sum = 0;
    foreach (Range r in text.AsSpan().Split(' '))   // .NET 9+: enumerates ranges without allocating
    {
        ReadOnlySpan<char> word = text.AsSpan()[r];
        if (word.Length > 0 && word[^1] == '7') sum += word.Length;
    }
    return sum;
});

// Native memory owned by a small managed object: tell the GC about it
using (var image = new NativeImage(50 * 1024 * 1024))
    Console.WriteLine($"Native image of {image.Size / 1024 / 1024} MB allocated");

static void Run(string name, Func<int> work)
{
    work();
    TimeSpan pauseBefore = GC.GetTotalPauseDuration();
    long allocBefore = GC.GetTotalAllocatedBytes();
    var sw = Stopwatch.StartNew();
    long total = 0;
    for (int i = 0; i < 5_000; i++) total += work();
    sw.Stop();
    Console.WriteLine($"{name,-15} {sw.ElapsedMilliseconds,5} ms, allocated {(GC.GetTotalAllocatedBytes() - allocBefore) / 1024 / 1024,5} MB, " +
                      $"GC pauses {(GC.GetTotalPauseDuration() - pauseBefore).TotalMilliseconds:N0} ms (sum {total})");
}

public sealed unsafe class NativeImage : IDisposable
{
    private void* _buffer;
    public long Size { get; }

    public NativeImage(long size)
    {
        Size = size;
        _buffer = NativeMemory.Alloc((nuint)size);
        GC.AddMemoryPressure(size);          // GC now knows this small object is expensive
    }

    public void Dispose()
    {
        if (_buffer == null) return;
        NativeMemory.Free(_buffer);
        _buffer = null;
        GC.RemoveMemoryPressure(Size);       // always balance
    }
}

Requires <AllowUnsafeBlocks>true</AllowUnsafeBlocks> for the pointer field. In production, wrap native memory in a SafeHandle so it is released even if Dispose is missed.