TLru using stopwatch (#31)

* stopwatch

* fix tests

* use static

* longer ttl for unit test

Author: bitfaster

BitFaster.Caching.Benchmarks/Lru/TLruTimeBenchmark.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using BenchmarkDotNet.Attributes;
+using BitFaster.Caching.Lru;
+
+namespace BitFaster.Caching.Benchmarks.Lru
+{
+    public class TLruTimeBenchmark
+    {
+        private static readonly TemplateConcurrentLru<int, int, TimeStampedLruItem<int, int>, TLruDateTimePolicy<int, int>, NullHitCounter> dateTimeTLru
+            = new TemplateConcurrentLru<int, int, TimeStampedLruItem<int, int>, TLruDateTimePolicy<int, int>, NullHitCounter>
+                (1, 3, EqualityComparer<int>.Default, new TLruDateTimePolicy<int, int>(TimeSpan.FromSeconds(1)), new NullHitCounter());
+
+        private static readonly TemplateConcurrentLru<int, int, TickCountLruItem<int, int>, TLruTicksPolicy<int, int>, NullHitCounter> tickCountTLru
+            = new TemplateConcurrentLru<int, int, TickCountLruItem<int, int>, TLruTicksPolicy<int, int>, NullHitCounter>
+                (1, 3, EqualityComparer<int>.Default, new TLruTicksPolicy<int, int>(TimeSpan.FromSeconds(1)), new NullHitCounter());
+
+        private static readonly TemplateConcurrentLru<int, int, LongTickCountLruItem<int, int>, TLruLongTicksPolicy<int, int>, NullHitCounter> stopwatchTLru
+            = new TemplateConcurrentLru<int, int, LongTickCountLruItem<int, int>, TLruLongTicksPolicy<int, int>, NullHitCounter>
+                (1, 3, EqualityComparer<int>.Default, new TLruLongTicksPolicy<int, int>(TimeSpan.FromSeconds(1)), new NullHitCounter());
+
+        [Benchmark(Baseline = true)]
+        public void DateTimeUtcNow()
+        {
+            Func<int, int> func = x => x;
+            dateTimeTLru.GetOrAdd(1, func);
+        }
+
+        [Benchmark()]
+        public void EnvironmentTickCount()
+        {
+            Func<int, int> func = x => x;
+            tickCountTLru.GetOrAdd(1, func);
+        }
+
+        [Benchmark()]
+        public void StopWatchGetTimestamp()
+        {
+            Func<int, int> func = x => x;
+            stopwatchTLru.GetOrAdd(1, func);
+        }
+    }
+}

BitFaster.Caching.Benchmarks/Program.cs

@@ -15,7 +15,7 @@ class Program
         static void Main(string[] args)
         {
             var summary = BenchmarkRunner
-                .Run<LruCycle>(ManualConfig.Create(DefaultConfig.Instance)
+                .Run<TLruTimeBenchmark>(ManualConfig.Create(DefaultConfig.Instance)
                 .AddJob(Job.RyuJitX64));
         }
     }

BitFaster.Caching.Benchmarks/TimeBenchmarks.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+using BenchmarkDotNet.Attributes;
+
+namespace BitFaster.Caching.Benchmarks
+{
+    public class TimeBenchmarks
+    {
+        private static readonly Stopwatch sw = Stopwatch.StartNew();
+
+        [Benchmark(Baseline = true)]
+        public DateTime DateTimeUtcNow()
+        {
+            return DateTime.UtcNow;
+        }
+
+        [Benchmark()]
+        public int EnvironmentTickCount()
+        {
+            return Environment.TickCount;
+        }
+
+        [Benchmark()]
+        public long StopWatchGetElapsed()
+        {
+            return sw.ElapsedTicks;
+        }
+    }
+}

BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs

@@ -43,7 +43,7 @@ public void WhenComparerIsNullCtorThrows()
         [Fact]
         public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue()
         {
-            var x = new ConcurrentTLru<int, int>(3);
+            var x = new ClassicLru<int, int>(3);
 
             x.GetOrAdd(1, k => k).Should().Be(1);
         }

BitFaster.Caching.UnitTests/Lru/ConcurrentTLruTests.cs

@@ -10,7 +10,7 @@ namespace BitFaster.Caching.UnitTests.Lru
 {
     public class ConcurrentTLruTests
     {
-        private readonly TimeSpan timeToLive = TimeSpan.FromMilliseconds(10);
+        private readonly TimeSpan timeToLive = TimeSpan.FromSeconds(1);
         private const int capacity = 9;
         private ConcurrentTLru<int, string> lru;
 

BitFaster.Caching.UnitTests/Lru/TlruLongTicksPolicyTests.cs

@@ -0,0 +1,116 @@
+using FluentAssertions;
+using FluentAssertions.Extensions;
+using BitFaster.Caching.Lru;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+using System.Diagnostics;
+
+namespace BitFaster.Caching.UnitTests.Lru
+{
+    public class TLruLongTicksPolicyTests
+    {
+        private readonly TLruLongTicksPolicy<int, int> policy = new TLruLongTicksPolicy<int, int>(TimeSpan.FromSeconds(10));
+
+        [Fact]
+        public void CreateItemInitializesKeyAndValue()
+        {
+            var item = this.policy.CreateItem(1, 2);
+
+            item.Key.Should().Be(1);
+            item.Value.Should().Be(2);
+        }
+
+        [Fact]
+        public void CreateItemInitializesTimestampToNow()
+        {
+            var item = this.policy.CreateItem(1, 2);
+
+            // seconds = ticks / Stopwatch.Frequency
+            ulong epsilon = (ulong)(TimeSpan.FromMilliseconds(20).TotalSeconds * Stopwatch.Frequency);
+            item.TickCount.Should().BeCloseTo(Stopwatch.GetTimestamp(), epsilon);
+        }
+
+        [Fact]
+        public void TouchUpdatesItemWasAccessed()
+        {
+            var item = this.policy.CreateItem(1, 2);
+            item.WasAccessed = false;
+
+            this.policy.Touch(item);
+
+            item.WasAccessed.Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenItemIsExpiredShouldDiscardIsTrue()
+        {
+            var item = this.policy.CreateItem(1, 2);
+            item.TickCount = Stopwatch.GetTimestamp() - TimeSpan.FromSeconds(11).Ticks;
+
+            this.policy.ShouldDiscard(item).Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenItemIsNotExpiredShouldDiscardIsFalse()
+        {
+            var item = this.policy.CreateItem(1, 2);
+            item.TickCount = Stopwatch.GetTimestamp() - TimeSpan.FromSeconds(9).Ticks;
+
+            this.policy.ShouldDiscard(item).Should().BeFalse();
+        }
+
+        [Theory]
+        [InlineData(false, true, ItemDestination.Remove)]
+        [InlineData(true, true, ItemDestination.Remove)]
+        [InlineData(true, false, ItemDestination.Warm)]
+        [InlineData(false, false, ItemDestination.Cold)]
+        public void RouteHot(bool wasAccessed, bool isExpired, ItemDestination expectedDestination)
+        {
+            var item = CreateItem(wasAccessed, isExpired);
+
+            this.policy.RouteHot(item).Should().Be(expectedDestination);
+        }
+
+        [Theory]
+        [InlineData(false, true, ItemDestination.Remove)]
+        [InlineData(true, true, ItemDestination.Remove)]
+        [InlineData(true, false, ItemDestination.Warm)]
+        [InlineData(false, false, ItemDestination.Cold)]
+        public void RouteWarm(bool wasAccessed, bool isExpired, ItemDestination expectedDestination)
+        {
+            var item = CreateItem(wasAccessed, isExpired);
+
+            this.policy.RouteWarm(item).Should().Be(expectedDestination);
+        }
+
+        [Theory]
+        [InlineData(false, true, ItemDestination.Remove)]
+        [InlineData(true, true, ItemDestination.Remove)]
+        [InlineData(true, false, ItemDestination.Warm)]
+        [InlineData(false, false, ItemDestination.Remove)]
+        public void RouteCold(bool wasAccessed, bool isExpired, ItemDestination expectedDestination)
+        {
+            var item = CreateItem(wasAccessed, isExpired);
+
+            this.policy.RouteCold(item).Should().Be(expectedDestination);
+        }
+
+        private LongTickCountLruItem<int, int> CreateItem(bool wasAccessed, bool isExpired)
+        {
+            var item = this.policy.CreateItem(1, 2);
+
+            item.WasAccessed = wasAccessed;
+
+            if (isExpired)
+            {
+                item.TickCount = Stopwatch.GetTimestamp() - TimeSpan.FromSeconds(11).Ticks;
+            }
+
+            return item;
+        }
+    }
+}

BitFaster.Caching/Lru/ConcurrentTLru.cs

@@ -6,15 +6,15 @@
 
 namespace BitFaster.Caching.Lru
 {
-    public sealed class ConcurrentTLru<K, V> : TemplateConcurrentLru<K, V, TimeStampedLruItem<K, V>, TLruDateTimePolicy<K, V>, HitCounter>
+    public sealed class ConcurrentTLru<K, V> : TemplateConcurrentLru<K, V, LongTickCountLruItem<K, V>, TLruLongTicksPolicy<K, V>, HitCounter>
     {
         public ConcurrentTLru(int capacity)
-            : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default, new TLruDateTimePolicy<K, V>(), new HitCounter())
+            : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default, new TLruLongTicksPolicy<K, V>(), new HitCounter())
         { 
         }
 
         public ConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)
-            : base(concurrencyLevel, capacity, comparer, new TLruDateTimePolicy<K, V>(timeToLive), new HitCounter())
+            : base(concurrencyLevel, capacity, comparer, new TLruLongTicksPolicy<K, V>(timeToLive), new HitCounter())
         {
         }
 

BitFaster.Caching/Lru/FastConcurrentTLru.cs

@@ -4,15 +4,15 @@
 
 namespace BitFaster.Caching.Lru
 {
-    public sealed class FastConcurrentTLru<K, V> : TemplateConcurrentLru<K, V, TickCountLruItem<K, V>, TLruTicksPolicy<K, V>, NullHitCounter>
+    public sealed class FastConcurrentTLru<K, V> : TemplateConcurrentLru<K, V, LongTickCountLruItem<K, V>, TLruLongTicksPolicy<K, V>, NullHitCounter>
     {
         public FastConcurrentTLru(int capacity)
-            : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default, new TLruTicksPolicy<K, V>(), new NullHitCounter())
+            : base(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default, new TLruLongTicksPolicy<K, V>(), new NullHitCounter())
         {
         }
 
         public FastConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)
-            : base(concurrencyLevel, capacity, comparer, new TLruTicksPolicy<K, V>(timeToLive), new NullHitCounter())
+            : base(concurrencyLevel, capacity, comparer, new TLruLongTicksPolicy<K, V>(timeToLive), new NullHitCounter())
         {
         }
     }

BitFaster.Caching/Lru/LongTickCountLruItem.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BitFaster.Caching.Lru
+{
+    public class LongTickCountLruItem<K, V> : LruItem<K, V>
+    {
+        public LongTickCountLruItem(K key, V value, long tickCount)
+            : base(key, value)
+        {
+            this.TickCount = tickCount;
+        }
+
+        public long TickCount { get; set; }
+    }
+}

BitFaster.Caching/Lru/TlruLongTicksPolicy.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BitFaster.Caching.Lru
+{
+    /// <summary>
+    /// Time aware Least Recently Used (TLRU) is a variant of LRU which discards the least 
+    /// recently used items first, and any item that has expired.
+    /// </summary>
+    /// <remarks>
+    /// This class measures time using stopwatch.
+    /// </remarks>
+    public readonly struct TLruLongTicksPolicy<K, V> : IPolicy<K, V, LongTickCountLruItem<K, V>>
+    {
+        private readonly long timeToLive;
+
+        public TLruLongTicksPolicy(TimeSpan timeToLive)
+        {
+            this.timeToLive = timeToLive.Ticks;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public LongTickCountLruItem<K, V> CreateItem(K key, V value)
+        {
+            return new LongTickCountLruItem<K, V>(key, value, Stopwatch.GetTimestamp());
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Touch(LongTickCountLruItem<K, V> item)
+        {
+            item.WasAccessed = true;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool ShouldDiscard(LongTickCountLruItem<K, V> item)
+        {
+            if (Stopwatch.GetTimestamp() - item.TickCount > this.timeToLive)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ItemDestination RouteHot(LongTickCountLruItem<K, V> item)
+        {
+            if (this.ShouldDiscard(item))
+            {
+                return ItemDestination.Remove;
+            }
+
+            if (item.WasAccessed)
+            {
+                return ItemDestination.Warm;
+            }
+
+            return ItemDestination.Cold;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ItemDestination RouteWarm(LongTickCountLruItem<K, V> item)
+        {
+            if (this.ShouldDiscard(item))
+            {
+                return ItemDestination.Remove;
+            }
+
+            if (item.WasAccessed)
+            {
+                return ItemDestination.Warm;
+            }
+
+            return ItemDestination.Cold;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ItemDestination RouteCold(LongTickCountLruItem<K, V> item)
+        {
+            if (this.ShouldDiscard(item))
+            {
+                return ItemDestination.Remove;
+            }
+
+            if (item.WasAccessed)
+            {
+                return ItemDestination.Warm;
+            }
+
+            return ItemDestination.Remove;
+        }
+    }
+}