[C#] Replace LockingMode with ConcurrencyControlMode (#867)

* Replace LockingMode with ConcurrencyControlMode

* Fix 'Remote' solution build

cs/benchmark/FasterSpanByteYcsbBenchmark.cs

@@ -80,11 +80,11 @@ internal FasterSpanByteYcsbBenchmark(KeySpanByte[] i_keys_, KeySpanByte[] t_keys
             if (testLoader.Options.UseSmallMemoryLog)
                 store = new FasterKV<SpanByte, SpanByte>
                     (testLoader.MaxKey / testLoader.Options.HashPacking, new LogSettings { LogDevice = device, PreallocateLog = true, PageSizeBits = 22, SegmentSizeBits = 26, MemorySizeBits = 26 },
-                    new CheckpointSettings { CheckpointDir = testLoader.BackupPath }, lockingMode: testLoader.LockingMode);
+                    new CheckpointSettings { CheckpointDir = testLoader.BackupPath }, concurrencyControlMode: testLoader.ConcurrencyControlMode);
             else
                 store = new FasterKV<SpanByte, SpanByte>
                     (testLoader.MaxKey / testLoader.Options.HashPacking, new LogSettings { LogDevice = device, PreallocateLog = true, MemorySizeBits = 35 },
-                    new CheckpointSettings { CheckpointDir = testLoader.BackupPath }, lockingMode: testLoader.LockingMode);
+                    new CheckpointSettings { CheckpointDir = testLoader.BackupPath }, concurrencyControlMode: testLoader.ConcurrencyControlMode);
         }
 
         internal void Dispose()

cs/benchmark/FasterYcsbBenchmark.cs

@@ -80,11 +80,11 @@ internal FASTER_YcsbBenchmark(Key[] i_keys_, Key[] t_keys_, TestLoader testLoade
             if (testLoader.Options.UseSmallMemoryLog)
                 store = new FasterKV<Key, Value>
                     (testLoader.MaxKey / testLoader.Options.HashPacking, new LogSettings { LogDevice = device, PreallocateLog = true, PageSizeBits = 25, SegmentSizeBits = 30, MemorySizeBits = 28 },
-                    new CheckpointSettings { CheckpointDir = testLoader.BackupPath }, lockingMode: testLoader.LockingMode);
+                    new CheckpointSettings { CheckpointDir = testLoader.BackupPath }, concurrencyControlMode: testLoader.ConcurrencyControlMode);
             else
                 store = new FasterKV<Key, Value>
                     (testLoader.MaxKey / testLoader.Options.HashPacking, new LogSettings { LogDevice = device, PreallocateLog = true },
-                    new CheckpointSettings { CheckpointDir = testLoader.BackupPath }, lockingMode: testLoader.LockingMode);
+                    new CheckpointSettings { CheckpointDir = testLoader.BackupPath }, concurrencyControlMode: testLoader.ConcurrencyControlMode);
         }
 
         internal void Dispose()

cs/benchmark/Options.cs

@@ -36,8 +36,8 @@ class Options
         [Option('z', "locking", Required = false, Default = 0,
              HelpText = "Locking Implementation:" +
                         "\n    0 = None (default)" +
-                        "\n    1 = Mixed-mode locking using main HashTable buckets")]
-        public int LockingMode { get; set; }
+                        "\n    1 = LockTable using main HashTable buckets")]
+        public int ConcurrencyControlMode { get; set; }
 
         [Option('i', "iterations", Required = false, Default = 1,
          HelpText = "Number of iterations of the test to run")]
@@ -100,7 +100,7 @@ class Options
         public string GetOptionsString()
         {
             static string boolStr(bool value) => value ? "y" : "n";
-            return $"d: {DistributionName.ToLower()}; n: {NumaStyle}; rumd: {string.Join(',', RumdPercents)}; t: {ThreadCount}; z: {LockingMode}; i: {IterationCount}; hp: {HashPacking}"
+            return $"d: {DistributionName.ToLower()}; n: {NumaStyle}; rumd: {string.Join(',', RumdPercents)}; t: {ThreadCount}; z: {ConcurrencyControlMode}; i: {IterationCount}; hp: {HashPacking}"
                         + $" sd: {boolStr(UseSmallData)}; sm: {boolStr(UseSmallMemoryLog)}; sy: {boolStr(this.UseSyntheticData)}; safectx: {boolStr(this.UseSafeContext)};"
                         + $" chkptms: {this.PeriodicCheckpointMilliseconds}; chkpttype: {(this.PeriodicCheckpointMilliseconds > 0 ? this.PeriodicCheckpointType.ToString() : "None")};"
                         + $" chkptincr: {boolStr(this.PeriodicCheckpointTryIncremental)}";

cs/benchmark/TestLoader.cs

@@ -28,7 +28,7 @@ class TestLoader
         internal KeySpanByte[] txn_span_keys = default;
 
         internal readonly BenchmarkType BenchmarkType;
-        internal readonly LockingMode LockingMode;
+        internal readonly ConcurrencyControlMode ConcurrencyControlMode;
         internal readonly long InitCount;
         internal readonly long TxnCount;
         internal readonly int MaxKey;
@@ -61,13 +61,13 @@ static bool verifyOption(bool isValid, string name, string info = null)
             if (!verifyOption(Options.NumaStyle >= 0 && Options.NumaStyle <= 1, "NumaStyle"))
                 return;
 
-            this.LockingMode = Options.LockingMode switch
+            this.ConcurrencyControlMode = Options.ConcurrencyControlMode switch
             {
-                0 => LockingMode.None,
-                1 => LockingMode.Standard,
-                _ => throw new InvalidOperationException($"Unknown Locking mode int: {Options.LockingMode}")
+                0 => ConcurrencyControlMode.None,
+                1 => ConcurrencyControlMode.LockTable,
+                _ => throw new InvalidOperationException($"Unknown Locking mode int: {Options.ConcurrencyControlMode}")
             };
-            if (!verifyOption(Enum.IsDefined(typeof(LockingMode), this.LockingMode), "LockingMode"))
+            if (!verifyOption(Enum.IsDefined(typeof(ConcurrencyControlMode), this.ConcurrencyControlMode), "ConcurrencyControlMode"))
                 return;
 
             if (!verifyOption(Options.IterationCount > 0, "Iteration Count"))

cs/remote/samples/FixedLenServer/Program.cs

@@ -39,7 +39,7 @@ static void Main(string[] args)
                 builder.SetMinimumLevel(LogLevel.Error);
             });
 
-            using var server = new FixedLenServer<Key, Value, Input, Output, Functions>(opts.GetServerOptions(), () => new Functions(), lockingMode: LockingMode.Standard);
+            using var server = new FixedLenServer<Key, Value, Input, Output, Functions>(opts.GetServerOptions(), () => new Functions(), concurrencyControlMode: ConcurrencyControlMode.LockTable);
             server.Start();
             Console.WriteLine("Started server");
 

cs/remote/src/FASTER.server/Servers/FixedLenServer.cs

@@ -23,11 +23,11 @@ public sealed class FixedLenServer<Key, Value, Input, Output, Functions> : Gener
         /// </summary>
         /// <param name="opts"></param>
         /// <param name="functionsGen"></param>
-        /// <param name="lockingMode"></param>
+        /// <param name="concurrencyControlMode"></param>
         /// <param name="maxSizeSettings"></param>
         /// <param name="loggerFactory"></param>
-        public FixedLenServer(ServerOptions opts, Func<Functions> functionsGen, LockingMode lockingMode, MaxSizeSettings maxSizeSettings = default, ILoggerFactory loggerFactory = null)
-            : base(opts, functionsGen, new FixedLenSerializer<Key, Value, Input, Output>(), new FixedLenKeySerializer<Key, Input>(), lockingMode: lockingMode, maxSizeSettings, loggerFactory)
+        public FixedLenServer(ServerOptions opts, Func<Functions> functionsGen, ConcurrencyControlMode concurrencyControlMode, MaxSizeSettings maxSizeSettings = default, ILoggerFactory loggerFactory = null)
+            : base(opts, functionsGen, new FixedLenSerializer<Key, Value, Input, Output>(), new FixedLenKeySerializer<Key, Input>(), concurrencyControlMode: concurrencyControlMode, maxSizeSettings, loggerFactory)
         {
         }
     }

cs/remote/src/FASTER.server/Servers/GenericServer.cs

@@ -31,11 +31,11 @@ public class GenericServer<Key, Value, Input, Output, Functions, ParameterSerial
         /// <param name="functionsGen"></param>
         /// <param name="serializer"></param>
         /// <param name="keyInputSerializer"></param>
-        /// <param name="lockingMode"></param>
+        /// <param name="concurrencyControlMode"></param>
         /// <param name="maxSizeSettings"></param>
         /// <param name="loggerFactory"></param>
-        public GenericServer(ServerOptions opts, Func<Functions> functionsGen, ParameterSerializer serializer, IKeyInputSerializer<Key, Input> keyInputSerializer, 
-                             LockingMode lockingMode, MaxSizeSettings maxSizeSettings = default, ILoggerFactory loggerFactory = null)
+        public GenericServer(ServerOptions opts, Func<Functions> functionsGen, ParameterSerializer serializer, IKeyInputSerializer<Key, Input> keyInputSerializer,
+                             ConcurrencyControlMode concurrencyControlMode, MaxSizeSettings maxSizeSettings = default, ILoggerFactory loggerFactory = null)
         {
             this.opts = opts;
 
@@ -45,7 +45,7 @@ public GenericServer(ServerOptions opts, Func<Functions> functionsGen, Parameter
             if (!Directory.Exists(opts.CheckpointDir))
                 Directory.CreateDirectory(opts.CheckpointDir);
 
-            store = new FasterKV<Key, Value>(indexSize, logSettings, checkpointSettings, lockingMode: lockingMode, loggerFactory: loggerFactory);
+            store = new FasterKV<Key, Value>(indexSize, logSettings, checkpointSettings, concurrencyControlMode: concurrencyControlMode, loggerFactory: loggerFactory);
 
             if (opts.Recover)
             {

cs/remote/src/FASTER.server/Servers/VarLenServer.cs

@@ -37,7 +37,7 @@ public VarLenServer(ServerOptions opts, ILoggerFactory loggerFactory = null)
             if (!Directory.Exists(opts.CheckpointDir))
                 Directory.CreateDirectory(opts.CheckpointDir);
 
-            store = new FasterKV<SpanByte, SpanByte>(indexSize, logSettings, checkpointSettings, lockingMode: LockingMode.Standard, loggerFactory: loggerFactory);
+            store = new FasterKV<SpanByte, SpanByte>(indexSize, logSettings, checkpointSettings, concurrencyControlMode: ConcurrencyControlMode.LockTable, loggerFactory: loggerFactory);
 
             if (!opts.DisablePubSub)
             {

cs/remote/test/FASTER.remote.test/TestUtils.cs

@@ -34,7 +34,7 @@ public static FixedLenServer<long, long, long, long, SimpleFunctions<long, long,
                 Recover = tryRecover,
                 IndexSize = "1m",
             };
-            return new FixedLenServer<long, long, long, long, SimpleFunctions<long, long, long>>(opts, () => new SimpleFunctions<long, long, long>(merger), lockingMode: LockingMode.Standard);
+            return new FixedLenServer<long, long, long, long, SimpleFunctions<long, long, long>>(opts, () => new SimpleFunctions<long, long, long>(merger), concurrencyControlMode: ConcurrencyControlMode.LockTable);
         }
 
         /// <summary>

cs/samples/StoreVarLenTypes/AsciiSumSample.cs

@@ -28,7 +28,7 @@ public static void Run()
             // For this test we require record-level locking
             using var store = new FasterKV<SpanByte, SpanByte>(
                 size: 1L << 20,
-                logSettings: new LogSettings { LogDevice = log, MemorySizeBits = 15, PageSizeBits = 12 }, lockingMode: LockingMode.Standard);
+                logSettings: new LogSettings { LogDevice = log, MemorySizeBits = 15, PageSizeBits = 12 }, concurrencyControlMode: ConcurrencyControlMode.LockTable);
 
             // Create session for ASCII sums. We require two callback function types to be provided:
             //    AsciiSumSpanByteFunctions implements RMW callback functions

cs/src/core/ClientSession/ClientSession.cs

@@ -241,7 +241,7 @@ public LockableUnsafeContext<Key, Value, Input, Output, Context, Functions> Lock
             get
             {
                 if (!this.fht.LockTable.IsEnabled)
-                    throw new FasterException($"LockableUnsafeContext requires {nameof(LockingMode.Standard)}");
+                    throw new FasterException($"LockableUnsafeContext requires {nameof(ConcurrencyControlMode.LockTable)}");
                 return luContext;
             }
         }
@@ -254,7 +254,7 @@ public LockableContext<Key, Value, Input, Output, Context, Functions> LockableCo
             get
             {
                 if (!this.fht.LockTable.IsEnabled)
-                    throw new FasterException($"LockableContext requires {nameof(LockingMode.Standard)}");
+                    throw new FasterException($"LockableContext requires {nameof(ConcurrencyControlMode.LockTable)}");
                 return lContext;
             }
         }

cs/src/core/ClientSession/ILockableContext.cs

@@ -25,7 +25,7 @@ public interface ILockableContext<TKey>
         /// <summary>
         /// If true, then keys must use one of the <see cref="IFasterContext{TKey}.GetKeyHash(ref TKey)"/> overloads to obtain a code by which groups of keys will be sorted for manual locking, to avoid deadlocks.
         /// </summary>
-        /// <remarks>Whether this returns true depends on the <see cref="LockingMode"/> on <see cref="FasterKVSettings{Key, Value}"/>, or passed to the FasterKV constructor.</remarks>
+        /// <remarks>Whether this returns true depends on the <see cref="ConcurrencyControlMode"/> on <see cref="FasterKVSettings{Key, Value}"/>, or passed to the FasterKV constructor.</remarks>
         bool NeedKeyHash { get; }
 
         /// <summary>

cs/src/core/Index/Common/FasterKVSettings.cs

@@ -24,7 +24,7 @@ public sealed class FasterKVSettings<Key, Value> : IDisposable
         /// <summary>
         /// How FASTER should do record locking
         /// </summary>
-        public LockingMode LockingMode;
+        public ConcurrencyControlMode ConcurrencyControlMode;
 
         /// <summary>
         /// Device used for main hybrid log
@@ -199,7 +199,7 @@ public override string ToString()
             var retStr = $"index: {Utility.PrettySize(IndexSize)}; log memory: {Utility.PrettySize(MemorySize)}; log page: {Utility.PrettySize(PageSize)}; log segment: {Utility.PrettySize(SegmentSize)}";
             retStr += $"; log device: {(LogDevice == null ? "null" : LogDevice.GetType().Name)}";
             retStr += $"; obj log device: {(ObjectLogDevice == null ? "null" : ObjectLogDevice.GetType().Name)}";
-            retStr += $"; mutable fraction: {MutableFraction}; locking mode: {this.LockingMode}";
+            retStr += $"; mutable fraction: {MutableFraction}; locking mode: {this.ConcurrencyControlMode}";
             retStr += $"; read cache (rc): {(ReadCacheEnabled ? "yes" : "no")}";
             retStr += $"; read copy options: {ReadCopyOptions}";
             if (ReadCacheEnabled)

cs/src/core/Index/FASTER/FASTER.cs

@@ -87,7 +87,7 @@ public FasterKV(FasterKVSettings<Key, Value> fasterKVSettings) :
                 fasterKVSettings.GetIndexSizeCacheLines(), fasterKVSettings.GetLogSettings(),
                 fasterKVSettings.GetCheckpointSettings(), fasterKVSettings.GetSerializerSettings(),
                 fasterKVSettings.EqualityComparer, fasterKVSettings.GetVariableLengthStructSettings(),
-                fasterKVSettings.TryRecoverLatest, fasterKVSettings.LockingMode, null, fasterKVSettings.logger)
+                fasterKVSettings.TryRecoverLatest, fasterKVSettings.ConcurrencyControlMode, null, fasterKVSettings.logger)
         { }
 
         /// <summary>
@@ -100,14 +100,14 @@ public FasterKV(FasterKVSettings<Key, Value> fasterKVSettings) :
         /// <param name="comparer">FASTER equality comparer for key</param>
         /// <param name="variableLengthStructSettings"></param>
         /// <param name="tryRecoverLatest">Try to recover from latest checkpoint, if any</param>
-        /// <param name="lockingMode">How FASTER should do record locking</param>
+        /// <param name="concurrencyControlMode">How FASTER should do record locking</param>
         /// <param name="loggerFactory">Logger factory to create an ILogger, if one is not passed in (e.g. from <see cref="FasterKVSettings{Key, Value}"/>).</param>
         /// <param name="logger">Logger to use.</param>
         /// <param name="lockTableSize">Number of buckets in the lock table</param>
         public FasterKV(long size, LogSettings logSettings,
             CheckpointSettings checkpointSettings = null, SerializerSettings<Key, Value> serializerSettings = null,
             IFasterEqualityComparer<Key> comparer = null,
-            VariableLengthStructSettings<Key, Value> variableLengthStructSettings = null, bool tryRecoverLatest = false, LockingMode lockingMode = LockingMode.Standard,
+            VariableLengthStructSettings<Key, Value> variableLengthStructSettings = null, bool tryRecoverLatest = false, ConcurrencyControlMode concurrencyControlMode = ConcurrencyControlMode.LockTable,
             ILoggerFactory loggerFactory = null, ILogger logger = null, int lockTableSize = Constants.kDefaultLockTableSize)
         {
             this.loggerFactory = loggerFactory;
@@ -134,8 +134,8 @@ public FasterKV(long size, LogSettings logSettings,
                 }
             }
 
-            this.DoTransientLocking = lockingMode == LockingMode.Standard;
-            this.DoEphemeralLocking = lockingMode == LockingMode.Ephemeral;
+            this.DoTransientLocking = concurrencyControlMode == ConcurrencyControlMode.LockTable;
+            this.DoEphemeralLocking = concurrencyControlMode == ConcurrencyControlMode.RecordIsolation;
 
             if (checkpointSettings is null)
                 checkpointSettings = new CheckpointSettings();
@@ -238,7 +238,7 @@ public FasterKV(long size, LogSettings logSettings,
             sectorSize = (int)logSettings.LogDevice.SectorSize;
             Initialize(size, sectorSize);
 
-            this.LockTable = new OverflowBucketLockTable<Key, Value>(lockingMode == LockingMode.Standard ? this : null);
+            this.LockTable = new OverflowBucketLockTable<Key, Value>(concurrencyControlMode == ConcurrencyControlMode.LockTable ? this : null);
 
             systemState = SystemState.Make(Phase.REST, 1);
 

cs/src/core/Index/FASTER/FASTERIterator.cs

@@ -104,7 +104,7 @@ public FasterKVIterator(FasterKV<Key, Value> fht, Functions functions, long unti
             }
 
             tempKv = new FasterKV<Key, Value>(fht.IndexSize, new LogSettings { LogDevice = new NullDevice(), ObjectLogDevice = new NullDevice(), MutableFraction = 1 }, comparer: fht.Comparer,
-                                              variableLengthStructSettings: variableLengthStructSettings, loggerFactory: loggerFactory, lockingMode: LockingMode.None);
+                                              variableLengthStructSettings: variableLengthStructSettings, loggerFactory: loggerFactory, concurrencyControlMode: ConcurrencyControlMode.None);
             tempKvSession = tempKv.NewSession<Input, Output, Context, Functions>(functions);
             mainKvIter = fht.Log.Scan(fht.Log.BeginAddress, untilAddress);
             pushScanIterator = mainKvIter as IPushScanIterator<Key>;

cs/src/core/Index/FASTER/Implementation/Locking/OverflowBucketLockTable.cs

@@ -19,13 +19,13 @@ internal struct OverflowBucketLockTable<TKey, TValue> : ILockTable<TKey>
         internal OverflowBucketLockTable(FasterKV<TKey, TValue> f) => this.fht = f;
 
         [Conditional("DEBUG")]
-        void AssertLockAllowed() => Debug.Assert(IsEnabled, $"Attempt to do Manual-locking lock when locking mode is not {LockingMode.Standard}");
+        void AssertLockAllowed() => Debug.Assert(IsEnabled, $"Attempt to do Manual-locking lock when locking mode is not {ConcurrencyControlMode.LockTable}");
 
         [Conditional("DEBUG")]
-        void AssertUnlockAllowed() => Debug.Assert(IsEnabled, $"Attempt to do Manual-locking unlock when locking mode is not {LockingMode.Standard}");
+        void AssertUnlockAllowed() => Debug.Assert(IsEnabled, $"Attempt to do Manual-locking unlock when locking mode is not {ConcurrencyControlMode.LockTable}");
 
         [Conditional("DEBUG")]
-        void AssertQueryAllowed() => Debug.Assert(IsEnabled, $"Attempt to do Manual-locking query when locking mode is not {LockingMode.Standard}");
+        void AssertQueryAllowed() => Debug.Assert(IsEnabled, $"Attempt to do Manual-locking query when locking mode is not {ConcurrencyControlMode.LockTable}");
 
         internal long GetSize() => fht.state[fht.resizeInfo.version].size_mask;