count evicted

BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs

@@ -261,6 +261,23 @@ public void WhenMoreKeysRequestedThanCapacityOldestItemIsEvicted()
             valueFactory.timesCalled.Should().Be(capacity + 2);
         }
 
+        [Fact]
+        public void WhenMoreKeysRequestedThanCapacityEvictedMetricRecordsNumberEvicted()
+        {
+            // request 3 items, LRU is now full
+            for (int i = 0; i < capacity; i++)
+            {
+                lru.GetOrAdd(i, valueFactory.Create);
+            }
+
+            lru.Metrics.Evicted.Should().Be(0);
+
+            // request 0, now item 1 is to be evicted
+            lru.GetOrAdd(4, valueFactory.Create);
+
+            lru.Metrics.Evicted.Should().Be(1);
+        }
+
         [Fact]
         public void WhenValueExpiresItIsDisposed()
         {

BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs

@@ -494,6 +494,16 @@ public void WhenValueEvictedItemRemovedEventIsFired()
             removedItems[1].Reason.Should().Be(ItemRemovedReason.Evicted);
         }
 
+        [Fact]
+        public void WhenValuesAreEvictedEvictionMetricCountsEvicted()
+        {
+            this.Warmup();
+
+            this.lru.GetOrAdd(1, valueFactory.Create);
+
+            this.lru.Metrics.Evicted.Should().Be(1);
+        }
+
         [Fact]
         public void WhenItemRemovedEventIsUnregisteredEventIsNotFired()
         {

BitFaster.Caching.UnitTests/Lru/NoTelemetryPolicyTests.cs

@@ -35,6 +35,12 @@ public void MissesIsZero()
             counter.Misses.Should().Be(0);
         }
 
+        [Fact]
+        public void EvictedIsZero()
+        {
+            counter.Evicted.Should().Be(0);
+        }
+
         [Fact]
         public void IsEnabledIsFalse()
         {

BitFaster.Caching.UnitTests/Lru/TelemetryPolicyTests.cs

@@ -64,6 +64,22 @@ public void WhenTotalCountIsZeroRatioReturnsZero()
             telemetryPolicy.HitRatio.Should().Be(0.0);
         }
 
+        [Fact]
+        public void WhenItemRemovedIsEvictedIncrementEvictedCount()
+        {
+            telemetryPolicy.OnItemRemoved(1, 2, ItemRemovedReason.Evicted);
+
+            telemetryPolicy.Evicted.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenItemRemovedIsRemovedDontIncrementEvictedCount()
+        {
+            telemetryPolicy.OnItemRemoved(1, 2, ItemRemovedReason.Removed);
+
+            telemetryPolicy.Evicted.Should().Be(0);
+        }
+
         [Fact]
         public void WhenOnItemRemovedInvokedEventIsFired()
         {

BitFaster.Caching/ICacheMetrics.cs

@@ -33,6 +33,11 @@ public interface ICacheMetrics
         /// </summary>
         long Misses { get; }
 
+        /// <summary>
+        /// Gets the total number of evicted items.
+        /// </summary>
+        long Evicted { get; }
+
         /// <summary>
         /// Gets a value indicating whether metrics are enabled.
         /// </summary>

BitFaster.Caching/Lru/ClassicLru.cs

@@ -135,6 +135,7 @@ public V GetOrAdd(K key, Func<K, V> valueFactory)
                 {
                     dictionary.TryRemove(first.Value.Key, out var removed);
 
+                    Interlocked.Increment(ref this.metrics.evictedCount);
                     Disposer<V>.Dispose(removed.Value.Value);
                 }
 
@@ -179,6 +180,7 @@ public async Task<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
                 {
                     dictionary.TryRemove(first.Value.Key, out var removed);
 
+                    Interlocked.Increment(ref this.metrics.evictedCount);
                     Disposer<V>.Dispose(removed.Value.Value);
                 }
 
@@ -267,6 +269,7 @@ public void AddOrUpdate(K key, V value)
                 {
                     dictionary.TryRemove(first.Value.Key, out var removed);
 
+                    Interlocked.Increment(ref this.metrics.evictedCount);
                     Disposer<V>.Dispose(removed.Value.Value);
                 }
 
@@ -374,6 +377,7 @@ private class CacheMetrics : ICacheMetrics
         {
             public long requestHitCount;
             public long requestTotalCount;
+            public long evictedCount;
 
             public double HitRatio => (double)requestHitCount / (double)requestTotalCount;
 
@@ -383,6 +387,8 @@ private class CacheMetrics : ICacheMetrics
 
             public long Misses => requestTotalCount - requestHitCount;
 
+            public long Evicted => evictedCount;
+
             public bool IsEnabled => true;
         }
     }

BitFaster.Caching/Lru/NoTelemetryPolicy.cs

@@ -17,6 +17,8 @@ public struct NoTelemetryPolicy<K, V> : ITelemetryPolicy<K, V>
 
         public long Misses => 0;
 
+        public long Evicted => 0;
+
         public bool IsEnabled => false;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

BitFaster.Caching/Lru/TelemetryPolicy.cs

@@ -12,6 +12,7 @@ public struct TelemetryPolicy<K, V> : ITelemetryPolicy<K, V>
     {
         private long hitCount;
         private long missCount;
+        private long evictedCount;
         private object eventSource;
 
         public double HitRatio => Total == 0 ? 0 : (double)hitCount / (double)Total;
@@ -22,6 +23,8 @@ public struct TelemetryPolicy<K, V> : ITelemetryPolicy<K, V>
 
         public long Misses => this.missCount;
 
+        public long Evicted => this.evictedCount;
+
         public bool IsEnabled => true;
 
         public EventHandler<ItemRemovedEventArgs<K, V>> ItemRemoved;
@@ -38,6 +41,11 @@ public void IncrementHit()
 
         public void OnItemRemoved(K key, V value, ItemRemovedReason reason)
         {
+            if (reason == ItemRemovedReason.Evicted)
+            {
+                Interlocked.Increment(ref this.evictedCount);
+            }
+
             // passing 'this' as source boxes the struct, and is anyway the wrong object
             this.ItemRemoved?.Invoke(this.eventSource, new ItemRemovedEventArgs<K, V>(key, value, reason));
         }