perf (#174)

* proxy

* tests

* cleanup

* cleanup

* move trim expired

Author: bitfaster

BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs

@@ -227,13 +227,13 @@ public void WhenRefToMetricsIsCapturedResultIsCorrect()
         [Fact]
         public void CanExpireIsFalse()
         {
-            this.lru.CanExpire.Should().BeFalse();
+            this.lru.Policy.ExpireAfterWrite.CanExpire.Should().BeFalse();
         }
 
         [Fact]
         public void TimeToLiveIsInfinite()
         {
-            this.lru.TimeToLive.Should().Be(NoneTimePolicy.Infinite);
+            this.lru.Policy.ExpireAfterWrite.TimeToLive.Should().Be(NoneTimePolicy.Infinite);
         }
 
         [Fact]

BitFaster.Caching.UnitTests/Lru/ConcurrentTLruTests.cs

@@ -55,13 +55,13 @@ public void ConstructPartitionCtorReturnsCapacity()
         [Fact]
         public void CanExpireIsTrue()
         {
-            this.lru.CanExpire.Should().BeTrue();
+            this.lru.Policy.ExpireAfterWrite.CanExpire.Should().BeTrue();
         }
 
         [Fact]
         public void TimeToLiveIsCtorArg()
         {
-            this.lru.TimeToLive.Should().Be(timeToLive);
+            this.lru.Policy.ExpireAfterWrite.TimeToLive.Should().Be(timeToLive);
         }
 
         [Fact]
@@ -155,7 +155,7 @@ public async Task WhenItemsAreExpiredExpireRemovesExpiredItems()
 
             await Task.Delay(timeToLive * 2);
 
-            lru.TrimExpired();
+            lru.Policy.ExpireAfterWrite.TrimExpired();
 
             lru.Count.Should().Be(0);
         }
@@ -177,7 +177,7 @@ public async Task WhenCacheHasExpiredAndFreshItemsExpireRemovesOnlyExpiredItems(
             lru.GetOrAdd(2, valueFactory.Create);
             lru.GetOrAdd(3, valueFactory.Create);
 
-            lru.TrimExpired();
+            lru.Policy.ExpireAfterWrite.TrimExpired();
 
             lru.Count.Should().Be(3);
         }

BitFaster.Caching.UnitTests/Lru/FastConcurrentTLruTests.cs

@@ -49,7 +49,7 @@ public async Task WhenItemsAreExpiredExpireRemovesExpiredItems()
 
             await Task.Delay(ttl * 2);
 
-            lru.TrimExpired();
+            lru.Policy.ExpireAfterWrite.TrimExpired();
 
             lru.Count.Should().Be(0);
         }

BitFaster.Caching/Lru/ConcurrentLruCore.cs

@@ -28,7 +28,7 @@ namespace BitFaster.Caching.Lru
     /// 5. When warm is full, warm tail is moved to warm head or cold depending on WasAccessed.
     /// 6. When cold is full, cold tail is moved to warm head or removed from dictionary on depending on WasAccessed.
     /// </remarks>
-    public class ConcurrentLruCore<K, V, I, P, T> : ICache<K, V>, IAsyncCache<K, V>, IBoundedPolicy, ITimePolicy, IEnumerable<KeyValuePair<K, V>>
+    public class ConcurrentLruCore<K, V, I, P, T> : ICache<K, V>, IAsyncCache<K, V>, IEnumerable<KeyValuePair<K, V>>
         where I : LruItem<K, V>
         where P : struct, IItemPolicy<K, V, I>
         where T : struct, ITelemetryPolicy<K, V>
@@ -53,8 +53,6 @@ public class ConcurrentLruCore<K, V, I, P, T> : ICache<K, V>, IAsyncCache<K, V>,
         // if mutate methods are called. Therefore, field must be mutable to maintain count.
         protected T telemetryPolicy;
 
-        private readonly CachePolicy policy;
-
         public ConcurrentLruCore(
             int concurrencyLevel,
             ICapacityPartition capacity,
@@ -85,8 +83,6 @@ public ConcurrentLruCore(
             this.itemPolicy = itemPolicy;
             this.telemetryPolicy = telemetryPolicy;
             this.telemetryPolicy.SetEventSource(this);
-
-            this.policy = new CachePolicy(this, this);
         }
 
         // No lock count: https://arbel.net/2013/02/03/best-practices-for-using-concurrentdictionary/
@@ -102,6 +98,8 @@ public ConcurrentLruCore(
         ///<inheritdoc/>
         public ICacheEvents<K, V> Events => new Proxy(this);
 
+        public CachePolicy Policy => CreatePolicy(this);
+
         public int HotCount => this.hotCount;
 
         public int WarmCount => this.warmCount;
@@ -113,12 +111,6 @@ public ConcurrentLruCore(
         /// </summary>
         public ICollection<K> Keys => this.dictionary.Keys;
 
-        public CachePolicy Policy => this.policy;
-
-        public bool CanExpire => this.itemPolicy.CanDiscard();
-
-        public TimeSpan TimeToLive => this.itemPolicy.TimeToLive;
-
         /// <summary>Returns an enumerator that iterates through the cache.</summary>
         /// <returns>An enumerator for the cache.</returns>
         /// <remarks>
@@ -350,11 +342,11 @@ public void Trim(int itemCount)
             TrimLiveItems(itemsRemoved, itemCount, capacity);
         }
 
-        public void TrimExpired()
+        private void TrimExpired()
         {
             if (this.itemPolicy.CanDiscard())
             {
-                TrimAllDiscardedItems();
+                this.TrimAllDiscardedItems();
             }
         }
 
@@ -631,14 +623,20 @@ IEnumerator IEnumerable.GetEnumerator()
             return ((ConcurrentLruCore<K, V, I, P, T>)this).GetEnumerator();
         }
 
+        private static CachePolicy CreatePolicy(ConcurrentLruCore<K, V, I, P, T> lru)
+        { 
+            var p = new Proxy(lru); 
+            return new CachePolicy(p, p); 
+        }
+
         // To get JIT optimizations, policies must be structs.
         // If the structs are returned directly via properties, they will be copied. Since  
         // telemetryPolicy is a mutable struct, copy is bad. One workaround is to store the 
         // state within the struct in an object. Since the struct points to the same object
         // it becomes immutable. However, this object is then somewhere else on the 
         // heap, which slows down the policies with hit counter logic in benchmarks. Likely
         // this approach keeps the structs data members in the same CPU cache line as the LRU.
-        private class Proxy : ICacheMetrics, ICacheEvents<K, V>
+        private class Proxy : ICacheMetrics, ICacheEvents<K, V>, IBoundedPolicy, ITimePolicy
         {
             private readonly ConcurrentLruCore<K, V, I, P, T> lru;
 
@@ -659,11 +657,27 @@ public Proxy(ConcurrentLruCore<K, V, I, P, T> lru)
 
             public bool IsEnabled => (lru.telemetryPolicy as ICacheMetrics).IsEnabled;
 
+            public int Capacity => lru.Capacity;
+
+            public bool CanExpire => lru.itemPolicy.CanDiscard();
+
+            public TimeSpan TimeToLive => lru.itemPolicy.TimeToLive;
+
             public event EventHandler<ItemRemovedEventArgs<K, V>> ItemRemoved
             {
                 add { this.lru.telemetryPolicy.ItemRemoved += value; }
                 remove { this.lru.telemetryPolicy.ItemRemoved -= value; }
             }
+
+            public void Trim(int itemCount)
+            {
+                lru.Trim(itemCount);
+            }
+
+            public void TrimExpired()
+            {
+                lru.TrimExpired();
+            }
         }
     }
 }