seqlock

Author: Alex Peck

BitFaster.Caching.Benchmarks/Lru/LruJustGetOrAddGuid.cs

@@ -9,6 +9,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Threading;
 
 namespace BitFaster.Caching.Benchmarks
 {

BitFaster.Caching/Lru/ConcurrentLruCore.cs

@@ -186,10 +186,7 @@ private bool GetOrDiscard(I item, [MaybeNullWhen(false)] out V value)
             else
             { 
                 // prevent torn read for non-atomic types
-                lock (item)
-                {
-                    value = item.Value;
-                }
+                value = item.SeqLockRead();
             }
 
             this.itemPolicy.Touch(item);
@@ -394,7 +391,16 @@ public bool TryUpdate(K key, V value)
                     if (!existing.WasRemoved)
                     {
                         V oldValue = existing.Value;
-                        existing.Value = value;
+
+                        if (TypeProps<V>.IsWriteAtomic)
+                        { 
+                            existing.Value = value;
+                        }
+                        else
+                        { 
+                            existing.SeqLockWrite(value);
+                        }
+                        
                         this.itemPolicy.Update(existing);
 // backcompat: remove conditional compile
 #if NETCOREAPP3_0_OR_GREATER

BitFaster.Caching/Lru/LruItem.cs

@@ -1,4 +1,6 @@
 
+using System.Threading;
+
 namespace BitFaster.Caching.Lru
 {
     /// <summary>
@@ -11,6 +13,8 @@ public class LruItem<K, V>
         private volatile bool wasAccessed;
         private volatile bool wasRemoved;
 
+        private int sequence;
+
         /// <summary>
         /// Initializes a new instance of the LruItem class with the specified key and value.
         /// </summary>
@@ -49,5 +53,39 @@ public bool WasRemoved
             get => this.wasRemoved;
             set => this.wasRemoved = value;
         }
+
+        internal V SeqLockRead()
+        { 
+            var spin = new SpinWait();
+            while (true)
+            { 
+                var start = Volatile.Read(ref this.sequence);
+
+                if ((start & 1) == 1) 
+                {
+                    // A write is in progress. Back off and keep spinning.
+                    spin.SpinOnce();
+                    continue;
+                }
+
+                V copy = this.Value;
+
+                var end = Volatile.Read(ref this.sequence);
+                if (start == end)
+                { 
+                    return copy;    
+                }
+            }
+        }
+
+        // Note: item should be locked while invoking this method. Multiple writer threads are not supported.
+        internal void SeqLockWrite(V value)
+        { 
+            Interlocked.Increment(ref sequence);
+
+            this.Value = value;
+
+            Interlocked.Increment(ref sequence);
+        }
     }
 }