12. ValueTask и производительность async¶

// Глава 12, §12.4. Цена async: синхронное завершение против реальной приостановки.
// PREDICT: у каких методов Allocated = 0? Во сколько раз реальная приостановка дороже?
// TODO 1: добавьте async ValueTask<int> с await Task.Yield() — на сколько байт он отличается от async Task<int>?
// TODO 2: добавьте тот же метод с [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<>))] и сравните Allocated.
// Запуск: dotnet run -c Release -- --filter *
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

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

#pragma warning disable CS1998   // async без await: нарочно
[MemoryDiagnoser]
public class AsyncBench
{
    [Benchmark(Baseline = true)]
    public Task<int> TaskFromResult() => Task.FromResult(1000);

    [Benchmark]
    public async Task<int> AsyncTaskSync() => 1000;

    [Benchmark]
    public ValueTask<int> ValueTaskSync() => new ValueTask<int>(1000);

    [Benchmark]
    public async ValueTask<int> AsyncValueTaskSync() => 1000;

    [Benchmark]
    public async Task<int> AsyncTaskRealSuspend() { await Task.Yield(); return 1000; }
}

// Глава 12, итог.
//   dotnet run -c Release -- --filter *   — бенчмарки (§12.4 + свой IValueTaskSource + пулинг builder'а)
//   dotnet run -c Release -- misuse       — что бывает при повторном await одного ValueTask (на разных «основах»)
//   dotnet run -c Release -- cost         — размер структуры, аллокации и цена приостановки без BenchmarkDotNet
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Threading.Tasks.Sources;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

switch (args.FirstOrDefault())
{
    case "misuse":
        await Misuse.RunAsync();
        return;
    case "cost":
        await Cost.RunAsync();
        return;
}

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

#pragma warning disable CS1998   // async без await: нарочно
[MemoryDiagnoser]
public class AsyncBench
{
    private readonly ReusableSource _source = new();

    [Benchmark(Baseline = true)]
    public Task<int> TaskFromResult() => Task.FromResult(1000);

    [Benchmark]
    public async Task<int> AsyncTaskSync() => 1000;

    [Benchmark]
    public ValueTask<int> ValueTaskSync() => new ValueTask<int>(1000);

    [Benchmark]
    public async ValueTask<int> AsyncValueTaskSync() => 1000;

    [Benchmark]
    public async Task<int> AsyncTaskRealSuspend() { await Task.Yield(); return 1000; }

    [Benchmark]
    public async ValueTask<int> AsyncValueTaskRealSuspend() { await Task.Yield(); return 1000; }

    // Тот же метод, но бокс машины состояний берётся из пула (§12.3).
    [Benchmark]
    [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<>))]
    public async ValueTask<int> PooledValueTaskRealSuspend() { await Task.Yield(); return 1000; }

    // ValueTask поверх переиспользуемого источника: ни Task, ни бокса.
    [Benchmark]
    public async ValueTask<int> ReusableSourceAwait()
    {
        ValueTask<int> vt = _source.Start();
        _source.Complete(1000);
        return await vt;
    }
}

// Переиспользуемый источник результата: так устроены, например, сокеты в .NET.
public sealed class ReusableSource : IValueTaskSource<int>
{
    private ManualResetValueTaskSourceCore<int> _core;   // изменяемая структура: не readonly!

    public ValueTask<int> Start()
    {
        _core.Reset();                                   // новая операция: Version++
        return new ValueTask<int>(this, _core.Version);
    }

    public void Complete(int value) => _core.SetResult(value);

    public int GetResult(short token) => _core.GetResult(token);
    public ValueTaskSourceStatus GetStatus(short token) => _core.GetStatus(token);
    public void OnCompleted(Action<object?> continuation, object? state, short token, ValueTaskSourceOnCompletedFlags flags) =>
        _core.OnCompleted(continuation, state, token, flags);
}

static class Misuse
{
    public static async Task RunAsync()
    {
        // 1. Один и тот же ValueTask ждут дважды. Что случится, зависит от того, что внутри.
        await Twice("готовое значение (_obj = null)", () => new ValueTask<int>(7));
        await Twice("завершённый Task", () => new ValueTask<int>(Task.FromResult(7)));
        await Twice("async-метод, приостановился (Task внутри)", () => Suspending());
        await Twice("async-метод с PoolingAsyncValueTaskMethodBuilder", () => PooledSuspending());

        var source = new ReusableSource();
        await Twice("ReusableSource, другая операция уже началась", () =>
        {
            ValueTask<int> vt = source.Start();
            source.Complete(7);
            return vt;
        }, between: () => source.Start());

        // 2. Результат до завершения: .Result / GetResult().
        var pending = new ReusableSource();
        ValueTask<int> notDone = pending.Start();
        Try("ReusableSource: .Result до завершения", () => notDone.Result);

        // 3. AsTask() один раз превращает источник в обычный Task: его можно ждать сколько угодно.
        var src2 = new ReusableSource();
        ValueTask<int> vt2 = src2.Start();
        Task<int> asTask = vt2.AsTask();
        src2.Complete(42);
        Console.WriteLine($"AsTask: {await asTask}, {await asTask}, тип {asTask.GetType().Name}");
        src2.Start();   // источник свободен для новой операции — Task от этого не пострадал
        Console.WriteLine($"AsTask после переиспользования источника: {await asTask}");
    }

    static async Task Twice(string name, Func<ValueTask<int>> make, Action? between = null)
    {
        ValueTask<int> vt = make();
        int first = await vt;
        between?.Invoke();
        try
        {
            int second = await vt;
            Console.WriteLine($"{name}: {first}, затем {second}");
        }
        catch (Exception e)
        {
            Console.WriteLine($"{name}: {first}, затем {e.GetType().Name}");
        }
    }

    static void Try(string name, Func<int> f)
    {
        try { Console.WriteLine($"{name}: {f()}"); }
        catch (Exception e) { Console.WriteLine($"{name}: {e.GetType().Name}"); }
    }

    static async ValueTask<int> Suspending() { await Task.Yield(); return 7; }

    [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<>))]
    static async ValueTask<int> PooledSuspending() { await Task.Yield(); return 7; }
}

static class Cost
{
    const int N = 200_000;

    public static async Task RunAsync()
    {
        Console.WriteLine($"sizeof(ValueTask<int>) = {Unsafe.SizeOf<ValueTask<int>>()}, sizeof(ValueTask) = {Unsafe.SizeOf<ValueTask>()}");
        Console.WriteLine($"PoolAsyncValueTasks (переменная окружения) = {Environment.GetEnvironmentVariable("DOTNET_SYSTEM_THREADING_POOLASYNCVALUETASKS") ?? "<не задана>"}");

        // Прогрев по времени: пока JIT не перевёл методы с Tier-0 на оптимизированный код
        // (отсчёт многоуровневой компиляции начинается через ~100 мс бездействия), цифры бессмысленны.
        for (int round = 0; round < 3; round++)
        {
            long until = Stopwatch.GetTimestamp() + Stopwatch.Frequency / 3;
            while (Stopwatch.GetTimestamp() < until) { await Yielding(); await PooledYielding(); await YieldingTask(); }
            await Task.Delay(300);
        }

        // Приостановка без пробуждения потока: Task.Yield отправляет продолжение в очередь пула,
        // а поток пула, дойдя до конца, берёт его же. Ждущий поток один раз в начале и один раз в конце.
        await Measure("Task.Yield в цикле внутри одного метода", async () =>
        {
            for (int i = 0; i < N; i++) await Task.Yield();
        });

        await Measure("async ValueTask, каждый вызов приостанавливается", async () =>
        {
            for (int i = 0; i < N; i++) await Yielding();
        });

        await Measure("то же, PoolingAsyncValueTaskMethodBuilder", async () =>
        {
            for (int i = 0; i < N; i++) await PooledYielding();
        });

        await Measure("то же, async Task", async () =>
        {
            for (int i = 0; i < N; i++) await YieldingTask();
        });
    }

    static async Task Measure(string name, Func<Task> body)
    {
        GC.Collect();
        long before = GC.GetTotalAllocatedBytes(precise: true);
        long t0 = Stopwatch.GetTimestamp();
        await Task.Run(body);
        TimeSpan elapsed = Stopwatch.GetElapsedTime(t0);
        long bytes = GC.GetTotalAllocatedBytes(precise: true) - before;
        Console.WriteLine($"{name}: {elapsed.TotalMilliseconds * 1e6 / N,7:F0} нс/оп, {bytes / (double)N,6:F1} Б/оп");
    }

    static async ValueTask<int> Yielding() { await Task.Yield(); return 1; }
    static async Task<int> YieldingTask() { await Task.Yield(); return 1; }

    [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<>))]
    static async ValueTask<int> PooledYielding() { await Task.Yield(); return 1; }
}