Reduce internal hot path allocations

Avoid single-item buffer arrays, skip unnecessary multi-bulk level collections, use cheaper pair normalization for ASCII symbols, cache observable stream wrappers, and refresh benchmark results.

Author: Marfusios

README.md

@@ -31,7 +31,7 @@ It helps to unify data models and usage of more clients together.
 
 The order book implementation is tuned for allocation-sensitive websocket streams. Common L2 diff processing avoids temporary notification objects when nobody is subscribed, keeps internal source-to-orderbook handoff on the single-update path, and uses list-based dispatch for bulk level updates to avoid interface enumerator allocations.
 
-The current benchmark suite focuses on `CryptoOrderBook`, `CryptoOrderBookL2`, and related source adapters. In the latest pass, representative BenchmarkDotNet runs showed `CryptoOrderBook.BidLevels` improving from 17,822 ns / 77 KB to 5,409 ns / 4.8 KB, and `CryptoOrderBookL2` diff processing improving from 935 ns / 545 B to 665 ns / 160 B. See the [benchmarks README](benchmarks/README.md) for commands and detailed results.
+The current benchmark suite focuses on `CryptoOrderBook`, `CryptoOrderBookL2`, and related source adapters. In the latest pass, representative BenchmarkDotNet runs showed `CryptoOrderBook.BidLevels` improving from 17,822 ns / 77 KB to 5,409 ns / 4.8 KB, and `CryptoOrderBookL2` diff processing improving from 935 ns / 545 B to 618 ns / 161 B. See the [benchmarks README](benchmarks/README.md) for commands and detailed results.
 
 ### Supported exchanges
 

benchmarks/README.md

@@ -37,12 +37,12 @@ Representative results from BenchmarkDotNet ShortRun on Windows, .NET 10.0.5, AM
 
 | Benchmark | Before | After | Improvement |
 | --- | ---: | ---: | ---: |
-| `CryptoOrderBookL2`, no observers | 935.4 ns, 545 B | 664.5 ns, 160 B | 29% faster, 71% less allocation |
-| `CryptoOrderBookL2`, `OrderBookUpdatedStream` observer | 933.6 ns, 545 B | 770.2 ns, 337 B | 18% faster, 38% less allocation |
-| `CryptoOrderBook`, no observers | 1,781.2 ns, 1,154 B | 1,290.2 ns, 770 B | 28% faster, 33% less allocation |
-| `CryptoOrderBook`, `OrderBookUpdatedStream` observer | 1,629.1 ns, 1,155 B | 1,308.6 ns, 947 B | 20% faster, 18% less allocation |
+| `CryptoOrderBookL2`, no observers | 935.4 ns, 545 B | 618.4 ns, 161 B | 34% faster, 70% less allocation |
+| `CryptoOrderBookL2`, `OrderBookUpdatedStream` observer | 933.6 ns, 545 B | 683.9 ns, 337 B | 27% faster, 38% less allocation |
+| `CryptoOrderBook`, no observers | 1,781.2 ns, 1,154 B | 1,140.0 ns, 770 B | 36% faster, 33% less allocation |
+| `CryptoOrderBook`, `OrderBookUpdatedStream` observer | 1,629.1 ns, 1,155 B | 1,238.4 ns, 947 B | 24% faster, 18% less allocation |
 
-The processing improvements mainly come from avoiding notification allocation when no stream has subscribers, handling the common single-diff path directly, using an internal single-bulk handoff from `OrderBookSourceBase` to order books while preserving the public `OrderBookStream` API, lazily materializing single-source notification metadata only when subscribers read `Sources`, dispatching built-in bulk updates through indexed `IReadOnlyList<T>` loops instead of interface enumerators, and avoiding repeated dictionary lookups in per-level update/delete paths.
+The processing improvements mainly come from avoiding notification allocation when no stream has subscribers, handling the common single-diff path directly, using an internal single-bulk handoff from `OrderBookSourceBase` to order books while preserving the public `OrderBookStream` API, lazily materializing single-source notification metadata only when subscribers read `Sources`, dispatching built-in bulk updates through indexed `IReadOnlyList<T>` loops instead of interface enumerators, avoiding repeated dictionary lookups in per-level update/delete paths, skipping temporary collections in buffered/small-batch paths, and caching observable stream wrappers.
 
 ### Order Book Reads
 

src/Crypto.Websocket.Extensions.Core/OrderBooks/CryptoOrderBookBase.cs

@@ -64,6 +64,11 @@ public abstract class CryptoOrderBookBase<T> : ICryptoOrderBook
         /// </summary>
         protected readonly Subject<TopNLevelsChangeInfo> TopNLevelsUpdated = new();
 
+        private readonly IObservable<IOrderBookChangeInfo> _bidAskUpdatedStream;
+        private readonly IObservable<IOrderBookChangeInfo> _topLevelUpdatedStream;
+        private readonly IObservable<IOrderBookChangeInfo> _orderBookUpdatedStream;
+        private readonly IObservable<ITopNLevelsChangeInfo> _topNLevelsUpdatedStream;
+
         /// <summary>
         /// All the bid levels (not grouped by price).
         /// </summary>
@@ -105,6 +110,11 @@ protected CryptoOrderBookBase(string targetPair, IOrderBookSource source)
             _previous = new L2Snapshot(this, Array.Empty<CryptoQuote>(), Array.Empty<CryptoQuote>());
             _current = new L2Snapshot(this, Array.Empty<CryptoQuote>(), Array.Empty<CryptoQuote>());
 
+            _bidAskUpdatedStream = BidAskUpdated.AsObservable();
+            _topLevelUpdatedStream = TopLevelUpdated.AsObservable();
+            _orderBookUpdatedStream = OrderBookUpdated.AsObservable();
+            _topNLevelsUpdatedStream = TopNLevelsUpdated.AsObservable();
+
             TargetPairOriginal = targetPair;
             TargetPair = CryptoPairsHelper.Clean(targetPair);
             Source = source;
@@ -217,16 +227,16 @@ public bool ValidityCheckEnabled
         public bool CalculateMetricsFromSnapshots { get; set; }
 
         /// <inheritdoc />
-        public IObservable<IOrderBookChangeInfo> BidAskUpdatedStream => BidAskUpdated.AsObservable();
+        public IObservable<IOrderBookChangeInfo> BidAskUpdatedStream => _bidAskUpdatedStream;
 
         /// <inheritdoc />
-        public IObservable<IOrderBookChangeInfo> TopLevelUpdatedStream => TopLevelUpdated.AsObservable();
+        public IObservable<IOrderBookChangeInfo> TopLevelUpdatedStream => _topLevelUpdatedStream;
 
         /// <inheritdoc />
-        public IObservable<IOrderBookChangeInfo> OrderBookUpdatedStream => OrderBookUpdated.AsObservable();
+        public IObservable<IOrderBookChangeInfo> OrderBookUpdatedStream => _orderBookUpdatedStream;
 
         /// <inheritdoc />
-        public IObservable<ITopNLevelsChangeInfo> TopNLevelsUpdatedStream => TopNLevelsUpdated.AsObservable();
+        public IObservable<ITopNLevelsChangeInfo> TopNLevelsUpdatedStream => _topNLevelsUpdatedStream;
 
         /// <inheritdoc />
         public int NotifyForLevelAndAbove
@@ -241,11 +251,14 @@ public int NotifyForLevelAndAbove
                     _current = new L2Snapshot(this, BlankQuotes(), BlankQuotes());
                 }
 
-                IReadOnlyList<CryptoQuote> BlankQuotes()
+                CryptoQuote[] BlankQuotes()
                 {
-                    var result = new List<CryptoQuote>(_notifyForLevelAndAbove);
+                    if (_notifyForLevelAndAbove <= 0)
+                        return Array.Empty<CryptoQuote>();
+
+                    var result = new CryptoQuote[_notifyForLevelAndAbove];
                     for (var index = 0; index < _notifyForLevelAndAbove; index++)
-                        result.Add(new CryptoQuote(0, 0));
+                        result[index] = new CryptoQuote(0, 0);
 
                     return result;
                 }
@@ -356,8 +369,9 @@ private OrderBookLevel[] FilterLevelsForTargetPair(OrderBookLevel[] levels)
                 return Array.Empty<OrderBookLevel>();
 
             var count = 0;
-            foreach (var level in levels)
+            for (var levelIndex = 0; levelIndex < levels.Length; levelIndex++)
             {
+                var level = levels[levelIndex];
                 if (TargetPair.Equals(level.Pair, StringComparison.Ordinal))
                     count++;
             }
@@ -370,8 +384,9 @@ private OrderBookLevel[] FilterLevelsForTargetPair(OrderBookLevel[] levels)
 
             var result = new OrderBookLevel[count];
             var index = 0;
-            foreach (var level in levels)
+            for (var levelIndex = 0; levelIndex < levels.Length; levelIndex++)
             {
+                var level = levels[levelIndex];
                 if (TargetPair.Equals(level.Pair, StringComparison.Ordinal))
                     result[index++] = level;
             }
@@ -382,21 +397,26 @@ private OrderBookLevel[] FilterLevelsForTargetPair(OrderBookLevel[] levels)
         private OrderBookLevelBulk[] FilterBulksForThis(OrderBookLevelBulk[] bulks)
         {
             var count = 0;
-            foreach (var bulk in bulks)
+            for (var index = 0; index < bulks.Length; index++)
             {
+                var bulk = bulks[index];
                 if (bulk != null && IsForThis(bulk))
                     count++;
             }
 
             if (count == 0)
                 return Array.Empty<OrderBookLevelBulk>();
 
+            if (count == bulks.Length)
+                return bulks;
+
             var result = new OrderBookLevelBulk[count];
-            var index = 0;
-            foreach (var bulk in bulks)
+            var resultIndex = 0;
+            for (var index = 0; index < bulks.Length; index++)
             {
+                var bulk = bulks[index];
                 if (bulk != null && IsForThis(bulk))
-                    result[index++] = bulk;
+                    result[resultIndex++] = bulk;
             }
 
             return result;
@@ -425,24 +445,36 @@ private void HandleDiffsSynchronized(OrderBookLevelBulk[] bulks)
                 return;
             }
 
-            var allLevels = new List<OrderBookLevel>();
+            var collectLevels = IsIndexComputationEnabled || DebugEnabled;
+            List<OrderBookLevel>? allLevels = collectLevels ? new List<OrderBookLevel>() : null;
+            var hasLevels = false;
 
             lock (Locker)
             {
                 foreach (var bulk in forThis)
                 {
                     var levelsForThis = FilterLevelsForTargetPair(bulk.Levels);
-                    allLevels.AddRange(levelsForThis);
+                    if (levelsForThis.Length <= 0)
+                        continue;
+
+                    hasLevels = true;
+                    allLevels?.AddRange(levelsForThis);
                     HandleDiff(bulk, levelsForThis);
                 }
 
-                if (allLevels.Count > 0)
+                if (hasLevels)
                 {
-                    RecomputeAfterChangeAndSetIndexes(allLevels);
+                    if (allLevels != null)
+                        RecomputeAfterChangeAndSetIndexes(allLevels);
+                    else
+                        RecomputeAfterChange();
 
                     if (HasNotificationObservers)
                     {
-                        var change = CreateBookChangeNotification(allLevels, forThis, false);
+                        var changedLevels = allLevels != null
+                            ? (IEnumerable<OrderBookLevel>)allLevels
+                            : Array.Empty<OrderBookLevel>();
+                        var change = CreateBookChangeNotification(changedLevels, forThis, false);
                         NotifyOrderBookChanges(change);
                     }
                 }
@@ -994,11 +1026,23 @@ private static OrderBookLevel[] CloneLevels(IEnumerable<OrderBookLevel> levels)
 
         private static IReadOnlyList<CryptoQuote> CopyValidQuotes(IReadOnlyList<CryptoQuote> quotes)
         {
-            var result = new List<CryptoQuote>(quotes.Count);
-            foreach (var quote in quotes)
+            var count = 0;
+            for (var index = 0; index < quotes.Count; index++)
+            {
+                if (quotes[index].IsValid)
+                    count++;
+            }
+
+            if (count == 0)
+                return Array.Empty<CryptoQuote>();
+
+            var result = new CryptoQuote[count];
+            var resultIndex = 0;
+            for (var index = 0; index < quotes.Count; index++)
             {
+                var quote = quotes[index];
                 if (quote.IsValid)
-                    result.Add(quote);
+                    result[resultIndex++] = quote;
             }
 
             return result;

src/Crypto.Websocket.Extensions.Core/OrderBooks/Models/OrderBookLevelBulk.cs

@@ -14,7 +14,7 @@ public OrderBookLevelBulk(OrderBookAction action, OrderBookLevel[] levels, Crypt
         {
             Action = action;
             OrderBookType = orderBookType;
-            Levels = levels ?? new OrderBookLevel[0];
+            Levels = levels ?? System.Array.Empty<OrderBookLevel>();
         }
 
         /// <summary>

src/Crypto.Websocket.Extensions.Core/OrderBooks/Sources/OrderBookSourceBase.cs

@@ -36,6 +36,9 @@ public abstract class OrderBookSourceBase : IOrderBookSource
         /// </summary>
         private readonly Subject<OrderBookLevelBulk[]> _orderBookSubject = new Subject<OrderBookLevelBulk[]>();
 
+        private readonly IObservable<OrderBookLevelBulk> _orderBookSnapshotStream;
+        private readonly IObservable<OrderBookLevelBulk[]> _orderBookStream;
+
         private Action<OrderBookLevelBulk>? _orderBookSingleHandlers;
         private Action<OrderBookLevelBulk[]>? _orderBookBatchHandlers;
 
@@ -45,6 +48,8 @@ public abstract class OrderBookSourceBase : IOrderBookSource
         protected OrderBookSourceBase(ILogger logger)
         {
             _logger = logger;
+            _orderBookSnapshotStream = _orderBookSnapshotSubject.AsObservable();
+            _orderBookStream = _orderBookSubject.AsObservable();
             StartProcessingFromBufferThread();
         }
 
@@ -93,10 +98,10 @@ public bool BufferEnabled
         public TimeSpan BufferInterval { get; set; } = TimeSpan.FromMilliseconds(10);
 
         /// <inheritdoc />
-        public IObservable<OrderBookLevelBulk> OrderBookSnapshotStream => _orderBookSnapshotSubject.AsObservable();
+        public IObservable<OrderBookLevelBulk> OrderBookSnapshotStream => _orderBookSnapshotStream;
 
         /// <inheritdoc />
-        public IObservable<OrderBookLevelBulk[]> OrderBookStream => _orderBookSubject.AsObservable();
+        public IObservable<OrderBookLevelBulk[]> OrderBookStream => _orderBookStream;
 
         /// <summary>
         /// Subscribes an order book to the internal allocation-aware stream.
@@ -254,21 +259,33 @@ private void StreamDataSynchronized()
 
         private void StreamData()
         {
-            object[] data;
+            object? singleData = null;
+            object[]? data = null;
+
             lock (_bufferLocker)
             {
-                data = _dataBuffer.ToArray();
-                _dataBuffer.Clear();
-
-                if (data.Length <= 0)
+                if (_dataBuffer.Count <= 0)
                 {
                     // no message in buffer, enable waiting
                     _bufferPauseEvent.Reset();
                     return;
                 }
+
+                if (_dataBuffer.Count == 1)
+                {
+                    singleData = _dataBuffer.Dequeue();
+                }
+                else
+                {
+                    data = _dataBuffer.ToArray();
+                    _dataBuffer.Clear();
+                }
             }
 
-            ConvertAndStream(data);
+            if (data != null)
+                ConvertAndStream(data);
+            else
+                ConvertAndStream(singleData!);
         }
 
         private void ConvertAndStream(object[] dataArr)

src/Crypto.Websocket.Extensions.Core/Orders/CryptoOrders.cs

@@ -21,6 +21,8 @@ public class CryptoOrders : ICryptoOrders
         private readonly long? _orderPrefix;
         private readonly Subject<CryptoOrder> _orderChanged = new Subject<CryptoOrder>();
         private readonly Subject<CryptoOrder> _ourOrderChanged = new Subject<CryptoOrder>();
+        private readonly IObservable<CryptoOrder> _orderChangedStream;
+        private readonly IObservable<CryptoOrder> _ourOrderChangedStream;
         private readonly CryptoOrderCollection _idToOrder = new CryptoOrderCollection();
 
         private long _cidCounter;
@@ -40,19 +42,21 @@ public CryptoOrders(IOrderSource source, long? orderPrefix = null, string? targe
             TargetPairOriginal = targetPair;
             _source.SetExistingOrders(_idToOrder);
             _orderPrefix = orderPrefix;
+            _orderChangedStream = _orderChanged.AsObservable();
+            _ourOrderChangedStream = _ourOrderChanged.AsObservable();
 
             Subscribe();
         }
 
         /// <summary>
         /// Order was changed stream
         /// </summary>
-        public IObservable<CryptoOrder> OrderChangedStream => _orderChanged.AsObservable();
+        public IObservable<CryptoOrder> OrderChangedStream => _orderChangedStream;
 
         /// <summary>
         /// Order was changed stream (only ours, based on client id prefix)
         /// </summary>
-        public IObservable<CryptoOrder> OurOrderChangedStream => _ourOrderChanged.AsObservable();
+        public IObservable<CryptoOrder> OurOrderChangedStream => _ourOrderChangedStream;
 
         /// <summary>
         /// Selected client id prefix

src/Crypto.Websocket.Extensions.Core/Orders/Sources/OrderSourceBase.cs

@@ -15,11 +15,18 @@ public abstract class OrderSourceBase : IOrderSource
         protected readonly Subject<CryptoOrder> OrderCreatedSubject = new Subject<CryptoOrder>();
         protected readonly Subject<CryptoOrder> OrderUpdatedSubject = new Subject<CryptoOrder>();
 
+        private readonly IObservable<CryptoOrder[]> _ordersInitialStream;
+        private readonly IObservable<CryptoOrder> _orderCreatedStream;
+        private readonly IObservable<CryptoOrder> _orderUpdatedStream;
+
         protected CryptoOrderCollection ExistingOrders = new CryptoOrderCollection();
 
         protected OrderSourceBase(ILogger logger)
         {
             Logger = logger;
+            _ordersInitialStream = OrderSnapshotSubject.AsObservable();
+            _orderCreatedStream = OrderCreatedSubject.AsObservable();
+            _orderUpdatedStream = OrderUpdatedSubject.AsObservable();
         }
 
         /// <summary>
@@ -35,17 +42,17 @@ protected OrderSourceBase(ILogger logger)
         /// <summary>
         /// Stream snapshot of currently active orders
         /// </summary>
-        public virtual IObservable<CryptoOrder[]> OrdersInitialStream => OrderSnapshotSubject.AsObservable();
+        public virtual IObservable<CryptoOrder[]> OrdersInitialStream => _ordersInitialStream;
 
         /// <summary>
         /// Stream info about new active order
         /// </summary>
-        public virtual IObservable<CryptoOrder> OrderCreatedStream => OrderCreatedSubject.AsObservable();
+        public virtual IObservable<CryptoOrder> OrderCreatedStream => _orderCreatedStream;
 
         /// <summary>
         /// Stream on every status change of the order
         /// </summary>
-        public virtual IObservable<CryptoOrder> OrderUpdatedStream => OrderUpdatedSubject.AsObservable();
+        public virtual IObservable<CryptoOrder> OrderUpdatedStream => _orderUpdatedStream;
 
         /// <summary>
         /// Set collection of existing orders (to correctly handle orders state)

src/Crypto.Websocket.Extensions.Core/Utils/CryptoPairsHelper.cs

@@ -37,7 +37,7 @@ public static string Clean(string? pair)
                 }
 
                 outputLength++;
-                needsCopy |= char.ToLowerInvariant(c) != c;
+                needsCopy |= ToLowerInvariant(c) != c;
             }
 
             if (outputLength == 0)
@@ -53,7 +53,7 @@ public static string Clean(string? pair)
                 {
                     var c = source.Pair[sourceIndex];
                     if (!IsSeparator(c))
-                        destination[index++] = char.ToLowerInvariant(c);
+                        destination[index++] = ToLowerInvariant(c);
                 }
             });
         }
@@ -69,5 +69,15 @@ public static bool AreSame(string? firstPair, string? secondPair)
         }
 
         private static bool IsSeparator(char c) => c is '/' or '-' or '\\';
+
+        private static char ToLowerInvariant(char c)
+        {
+            if (c is >= 'A' and <= 'Z')
+                return (char)(c + ('a' - 'A'));
+
+            return c <= 127
+                ? c
+                : char.ToLowerInvariant(c);
+        }
     }
 }