update ttl (#123)

* update ttl

* policy tests

Author: bitfaster

BitFaster.Caching.UnitTests/Lru/ConcurrentTLruTests.cs

@@ -54,6 +54,18 @@ public async Task WhenItemIsExpiredItIsRemoved()
             lru.TryGet(1, out var value).Should().BeFalse();
         }
 
+        [Fact]
+        public async Task WhenItemIsUpdatedTtlIsExtended()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+
+            await Task.Delay(timeToLive * 2);
+
+            lru.TryUpdate(1, "3");
+
+            lru.TryGet(1, out var value).Should().BeTrue();
+        }
+
         [Fact]
         public void WhenValueEvictedItemRemovedEventIsFired()
         {

BitFaster.Caching.UnitTests/Lru/TlruDateTimePolicyTests.cs

@@ -42,6 +42,19 @@ public void TouchUpdatesItemWasAccessed()
             item.WasAccessed.Should().BeTrue();
         }
 
+        [Fact]
+        public async Task UpdateUpdatesTickCount()
+        {
+            var item = this.policy.CreateItem(1, 2);
+            var ts = item.TimeStamp;
+
+            await Task.Delay(TimeSpan.FromMilliseconds(1));
+
+            this.policy.Update(item);
+
+            item.TimeStamp.Should().BeAfter(ts);
+        }
+
         [Fact]
         public void WhenItemIsExpiredShouldDiscardIsTrue()
         {

BitFaster.Caching.UnitTests/Lru/TlruLongTicksPolicyTests.cs

@@ -45,6 +45,19 @@ public void TouchUpdatesItemWasAccessed()
             item.WasAccessed.Should().BeTrue();
         }
 
+        [Fact]
+        public async Task UpdateUpdatesTickCount()
+        {
+            var item = this.policy.CreateItem(1, 2);
+            var tc = item.TickCount;
+
+            await Task.Delay(TimeSpan.FromMilliseconds(1));
+
+            this.policy.Update(item);
+
+            item.TickCount.Should().BeGreaterThan(tc);
+        }
+
         [Fact]
         public void WhenItemIsExpiredShouldDiscardIsTrue()
         {

BitFaster.Caching.UnitTests/Lru/TlruTicksPolicyTests.cs

@@ -42,6 +42,19 @@ public void TouchUpdatesItemWasAccessed()
             item.WasAccessed.Should().BeTrue();
         }
 
+        [Fact]
+        public async Task UpdateUpdatesTickCount()
+        {
+            var item = this.policy.CreateItem(1, 2);
+            var tc = item.TickCount;
+
+            await Task.Delay(TimeSpan.FromMilliseconds(1));
+
+            this.policy.Update(item);
+
+            item.TickCount.Should().BeGreaterThan(tc);
+        }
+
         [Fact]
         public void WhenItemIsExpiredShouldDiscardIsTrue()
         {

BitFaster.Caching/Lru/IItemPolicy.cs

@@ -12,6 +12,8 @@ public interface IItemPolicy<in K, in V, I> where I : LruItem<K, V>
 
         void Touch(I item);
 
+        void Update(I item);
+
         bool ShouldDiscard(I item);
 
         bool CanDiscard();

BitFaster.Caching/Lru/LruPolicy.cs

@@ -24,6 +24,11 @@ public void Touch(LruItem<K, V> item)
             item.WasAccessed = true;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Update(LruItem<K, V> item)
+        {
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool ShouldDiscard(LruItem<K, V> item)
         {

BitFaster.Caching/Lru/TemplateConcurrentLru.cs

@@ -258,7 +258,7 @@ public bool TryUpdate(K key, V value)
                     {
                         V oldValue = existing.Value;
                         existing.Value = value;
-
+                        this.itemPolicy.Update(existing);
                         Disposer<V>.Dispose(oldValue);
 
                         return true;

BitFaster.Caching/Lru/TlruDateTimePolicy.cs

@@ -32,6 +32,12 @@ public void Touch(TimeStampedLruItem<K, V> item)
             item.WasAccessed = true;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Update(TimeStampedLruItem<K, V> item)
+        {
+            item.TimeStamp = DateTime.UtcNow;
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool ShouldDiscard(TimeStampedLruItem<K, V> item)
         {

BitFaster.Caching/Lru/TlruLongTicksPolicy.cs

@@ -38,6 +38,12 @@ public void Touch(LongTickCountLruItem<K, V> item)
             item.WasAccessed = true;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Update(LongTickCountLruItem<K, V> item)
+        {
+            item.TickCount = Stopwatch.GetTimestamp();
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool ShouldDiscard(LongTickCountLruItem<K, V> item)
         {

BitFaster.Caching/Lru/TlruTicksPolicy.cs

@@ -37,6 +37,12 @@ public void Touch(TickCountLruItem<K, V> item)
             item.WasAccessed = true;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Update(TickCountLruItem<K, V> item)
+        {
+            item.TickCount = Environment.TickCount;
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool ShouldDiscard(TickCountLruItem<K, V> item)
         {