fix: adjust mysql and postgres benchmark settings

Author: SockworkOrange

benchmark/BenchmarkRunner/Benchmarks/MysqlReadBenchmark.cs

@@ -19,7 +19,7 @@ public class MysqlReadBenchmark
     private const int CustomerCount = 500;
     private const int QueriesToRun = 1000;
 
-    [Params(50, 500, 5000)]
+    [Params(50, 500, 1000)]
     public int Limit { get; set; }
 
     [Params(10, 50)]

benchmark/BenchmarkRunner/Benchmarks/PostgresqlReadBenchmark.cs

@@ -19,7 +19,7 @@ public class PostgresqlReadBenchmark
     private const int CustomerCount = 500;
     private const int QueriesToRun = 1000;
 
-    [Params(50, 500, 5000)]
+    [Params(50, 500, 1000)]
     public int Limit { get; set; }
 
     [Params(10, 50)]
@@ -29,7 +29,6 @@ public class PostgresqlReadBenchmark
     public async Task GlobalSetup()
     {
         _sqlcImpl = new(_connectionString);
-
         await PostgresqlDatabaseHelper.CleanupDatabaseAsync(_connectionString);
         var seeder = new PostgresqlDatabaseSeeder(_connectionString);
         await seeder.SeedAsync(

benchmark/BenchmarkRunner/Benchmarks/SqliteReadBenchmark.cs

@@ -18,7 +18,7 @@ public class SqliteReadBenchmark
     private QuerySql _sqlcImpl = null!;
     private const int CustomerCount = 250;
     private const int QueriesToRun = 500;
-
+    
     [Params(50, 500)]
     public int Limit { get; set; }
 
@@ -29,7 +29,6 @@ public class SqliteReadBenchmark
     public async Task GlobalSetup()
     {
         _sqlcImpl = new QuerySql(_connectionString);
-
         SqliteDatabaseHelper.CleanupDatabase(_connectionString);
         await SqliteDatabaseHelper.InitializeDatabaseAsync(_connectionString);
         var seeder = new SqliteDatabaseSeeder(_connectionString);

benchmark/BenchmarkRunner/MysqlRunner.cs

@@ -1,12 +1,13 @@
+using System.Diagnostics;
 using BenchmarkDotNet.Configs;
 using BenchmarkRunner.Benchmarks;
+using BenchmarkRunner.Utils;
 using Microsoft.Extensions.Logging;
 
 public class MysqlRunner(string connectionString, ILogger<MysqlRunner> logger)
 {
     private readonly string _connectionString = connectionString;
     private readonly ILogger<MysqlRunner> _logger = logger;
-
     public string ConnectionString => _connectionString;
 
     public Task RunAsync()
@@ -15,9 +16,19 @@ public Task RunAsync()
         var config = DefaultConfig.Instance.WithArtifactsPath(path);
 
         _logger.LogInformation("Running MySQL Reads benchmarks...");
+        var stopwatch = Stopwatch.StartNew();
         BenchmarkDotNet.Running.BenchmarkRunner.Run<MysqlReadBenchmark>(config);
+        stopwatch.Stop();
+        var readTime = stopwatch.Elapsed;
+
         _logger.LogInformation("Running MySQL Writes benchmarks...");
+        stopwatch.Restart();
         BenchmarkDotNet.Running.BenchmarkRunner.Run<MysqlWriteBenchmark>(config);
+        stopwatch.Stop();
+        var writeTime = stopwatch.Elapsed;
+
+        _logger.LogInformation("MySQL Reads benchmarks completed in {ElapsedTime}", Helpers.FormatElapsedTime(readTime));
+        _logger.LogInformation("MySQL Writes benchmarks completed in {ElapsedTime}", Helpers.FormatElapsedTime(writeTime));
         return Task.CompletedTask;
     }
 }

benchmark/BenchmarkRunner/PostgresqlRunner.cs

@@ -1,12 +1,13 @@
+using System.Diagnostics;
 using BenchmarkDotNet.Configs;
 using BenchmarkRunner.Benchmarks;
+using BenchmarkRunner.Utils;
 using Microsoft.Extensions.Logging;
 
 public class PostgresqlRunner(string connectionString, ILogger<PostgresqlRunner> logger)
 {
     private readonly string _connectionString = connectionString;
     private readonly ILogger<PostgresqlRunner> _logger = logger;
-
     public string ConnectionString => _connectionString;
 
     public Task RunAsync()
@@ -15,9 +16,19 @@ public Task RunAsync()
         var config = DefaultConfig.Instance.WithArtifactsPath(path);
 
         _logger.LogInformation("Running PostgreSQL Reads benchmarks...");
+        var stopwatch = Stopwatch.StartNew();
         BenchmarkDotNet.Running.BenchmarkRunner.Run<PostgresqlReadBenchmark>(config);
+        stopwatch.Stop();
+        var readTime = stopwatch.Elapsed;
+
         _logger.LogInformation("Running PostgreSQL Writes benchmarks...");
+        stopwatch.Restart();
         BenchmarkDotNet.Running.BenchmarkRunner.Run<PostgresqlWriteBenchmark>(config);
+        stopwatch.Stop();
+        var writeTime = stopwatch.Elapsed;
+
+        _logger.LogInformation("PostgreSQL Reads benchmarks completed in {ElapsedTime}", Helpers.FormatElapsedTime(readTime));
+        _logger.LogInformation("PostgreSQL Writes benchmarks completed in {ElapsedTime}", Helpers.FormatElapsedTime(writeTime));
         return Task.CompletedTask;
     }
 }

benchmark/BenchmarkRunner/SqliteRunner.cs

@@ -1,5 +1,7 @@
+using System.Diagnostics;
 using BenchmarkDotNet.Configs;
 using BenchmarkRunner.Benchmarks;
+using BenchmarkRunner.Utils;
 using Microsoft.Extensions.Logging;
 
 public class SqliteRunner(string connectionString, ILogger<SqliteRunner> logger)
@@ -15,9 +17,19 @@ public Task RunAsync()
         var config = DefaultConfig.Instance.WithArtifactsPath(path);
 
         _logger.LogInformation("Running SQLite Reads benchmarks...");
+        var stopwatch = Stopwatch.StartNew();
         BenchmarkDotNet.Running.BenchmarkRunner.Run<SqliteReadBenchmark>(config);
+        stopwatch.Stop();
+        var readTime = stopwatch.Elapsed;
+
         _logger.LogInformation("Running SQLite Writes benchmarks...");
+        stopwatch.Restart();
         BenchmarkDotNet.Running.BenchmarkRunner.Run<SqliteWriteBenchmark>(config);
+        stopwatch.Stop();
+        var writeTime = stopwatch.Elapsed;;
+
+        _logger.LogInformation("SQLite Reads benchmarks completed in {ElapsedTime}", Helpers.FormatElapsedTime(readTime));
+        _logger.LogInformation("SQLite Writes benchmarks completed in {ElapsedTime}", Helpers.FormatElapsedTime(writeTime))
         return Task.CompletedTask;
     }
 }

benchmark/BenchmarkRunner/Utils/Helpers.cs

@@ -1,23 +1,44 @@
-using System.Linq;
+using Microsoft.Extensions.Logging;
 
 namespace BenchmarkRunner.Utils;
 
 public static class Helpers
 {
+    private static readonly ILoggerFactory LoggerFactory = Microsoft.Extensions.Logging.LoggerFactory.Create(builder =>
+    {
+        builder
+            .AddConsole()
+            .SetMinimumLevel(LogLevel.Information);
+    });
+
+    public static ILogger<T> CreateLogger<T>() => LoggerFactory.CreateLogger<T>();
+
     public static void InvokeGarbageCollection()
     {
         GC.Collect();
         GC.WaitForPendingFinalizers();
         GC.Collect();
     }
 
-    public static async Task InsertInBatchesAsync<T>(List<T> items, int batchSize, Func<List<T>, Task> insertBatch)
+    /// <summary>
+    /// Formats elapsed time in a human-readable format (e.g., "1m 23.45s" or "45.67s")
+    /// </summary>
+    public static string FormatElapsedTime(TimeSpan elapsed)
     {
-        for (int i = 0; i < items.Count; i += batchSize)
+        if (elapsed.TotalMinutes >= 1)
         {
-            var batch = items.Skip(i).Take(batchSize).ToList();
-            await insertBatch(batch);
+            var minutes = (int)elapsed.TotalMinutes;
+            var seconds = elapsed.TotalSeconds % 60;
+            return $"{minutes}m {seconds:F2}s";
         }
+        return $"{elapsed.TotalSeconds:F2}s";
+    }
+
+    public static async Task InsertInBatchesAsync<T>(List<T> items, int batchSize, Func<List<T>, Task> insertBatch)
+    {
+        var batches = items.Chunk(batchSize);
+        foreach (var batch in batches)
+            await insertBatch([.. batch]);
     }
 
     private static int CalculateMaxConcurrency(int totalTasks, int maxConcurrency)
@@ -32,20 +53,20 @@ public static async Task<List<T>> ExecuteConcurrentlyAsync<T>(
         Func<int, Task<List<T>>> taskFactory)
     {
         maxConcurrency = CalculateMaxConcurrency(totalTasks, maxConcurrency);
-        var semaphore = new SemaphoreSlim(maxConcurrency, maxConcurrency);
+        using var semaphore = new SemaphoreSlim(maxConcurrency, maxConcurrency);
         var tasks = new List<Task<List<T>>>();
         for (int i = 0; i < totalTasks; i++)
-            tasks.Add(ExecuteWithThrottleAsync(semaphore, () => taskFactory(i)));
+        {
+            var index = i; // Capture for closure
+            tasks.Add(ExecuteWithThrottleAsync(semaphore, () => taskFactory(index)));
+        }
 
-        var results = await Task.WhenAll(tasks);
+        var results = await Task.WhenAll([.. tasks]);
         return [.. results.SelectMany(r => r)];
     }
 
-    private static async Task<T> ExecuteWithThrottleAsync<T>(SemaphoreSlim? semaphore, Func<Task<T>> taskFactory)
+    private static async Task<List<T>> ExecuteWithThrottleAsync<T>(SemaphoreSlim semaphore, Func<Task<List<T>>> taskFactory)
     {
-        if (semaphore == null)
-            return await taskFactory();
-
         await semaphore.WaitAsync();
         try
         {