Add .NET 10 Preview 2 release notes -- Libraries and Runtime

[richlander]

This is the space for libraries and runtime improvements. We'll aim to merge this PR by March 7th to align with the planned ship date of March 11th.

Everyone is welcome to add feature descriptions and participate in this process.

Parent PR/branch: #9769.

[hez2010]

Inlining of Late Devirtualized Virtual Methods

In .NET, the JIT compiler can optimize virtual method calls by replacing them with non-virtual calls when it can determine the exact type of the this object. However, sometimes this type information is only available if the call is inlined. Consider the following example:

IC obj = GetObject();
obj.M();

IC GetObject() => new C();

interface IC
{
    void M();
}
class C : IC
{
    public void M() => Console.WriteLine(42);
}

If the call to GetObject is not inlined, the JIT cannot determine that obj is actually of type C rather than IC, so that the subsequent call M() on obj will not be devirtualized. Late devirtualization occurs when a call becomes eligible for devirtualization due to previous inlining. This, in turn, can create new inlining opportunities. Previously, such opportunities were abandoned, but with dotnet/runtime#110827, the JIT now marks and seamlessly inlines these late devirtualized calls. Inlining a late devirtualized call can, in turn, create additional devirtualization opportunities, which can then be inlined, further enhancing optimization potential.

Devirtualize based on Inlining Observation

During inlining, a temporary variable may be created to hold the return value from the callee. With dotnet/runtime#111948, the JIT analyzes and updates the type of this temporary variable accordingly. If all return sites in a callee yield the same exact type, this precise type information is leveraged to devirtualize subsequent calls.

---

With the above two improvements, along with recent efforts on array de-abstraction, the JIT can now devirtualize, inline, stack-allocate, and then perform struct promotion on arbitrary enumerators, so that the enumerator abstraction can be entirely eliminated, even without PGO. Consider the following example:

var r = GetRangeEnumerable(0, 10);
foreach (var i in r)
{
    Console.WriteLine(i);
}

static IEnumerable<int> GetRangeEnumerable(int start, int count) => new RangeEnumerable(start, count);

class RangeEnumerable(int start, int count) : IEnumerable<int>
{
    public class RangeEnumerator(int start, int count) : IEnumerator<int>
    {
        private int _value = start - 1;
        public int Current => _value;
        object IEnumerator.Current => Current;
        public void Dispose() { }
        public bool MoveNext()
        {
            _value++;
            return count-- != 0;
        }
        public void Reset() => _value = start - 1;
    }

    public IEnumerator<int> GetEnumerator() => new RangeEnumerator(start, count);
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

With recent JIT improvements, the compiler now produces fully optimized code that devirtualizes and inlines all virtual calls, while also eliminating the enumerator allocation, which is achieved through escape analysis and struct promotion, allowing the enumerator to be entirely stack-allocated, resulting in zero heap allocations and optimal performance:

...
G_M27646_IG02:
       mov      ebx, 10
       mov      r15d, -1
       jmp      SHORT G_M27646_IG04
G_M27646_IG03:
       mov      edi, r15d
       call     [System.Console:WriteLine(int)]
       mov      ebx, r14d
G_M27646_IG04:
       inc      r15d
       lea      edi, [rbx-0x01]
       mov      r14d, edi
       test     ebx, ebx
       jne      SHORT G_M27646_IG03
...

See the full comparison of codegen between .NET 9 and .NET 10 here.

Support for Casting and Negation in NativeAOT Type Preinitializer

NativeAOT includes a type preinitializer that can execute type initializers (static constructors) without side effects at compile time using an IL interpreter. The results are then embedded directly into the binary, allowing the elimination of these initializers entirely. With dotnet/runtime#112073, support has been extended to cover all variants of conv.* and neg opcodes, enabling preinitialization of methods that include casting or negation operations.

[richlander]

Looks great @hez2010 -- Can you create a PR on the branch?

Can you define "late devitalization" in the text? "late" can be used in multiple ways, like "late-stage capitalism". We want to make it clear to readers.

As much as possible, can you align with the format we've used in release notes previously, to match?

Also, if that's too much, I'm happy to do this myself.

[amanasifkhalid]

As much as possible, can you align with the format we've used in release notes previously, to match?

Also, if that's too much, I'm happy to do this myself.

If it's easier, I can add @hez2010's notes to my batch of JIT notes.

[richlander]

Sounds good @amanasifkhalid. Let's do that.

[hez2010]

Can you define "late devitalization" in the text? "late" can be used in multiple ways, like "late-stage capitalism". We want to make it clear to readers.

As much as possible, can you align with the format we've used in release notes previously, to match?

I have updated the original comment to reflect these.

If it's easier, I can add @hez2010's notes to my batch of JIT notes.

Given it is going to be included in your JIT notes, I will not send a separate PR for this.

[amanasifkhalid]

@AndyAyersMS do you have updated benchmark runs for the opaque case? Also I'm guessing the above benchmarks I took from your conditional escape analysis doc aren't up-to-date, now that we have @hez2010's changes in.

[AndyAyersMS]

These are tracked in the benchmark system, eg https://pvscmdupload.z22.web.core.windows.net/reports/allTestHistory/refs/heads/main_x64_ubuntu%2022.04/ViperUbuntu/ArrayDeAbstraction.foreach_opaque_array_via_interface.html

If you want a table I can run some stuff locally and get you something.

Also the array alloc revert has made it into P2.

[AndyAyersMS]

I don't believe the more recent changes from @hez2010 impacted the lab benchmark numbers since PGO could already get those cases (neither PR above has any lab annotations).

[hez2010]

Yeah changes to late devirt were mainly for non-PGO scenarios, PGO benchmark shouldn't be affected (the guard created by GDV was blocking stackalloc before conditional escape analysis).

[AndyAyersMS]

Here's some locally collected data.

Method	Toolchain	Mean	Median	Ratio	Allocated	Alloc Ratio
foreach_static_readonly_array	net9.0	150.78 ns	150.72 ns	1.00	-	NA
foreach_static_readonly_array_via_interface_property	net9.0	851.75 ns	849.93 ns	5.65	32 B	NA
foreach_opaque_array_via_interface	net9.0	874.66 ns	877.68 ns	5.80	32 B	NA
foreach_static_readonly_array	net10.0p2	151.75 ns	151.14 ns	1.01	-	NA
foreach_static_readonly_array_via_interface_property	net10.0p2	280.04 ns	278.77 ns	1.86	-	NA
foreach_opaque_array_via_interface	net10.0p2	277.89 ns	277.16 ns	1.84	-	NA

[amanasifkhalid]

Thank you both, I'll update the tables

[hez2010]

For Non-PGO you can check the benchmark numbers here: dotnet/runtime#111948 (comment)
It was benchmarked without tiering compilation to demonstrate how late devirt inlining improvements interact with array de-abstraction.

[jongalloway]

Should this say Preview 2? Or is this a Preview 1 feature we didn't call out before, or something being improved on furth in preview 2? This is confusing 😕

[amanasifkhalid]

or something being improved on further in preview 2

It's this case. I'll add something here to transition into Preview 2-specific work.

[richlander]

If I understand correctly, it is usually devirt that enables inlining. In this case, it is the opposite, that we need inlining to enable devirt, which may allow further inlining. Fair? If so, this example is great to talk to.

[amanasifkhalid]

You're correct, the two tend to create virtuous cycles out of each other.

[richlander]

Thanks everyone. The contributions look great!

[AndyAyersMS]

Somehow this data table got modified -- it should not show allocation in .NET 10 (that's part of the point of the optimization).

[amanasifkhalid]

@AndyAyersMS thanks for catching that, I opened #9813 to fix this