.NET 9 Performance Guide: Runtime Tuning, Allocation Control, and Throughput Optimization

110 MB | 3 |

Note: Native AOT throughput gains assume stateless API workloads with compatible dependency graphs. Reflection-heavy ORMs or dynamic proxies will degrade performance.

---

Core Solution

Step 1: Enable & Validate Runtime Optimizations

.NET 9 ships with PGO and tiered compilation enabled by default, but production builds require explicit configuration to ensure optimization stages complete before traffic hits.

runtimeconfig.template.json

{
  "runtimeOptions": {
    "configProperties": {
      "System.GC.Server": true,
      "System.GC.Concurrent": true,
      "System.GC.RetainVM": false,
      "System.Threading.ThreadPool.MinThreads": 16,
      "System.Threading.ThreadPool.MaxThreads": 256,
      "System.Runtime.TieredCompilation": true,
      "System.Runtime.TieredPGO": true,
      "System.Runtime.EnableProfiling": false
    }
  }
}

Deploy this alongside your application. PGO requires a training run to generate pgdata files. Use DOTNET_TC_QuickJitForLoops=1 during staging to accelerate tier 0→1 transitions.

Architecture Decision: Keep JIT compilation for services with dynamic routing, plugin architectures, or heavy reflection. Switch to Native AOT only for stateless, compile-time-resolvable APIs where startup time and memory footprint are critical.

Step 2: Tune Garbage Collection for Workload Type

Default GC prioritizes developer machine responsiveness. Production throughput requires generation-specific tuning.

appsettings.json (GC Section)

{
  "GC": {
    "Server": true,
    "Concurrent": true,
    "HeapHardLimit": "0x80000000",
    "HeapCount": 0,
    "LatencyMode": "Throughput",
    "EphemeralHeapSegmentSize": 256
  }
}

• HeapHardLimit: Caps total GC heap (2GB in hex). Prevents unbounded growth in containerized environments.
• LatencyMode: Throughput minimizes pause time at the cost of slightly higher memory usage. Use Batch for background workers, Interactive only for UI/daemon processes.
• EphemeralHeapSegmentSize: Controls Gen 0/1 sizing. Larger segments reduce promotion rate to Gen 2.

Verification: Run dotnet-counters monitor -p <pid> --counters System.GC and track gen-2-collection-count and heap-size. Target <5 Gen 2 collections/min under steady load.

Step 3: Optimize Serialization & I/O Pipelines

Reflection-based JSON deserialization is the primary allocation source in modern .NET APIs. .NET 9's source generators eliminate runtime IL emission and string encoding overhead.

JsonSourceGenerator Implementation

using System.Text.Json.Serialization;

[JsonSerializable(typeof(ApiRequest))]
[JsonSerializable(typeof(ApiResponse))]
[JsonSourceGenerationOptions(
    PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    WriteIndented = false)]
public partial class AppJsonContext : JsonSerializerContext { }

// Usage
var options = AppJsonContext.Default.Options;
var request = JsonSerializer.Deserialize<ApiRequest>(jsonBytes, options);

UTF-8 Pipeline with Kestrel HTTP/3

builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.MaxRequestBodySize = 10 * 1024 * 1024;
    options.ListenAnyIP(5000, listen =>
    {
        listen.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
        listen.UseHttps("cert.pfx", "password");
    });
    options.ListenAnyIP(5001, listen =>
    {
        listen.Protocols = HttpProtocols.Http3;
        listen.UseHttps("cert.pfx", "password");
    });
});

HTTP/3 requires UDP exposure in Kubernetes/LoadBalancers. Configure service.beta.kubernetes.io/aws-load-balancer-type: nlb or equivalent cloud annotations. Always implement HTTP/2 fallback for compatibility.

Step 4: Eliminate Allocation Hot Paths

.NET 9 improves LINQ vectorization and Span<T> performance. Replace deferred LINQ chains with structural parsing in hot paths.

Before (Allocation Heavy)

var results = logs
    .Where(l => l.Level == LogLevel.Error)
    .Select(l => new { l.Timestamp, l.Message })
    .OrderByDescending(x => x.Timestamp)
    .Take(100)
    .ToList();

After (Span-Based, Allocation-Aware)

var span = logs.AsSpan();
var filtered = ArrayPool<LogEntry>.Shared.Rent(span.Length);
int count = 0;

for (int i = 0; i < span.Length; i++)
{
    if (span[i].Level == LogLevel.Error)
        filtered[count++] = span[i];
}

Array.Sort(filtered, 0, count, Comparer<LogEntry>.Create((a, b) => b.Timestamp.CompareTo(a.Timestamp)));
var top100 = filtered.Take(Math.Min(100, count)).ToArray();
ArrayPool<LogEntry>.Shared.Return(filtered);

Use System.Buffers.ArrayPool<T> for temporary buffers. Prefer ReadOnlySequence<byte> and IBufferWriter<byte> for streaming I/O. .NET 9's MemoryMarshal and hardware intrinsics accelerate parsing when data alignment permits.

---

Pitfall Guide

1. Enabling Native AOT Without Dependency Auditing: Native AOT breaks at runtime if libraries use Type.GetType, Assembly.Load, or dynamic proxies. Audit with ilc warnings and PublishTrimmed=true. Replace reflection-heavy ORMs with compile-time query builders.
2. Overriding GC Settings Blindly: Setting GCHeapHardLimit too low triggers constant Gen 2 collections. Tune based on dotnet-counters heap growth curves, not arbitrary values.
3. Skipping PGO Training Runs: Production builds without pgdata files run in tier 0 (quick JIT). Throughput drops 15–20%. Run a 5-minute synthetic load to generate PGO data before deploying.
4. Using String-Based JSON APIs: JsonSerializer.Deserialize<T>(string) forces UTF-8→UTF-16 conversion. Use ReadOnlySpan<byte> or Utf8JsonReader with source generators to eliminate encoding overhead.
5. Misconfiguring HTTP/3 Fallback: UDP blocking in corporate firewalls or cloud WAFs breaks HTTP/3. Always configure HttpProtocols.Http1AndHttp2AndHttp3 and validate ALPN negotiation. Monitor QUIC connection drops.
6. Chaining LINQ Without Materialization Awareness: Deferred execution causes repeated enumeration in loops or middleware pipelines. Call .ToArray() or .ToList() explicitly when data won't change, or switch to for/Span loops for hot paths.
7. Assuming async/await Eliminates Thread Contention: ConfigureAwait(false) is default in .NET 9, but thread pool starvation occurs when sync-over-async blocks or high-latency I/O saturates workers. Use Channel<T>, SemaphoreSlim, or BackgroundService for bounded concurrency.

---

Production Bundle

Action Checklist

• Profile baseline with dotnet-counters and dotnet-trace before applying changes
• Enable PGO and run a 5-minute training workload to generate pgdata
• Configure runtimeconfig.template.json with server GC, tiered compilation, and thread pool bounds
• Replace reflection-based JSON with [JsonSourceGenerationOptions] and Utf8JsonReader
• Audit hot paths for LINQ allocations; replace with Span<T>, ArrayPool<T>, or for loops
• Configure Kestrel HTTP/3 with TLS 1.3, UDP exposure, and HTTP/2 fallback
• Validate Gen 2 collection rate and P99 latency under 80% sustained load
• Document GC limits and PGO deployment steps in CI/CD pipeline

Decision Matrix

Strategy	Startup Time	Peak Throughput	Memory Footprint	Deployment Complexity	Library Compatibility
JIT + PGO + Server GC	Fast (~200ms)	High	Medium	Low	Full
R2R + Tiered Compilation	Very Fast (~80ms)	High	Medium	Low	Full
Native AOT	Instant (~10ms)	Very High	Low	Medium	Restricted (no reflection/dynamic)
JIT + HTTP/3 + UTF8 JSON	Fast	High	Medium	Low	Full

Recommendation: Use JIT+PGO for general APIs. Reserve Native AOT for edge functions, background workers, and containerized stateless services with verified dependency graphs.

Configuration Template

Dockerfile (Optimized Publish)

FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /app/publish \
    /p:PublishTrimmed=true \
    /p:PublishReadyToRun=true \
    /p:PublishReadyToRunShowWarnings=true \
    /p:TieredPGO=true \
    /p:EnableCompressionInSingleFile=true

FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS runtime
WORKDIR /app
COPY --from=build /app/publish .
ENV DOTNET_GCHeapHardLimit=0x80000000
ENV DOTNET_TieredCompilation=true
ENV DOTNET_TieredPGO=true
ENTRYPOINT ["dotnet", "YourApp.dll"]

docker-compose.yml (Load Testing)

version: '3.8'
services:
  api:
    build: .
    ports:
      - "5000:5000"
      - "5001:5001/udp"
    environment:
      - DOTNET_gcServer=true
      - DOTNET_gcConcurrent=true
      - DOTNET_gcLatencyMode=Throughput
    deploy:
      resources:
        limits:
          memory: 2G
          cpus: '4'

Quick Start Guide

1. Baseline Measurement: Run dotnet-counters monitor -p <pid> and bombardier -c 500 -d 60s http://localhost:5000/api/endpoint. Record RPS, P99, and allocations.
2. Apply Runtime Flags: Add runtimeconfig.template.json and environment variables. Rebuild with /p:TieredPGO=true and /p:PublishReadyToRun=true.
3. Optimize Hot Paths: Replace JSON reflection with source generators. Convert LINQ chains in middleware/controllers to Span<T> or ArrayPool<T>.
4. Validate Under Load: Redeploy to staging. Run identical load test. Compare Gen 2 collections, P99 latency, and CPU utilization. Iterate GC limits if heap growth exceeds thresholds.
5. Promote to Production: Package with PGO data. Configure load balancer UDP exposure for HTTP/3. Enable observability dashboards tracking gc-heap-size, threadpool-queue-length, and kestrel-connections-active.

---

Final Notes

.NET 9 delivers measurable performance gains only when runtime configuration, allocation patterns, and I/O pipelines are aligned with workload characteristics. Default settings prioritize developer velocity; production demands intentional tuning. Profile before optimizing, validate with sustained load, and treat PGO, GC limits, and UTF-8 serialization as non-negotiable baseline configurations. The framework provides the tools; architecture and discipline determine the outcome.