fix: read benchmarks logic

SockworkOrange · SockworkOrange · commit e204946effbb · 2025-12-10T00:41:10.000+01:00
diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
@@ -11,6 +11,8 @@ env:
   DOTNET_VERSION: '8.0.x'
 
 on:
+  push:
+    branches: [ "add-performance-benchmark-with-efcore" ]
   release:
     types: [ published ]
   workflow_dispatch:
diff --git a/benchmark/BenchmarkRunner/Benchmarks/MysqlReadBenchmark.cs b/benchmark/BenchmarkRunner/Benchmarks/MysqlReadBenchmark.cs
@@ -14,9 +14,10 @@ namespace BenchmarkRunner.Benchmarks;
 [CategoriesColumn]
 public class MysqlReadBenchmark
 {
-    private const int CustomerCount = 500;
     private readonly string _connectionString = Config.GetMysqlConnectionString();
     private QuerySql _sqlcImpl = null!;
+    private const int CustomerCount = 500;
+    private const int QueriesToRun = 10000;
 
     [Params(5000, 10000, 20000)]
     public int Limit { get; set; }
@@ -46,7 +47,7 @@ await seeder.SeedAsync(
     [Benchmark(Baseline = true, Description = "SQLC - GetCustomerOrders")]
     public async Task<List<QuerySql.GetCustomerOrdersRow>> Sqlc_GetCustomerOrders()
     {
-        return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, _ =>
+        return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, _ =>
         {
             return _sqlcImpl.GetCustomerOrdersAsync(new QuerySql.GetCustomerOrdersArgs(
                 CustomerId: Random.Shared.Next(1, CustomerCount),
@@ -60,7 +61,7 @@ await seeder.SeedAsync(
     [Benchmark(Description = "EFCore (NoTracking) - GetCustomerOrders")]
     public async Task<List<Queries.GetCustomerOrdersRow>> EFCore_NoTracking_GetCustomerOrders()
     {
-        return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, async _ =>
+        return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, async _ =>
         {
             await using var dbContext = new SalesDbContext(_connectionString);
             var queries = new Queries(dbContext, useTracking: false);
@@ -76,7 +77,7 @@ await seeder.SeedAsync(
     [Benchmark(Description = "EFCore (WithTracking) - GetCustomerOrders")]
     public async Task<List<Queries.GetCustomerOrdersRow>> EFCore_WithTracking_GetCustomerOrders()
     {
-        return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, async _ =>
+        return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, async _ =>
         {
             await using var dbContext = new SalesDbContext(_connectionString);
             var queries = new Queries(dbContext, useTracking: true);
diff --git a/benchmark/BenchmarkRunner/Benchmarks/PostgresqlReadBenchmark.cs b/benchmark/BenchmarkRunner/Benchmarks/PostgresqlReadBenchmark.cs
@@ -14,9 +14,10 @@ namespace BenchmarkRunner.Benchmarks;
 [CategoriesColumn]
 public class PostgresqlReadBenchmark
 {
-    private const int CustomerCount = 500;
     private readonly string _connectionString = Config.GetPostgresConnectionString();
     private QuerySql _sqlcImpl = null!;
+    private const int CustomerCount = 500;
+    private const int QueriesToRun = 10000;
 
     [Params(5000, 10000, 20000)]
     public int Limit { get; set; }
@@ -48,7 +49,7 @@ await seeder.SeedAsync(
     [Benchmark(Baseline = true, Description = "SQLC - GetCustomerOrders")]
     public async Task<List<QuerySql.GetCustomerOrdersRow>> Sqlc_GetCustomerOrders()
     {
-        return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, _ =>
+        return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, _ =>
         {
             return _sqlcImpl.GetCustomerOrdersAsync(new QuerySql.GetCustomerOrdersArgs(
                 CustomerId: Random.Shared.Next(1, CustomerCount),
@@ -62,7 +63,7 @@ await seeder.SeedAsync(
     [Benchmark(Description = "EFCore (NoTracking) - GetCustomerOrders")]
     public async Task<List<Queries.GetCustomerOrdersRow>> EFCore_NoTracking_GetCustomerOrders()
     {
-        return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, async _ =>
+        return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, async _ =>
         {
             await using var dbContext = new SalesDbContext(_connectionString);
             var queries = new Queries(dbContext, useTracking: false);
@@ -78,7 +79,7 @@ await seeder.SeedAsync(
     [Benchmark(Description = "EFCore (WithTracking) - GetCustomerOrders")]
     public async Task<List<Queries.GetCustomerOrdersRow>> EFCore_WithTracking_GetCustomerOrders()
     {
-        return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, async _ =>
+        return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, async _ =>
         {
             await using var dbContext = new SalesDbContext(_connectionString);
             var queries = new Queries(dbContext, useTracking: true);
diff --git a/benchmark/BenchmarkRunner/Benchmarks/SqliteReadBenchmark.cs b/benchmark/BenchmarkRunner/Benchmarks/SqliteReadBenchmark.cs
@@ -14,14 +14,15 @@ namespace BenchmarkRunner.Benchmarks;
 [CategoriesColumn]
 public class SqliteReadBenchmark
 {
-    private const int CustomerCount = 500;
     private readonly string _connectionString = Config.GetSqliteConnectionString();
     private QuerySql _sqlcImpl = null!;
+    private const int CustomerCount = 500;
+    private const int QueriesToRun = 1000;
 
     [Params(5000, 10000, 20000)]
     public int Limit { get; set; }
 
-    [Params(1, 10)]
+    [Params(5, 50)]
     public int ConcurrentQueries { get; set; }
 
     [GlobalSetup]
@@ -48,7 +49,7 @@ await seeder.SeedAsync(
     [Benchmark(Baseline = true, Description = "SQLC - GetCustomerOrders")]
     public async Task<List<QuerySql.GetCustomerOrdersRow>> Sqlc_GetCustomerOrders()
     {
-        return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, _ =>
+        return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, _ =>
         {
             return _sqlcImpl.GetCustomerOrdersAsync(new QuerySql.GetCustomerOrdersArgs(
                 CustomerId: Random.Shared.Next(1, CustomerCount),
@@ -62,7 +63,7 @@ await seeder.SeedAsync(
     [Benchmark(Description = "EFCore (NoTracking) - GetCustomerOrders")]
     public async Task<List<Queries.GetCustomerOrdersRow>> EFCore_NoTracking_GetCustomerOrders()
     {
-        return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, async _ =>
+        return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, async _ =>
         {
             await using var dbContext = new SalesDbContext(_connectionString);
             var queries = new Queries(dbContext, useTracking: false);
@@ -78,7 +79,7 @@ await seeder.SeedAsync(
     [Benchmark(Description = "EFCore (WithTracking) - GetCustomerOrders")]
     public async Task<List<Queries.GetCustomerOrdersRow>> EFCore_WithTracking_GetCustomerOrders()
     {
-        return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, async _ =>
+        return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, async _ =>
         {
             await using var dbContext = new SalesDbContext(_connectionString);
             var queries = new Queries(dbContext, useTracking: true);
diff --git a/benchmark/BenchmarkRunner/Utils/Helpers.cs b/benchmark/BenchmarkRunner/Utils/Helpers.cs
@@ -20,15 +20,33 @@ public static async Task InsertInBatchesAsync<T>(List<T> items, int batchSize, F
         }
     }
 
-    public static async Task<List<T>> ExecuteConcurrentlyAsync<T>(int concurrency, Func<int, Task<List<T>>> taskFactory)
+    public static async Task<List<T>> ExecuteConcurrentlyAsync<T>(
+        int totalTasks,
+        int maxConcurrency, 
+        Func<int, Task<List<T>>> taskFactory)
     {
+        var semaphore = new SemaphoreSlim(maxConcurrency, maxConcurrency);
         var tasks = new List<Task<List<T>>>();
-        for (int i = 0; i < concurrency; i++)
-        {
-            tasks.Add(taskFactory(i));
-        }
+        for (int i = 0; i < totalTasks; i++)
+            tasks.Add(ExecuteWithThrottleAsync(semaphore, () => taskFactory(i)));
 
         var results = await Task.WhenAll(tasks);
         return [.. results.SelectMany(r => r)];
     }
+
+    private static async Task<T> ExecuteWithThrottleAsync<T>(SemaphoreSlim? semaphore, Func<Task<T>> taskFactory)
+    {
+        if (semaphore == null)
+            return await taskFactory();
+
+        await semaphore.WaitAsync();
+        try
+        {
+            return await taskFactory();
+        }
+        finally
+        {
+            semaphore.Release();
+        }
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -14,9 +14,10 @@ namespace BenchmarkRunner.Benchmarks;`
`14`	`14`	`[CategoriesColumn]`
`15`	`15`	`public class MysqlReadBenchmark`
`16`	`16`	`{`
`17`		`- private const int CustomerCount = 500;`
`18`	`17`	`private readonly string _connectionString = Config.GetMysqlConnectionString();`
`19`	`18`	`private QuerySql _sqlcImpl = null!;`
	`19`	`+ private const int CustomerCount = 500;`
	`20`	`+ private const int QueriesToRun = 10000;`
`20`	`21`
`21`	`22`	`[Params(5000, 10000, 20000)]`
`22`	`23`	`public int Limit { get; set; }`
`@@ -46,7 +47,7 @@ await seeder.SeedAsync(`
`46`	`47`	`[Benchmark(Baseline = true, Description = "SQLC - GetCustomerOrders")]`
`47`	`48`	`public async Task<List<QuerySql.GetCustomerOrdersRow>> Sqlc_GetCustomerOrders()`
`48`	`49`	`{`
`49`		`- return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, _ =>`
	`50`	`+ return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, _ =>`
`50`	`51`	`{`
`51`	`52`	`return _sqlcImpl.GetCustomerOrdersAsync(new QuerySql.GetCustomerOrdersArgs(`
`52`	`53`	`CustomerId: Random.Shared.Next(1, CustomerCount),`
`@@ -60,7 +61,7 @@ await seeder.SeedAsync(`
`60`	`61`	`[Benchmark(Description = "EFCore (NoTracking) - GetCustomerOrders")]`
`61`	`62`	`public async Task<List<Queries.GetCustomerOrdersRow>> EFCore_NoTracking_GetCustomerOrders()`
`62`	`63`	`{`
`63`		`- return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, async _ =>`
	`64`	`+ return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, async _ =>`
`64`	`65`	`{`
`65`	`66`	`await using var dbContext = new SalesDbContext(_connectionString);`
`66`	`67`	`var queries = new Queries(dbContext, useTracking: false);`
`@@ -76,7 +77,7 @@ await seeder.SeedAsync(`
`76`	`77`	`[Benchmark(Description = "EFCore (WithTracking) - GetCustomerOrders")]`
`77`	`78`	`public async Task<List<Queries.GetCustomerOrdersRow>> EFCore_WithTracking_GetCustomerOrders()`
`78`	`79`	`{`
`79`		`- return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, async _ =>`
	`80`	`+ return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, async _ =>`
`80`	`81`	`{`
`81`	`82`	`await using var dbContext = new SalesDbContext(_connectionString);`
`82`	`83`	`var queries = new Queries(dbContext, useTracking: true);`
Original file line number	Diff line number	Diff line change
`@@ -14,14 +14,15 @@ namespace BenchmarkRunner.Benchmarks;`
`14`	`14`	`[CategoriesColumn]`
`15`	`15`	`public class SqliteReadBenchmark`
`16`	`16`	`{`
`17`		`- private const int CustomerCount = 500;`
`18`	`17`	`private readonly string _connectionString = Config.GetSqliteConnectionString();`
`19`	`18`	`private QuerySql _sqlcImpl = null!;`
	`19`	`+ private const int CustomerCount = 500;`
	`20`	`+ private const int QueriesToRun = 1000;`
`20`	`21`
`21`	`22`	`[Params(5000, 10000, 20000)]`
`22`	`23`	`public int Limit { get; set; }`
`23`	`24`
`24`		`- [Params(1, 10)]`
	`25`	`+ [Params(5, 50)]`
`25`	`26`	`public int ConcurrentQueries { get; set; }`
`26`	`27`
`27`	`28`	`[GlobalSetup]`
`@@ -48,7 +49,7 @@ await seeder.SeedAsync(`
`48`	`49`	`[Benchmark(Baseline = true, Description = "SQLC - GetCustomerOrders")]`
`49`	`50`	`public async Task<List<QuerySql.GetCustomerOrdersRow>> Sqlc_GetCustomerOrders()`
`50`	`51`	`{`
`51`		`- return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, _ =>`
	`52`	`+ return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, _ =>`
`52`	`53`	`{`
`53`	`54`	`return _sqlcImpl.GetCustomerOrdersAsync(new QuerySql.GetCustomerOrdersArgs(`
`54`	`55`	`CustomerId: Random.Shared.Next(1, CustomerCount),`
`@@ -62,7 +63,7 @@ await seeder.SeedAsync(`
`62`	`63`	`[Benchmark(Description = "EFCore (NoTracking) - GetCustomerOrders")]`
`63`	`64`	`public async Task<List<Queries.GetCustomerOrdersRow>> EFCore_NoTracking_GetCustomerOrders()`
`64`	`65`	`{`
`65`		`- return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, async _ =>`
	`66`	`+ return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, async _ =>`
`66`	`67`	`{`
`67`	`68`	`await using var dbContext = new SalesDbContext(_connectionString);`
`68`	`69`	`var queries = new Queries(dbContext, useTracking: false);`
`@@ -78,7 +79,7 @@ await seeder.SeedAsync(`
`78`	`79`	`[Benchmark(Description = "EFCore (WithTracking) - GetCustomerOrders")]`
`79`	`80`	`public async Task<List<Queries.GetCustomerOrdersRow>> EFCore_WithTracking_GetCustomerOrders()`
`80`	`81`	`{`
`81`		`- return await Helpers.ExecuteConcurrentlyAsync(ConcurrentQueries, async _ =>`
	`82`	`+ return await Helpers.ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, async _ =>`
`82`	`83`	`{`
`83`	`84`	`await using var dbContext = new SalesDbContext(_connectionString);`
`84`	`85`	`var queries = new Queries(dbContext, useTracking: true);`