Remove ConcurrentDictionary from RelationalTransactionRegistry

source/Nevermore.Benchmarks/RelationalTransactionRegistryBenchmark.cs

@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using BenchmarkDotNet.Attributes;
+using Nevermore.Advanced;
+
+namespace Nevermore.Benchmarks;
+
+public class RelationalTransactionRegistryBenchmark
+{
+    readonly RelationalStoreConfiguration config = new("");
+    RelationalTransactionRegistry registry;
+    List<ReadTransaction> transactions;
+
+    [Params(5_000, 100_000)]
+    public int TransactionCount { get; set; }
+
+    [IterationSetup(Target = nameof(AddTransactions))]
+    public void SetupAddBenchmark()
+    {
+        registry = new RelationalTransactionRegistry(maxSqlConnectionPoolSize: int.MaxValue);
+    }
+
+    [Benchmark]
+    public void AddTransactions()
+    {
+        for (var i = 0; i < TransactionCount; i++)
+        {
+            _ = new ReadTransaction(null!, registry, RetriableOperation.None, config);
+        }
+    }
+
+    [IterationSetup(Target = nameof(RemoveTransactions))]
+    public void SetupRemovalBenchmark()
+    {
+        registry = new RelationalTransactionRegistry(maxSqlConnectionPoolSize: int.MaxValue);
+        transactions = new List<ReadTransaction>(capacity: TransactionCount);
+
+        for (var i = 0; i < TransactionCount; i++)
+        {
+            transactions.Add(new ReadTransaction(null!, registry, RetriableOperation.None, config));
+        }
+    }
+
+    [Benchmark]
+    public void RemoveTransactions()
+    {
+        foreach (var t in transactions)
+        {
+            registry.Remove(t);
+        }
+    }
+}

source/Nevermore/Advanced/RelationalTransactionRegistry.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -25,19 +24,23 @@ public class RelationalTransactionRegistry : IRelationalTransactionRegistry
         static readonly ILog Log = LogProvider.For<RelationalTransactionRegistry>();
 
         readonly int maxSqlConnectionPoolSize;
-        readonly ConcurrentDictionary<ReadTransaction, ReadTransaction> transactions = new();
+        readonly HashSet<ReadTransaction> transactions = new(); // lock transactions before accessing
 
         DateTime? lastHighNumberOfTransactionLogTime;
-
         public RelationalTransactionRegistry(int maxSqlConnectionPoolSize)
         {
             this.maxSqlConnectionPoolSize = maxSqlConnectionPoolSize;
         }
 
         public void Add(ReadTransaction trn)
         {
-            transactions.TryAdd(trn, trn);
-            var numberOfTransactions = transactions.Count;
+            int numberOfTransactions;
+            lock (transactions)
+            {
+                transactions.Add(trn);
+                numberOfTransactions = transactions.Count;
+            }
+
             if (numberOfTransactions > maxSqlConnectionPoolSize * 0.8)
                 Log.Info($"{numberOfTransactions} transactions active");
 
@@ -47,7 +50,10 @@ public void Add(ReadTransaction trn)
 
         public void Remove(ReadTransaction trn)
         {
-            transactions.TryRemove(trn, out _);
+            lock (transactions)
+            {
+                transactions.Remove(trn);
+            }
         }
 
         bool ShouldLogHighNumberOfTransactionsMessage() => lastHighNumberOfTransactionLogTime == null || DateTime.Now - lastHighNumberOfTransactionLogTime > TimeSpan.FromMinutes(1);
@@ -78,7 +84,9 @@ public virtual void WriteCurrentTransactions(StringBuilder sb)
         {
             ReadTransaction[] copy;
             lock (transactions)
-                copy = transactions.Keys.ToArray();
+            {
+                copy = transactions.ToArray();
+            }
 
             foreach (var trn in copy.OrderBy(t => t.CreatedTime))
             {