TigerBeetle client batching benchmark

Benchmark.cs

using System;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Threading;
using System.Threading.Tasks;

namespace TigerBeetle.Benchmarks
{
    public static partial class BenchmarkBatching
    {
        private const int TRANSFERS_COUNT = 1_000_000;

        public static async Task Main()
        {
            Console.WriteLine($"Benchmarking client batching on dotnet");

            // The max number of tasks calling `CreateTransferAsync` at the same time:
            const int MAX_CONCURRENCY = 4096;

            using var maxConcurrencyLimiter = new SemaphoreSlim(MAX_CONCURRENCY);
            using var client = new Client(0, new string[] { "3001" }, MAX_CONCURRENCY);

            var accounts = new[] {
                new Account
                {
                    Id = 1,
                    Code = 2,
                    Ledger = 777,
                },
                new Account
                {
                    Id = 2,
                    Code = 2,
                    Ledger = 777,
                }
            };

            Console.WriteLine("creating accounts...");

            var results = await client.CreateAccountsAsync(accounts);
            if (results.Length > 0) throw new Exception("Invalid account results");

            Console.WriteLine("starting benchmark...");

            var stopWatch = Stopwatch.StartNew();
            var transfers = new Task<long>[TRANSFERS_COUNT];
            for (int i = 0; i < TRANSFERS_COUNT; i++)
            {
                var transfer = new Transfer
                {
                    Id = new UInt128((ulong)i + 1, 0),
                    DebitAccountId = accounts[0].Id,
                    CreditAccountId = accounts[1].Id,
                    Amount = 1,
                    Code = 1,
                    Ledger = 777,
                };
                transfers[i] = Task.Run<long>(async () =>
                {
                    await maxConcurrencyLimiter.WaitAsync();
                    var stopWatch = Stopwatch.StartNew();
                    var result = await client.CreateTransferAsync(transfer);
                    var elapsedMilliseconds = stopWatch.ElapsedMilliseconds;
                    _ = maxConcurrencyLimiter.Release();

                    if (result != CreateTransferResult.Ok) throw new Exception("Invalid transfer result");
                    return elapsedMilliseconds;
                });
            }

            await Task.WhenAll(transfers);
            var totalTime = stopWatch.ElapsedMilliseconds;

            Console.WriteLine("============================================");

            var tps = TRANSFERS_COUNT * 1000L / totalTime;
            var p100 = transfers.Max(x => x.Result);
            Console.WriteLine($"{tps} transfers per second with {MAX_CONCURRENCY} concurrent tasks.");
            Console.WriteLine($"create_transfers max p100 latency per transfer = {p100}ms.");
            Console.WriteLine($"total {TRANSFERS_COUNT} transfers in {totalTime}ms.");
        }
    }
}