14. Runtime Async: async-методы в рантайме¶

private struct <C>d__7 : IAsyncStateMachine
{
    public int <>1__state;                                  // (1)!
    public AsyncTaskMethodBuilder <>t__builder;             // (2)!
    public bool suspend;                                    // (3)!
    private YieldAwaitable.YieldAwaiter <>u__1;             // (4)!

    private void MoveNext()
    {
        int num = <>1__state;
        try
        {
            YieldAwaitable.YieldAwaiter awaiter;
            if (num == 0) { awaiter = <>u__1; <>u__1 = default; num = (<>1__state = -1); goto IL_0065; }
            if (suspend)
            {
                awaiter = Task.Yield().GetAwaiter();
                if (!awaiter.IsCompleted)
                {
                    num = (<>1__state = 0);
                    <>u__1 = awaiter;
                    <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
                    return;
                }
                goto IL_0065;
            }
            goto end_IL_0007;
            IL_0065: awaiter.GetResult();
            end_IL_0007:;
        }
        catch (Exception exception) { <>1__state = -2; <>t__builder.SetException(exception); return; }
        <>1__state = -2;
        <>t__builder.SetResult();
    }
}

// Глава 14. Что компилятор делает с async-методом при RuntimeAsync=on.
// PREDICT: сколько вложенных типов вида <...>d__N появится у Probe после сборки с -p:RuntimeAsync=on?
// TODO 1: соберите и запустите обычным способом, потом с -p:RuntimeAsync=on БЕЗ переменной DOTNET_RuntimeAsync (на .NET 10) — что произойдёт?
// TODO 2: запустите с DOTNET_RuntimeAsync=1 режим stack — какие кадры исчезли из трассы?
// Запуск: dotnet run -c Release --project start -- info
//         $env:DOTNET_RuntimeAsync = 1; dotnet run -c Release --project start -p:RuntimeAsync=on -- stack
using System.Reflection;

switch (args.FirstOrDefault() ?? "info")
{
    case "info": Probe.Info(); break;
    case "stack": await Probe.Stack(); break;
}

static class Probe
{
    const MethodImplAttributes AsyncFlag = (MethodImplAttributes)0x2000;   // MethodImplAttributes.Async

    public static void Info()
    {
        MethodInfo m = typeof(Probe).GetMethod(nameof(C), BindingFlags.Static | BindingFlags.NonPublic)!;
        Console.WriteLine($"рантайм: {Environment.Version}, DOTNET_RuntimeAsync={Environment.GetEnvironmentVariable("DOTNET_RuntimeAsync") ?? "<не задана>"}");
        Console.WriteLine($"C: Async = {(m.GetMethodImplementationFlags() & AsyncFlag) != 0}");
        var nested = typeof(Probe).GetNestedTypes(BindingFlags.NonPublic).Select(t => t.Name).ToArray();
        Console.WriteLine($"вложенные типы Probe: {(nested.Length == 0 ? "нет" : string.Join(", ", nested))}");
    }

    public static async Task Stack()
    {
        try { await A(); }
        catch (Exception e) { Console.WriteLine(e.StackTrace); }
    }

    static async Task A() { await B(); }
    static async Task B() { await C(); }
    static async Task C() { await Task.Yield(); throw new InvalidOperationException("из C"); }
}

// Глава 14. Один и тот же код, две модели async. Режимы (после -- ):
//   info     — что компилятор записал в метаданные: флаг Async или вложенная машина состояний;
//   stack    — трасса исключения после приостановки в цепочке A -> B -> C;
//   cost     — аллокации и время: цепочка из трёх async-методов, синхронный путь и приостановка;
//   context  — AsyncLocal и SynchronizationContext в этих методах.
// Сборка и запуск:
//   dotnet run -c Release --project final -- info                                       (машины состояний компилятора)
//   $env:DOTNET_RuntimeAsync = 1; dotnet run -c Release --project final -p:RuntimeAsync=on -- info    (.NET 10, runtime async)
using System.Diagnostics;
using System.Reflection;

switch (args.FirstOrDefault() ?? "info")
{
    case "info": Probe.Info(); break;
    case "stack": await Probe.Stack(); break;
    case "cost": await Probe.Cost(); break;
    case "context": await Probe.Context(); break;
}

static class Probe
{
    const MethodImplAttributes AsyncFlag = (MethodImplAttributes)0x2000;   // MethodImplAttributes.Async

    public static void Info()
    {
        Console.WriteLine($"рантайм: {Environment.Version}, DOTNET_RuntimeAsync={Environment.GetEnvironmentVariable("DOTNET_RuntimeAsync") ?? "<не задана>"}");
        MethodInfo m = typeof(Probe).GetMethod(nameof(C), BindingFlags.Static | BindingFlags.NonPublic)!;
        MethodImplAttributes flags = m.GetMethodImplementationFlags();
        Console.WriteLine($"C: MethodImplAttributes = {flags} (0x{(int)flags:X}), Async = {(flags & AsyncFlag) != 0}");
        Console.WriteLine($"C: AsyncStateMachineAttribute = {(m.GetCustomAttribute<System.Runtime.CompilerServices.AsyncStateMachineAttribute>() is not null)}");
        var nested = typeof(Probe).GetNestedTypes(BindingFlags.NonPublic).Select(t => t.Name).ToArray();
        Console.WriteLine($"вложенные типы Probe: {(nested.Length == 0 ? "нет" : string.Join(", ", nested))}");
    }

    public static async Task Stack()
    {
        try { await StackA(); }
        catch (Exception e)
        {
            Console.WriteLine(e.GetType().Name + ": " + e.Message);
            foreach (string line in e.StackTrace!.Split('\n'))
                Console.WriteLine("  " + System.Text.RegularExpressions.Regex.Replace(line.TrimEnd(), @" in .*[/\\]", " in "));
        }
    }

    public static async Task Cost()
    {
        const int sync = 2_000_000, susp = 200_000;
        // Прогрев по времени: пока JIT не переведёт методы с Tier-0 на оптимизированный код
        // (отсчёт многоуровневой компиляции начинается через ~100 мс бездействия), цифры бессмысленны.
        for (int round = 0; round < 3; round++)
        {
            long until = Stopwatch.GetTimestamp() + Stopwatch.Frequency / 3;
            while (Stopwatch.GetTimestamp() < until) { await A(false); await A(true); }
            await Task.Delay(300);
        }

        GC.Collect();
        long b0 = GC.GetAllocatedBytesForCurrentThread();
        long t0 = Stopwatch.GetTimestamp();
        for (int i = 0; i < sync; i++) await A(false);
        double ns = Stopwatch.GetElapsedTime(t0).TotalMilliseconds * 1e6 / sync;
        long bytes = GC.GetAllocatedBytesForCurrentThread() - b0;
        Console.WriteLine($"цепочка A→B→C без приостановки: {ns,7:F1} нс/оп, {bytes / (double)sync,6:F1} Б/оп");

        await Task.Run(async () =>
        {
            GC.Collect();
            long b1 = GC.GetTotalAllocatedBytes(precise: true);
            long t1 = Stopwatch.GetTimestamp();
            for (int i = 0; i < susp; i++) await A(true);
            double ns2 = Stopwatch.GetElapsedTime(t1).TotalMilliseconds * 1e6 / susp;
            long bytes2 = GC.GetTotalAllocatedBytes(precise: true) - b1;
            Console.WriteLine($"цепочка A→B→C, C приостанавливается: {ns2,7:F0} нс/оп, {bytes2 / (double)susp,6:F1} Б/оп");
        });
    }

    public static async Task Context()
    {
        // AsyncLocal, записанный в вызываемом async-методе, не виден вызывающему (как и всегда).
        var local = new AsyncLocal<string>();
        async Task Set() { local.Value = "из Set"; await Task.Yield(); }
        local.Value = "до";
        await Set();
        Console.WriteLine($"AsyncLocal после await Set(): {local.Value}");

        // Значение, записанное до await, видно после него.
        local.Value = "перед Yield";
        await Task.Yield();
        Console.WriteLine($"AsyncLocal после Yield: {local.Value}");

        // SynchronizationContext: продолжение должно вернуться в него.
        var ctx = new CountingContext();
        SynchronizationContext.SetSynchronizationContext(ctx);
        await Task.Yield();
        Console.WriteLine($"после Yield под SynchronizationContext: Post вызван {ctx.Posts} раз, контекст тот же = {ReferenceEquals(SynchronizationContext.Current, ctx)}");
        await Task.Delay(10).ConfigureAwait(false);
        Console.WriteLine($"после ConfigureAwait(false): контекст = {SynchronizationContext.Current?.GetType().Name ?? "null"}");
        SynchronizationContext.SetSynchronizationContext(null);
    }

    static async Task A(bool suspend = false) { await B(suspend); }
    static async Task B(bool suspend) { await C(suspend); }
    static async Task C(bool suspend)
    {
        if (suspend) await Task.Yield();
    }

    // Для режима stack: исключение бросается после приостановки.
    static async Task StackA() { await StackB(); }
    static async Task StackB() { await StackC(); }
    static async Task StackC() { await Task.Yield(); throw new InvalidOperationException("из StackC"); }
}

sealed class CountingContext : SynchronizationContext
{
    public int Posts;
    public override void Post(SendOrPostCallback d, object? state)
    {
        Interlocked.Increment(ref Posts);
        ThreadPool.QueueUserWorkItem(_ => { SetSynchronizationContext(this); d(state); });
    }
}