Optimize await Task.Yield() in runtime async

[jakobbotsch]

YieldAwaiter is already optimized for async1 by virtue of implementing the internal IStateMachineBoxAwareAwaiter interface. This allows await Task.Yield() to skip allocating internal thread pool objects for async1. Since await Task.Yield() is frequently used by micro benchmarks this makes it hard to make apples-to-apples comparisons. To fix that this PR implements the same optimization for runtime async.

Also remove leftover and unused AsyncHelpers.TaskContinuation.cs; it was replaced by RuntimeAsyncTaskContinuation.

Micro benchmark with warmup:

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace AsyncMicro;

public class Program
{
    static void Main()
    {
        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j < 100; j++)
            {
                Task t = Foo(100);
                t.Wait();
            }

            Thread.Sleep(100);
        }

        for (int i = 0; i < 10; i++)
        {
            Task t = Foo(10_000_000);
            t.Wait();
        }
    }

    static async Task Foo(int n)
    {
        Stopwatch timer = Stopwatch.StartNew();
        for (int i = 0; i < n; i++)
        {
            await Task.Yield();
        }

        if (n > 100)
            Console.WriteLine("Took {0:F1} ms", timer.Elapsed.TotalMilliseconds);
    }
}

-Took 726.1 ms
-Took 719.9 ms
-Took 724.5 ms
-Took 721.1 ms
-Took 722.0 ms
-Took 723.6 ms
-Took 721.4 ms
-Took 727.3 ms
-Took 723.6 ms
-Took 721.9 ms
+Took 533.5 ms
+Took 533.7 ms
+Took 534.1 ms
+Took 533.2 ms
+Took 534.3 ms
+Took 531.7 ms
+Took 540.4 ms
+Took 535.1 ms
+Took 535.1 ms
+Took 538.9 ms

Async1 time for comparison:

Took 535.2 ms
Took 529.6 ms
Took 551.1 ms
Took 536.7 ms
Took 553.4 ms
Took 530.8 ms
Took 557.2 ms
Took 543.5 ms
Took 543.2 ms
Took 562.2 ms

Not surprisingly they are equal now, this benchmark basically measures thread pool performance more so than anything about async performance.

[dotnet-policy-service]

Tagging subscribers to this area: @steveisok, @dotnet/area-system-reflection
See info in area-owners.md if you want to be subscribed.

[Copilot]

Pull request overview

This PR adds a runtime-async fast path for await Task.Yield() that avoids per-await allocations by swapping the boxed YieldAwaiter with a singleton ICriticalNotifyCompletion implementation, aligning runtime-async behavior more closely with the existing async1 optimization. It also removes an unused legacy continuation helper.

Changes:

• Special-case YieldAwaitable.YieldAwaiter in AsyncHelpers.UnsafeAwaitAwaiter<TAwaiter> to use a singleton notifier instead of boxing the awaiter.
• Introduce RuntimeAsyncYielder to schedule the runtime-async continuation onto SynchronizationContext / TaskScheduler / thread pool without allocating extra thread-pool objects.
• Remove the unused AsyncHelpers.TaskContinuation.cs and wire the new file into CoreCLR + NativeAOT CoreLib builds.

Reviewed changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.cs	Adds a Task.Yield()-specific fast path for runtime async by using RuntimeAsyncYielder.Instance.
src/libraries/System.Private.CoreLib/src/System/Delegate.cs	Adds an internal helper to cheaply fetch the target of a single-cast instance delegate (used by the new yielder).
src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj	Includes the new AsyncHelpers.RuntimeAsyncYielder.cs source file in CoreCLR CoreLib builds.
src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.TaskContinuation.cs	Deletes an unused legacy runtime-async task continuation helper.
src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.RuntimeAsyncYielder.cs	Implements the singleton yielder used to schedule runtime-async continuations for Task.Yield().
src/coreclr/nativeaot/System.Private.CoreLib/src/System/Delegate.cs	Adds the same internal delegate-target helper for NativeAOT’s Delegate implementation.
src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj	Includes the new yielder file for NativeAOT CoreLib builds.

[teo-tsirpanis]

Suggested change

	continuationTarget.GetType().IsGenericType &&
	continuationTarget.GetType().GetGenericTypeDefinition() == typeof(RuntimeAsyncTask<>));
	continuationTarget.GetType().HasSameMetadataDefinitionAs(typeof(RuntimeAsyncTask<>)));

[hez2010]

IsGenericType and GetGenericTypeDefinition are jit intrinsics that will be folded to constants in this case. Using HasSameMetadataDefinitionAs here will be much more slower.

https://godbolt.org/z/eMv5Ka9d6

UPDATE: I see its obj.GetType() instead of typeof(T), then this might be less relevant as we don't fold such cases.