Restore current task tracking for runtime async dispatch

[max-charlamb]

Summary

• Restore AsyncDispatcherInfo.CurrentTask on the standard, non-instrumented DispatchContinuations path.
• Make the current runtime async task available while its continuation chain is being dispatched.

This assignment was present before the instrumented and non-instrumented dispatch paths were separated in #126091.

Reasoning

Without this link, diagnostics tools cannot deterministically find the parent Task for a runtime async continuation chain in non-instrumented scenarios like crash dumps. While it is possible to use heuristics to link the tasks (trying to find the 'this' parameter of the DispatchContinuations caller) these do not work in all scenarios.

Given the very low overhead of writing this field, I believe it is valuable enough to re-add to the normal path.

Performance

Measured on Windows x64 under Hyper-V using BenchmarkDotNet with tiered compilation disabled. The benchmark performs 10,000 runtime-async suspensions and resumptions per invocation and compares separate baseline and changed Release testhosts.

Across 10 paired runs:

Runtime	Mean
Baseline	65.857 ns
Changed	64.652 ns

The changed runtime measured 1.83% faster overall. The eight additional runs measured 1.24% faster, with the changed runtime faster in all eight. Because the change adds a store and shifts generated code layout, the apparent improvement should be treated as layout or environmental noise rather than a causal speedup. No performance regression was detected.

ReadyToRun code size for RuntimeAsyncTask<int>.DispatchContinuations increased by 7 bytes, from 1,488 to 1,495 bytes.

Testing

• Release CoreCLR and libraries build
• System.Runtime.Tests: 77,810 total, 0 failed, 88 skipped

Note

This pull request description was generated with GitHub Copilot.

[azure-pipelines]

Azure Pipelines:
Successfully started running 3 pipeline(s).
13 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

Tagging subscribers to this area: @agocke
See info in area-owners.md if you want to be subscribed.

[max-charlamb]

@EgorBot -windows_amd -windows_intel --envvars DOTNET_TieredCompilation:0

using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(DispatchContinuationsBenchmarks).Assembly).Run(args);

public class DispatchContinuationsBenchmarks
{
    private const int IterationCount = 10_000_000;

    private static int s_value;

    private readonly NullAwaiter _awaiter = new();

    [IterationSetup]
    public void Warmup()
    {
        for (int i = 0; i < IterationCount; i++)
        {
            s_value += i;
        }
    }

    [Benchmark(OperationsPerInvoke = IterationCount)]
    public void DispatchContinuations()
    {
        Task task = RunContinuations(_awaiter);

        while (!task.IsCompleted)
        {
            _awaiter.Continue();
        }

        task.GetAwaiter().GetResult();
    }

    [RuntimeAsyncMethodGeneration(true)]
    private static async Task RunContinuations(NullAwaiter awaiter)
    {
        for (int i = 0; i < IterationCount; i++)
        {
            await awaiter;
        }
    }

    private sealed class NullAwaiter : ICriticalNotifyCompletion
    {
        private Action? _continuation;

        public NullAwaiter GetAwaiter() => this;

        public bool IsCompleted => false;

        public void Continue()
        {
            Action continuation = _continuation!;
            _continuation = null;
            continuation();
        }

        public void GetResult()
        {
        }

        public void OnCompleted(Action continuation) => throw new NotSupportedException();

        public void UnsafeOnCompleted(Action continuation) => _continuation = continuation;
    }
}

namespace System.Runtime.CompilerServices
{
    [AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
    internal sealed class RuntimeAsyncMethodGenerationAttribute(bool runtimeAsync) : Attribute
    {
        public bool RuntimeAsync => runtimeAsync;
    }
}

[azure-pipelines]

Azure Pipelines:
Successfully started running 3 pipeline(s).
13 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[Copilot]

🟢 Approval recommended

Pull request overview

Restores population of AsyncDispatcherInfo.CurrentTask during the standard (non-instrumented) runtime-async continuation dispatch path in CoreCLR, so diagnostic tooling can reliably correlate nested runtime-async tasks with their continuation chains.

Changes:

• Set asyncDispatcherInfo.CurrentTask = this; in the non-instrumented DispatchContinuations path to match the intent of the instrumented path (which sets it via RuntimeAsyncInstrumentationHelpers.ResumeRuntimeAsyncContext).

File summaries

File	Description
src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs	Restores AsyncDispatcherInfo.CurrentTask assignment for standard continuation dispatch to enable correct current-task tracking during dispatch.

Review details

• Files reviewed: 1/1 changed files
• Comments generated: 0
• Review effort level: Lite

[max-charlamb]

/backport to release/11.0

[github-actions]

Started backporting to release/11.0 (link to workflow run)