nodelist (#187)

Author: bitfaster

BitFaster.Caching/Lfu/ConcurrentLfu.cs

@@ -37,18 +37,18 @@ public class ConcurrentLfu<K, V> : ICache<K, V>, IBoundedPolicy
 
         public const int BufferSize = 128;
 
-        private readonly ConcurrentDictionary<K, LinkedListNode<LfuNode<K, V>>> dictionary;
+        private readonly ConcurrentDictionary<K, LfuNode<K, V>> dictionary;
 
-        private readonly StripedBuffer<LinkedListNode<LfuNode<K, V>>> readBuffer;
-        private readonly StripedBuffer<LinkedListNode<LfuNode<K, V>>> writeBuffer;
+        private readonly StripedBuffer<LfuNode<K, V>> readBuffer;
+        private readonly StripedBuffer<LfuNode<K, V>> writeBuffer;
 
         private readonly CacheMetrics metrics = new CacheMetrics();
 
         private readonly CmSketch<K> cmSketch;
 
-        private readonly LinkedList<LfuNode<K, V>> windowLru;
-        private readonly LinkedList<LfuNode<K, V>> probationLru;
-        private readonly LinkedList<LfuNode<K, V>> protectedLru;
+        private readonly LfuNodeList<K, V> windowLru;
+        private readonly LfuNodeList<K, V> probationLru;
+        private readonly LfuNodeList<K, V> protectedLru;
 
         private readonly LfuCapacityPartition capacity;
 
@@ -58,7 +58,7 @@ public class ConcurrentLfu<K, V> : ICache<K, V>, IBoundedPolicy
         private readonly IScheduler scheduler;
 
 #if NETSTANDARD2_0
-        private readonly LinkedListNode<LfuNode<K, V>>[] localDrainBuffer = new LinkedListNode<LfuNode<K, V>>[TakeBufferSize];
+        private readonly LfuNode<K, V>[] localDrainBuffer = new LfuNode<K, V>[TakeBufferSize];
 #endif
 
         public ConcurrentLfu(int capacity)
@@ -70,16 +70,16 @@ public ConcurrentLfu(int concurrencyLevel, int capacity, IScheduler scheduler)
         {
             var comparer = EqualityComparer<K>.Default;
 
-            this.dictionary = new ConcurrentDictionary<K, LinkedListNode<LfuNode<K, V>>>(concurrencyLevel, capacity, comparer);
+            this.dictionary = new ConcurrentDictionary<K, LfuNode<K, V>>(concurrencyLevel, capacity, comparer);
 
-            this.readBuffer = new StripedBuffer<LinkedListNode<LfuNode<K, V>>>(concurrencyLevel, BufferSize);
-            this.writeBuffer = new StripedBuffer<LinkedListNode<LfuNode<K, V>>>(concurrencyLevel, BufferSize);
+            this.readBuffer = new StripedBuffer<LfuNode<K, V>>(concurrencyLevel, BufferSize);
+            this.writeBuffer = new StripedBuffer<LfuNode<K, V>>(concurrencyLevel, BufferSize);
 
             this.cmSketch = new CmSketch<K>(1, comparer);
             this.cmSketch.EnsureCapacity(capacity);
-            this.windowLru = new LinkedList<LfuNode<K, V>>();
-            this.probationLru = new LinkedList<LfuNode<K, V>>();
-            this.protectedLru = new LinkedList<LfuNode<K, V>>();
+            this.windowLru = new LfuNodeList<K, V>();
+            this.probationLru = new LfuNodeList<K, V>();
+            this.protectedLru = new LfuNodeList<K, V>();
 
             this.capacity = new LfuCapacityPartition(capacity);
 
@@ -109,7 +109,7 @@ public void AddOrUpdate(K key, V value)
                     return;
                 }
 
-                var node = new LinkedListNode<LfuNode<K, V>>(new LfuNode<K, V>(key, value));
+                var node = new LfuNode<K, V>(key, value);
                 if (this.dictionary.TryAdd(key, node))
                 {
                     AfterWrite(node);
@@ -133,7 +133,7 @@ public void Clear()
         public void Trim(int itemCount)
         {
             itemCount = Math.Min(itemCount, this.Count);
-            var candidates = new List<LinkedListNode<LfuNode<K, V>>>(itemCount);
+            var candidates = new List<LfuNode<K, V>>(itemCount);
 
             // TODO: this is LRU order eviction, Caffeine void evictFromMain(int candidates) is based on frequency
             lock (maintenanceLock)
@@ -146,7 +146,7 @@ public void Trim(int itemCount)
 
             foreach (var candidate in candidates)
             {
-                this.TryRemove(candidate.Value.Key);
+                this.TryRemove(candidate.Key);
             }
         }
 
@@ -159,11 +159,11 @@ public V GetOrAdd(K key, Func<K, V> valueFactory)
                     return value;
                 }
 
-                var node = new LinkedListNode<LfuNode<K, V>>(new LfuNode<K, V>(key, valueFactory(key)));
+                var node = new LfuNode<K, V>(key, valueFactory(key));
                 if (this.dictionary.TryAdd(key, node))
                 {
                     AfterWrite(node);
-                    return node.Value.Value;
+                    return node.Value;
                 }
             }
         }
@@ -178,7 +178,7 @@ public bool TryGet(K key, out V value)
                 { 
                     TryScheduleDrain(); 
                 }
-                value = node.Value.Value;               
+                value = node.Value;               
                 return true;
             }
 
@@ -192,7 +192,7 @@ public bool TryRemove(K key)
         {
             if (this.dictionary.TryRemove(key, out var node))
             {
-                node.Value.WasRemoved = true;
+                node.WasRemoved = true;
                 AfterWrite(node);
                 return true;
             }
@@ -204,7 +204,7 @@ public bool TryUpdate(K key, V value)
         {
             if (this.dictionary.TryGetValue(key, out var node))
             {
-                node.Value.Value = value;
+                node.Value = value;
 
                 // It's ok for this to be lossy, since the node is already tracked
                 // and we will just lose ordering/hit count, but not orphan the node.
@@ -225,11 +225,11 @@ public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
         {
             foreach (var kvp in this.dictionary)
             {
-                yield return new KeyValuePair<K, V>(kvp.Key, kvp.Value.Value.Value);
+                yield return new KeyValuePair<K, V>(kvp.Key, kvp.Value.Value);
             }
         }
 
-        private static void TakeCandidatesInLruOrder(LinkedList<LfuNode<K, V>> lru, List<LinkedListNode<LfuNode<K, V>>> candidates, int itemCount)
+        private static void TakeCandidatesInLruOrder(LfuNodeList<K, V> lru, List<LfuNode<K, V>> candidates, int itemCount)
         {
             var curr = lru.First;
 
@@ -240,7 +240,7 @@ private static void TakeCandidatesInLruOrder(LinkedList<LfuNode<K, V>> lru, List
             }
         }
 
-        private void AfterWrite(LinkedListNode<LfuNode<K, V>> node)
+        private void AfterWrite(LfuNode<K, V> node)
         {
             var spinner = new SpinWait();
 
@@ -351,16 +351,14 @@ private void DrainBuffers()
             }
         }
 
-        const int takeBufferSize = 1024;
-
         private bool Maintenance()
         {
             this.drainStatus.Set(DrainStatus.ProcessingToIdle);
 
             bool wasDrained = false;
 
 #if !NETSTANDARD2_0
-            var localDrainBuffer = ArrayPool<LinkedListNode<LfuNode<K, V>>>.Shared.Rent(TakeBufferSize);
+            var localDrainBuffer = ArrayPool<LfuNode<K, V>>.Shared.Rent(TakeBufferSize);
 #endif
             int maxSweeps = 1;
             int count = 0;
@@ -374,7 +372,7 @@ private bool Maintenance()
 
                 for (int i = 0; i < count; i++)
                 {
-                    this.cmSketch.Increment(localDrainBuffer[i].Value.Key);
+                    this.cmSketch.Increment(localDrainBuffer[i].Key);
                 }
 
                 for (int i = 0; i < count; i++)
@@ -393,7 +391,7 @@ private bool Maintenance()
             }
 
 #if !NETSTANDARD2_0
-            ArrayPool<LinkedListNode<LfuNode<K, V>>>.Shared.Return(localDrainBuffer);
+            ArrayPool<LfuNode<K, V>>.Shared.Return(localDrainBuffer);
 #endif
 
             // TODO: hill climb
@@ -411,18 +409,18 @@ private bool Maintenance()
             return wasDrained;
         }
 
-        private void OnAccess(LinkedListNode<LfuNode<K, V>> node)
+        private void OnAccess(LfuNode<K, V> node)
         {
             // there was a cache hit even if the item was removed or is not yet added.
             this.metrics.requestHitCount++;
 
             // Node is added to read buffer while it is removed by maintenance, or it is read before it has been added.
-            if (node.List == null)
+            if (node.list == null)
             {
                 return;
             }
 
-            switch (node.Value.Position)
+            switch (node.Position)
             {
                 case Position.Window:
                     this.windowLru.MoveToEnd(node); 
@@ -436,27 +434,27 @@ private void OnAccess(LinkedListNode<LfuNode<K, V>> node)
             }
         }
 
-        private void OnWrite(LinkedListNode<LfuNode<K, V>> node)
+        private void OnWrite(LfuNode<K, V> node)
         {
             // Nodes can be removed while they are in the write buffer, in which case they should
             // not be added back into the LRU.
-            if (node.Value.WasRemoved)
+            if (node.WasRemoved)
             {
-                if (node.List != null)
+                if (node.list != null)
                 {
-                    node.List.Remove(node);
+                    node.list.Remove(node);
                 }
 
                 return;
             }
 
-            this.cmSketch.Increment(node.Value.Key);
+            this.cmSketch.Increment(node.Key);
 
             // node can already be in one of the queues due to update
-            switch (node.Value.Position)
+            switch (node.Position)
             {
                 case Position.Window:
-                    if (node.List == null)
+                    if (node.list == null)
                     {
                         this.windowLru.AddLast(node);
                         TryEvict();
@@ -490,42 +488,42 @@ private void TryEvict()
                 if (this.protectedLru.Count < capacity.Protected)
                 {
                     this.protectedLru.AddLast(candidate);
-                    candidate.Value.Position = Position.Protected;
+                    candidate.Position = Position.Protected;
                     return;
                 }
 
                 this.probationLru.AddLast(candidate);
-                candidate.Value.Position = Position.Probation;
+                candidate.Position = Position.Probation;
 
                 // remove either candidate or probation.first
                 if (this.probationLru.Count > capacity.Probation)
                 {
-                    var c = this.cmSketch.EstimateFrequency(candidate.Value.Key);
-                    var p = this.cmSketch.EstimateFrequency(this.probationLru.First.Value.Key);
+                    var c = this.cmSketch.EstimateFrequency(candidate.Key);
+                    var p = this.cmSketch.EstimateFrequency(this.probationLru.First.Key);
 
                     // TODO: random factor?
                     var victim = (c > p) ? this.probationLru.First : candidate;
 
-                    this.dictionary.TryRemove(victim.Value.Key, out var _);
-                    victim.List.Remove(victim);
+                    this.dictionary.TryRemove(victim.Key, out var _);
+                    victim.list.Remove(victim);
 
                     this.metrics.evictedCount++;
                 }
             }
         }
 
-        private void PromoteProbation(LinkedListNode<LfuNode<K, V>> node)
+        private void PromoteProbation(LfuNode<K, V> node)
         {
             this.probationLru.Remove(node);
             this.protectedLru.AddLast(node);
-            node.Value.Position = Position.Protected;
+            node.Position = Position.Protected;
 
             if (this.protectedLru.Count > capacity.Protected)
             {
                 var demoted = this.protectedLru.First;
                 this.protectedLru.RemoveFirst();
 
-                demoted.Value.Position = Position.Probation;
+                demoted.Position = Position.Probation;
                 this.probationLru.AddLast(demoted);
             }
         }

BitFaster.Caching/Lfu/LfuNode.cs

@@ -6,6 +6,10 @@ namespace BitFaster.Caching.Lfu
 {
     internal class LfuNode<K, V>
     {
+        internal LfuNodeList<K, V> list;
+        internal LfuNode<K, V> next;
+        internal LfuNode<K, V> prev;
+
         private volatile bool wasRemoved;
 
         public LfuNode(K k, V v)
@@ -14,6 +18,13 @@ public LfuNode(K k, V v)
             this.Value = v;
         }
 
+        public LfuNode(LfuNodeList<K, V> list, K k, V v)
+        {
+            this.list = list;
+            this.Key = k;
+            this.Value = v;
+        }
+
         public readonly K Key;
 
         public V Value { get; set; }
@@ -25,6 +36,18 @@ public bool WasRemoved
             get => this.wasRemoved;
             set => this.wasRemoved = value;
         }
+
+        public LfuNode<K, V> Next
+        {
+            get { return next == null || next == list.head ? null : next; }
+        }
+
+        internal void Invalidate()
+        {
+            list = null;
+            next = null;
+            prev = null;
+        }
     }
 
     public enum Position