bgrainger · February 13, 2023 05:34
diff --git a/BenchmarkResults.md b/BenchmarkResults.md
diff --git a/Program.cs b/Program.cs
 [MemoryDiagnoser]
 public class Program
 {
    static void Main(string[] args)
    {
        var summary = BenchmarkRunner.Run<Program>();

    }

    [Benchmark]
    public async Task<int> CountAsync()
    {
        var index = 0;
        await s_semaphore.WaitAsync().ConfigureAwait(false);
        s_counters[index]++;
        s_semaphore.Release();
        return s_counters[index];
    }

    [Benchmark]
    public async ValueTask<int> CountAsyncValueTask()
    {
        var index = 0;
        await s_semaphore.WaitAsync().ConfigureAwait(false);
        s_counters[index]++;
        s_semaphore.Release();
        return s_counters[index];
    }

    [Benchmark]
    public ValueTask<int> CountAsyncValueTaskLocalFunction()
    {
        var index = 0;
        var task = s_semaphore.WaitAsync();
        return task.IsCompleted ? new ValueTask<int>(Remainder()) :
            new ValueTask<int>(Awaited());

        async Task<int> Awaited()
        {
            await task.ConfigureAwait(false);
            return Remainder();
        }

        int Remainder()
        {
            s_counters[index]++;
            s_semaphore.Release();
            return s_counters[index];
        }
    }

    [Benchmark]
    public ValueTask<int> CountAsyncValueTaskLocalFunctionNoCapture()
    {
        var index = 0;
        var task = s_semaphore.WaitAsync();
        return task.IsCompleted ? new ValueTask<int>(Remainder(index)) :
            new ValueTask<int>(Awaited(task, index));

        async Task<int> Awaited(Task task_, int index_)
        {
            await task_.ConfigureAwait(false);
            return Remainder(index_);
        }

        int Remainder(int index_)
        {
            s_counters[index_]++;
            s_semaphore.Release();
            return s_counters[index_];
        }
    }

    [Benchmark]
    public ValueTask<int> CountAsyncValueTaskMultipleFunctions()
    {
        var index = 0;
        var task = s_semaphore.WaitAsync();
        return task.IsCompleted ? new ValueTask<int>(CountAsyncValueTaskMultipleFunctionsRemainder(index)) :
            new ValueTask<int>(CountAsyncValueTaskMultipleFunctionsAwaited(task, index));
    }

    static async Task<int> CountAsyncValueTaskMultipleFunctionsAwaited(Task task, int index)
    {
        await task.ConfigureAwait(false);
        return CountAsyncValueTaskMultipleFunctionsRemainder(index);
    }

    static int CountAsyncValueTaskMultipleFunctionsRemainder(int index)
    {
        s_counters[index]++;
        s_semaphore.Release();
        return s_counters[index];
    }

    static readonly int[] s_counters = new int[20];
    static readonly SemaphoreSlim s_semaphore = new SemaphoreSlim(20, 20);
 }
Method	Mean	StdDev	Gen 0	Allocated
CountAsync	90.1756 ns	0.8802 ns	0.0154	136 B
CountAsyncValueTask	97.2691 ns	0.8378 ns	0.0037	64 B
CountAsyncValueTaskLocalFunction	58.7156 ns	0.6790 ns	0.0118	96 B
CountAsyncValueTaskLocalFunctionNoCapture	46.9273 ns	0.5879 ns	0.0068	64 B
CountAsyncValueTaskMultipleFunctions	45.3743 ns	0.4451 ns	0.0069	64 B
	[MemoryDiagnoser]
	public class Program
	{
	static void Main(string[] args)
	{
	var summary = BenchmarkRunner.Run<Program>();

	}

	[Benchmark]
	public async Task<int> CountAsync()
	{
	var index = 0;
	await s_semaphore.WaitAsync().ConfigureAwait(false);
	s_counters[index]++;
	s_semaphore.Release();
	return s_counters[index];
	}

	[Benchmark]
	public async ValueTask<int> CountAsyncValueTask()
	{
	var index = 0;
	await s_semaphore.WaitAsync().ConfigureAwait(false);
	s_counters[index]++;
	s_semaphore.Release();
	return s_counters[index];
	}

	[Benchmark]
	public ValueTask<int> CountAsyncValueTaskLocalFunction()
	{
	var index = 0;
	var task = s_semaphore.WaitAsync();
	return task.IsCompleted ? new ValueTask<int>(Remainder()) :
	new ValueTask<int>(Awaited());

	async Task<int> Awaited()
	{
	await task.ConfigureAwait(false);
	return Remainder();
	}

	int Remainder()
	{
	s_counters[index]++;
	s_semaphore.Release();
	return s_counters[index];
	}
	}

	[Benchmark]
	public ValueTask<int> CountAsyncValueTaskLocalFunctionNoCapture()
	{
	var index = 0;
	var task = s_semaphore.WaitAsync();
	return task.IsCompleted ? new ValueTask<int>(Remainder(index)) :
	new ValueTask<int>(Awaited(task, index));

	async Task<int> Awaited(Task task_, int index_)
	{
	await task_.ConfigureAwait(false);
	return Remainder(index_);
	}

	int Remainder(int index_)
	{
	s_counters[index_]++;
	s_semaphore.Release();
	return s_counters[index_];
	}
	}

	[Benchmark]
	public ValueTask<int> CountAsyncValueTaskMultipleFunctions()
	{
	var index = 0;
	var task = s_semaphore.WaitAsync();
	return task.IsCompleted ? new ValueTask<int>(CountAsyncValueTaskMultipleFunctionsRemainder(index)) :
	new ValueTask<int>(CountAsyncValueTaskMultipleFunctionsAwaited(task, index));
	}

	static async Task<int> CountAsyncValueTaskMultipleFunctionsAwaited(Task task, int index)
	{
	await task.ConfigureAwait(false);
	return CountAsyncValueTaskMultipleFunctionsRemainder(index);
	}

	static int CountAsyncValueTaskMultipleFunctionsRemainder(int index)
	{
	s_counters[index]++;
	s_semaphore.Release();
	return s_counters[index];
	}

	static readonly int[] s_counters = new int[20];
	static readonly SemaphoreSlim s_semaphore = new SemaphoreSlim(20, 20);
	}