Avoid tempKv-driven scan iteration in Garnet callers (#1797)

badrishc · Copilot · web-flow · commit a9aa8b72a015 · 2026-05-13T11:03:49.000-07:00
* Avoid tempKv-driven scan iteration in Garnet callers Replace the four Garnet/Cluster callsites of `Session.Iterate(...)` (which allocates a parallel `tempKv` proportional to the keyspace and copies every in-range record into it) with the lookup-based `Session.IterateLookupSnapshot`, a new Tsavorite ClientSession method that captures `Log.TailAddress` once and pins both `untilAddress` and `maxAddress` to it. This preserves the prior snapshot semantics (each unique live key emitted exactly once based on its latest in-range version, with the in-flight RCU race window correctly handled) without the O(N) `tempKv` memory cost. Converted callsites: - `StoreWrapper.HasKeysInSlots`: collapses two pull-iterations (string + object) into a single push scan over the unified context with a cached early-exit callback (`hasKeysInSlotsFuncs` field on StoreWrapper). - `StorageSession.DBKeys` (KEYS command): switched the existing cached `unifiedStoreDbKeysFuncs` callback from `Session.Iterate(...)` to `IterateLookupSnapshot`. - `ClusterManagerSlotState.DeleteKeysInSlots`: refactored into a new `StorageSession.DeleteSlotKeys(slots)` method on the unified context with a cached `deleteSlotKeysFuncs` callback. Cluster static helper now one-line delegate. Preserves prior behavior — deletes every matched live key including expired-but-not-yet-tombstoned ones (no expiry filter). - `VectorManager.Cleanup`: switched from push `Session.Iterate(ref callbacks)` to `IterateLookupSnapshot`. API changes: - New `ClientSession.IterateLookupSnapshot<TScanFunctions>(ref scanFns, bool includeTombstones = false)` on Tsavorite. Wraps `ScanCursor` with the snapshot pattern `untilAddress = maxAddress = capturedTail`. - Removed parameterless pull `IGarnetApi.IterateStore()` overload (the only Garnet API method that exposed the tempKv pull iterator). The push overload `IterateStore<TScanFunctions>(...)` is unchanged. **Breaking change** for out-of-tree extensions that bind to `IGarnetApi`. - Removed deprecated `LogCompactionType.ShiftForced` enum value plus its back-compat shim. `ShiftForced` was deprecated in PR #482 (June 2024, almost two years ago); long-deprecated values are removed in v2. Migration: `--compaction-type Shift --compaction-force-delete true`. **Breaking change** in config surface — `CommandLineParser` produces a clear startup error listing the now-valid values `None | Shift | Lookup | Scan`. - Reordered `LogCompactionType` enum members + help-text to `None | Shift | Lookup | Scan` so users see the recommended `Lookup` before the not-recommended `Scan`. Added a startup `LogWarning` when `CompactionType = Scan` is selected to flag the temporary-memory-spike cost. `Scan` itself still works as before — no behavior change. All callbacks follow the existing cached-field pattern (`xxxFuncs ??= new(); xxxFuncs.Initialize(...)`) used by `unifiedStoreDbKeysFuncs`, `unifiedStoreDbScanFuncs`, `unifiedStoreDbSizeFuncs`, `expiredKeyDeletionScanFuncs` — steady-state per-call callback allocations are zero. Net per-call cost on the four hot paths drops from `{1-2 sessions + 1-2 TsavoriteKV instances + 2 iterators + O(N) record copies}` to `{1 session, 0 callback alloc}`. Tests added: - `SpanByteIterateLookupSnapshotBasicCorrectness` (libs/storage/Tsavorite/cs/test/SpanByteIterationTests.cs): inserts 200 keys, RCUs all of them, asserts `IterateLookupSnapshot` emits each unique live key exactly once with the post-RCU value; asserts the snapshot is stable across calls. - `ClusterDelKeysInSlotRemovesStringAndObjectKeys` (test/Garnet.test.cluster/ClusterMigrateTests.cs): exercises `CLUSTER DELKEYSINSLOT` over both raw-string and collection-object keys via the unified scan; asserts both are deleted. - `SeKeysNoDuplicatesUnderRcu` (test/Garnet.test/RespScanCommandsTests.cs): runs concurrent SET RCUs while issuing KEYS in a loop, asserts each key is returned exactly once across multiple rounds. Documentation: - `libs/host/defaults.conf` and `website/docs/getting-started/configuration.md` updated to use the new compaction-type ordering and call out `Scan` as NOT RECOMMENDED. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> * Address PR review feedback - ClusterDelKeysInSlotRemovesStringAndObjectKeys: change [Order(22)] to [Order(28)] to avoid collision with the existing #if DEBUG-gated Order(22) test in the same fixture (ordered, non-parallelizable execution would otherwise be ambiguous). - SeKeysNoDuplicatesUnderRcu: assert that the background writer actually stops within the wait window (raised from 5s to 30s) and surface any exception the writer threw, so a hung/faulted writer can't leak a connection or silently mask test failures. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> * Strengthen ClusterDelKeysInSlotRemovesStringAndObjectKeys: add control slot The previous version of the test only verified that DELKEYSINSLOT removed the targeted keys; it did not verify that keys in OTHER slots are preserved. A bug in the slot-set filter inside DeleteSlotKeysScan.Reader (e.g., a wrong `slots.Contains(...)` check or a hash-slot computation regression) would have collateral-deleted unrelated keys without this test catching it. Now the test: - Picks two distinct slots owned by node 0 (delSlot, keepSlot). - Inserts one string key + one object key in EACH slot (4 keys total). - Runs CLUSTER DELKEYSINSLOT on delSlot only. - Asserts delSlot is empty and both delSlot keys are gone via GET/EXISTS. - Asserts keepSlot still has both keys with original values (string GET returns 'raw-keep'; SCARD on the object key returns 3). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
diff --git a/libs/cluster/Server/ClusterManagerSlotState.cs b/libs/cluster/Server/ClusterManagerSlotState.cs
@@ -5,9 +5,7 @@
 using System.Collections.Generic;
 using System.Text;
 using System.Threading;
-using Garnet.common;
 using Microsoft.Extensions.Logging;
-using Tsavorite.core;
 
 namespace Garnet.cluster
 {
@@ -467,15 +465,6 @@ public void TryResetSlotState(HashSet<int> slots)
         /// <param name="basicGarnetApi"></param>
         /// <param name="slots">Slot list</param>
         public static void DeleteKeysInSlots(BasicGarnetApi basicGarnetApi, HashSet<int> slots)
-        {
-            using var iter = basicGarnetApi.IterateStore();
-            while (iter.GetNext())
-            {
-                var key = iter.Key;
-                var s = HashSlotUtils.HashSlot(key);
-                if (slots.Contains(s))
-                    _ = basicGarnetApi.DELETE(PinnedSpanByte.FromPinnedSpan(key));
-            }
-        }
+            => basicGarnetApi.DeleteSlotKeys(slots);
     }
 }
diff --git a/libs/host/Configuration/Options.cs b/libs/host/Configuration/Options.cs
@@ -236,7 +236,7 @@ internal sealed class Options : ICloneable
         [Option("expired-object-collection-freq", Required = false, HelpText = "Frequency in seconds for the background task to perform object collection which removes expired members within object from memory. 0 = disabled. Use the HCOLLECT and ZCOLLECT API to collect on-demand.")]
         public int ExpiredObjectCollectionFrequencySecs { get; set; }
 
-        [Option("compaction-type", Required = false, HelpText = "Hybrid log compaction type. Value options: None - no compaction, Shift - shift begin address without compaction (data loss), Scan - scan old pages and move live records to tail (no data loss), Lookup - lookup each record in compaction range, for record liveness checking using hash chain (no data loss)")]
+        [Option("compaction-type", Required = false, HelpText = "Hybrid log compaction type. Value options: None - no compaction, Shift - shift begin address without compaction (data loss), Lookup - lookup each record in compaction range, for record liveness checking using hash chain (no data loss; recommended for production use), Scan - scan old pages and move live records to tail (no data loss; NOT RECOMMENDED - builds a temporary parallel KV index proportional to the keyspace, causing significant transient memory use; prefer Lookup)")]
         public LogCompactionType CompactionType { get; set; }
 
         [OptionValidation]
@@ -773,12 +773,11 @@ endpoint is IPEndPoint listenEp && clusterAnnounceEndpoint[0] is IPEndPoint anno
                     throw new Exception("Revivification cannot specify RevivifiableFraction without specifying bins.");
             }
 
-            // For backwards compatibility
-            if (CompactionType == LogCompactionType.ShiftForced)
+            // Warn users who explicitly opt into Scan compaction about the memory-spike cost.
+            // Scan builds a temporary parallel KV index proportional to the keyspace; Lookup is the recommended alternative.
+            if (CompactionType == LogCompactionType.Scan)
             {
-                logger?.LogWarning("Compaction type ShiftForced is deprecated. Use Shift instead along with CompactionForceDelete.");
-                CompactionType = LogCompactionType.Shift;
-                CompactionForceDelete = true;
+                logger?.LogWarning("Compaction type Scan builds a temporary parallel KV index proportional to the keyspace, causing significant transient memory use. Use Lookup instead unless you have a specific reason for Scan.");
             }
 
             if (SlowLogThreshold > 0)
diff --git a/libs/host/defaults.conf b/libs/host/defaults.conf
@@ -162,8 +162,8 @@
 	/* Hybrid log compaction type. Value options: */ 
 	/*  None - no compaction */
 	/*  Shift - shift begin address without compaction (data loss) */ 
-	/*  Scan - scan old pages and move live records to tail (no data loss) */
-	/*  Lookup - lookup each record in compaction range, for record liveness checking using hash chain (no data loss) */
+	/*  Lookup - lookup each record in compaction range, for record liveness checking using hash chain (no data loss). Recommended for production use. */
+	/*  Scan - scan old pages and move live records to tail (no data loss). NOT RECOMMENDED: this strategy builds a temporary parallel KV index proportional to the keyspace, causing significant transient memory use. Prefer Lookup. */
 	"CompactionType" : "None",
 
 	/* Forcefully delete the inactive segments immediately after the compaction strategy (type) is applied. */
diff --git a/libs/server/API/GarnetApi.cs b/libs/server/API/GarnetApi.cs
@@ -354,8 +354,8 @@ public readonly bool IterateStore<TScanFunctions>(ref TScanFunctions scanFunctio
             => storageSession.IterateStore(ref scanFunctions, ref cursor, untilAddress, maxAddress: maxAddress, includeTombstones: includeTombstones);
 
         /// <inheritdoc />
-        public readonly ITsavoriteScanIterator IterateStore()
-            => storageSession.IterateStore();
+        public readonly void DeleteSlotKeys(HashSet<int> slots)
+            => storageSession.DeleteSlotKeys(slots);
 
         #endregion
 
diff --git a/libs/server/API/GarnetWatchApi.cs b/libs/server/API/GarnetWatchApi.cs
@@ -602,8 +602,8 @@ public bool IterateStore<TScanFunctions>(ref TScanFunctions scanFunctions, ref l
             => garnetApi.IterateStore(ref scanFunctions, ref cursor, untilAddress, maxAddress: maxAddress, includeTombstones: includeTombstones);
 
         /// <inheritdoc />
-        public ITsavoriteScanIterator IterateStore()
-            => garnetApi.IterateStore();
+        public void DeleteSlotKeys(HashSet<int> slots)
+            => garnetApi.DeleteSlotKeys(slots);
 
         #endregion
 
diff --git a/libs/server/API/IGarnetApi.cs b/libs/server/API/IGarnetApi.cs
@@ -2077,10 +2077,12 @@ public bool IterateStore<TScanFunctions>(ref TScanFunctions scanFunctions, ref l
             where TScanFunctions : IScanIteratorFunctions;
 
         /// <summary>
-        /// Iterate the contents of the store (pull based)
+        /// Delete every live key whose hash slot is in <paramref name="slots"/>.
+        /// Uses lookup-based iteration (no <c>tempKv</c>); preserves pull-iterator semantics —
+        /// every matched live key is deleted, including expired-but-not-yet-tombstoned records.
         /// </summary>
-        /// <returns></returns>
-        public ITsavoriteScanIterator IterateStore();
+        /// <param name="slots">Hash slot set to delete.</param>
+        public void DeleteSlotKeys(HashSet<int> slots);
 
         #endregion
 
diff --git a/libs/server/LogCompactionType.cs b/libs/server/LogCompactionType.cs
@@ -20,21 +20,18 @@ public enum LogCompactionType
         Shift,
 
         /// <summary>
-        /// Shift the begin address without compacting active records (data loss)
-        /// Immediately deletes files - do not use if you plan to recover after failure.
+        /// Lookup each record in compaction range, for record liveness checking using hash chain - no data loss
+        /// (to delete actual data files from disk, take a checkpoint after compaction).
+        /// Recommended for production use.
         /// </summary>
-        ShiftForced,
+        Lookup,
 
         /// <summary>
         /// Scan from untilAddress to read-only address to check for record liveness checking - no data loss
-        /// (to delete actual data files from disk, take a checkpoint after compaction)
+        /// (to delete actual data files from disk, take a checkpoint after compaction).
+        /// NOT RECOMMENDED: this strategy builds a temporary parallel KV index proportional to the keyspace,
+        /// causing significant transient memory use. Prefer Lookup.
         /// </summary>
         Scan,
-
-        /// <summary>
-        /// Lookup each record in compaction range, for record liveness checking using hash chain - no data loss
-        /// (to delete actual data files from disk, take a checkpoint after compaction)
-        /// </summary>
-        Lookup,
     }
 }
diff --git a/libs/server/Resp/Vector/VectorManager.Cleanup.cs b/libs/server/Resp/Vector/VectorManager.Cleanup.cs
@@ -143,10 +143,12 @@ private async Task RunCleanupTaskAsync()
                     ref var scanCtx = ref cleanupSession.storageSession.stringBasicContext;
                     ref var delCtx = ref cleanupSession.storageSession.vectorBasicContext;
 
-                    // Scan whole keyspace (sigh) and remove any associated data
-                    //
-                    // We don't really have a choice here, just do it
-                    _ = scanCtx.Session.Iterate(ref callbacks);
+                    // Scan whole keyspace and remove any associated data using a snapshot
+                    // lookup-based push iterator. This avoids building a parallel tempKv (which
+                    // would cost memory proportional to the keyspace) — IterateLookupSnapshot
+                    // walks the log and uses hash-chain liveness checks bounded to the snapshot's
+                    // TailAddress, so concurrent RCUs don't drop records.
+                    _ = scanCtx.Session.IterateLookupSnapshot(ref callbacks);
 
                     // Key is mostly ignored when deleting from InProgressDeletes
                     // So we just need a non-empty one to use with the context
diff --git a/libs/server/Storage/Session/Common/ArrayKeyIterationFunctions.cs b/libs/server/Storage/Session/Common/ArrayKeyIterationFunctions.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using Garnet.common;
 using Tsavorite.core;
 
 namespace Garnet.server
@@ -25,6 +26,9 @@ sealed partial class StorageSession : IDisposable
         // Iterator for KEYS command
         private ArrayKeyIterationFunctions.UnifiedStoreGetDBKeys unifiedStoreDbKeysFuncs;
 
+        // Iterator for cluster slot deletion (DeleteSlotKeys)
+        private ArrayKeyIterationFunctions.DeleteSlotKeysScan deleteSlotKeysFuncs;
+
         long lastScanCursor;
         List<byte[]> Keys;
 
@@ -119,10 +123,22 @@ internal bool IterateStore<TScanFunctions>(ref TScanFunctions scanFunctions, ref
             => stringBasicContext.Session.IterateLookup(ref scanFunctions, ref cursor, untilAddress, validateCursor: validateCursor, maxAddress: maxAddress, resetCursor: false, includeTombstones: includeTombstones);
 
         /// <summary>
-        /// Iterate the contents of the store (pull based)
+        /// Delete every live key whose hash slot is in <paramref name="slots"/>.
+        /// Uses lookup-based push iteration over the unified context (no <c>tempKv</c>) with
+        /// snapshot semantics: every key live at scan-start whose slot matches is deleted.
+        /// Preserves the previous pull-iterator semantics — every matched live key is deleted,
+        /// including expired-but-not-yet-tombstoned records (no expiry filter).
         /// </summary>
-        internal ITsavoriteScanIterator IterateStore()
-            => stringBasicContext.Session.Iterate();
+        /// <param name="slots">Hash slot set to delete.</param>
+        internal void DeleteSlotKeys(HashSet<int> slots)
+        {
+            deleteSlotKeysFuncs ??= new();
+            deleteSlotKeysFuncs.Initialize(this, slots);
+
+            // Snapshot semantics: ensures records RCU'd above TailAddress during the scan are
+            // not silently suppressed (which would leave keys behind).
+            _ = unifiedBasicContext.Session.IterateLookupSnapshot(ref deleteSlotKeysFuncs);
+        }
 
         /// <summary>
         ///  Get a list of the keys in the store and object store when using pattern
@@ -137,7 +153,11 @@ internal unsafe List<byte[]> DBKeys(PinnedSpanByte pattern)
 
             unifiedStoreDbKeysFuncs ??= IsConsistentReadSession ? new ConsistentUnifiedStoreGetDBKeys(readSessionState) : new UnifiedStoreGetDBKeys();
             unifiedStoreDbKeysFuncs.Initialize(Keys, allKeys ? null : pattern.ToPointer(), pattern.Length);
-            unifiedBasicContext.Session.Iterate(ref unifiedStoreDbKeysFuncs);
+
+            // Snapshot semantics: emit each unique live key exactly once based on its latest in-range
+            // version at scan-start, even if a concurrent RCU moves the key's tail above the captured
+            // TailAddress during the scan. Equivalent to the legacy tempKv-backed Iterate(...).
+            _ = unifiedBasicContext.Session.IterateLookupSnapshot(ref unifiedStoreDbKeysFuncs);
 
             return Keys;
         }
@@ -321,6 +341,75 @@ public bool Reader<TSourceLogRecord>(in TSourceLogRecord logRecord, RecordMetada
                 public void OnStop(bool completed, long numberOfRecords) { }
                 public void OnException(Exception exception, long numberOfRecords) { }
             }
+
+            /// <summary>
+            /// Lookup-based push iterator callback that deletes every live key whose hash slot is
+            /// in the supplied set. Cached on <see cref="StorageSession"/> via the
+            /// <c>deleteSlotKeysFuncs</c> field; re-initialised per call.
+            /// IMPORTANT: matches the previous pull-iterator semantics — every matched live key is
+            /// deleted, including expired-but-not-yet-tombstoned records (no expiry filter).
+            /// </summary>
+            internal sealed class DeleteSlotKeysScan : IScanIteratorFunctions
+            {
+                private StorageSession storageSession;
+                private HashSet<int> slots;
+
+                internal void Initialize(StorageSession storageSession, HashSet<int> slots)
+                {
+                    this.storageSession = storageSession;
+                    this.slots = slots;
+                }
+
+                public bool Reader<TSourceLogRecord>(in TSourceLogRecord logRecord, RecordMetadata recordMetadata, long numberOfRecords, out CursorRecordResult cursorRecordResult)
+                    where TSourceLogRecord : ISourceLogRecord
+                {
+                    cursorRecordResult = CursorRecordResult.Skip;
+                    if (slots.Contains(HashSlotUtils.HashSlot(logRecord.Key)))
+                    {
+                        _ = storageSession.DELETE(PinnedSpanByte.FromPinnedSpan(logRecord.Key), ref storageSession.unifiedBasicContext);
+                        cursorRecordResult = CursorRecordResult.Accept;
+                    }
+                    return true;
+                }
+
+                public bool OnStart(long beginAddress, long endAddress) => true;
+                public void OnStop(bool completed, long numberOfRecords) { }
+                public void OnException(Exception exception, long numberOfRecords) { }
+            }
+
+            /// <summary>
+            /// Lookup-based push iterator callback that returns true from <see cref="Found"/> if
+            /// any live record's key hashes to a slot in the supplied set. Stops scanning on the
+            /// first match by returning <c>false</c> from <see cref="Reader"/>. Cached on
+            /// <see cref="StoreWrapper"/> via the <c>hasKeysInSlotsFuncs</c> field; re-initialised per call.
+            /// </summary>
+            internal sealed class HasKeysInSlotsScan : IScanIteratorFunctions
+            {
+                private List<int> slots;
+                internal bool Found;
+
+                internal void Initialize(List<int> slots)
+                {
+                    this.slots = slots;
+                    Found = false;
+                }
+
+                public bool Reader<TSourceLogRecord>(in TSourceLogRecord logRecord, RecordMetadata recordMetadata, long numberOfRecords, out CursorRecordResult cursorRecordResult)
+                    where TSourceLogRecord : ISourceLogRecord
+                {
+                    cursorRecordResult = CursorRecordResult.Skip;
+                    if (slots.Contains(HashSlotUtils.HashSlot(logRecord.Key)))
+                    {
+                        Found = true;
+                        return false; // early exit
+                    }
+                    return true;
+                }
+
+                public bool OnStart(long beginAddress, long endAddress) => true;
+                public void OnStop(bool completed, long numberOfRecords) { }
+                public void OnException(Exception exception, long numberOfRecords) { }
+            }
         }
     }
 }
diff --git a/libs/server/StoreWrapper.cs b/libs/server/StoreWrapper.cs
@@ -805,40 +805,30 @@ internal void Start()
 
         private void StartSizeTrackers() => databaseManager.StartSizeTrackers(ctsCommit.Token);
 
+        /// <summary>
+        /// Cached callback for <see cref="HasKeysInSlots"/>. Allocated once per StoreWrapper, reused
+        /// across calls (cluster control-plane operations are serialised by the cluster manager).
+        /// </summary>
+        private StorageSession.ArrayKeyIterationFunctions.HasKeysInSlotsScan hasKeysInSlotsFuncs;
+
         public bool HasKeysInSlots(List<int> slots)
         {
-            if (slots.Count > 0)
-            {
-                bool hasKeyInSlots = false;
-                {
-                    using var iter = store.Iterate<IGarnetObject, IGarnetObject, Empty, SimpleGarnetObjectSessionFunctions>(new SimpleGarnetObjectSessionFunctions());  // TODO replace with Push iterator
-                    while (!hasKeyInSlots && iter.GetNext())
-                    {
-                        var key = iter.Key;
-                        ushort hashSlotForKey = HashSlotUtils.HashSlot(key);
-                        if (slots.Contains(hashSlotForKey))
-                            hasKeyInSlots = true;
-                    }
-                }
+            if (slots.Count == 0) return false;
 
-                if (!hasKeyInSlots && !serverOptions.DisableObjects)
-                {
-                    var functionsState = databaseManager.CreateFunctionsState();
-                    var objStoreFunctions = new ObjectSessionFunctions(functionsState);
-                    using var objectStoreSession = store?.NewSession<FixedSpanByteKey, ObjectInput, ObjectOutput, long, ObjectSessionFunctions>(objStoreFunctions);
-                    using var iter = objectStoreSession.Iterate();
-                    while (!hasKeyInSlots && iter.GetNext())
-                    {
-                        ushort hashSlotForKey = HashSlotUtils.HashSlot(iter.Key);
-                        if (slots.Contains(hashSlotForKey))
-                            hasKeyInSlots = true;
-                    }
-                }
+            // Single lookup-based push scan over the unified context. Since the migration to a
+            // single store, the unified context surfaces every record (string + object) so one
+            // scan suffices. No tempKv is allocated. IterateLookupSnapshot pins both untilAddress
+            // and maxAddress to a single captured TailAddress so the scan is a consistent
+            // point-in-time view (records RCU'd above the snapshot don't suppress in-range ones).
+            var functionsState = databaseManager.CreateFunctionsState();
+            var unifiedFunctions = new UnifiedSessionFunctions(functionsState);
+            using var unifiedSession = store.NewSession<FixedSpanByteKey, UnifiedInput, UnifiedOutput, long, UnifiedSessionFunctions>(unifiedFunctions);
 
-                return hasKeyInSlots;
-            }
+            hasKeysInSlotsFuncs ??= new StorageSession.ArrayKeyIterationFunctions.HasKeysInSlotsScan();
+            hasKeysInSlotsFuncs.Initialize(slots);
 
-            return false;
+            _ = unifiedSession.IterateLookupSnapshot(ref hasKeysInSlotsFuncs);
+            return hasKeysInSlotsFuncs.Found;
         }
 
         /// <summary>
diff --git a/libs/storage/Tsavorite/cs/src/core/ClientSession/ClientSession.cs b/libs/storage/Tsavorite/cs/src/core/ClientSession/ClientSession.cs
diff --git a/libs/storage/Tsavorite/cs/test/SpanByteIterationTests.cs b/libs/storage/Tsavorite/cs/test/SpanByteIterationTests.cs
diff --git a/test/Garnet.test.cluster/ClusterMigrateTests.cs b/test/Garnet.test.cluster/ClusterMigrateTests.cs
diff --git a/test/Garnet.test/RespScanCommandsTests.cs b/test/Garnet.test/RespScanCommandsTests.cs
diff --git a/website/docs/getting-started/configuration.md b/website/docs/getting-started/configuration.md
