Annual Performance Analysis
It’s that time of year, when Microsoft’s elves come out with a new version of .Net with that new code smell. My favorite aspect is the annual reading of Stephen Taub’s performance gain analysis; the how they did it.
Get Bill Musgrave’s stories in your inbox
Join Medium for free to get updates from this writer.
I enjoy reading each and every micro-optimization the .Net team comes up with. But if you are impatient and don’t want to read Stephen’s article, I’ve boiled down this years performance to the highlights below:
High‑Level Categories of Enhancements in .NET 11
Each category includes a short sentence describing the theme, followed by subcategories with one‑sentence explanations.
1. JIT (Just‑In‑Time Compiler) Improvements
Theme: The JIT becomes smarter at removing overhead, eliminating allocations, and optimizing hot paths.
- Devirtualization / Guarded Devirtualization (GDV) The JIT more often converts virtual/interface calls into direct calls, enabling inlining and major speedups.
- Escape Analysis & Stack Allocation More temporary objects are proven not to escape and are stack‑allocated or eliminated entirely.
- Nullable Boxing Optimization Boxing of nullable types is reduced or eliminated when the boxed value doesn’t escape.
- Enumerator Optimization (CEA) Foreach loops over common collection patterns avoid heap allocations for enumerators.
- Generic Virtual Method (GVM) Devirtualization Generic interface calls are now devirtualized and inlined in more cases, eliminating allocations and indirect calls.
- Improved Inlining Heuristics Intrinsic types (Span, Vector) get more aggressive inlining budgets, exposing more optimization opportunities.
- Delegate Layout Optimization Delegates are smaller and faster due to reduced field count and better field ordering.
- Tier 0 Improvements Some optimizations previously only in Tier 1 (optimized code) now apply in Tier 0, reducing startup overhead.
2. GC (Garbage Collector) Improvements
Theme: Reduced allocations and better escape analysis reduce GC pressure and improve throughput.
- Fewer Temporary Allocations Eliminated boxing, enumerators, and short-lived objects reduce GC frequency.
- Stack Allocation of Delegates / Closures More closures and delegates avoid heap allocation entirely.
3. Runtime Infrastructure Improvements
Theme: Core runtime operations (delegates, type checks, interface dispatch) become cheaper.
- Delegate Representation Simplification Delegates shrink by 8 bytes on CoreCLR, improving memory footprint and invocation speed.
- Better Type Information Preservation The JIT preserves exact type info through transformations, enabling more devirtualization.
- Improved Interface Dispatch Interface calls are optimized more aggressively, especially in generic scenarios.
4. Async / Await Improvements
Theme: Async state machines and continuations get faster and allocate less.
- Reduced Async Overhead Async methods generate less overhead in state machines and continuations.
- Better Exception Handling Paths Async exception paths are optimized to reduce cost in common scenarios.
5. Collections & LINQ Improvements
Theme: Common operations on collections and LINQ pipelines run faster and allocate less.
- Enumerator Allocation Removal Foreach loops over arrays, read-only arrays, and common patterns avoid heap allocations.
- Faster Equality Comparisons EqualityComparer<T> avoids boxing and unnecessary allocations.
- Improved Generic Collection Operations Generic virtual methods in collections are devirtualized and inlined.
6. Math, SIMD, and Numerics Improvements
Theme: More operations are vectorized or mapped to hardware intrinsics.
- Better Intrinsic Recognition Span, Vector, and numeric operations inline more often and map to SIMD instructions.
- Instruction Fusion Multiple instructions are fused into single CPU instructions where possible.
7. I/O and System Libraries Improvements
Theme: Lower-level operations in System.IO, hashing, caching, and tensors get faster.
- Hashing Improvements System.IO.Hashing operations are faster due to better inlining and fewer allocations.
- Caching Improvements System.Runtime.Caching benefits from JIT optimizations and reduced overhead.
- Tensor Operations System.Numerics.Tensors sees better vectorization and reduced overhead.
8. NativeAOT Improvements
Theme: NativeAOT gets better devirtualization and generic method resolution.
- Fat Pointer Optimization Generic virtual method resolution is deferred to allow devirtualization first.
- Better Inlining of GVMs NativeAOT now inlines more generic virtual calls, reducing code size and improving speed.
9. ReadyToRun Improvements
Theme: Precompiled code benefits from better generic method resolution.
- More Non‑Shared GVM Devirtualization ReadyToRun can resolve more generic virtual calls at compile time.
10. General Micro-Optimizations
Theme: Hundreds of tiny improvements accumulate into measurable throughput gains.
- Bounds Check Removal More loops eliminate redundant bounds checks.
- Constant Folding More comparisons and branches fold into constants.
- Redundant Check Hoisting Checks move out of loops to reduce per-iteration cost.
- Syscall Avoidance Some operations avoid system calls entirely.
.NET 11’s performance improvements center on smarter JIT optimizations, reduced allocations, better devirtualization, faster async, improved collections, enhanced SIMD usage, and major gains in generic and interface dispatch — resulting in faster, smaller, and more efficient applications across the board.
If your Agile feels more sluggish than adaptive, or your DevOps pipeline isn’t delivering the speed you expect — I can help. I’ve spent 30 years leading software delivery transformations that align teams, tools, and outcomes. Learn more at https://www.musgrave.com .
