handle TLFU

Author: Alex Peck

BitFaster.Caching/Lfu/ConcurrentLfuCore.cs

@@ -371,7 +371,7 @@ public bool TryUpdate(K key, V value)
                 }
                 else
                 { 
-                    var newNode = policy.Create(key, value);
+                    var newNode = policy.Clone(node, value);
                     if (this.dictionary.TryUpdate(key, newNode, node))
                     { 
                         // This can't be lossy, because we need to attach the new node.

BitFaster.Caching/Lfu/LfuNode.cs

@@ -114,6 +114,9 @@ public void SetPreviousInTimeOrder(TimeOrderNode<K, V> prev)
             this.prevTime = prev;
         }
 
+        // Note: there is a special case for non-atomic value types. When the node has been updated,
+        // GetNextInTimeOrder() will return this. In this situation, the node is not attached to the
+        // timer wheel.
         public TimeOrderNode<K, V> GetNextInTimeOrder()
         {
             return nextTime;

BitFaster.Caching/Lfu/NodePolicy.cs

@@ -9,6 +9,7 @@ internal interface INodePolicy<K, V, N>
         where N : LfuNode<K, V>
     {
         N Create(K key, V value);
+        N Clone(N previous, V value);
         bool IsExpired(N node);
         void AdvanceTime();
         void OnRead(N node);
@@ -26,6 +27,11 @@ public AccessOrderNode<K, V> Create(K key, V value)
             return new AccessOrderNode<K, V>(key, value);
         }
 
+        public AccessOrderNode<K, V> Clone(AccessOrderNode<K, V> prev, V value)
+        {
+            return new AccessOrderNode<K, V>(prev.Key, value);
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool IsExpired(AccessOrderNode<K, V> node)
         {
@@ -82,6 +88,14 @@ public TimeOrderNode<K, V> Create(K key, V value)
             return new TimeOrderNode<K, V>(key, value) { TimeToExpire = Duration.SinceEpoch() + expiry };
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public TimeOrderNode<K, V> Clone(TimeOrderNode<K, V> prev, V value)
+        {
+            var node = new TimeOrderNode<K, V>(prev.Key, value) { TimeToExpire = prev.TimeToExpire };
+            node.SetNextInTimeOrder(node);
+            return node;
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool IsExpired(TimeOrderNode<K, V> node)
         {
@@ -118,9 +132,19 @@ public void OnWrite(TimeOrderNode<K, V> node)
             {
                 var oldTte = node.TimeToExpire;
                 node.TimeToExpire = current + expiryCalculator.GetExpireAfterUpdate(node.Key, node.Value, node.TimeToExpire - current);
-                if (oldTte.raw != node.TimeToExpire.raw)
-                {
-                    wheel.Reschedule(node);
+                
+                // non-atomic write value node was updated and replaced, schedule
+                // can JIT elide this branch for atomic writes?
+                if (!TypeProps<V>.IsWriteAtomic && node.GetNextInTimeOrder() == node)
+                { 
+                    wheel.Schedule(node);
+                }
+                else
+                { 
+                    if (oldTte.raw != node.TimeToExpire.raw)
+                    {
+                        wheel.Reschedule(node);
+                    }
                 }
             }
         }