count once (#24)

bitfaster · web-flow · commit 9f1abbdfd989 · 2020-06-14T15:29:05.000-07:00
diff --git a/BitFaster.Caching.Benchmarks/Program.cs b/BitFaster.Caching.Benchmarks/Program.cs
@@ -15,7 +15,7 @@ class Program
         static void Main(string[] args)
         {
             var summary = BenchmarkRunner
-                .Run<LruCycle2>(ManualConfig.Create(DefaultConfig.Instance)
+                .Run<MissHitHitRemove>(ManualConfig.Create(DefaultConfig.Instance)
                 .AddJob(Job.RyuJitX64));
         }
     }
diff --git a/BitFaster.Caching.UnitTests/Lru/HitCounterTests.cs b/BitFaster.Caching.UnitTests/Lru/HitCounterTests.cs
@@ -13,20 +13,19 @@ public class HitCounterTests
         public void WhenHitCountAndTotalCountAreEqualRatioIs1()
         {
             HitCounter counter = new HitCounter();
-            counter.IncrementTotalCount();
-            counter.IncrementHitCount();
+
+            counter.IncrementHit();
 
             counter.HitRatio.Should().Be(1.0);
         }
 
         [Fact]
-        public void WhenHitCountIsHalfTotalCountRatioIsHalf()
+        public void WhenHitCountIsEqualToMissCountRatioIsHalf()
         {
             HitCounter counter = new HitCounter();
 
-            counter.IncrementTotalCount();
-            counter.IncrementTotalCount();
-            counter.IncrementHitCount();
+            counter.IncrementMiss();
+            counter.IncrementHit();
 
             counter.HitRatio.Should().Be(0.5);
         }
@@ -36,8 +35,6 @@ public void WhenTotalCountIsZeroRatioReturnsZero()
         {
             HitCounter counter = new HitCounter();
 
-            counter.IncrementHitCount();
-
             counter.HitRatio.Should().Be(0.0);
         }
     }
diff --git a/BitFaster.Caching.UnitTests/Lru/NullHitCounterTests.cs b/BitFaster.Caching.UnitTests/Lru/NullHitCounterTests.cs
@@ -20,13 +20,13 @@ public void HitRatioIsZero()
         [Fact]
         public void IncrementHitCountIsNoOp()
         {
-            counter.Invoking(c => c.IncrementHitCount()).Should().NotThrow();
+            counter.Invoking(c => c.IncrementHit()).Should().NotThrow();
         }
 
         [Fact]
         public void IncrementTotalCountIsNoOp()
         {
-            counter.Invoking(c => c.IncrementTotalCount()).Should().NotThrow();
+            counter.Invoking(c => c.IncrementMiss()).Should().NotThrow();
         }
     }
 }
diff --git a/BitFaster.Caching/Lru/HitCounter.cs b/BitFaster.Caching/Lru/HitCounter.cs
@@ -10,19 +10,21 @@ namespace BitFaster.Caching.Lru
 {
     public struct HitCounter : IHitCounter
     {
-        private long requestHitCount;
-        private long requestTotalCount;
+        private long hitCount;
+        private long missCount;
 
-        public double HitRatio => requestTotalCount == 0 ? 0 : (double)requestHitCount / (double)requestTotalCount;
+        public double HitRatio => Total == 0 ? 0 : (double)hitCount / (double)Total;
 
-        public void IncrementTotalCount()
+        public long Total => this.hitCount + this.missCount;
+
+        public void IncrementMiss()
         {
-            Interlocked.Increment(ref this.requestTotalCount);
+            Interlocked.Increment(ref this.missCount);
         }
 
-        public void IncrementHitCount()
+        public void IncrementHit()
         {
-            Interlocked.Increment(ref this.requestHitCount);
+            Interlocked.Increment(ref this.hitCount);
         }
     }
 }
diff --git a/BitFaster.Caching/Lru/IHitCounter.cs b/BitFaster.Caching/Lru/IHitCounter.cs
@@ -8,9 +8,9 @@ namespace BitFaster.Caching.Lru
 {
     public interface IHitCounter
     {
-        void IncrementTotalCount();
+        void IncrementMiss();
 
-        void IncrementHitCount();
+        void IncrementHit();
 
         double HitRatio { get; }
     }
diff --git a/BitFaster.Caching/Lru/NullHitCounter.cs b/BitFaster.Caching/Lru/NullHitCounter.cs
@@ -12,12 +12,12 @@ public struct NullHitCounter : IHitCounter
         public double HitRatio => 0.0;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void IncrementTotalCount()
+        public void IncrementMiss()
         {
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void IncrementHitCount()
+        public void IncrementHit()
         {
         }
     }
diff --git a/BitFaster.Caching/Lru/TemplateConcurrentLru.cs b/BitFaster.Caching/Lru/TemplateConcurrentLru.cs
@@ -94,8 +94,6 @@ public TemplateConcurrentLru(
 
         public bool TryGet(K key, out V value)
         {
-            this.hitCounter.IncrementTotalCount();
-
             I item;
             if (dictionary.TryGetValue(key, out item))
             {
@@ -108,11 +106,12 @@ public bool TryGet(K key, out V value)
 
                 value = item.Value;
                 this.policy.Touch(item);
-                this.hitCounter.IncrementHitCount();
+                this.hitCounter.IncrementHit();
                 return true;
             }
 
             value = default(V);
+            this.hitCounter.IncrementMiss();
             return false;
         }
 
@@ -124,7 +123,7 @@ public V GetOrAdd(K key, Func<K, V> valueFactory)
             }
 
             // The value factory may be called concurrently for the same key, but the first write to the dictionary wins.
-            // This is identical logic to the ConcurrentDictionary.GetOrAdd method.
+            // This is identical logic in ConcurrentDictionary.GetOrAdd method.
             var newItem = this.policy.CreateItem(key, valueFactory(key));
 
             if (this.dictionary.TryAdd(key, newItem))
@@ -146,7 +145,7 @@ public async Task<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
             }
 
             // The value factory may be called concurrently for the same key, but the first write to the dictionary wins.
-            // This is identical logic to the ConcurrentDictionary.GetOrAdd method.
+            // This is identical logic in ConcurrentDictionary.GetOrAdd method.
             var newItem = this.policy.CreateItem(key, await valueFactory(key).ConfigureAwait(false));
 
             if (this.dictionary.TryAdd(key, newItem))
diff --git a/README.md b/README.md
@@ -43,32 +43,31 @@ Cache contains 6 items which are fetched repeatedly, no items are evicted. Repre
 
 FastConcurrentLru does not allocate and is approximately 10x faster than MemoryCache.
 
-|                       Method |      Mean |    Error |   StdDev | Ratio |  Gen 0 | Allocated |
-|----------------------------- |----------:|---------:|---------:|------:|-------:|----------:|
-| ConcurrentDictionaryGetOrAdd |  18.72 ns | 0.289 ns | 0.641 ns |  1.00 |      - |         - |
-|    FastConcurrentLruGetOrAdd |  25.64 ns | 0.434 ns | 0.427 ns |  1.35 |      - |         - |
-|        ConcurrentLruGetOrAdd |  35.53 ns | 0.259 ns | 0.216 ns |  1.86 |      - |         - |
-|   FastConcurrentTLruGetOrAdd | 132.75 ns | 1.493 ns | 1.397 ns |  6.96 |      - |         - |
-|       ConcurrentTLruGetOrAdd | 144.87 ns | 2.179 ns | 1.819 ns |  7.59 |      - |         - |
-|           ClassicLruGetOrAdd |  75.67 ns | 1.513 ns | 1.554 ns |  3.99 |      - |         - |
-|      MemoryCacheGetStringKey | 309.14 ns | 2.155 ns | 1.910 ns | 16.17 | 0.0153 |      32 B |
+|               Method |      Mean |    Error |   StdDev | Ratio |  Gen 0 | Allocated |
+|--------------------- |----------:|---------:|---------:|------:|-------:|----------:|
+| ConcurrentDictionary |  15.83 ns | 0.242 ns | 0.215 ns |  1.00 |      - |         - |
+|    FastConcurrentLru |  20.42 ns | 0.319 ns | 0.283 ns |  1.29 |      - |         - |
+|        ConcurrentLru |  24.59 ns | 0.484 ns | 0.594 ns |  1.56 |      - |         - |
+|   FastConcurrentTLru | 110.76 ns | 0.664 ns | 0.518 ns |  6.98 |      - |         - |
+|       ConcurrentTLru | 114.99 ns | 1.652 ns | 1.465 ns |  7.27 |      - |         - |
+|           ClassicLru |  69.01 ns | 0.503 ns | 0.446 ns |  4.36 |      - |         - |
+|          MemoryCache | 257.83 ns | 4.786 ns | 4.700 ns | 16.30 | 0.0153 |      32 B |
 
 ### Mixed workload
 
 Tests 4 operations, 1 miss (adding the item), 2 hits then remove.
 
 This test needs to be improved to provoke queue cycling.
 
-
 |               Method |       Mean |    Error |   StdDev | Ratio |  Gen 0 | Allocated |
 |--------------------- |-----------:|---------:|---------:|------:|-------:|----------:|
-| ConcurrentDictionary |   178.1 ns |  1.47 ns |  1.23 ns |  1.00 | 0.0381 |      80 B |
-|    FastConcurrentLru |   420.4 ns |  7.52 ns |  6.67 ns |  2.36 | 0.0534 |     112 B |
-|        ConcurrentLru |   423.7 ns |  3.17 ns |  2.64 ns |  2.38 | 0.0534 |     112 B |
-|   FastConcurrentTlru |   941.6 ns |  6.69 ns |  5.93 ns |  5.29 | 0.0572 |     120 B |
-|       ConcurrentTlru |   960.3 ns | 17.73 ns | 14.80 ns |  5.39 | 0.0572 |     120 B |
-|           ClassicLru |   363.5 ns |  3.65 ns |  3.23 ns |  2.04 | 0.0763 |     160 B |
-|          MemoryCache | 2,380.9 ns | 33.22 ns | 27.74 ns | 13.37 | 2.3460 |    4912 B |
+| ConcurrentDictionary |   151.7 ns |  2.34 ns |  1.96 ns |  1.00 | 0.0381 |      80 B |
+|    FastConcurrentLru |   369.2 ns |  7.29 ns |  7.16 ns |  2.44 | 0.0534 |     112 B |
+|        ConcurrentLru |   373.6 ns |  2.97 ns |  2.64 ns |  2.46 | 0.0534 |     112 B |
+|   FastConcurrentTlru |   838.6 ns | 11.49 ns | 13.68 ns |  5.53 | 0.0572 |     120 B |
+|       ConcurrentTlru |   852.7 ns | 16.12 ns | 13.46 ns |  5.62 | 0.0572 |     120 B |
+|           ClassicLru |   347.3 ns |  2.67 ns |  2.08 ns |  2.29 | 0.0763 |     160 B |
+|          MemoryCache | 1,987.5 ns | 38.29 ns | 57.31 ns | 13.15 | 2.3460 |    4912 B |
 
 
 ### LruCycle2

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ class Program`
`15`	`15`	`static void Main(string[] args)`
`16`	`16`	`{`
`17`	`17`	`var summary = BenchmarkRunner`
`18`		`- .Run<LruCycle2>(ManualConfig.Create(DefaultConfig.Instance)`
	`18`	`+ .Run<MissHitHitRemove>(ManualConfig.Create(DefaultConfig.Instance)`
`19`	`19`	`.AddJob(Job.RyuJitX64));`
`20`	`20`	`}`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,20 +13,19 @@ public class HitCounterTests`
`13`	`13`	`public void WhenHitCountAndTotalCountAreEqualRatioIs1()`
`14`	`14`	`{`
`15`	`15`	`HitCounter counter = new HitCounter();`
`16`		`- counter.IncrementTotalCount();`
`17`		`- counter.IncrementHitCount();`
	`16`	`+`
	`17`	`+ counter.IncrementHit();`
`18`	`18`
`19`	`19`	`counter.HitRatio.Should().Be(1.0);`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`[Fact]`
`23`		`- public void WhenHitCountIsHalfTotalCountRatioIsHalf()`
	`23`	`+ public void WhenHitCountIsEqualToMissCountRatioIsHalf()`
`24`	`24`	`{`
`25`	`25`	`HitCounter counter = new HitCounter();`
`26`	`26`
`27`		`- counter.IncrementTotalCount();`
`28`		`- counter.IncrementTotalCount();`
`29`		`- counter.IncrementHitCount();`
	`27`	`+ counter.IncrementMiss();`
	`28`	`+ counter.IncrementHit();`
`30`	`29`
`31`	`30`	`counter.HitRatio.Should().Be(0.5);`
`32`	`31`	`}`
`@@ -36,8 +35,6 @@ public void WhenTotalCountIsZeroRatioReturnsZero()`
`36`	`35`	`{`
`37`	`36`	`HitCounter counter = new HitCounter();`
`38`	`37`
`39`		`- counter.IncrementHitCount();`
`40`		`-`
`41`	`38`	`counter.HitRatio.Should().Be(0.0);`
`42`	`39`	`}`
`43`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,13 +20,13 @@ public void HitRatioIsZero()`
`20`	`20`	`[Fact]`
`21`	`21`	`public void IncrementHitCountIsNoOp()`
`22`	`22`	`{`
`23`		`- counter.Invoking(c => c.IncrementHitCount()).Should().NotThrow();`
	`23`	`+ counter.Invoking(c => c.IncrementHit()).Should().NotThrow();`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`[Fact]`
`27`	`27`	`public void IncrementTotalCountIsNoOp()`
`28`	`28`	`{`
`29`		`- counter.Invoking(c => c.IncrementTotalCount()).Should().NotThrow();`
	`29`	`+ counter.Invoking(c => c.IncrementMiss()).Should().NotThrow();`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,19 +10,21 @@ namespace BitFaster.Caching.Lru`
`10`	`10`	`{`
`11`	`11`	`public struct HitCounter : IHitCounter`
`12`	`12`	`{`
`13`		`- private long requestHitCount;`
`14`		`- private long requestTotalCount;`
	`13`	`+ private long hitCount;`
	`14`	`+ private long missCount;`
`15`	`15`
`16`		`- public double HitRatio => requestTotalCount == 0 ? 0 : (double)requestHitCount / (double)requestTotalCount;`
	`16`	`+ public double HitRatio => Total == 0 ? 0 : (double)hitCount / (double)Total;`
`17`	`17`
`18`		`- public void IncrementTotalCount()`
	`18`	`+ public long Total => this.hitCount + this.missCount;`
	`19`	`+`
	`20`	`+ public void IncrementMiss()`
`19`	`21`	`{`
`20`		`- Interlocked.Increment(ref this.requestTotalCount);`
	`22`	`+ Interlocked.Increment(ref this.missCount);`
`21`	`23`	`}`
`22`	`24`
`23`		`- public void IncrementHitCount()`
	`25`	`+ public void IncrementHit()`
`24`	`26`	`{`
`25`		`- Interlocked.Increment(ref this.requestHitCount);`
	`27`	`+ Interlocked.Increment(ref this.hitCount);`
`26`	`28`	`}`
`27`	`29`	`}`
`28`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,9 +8,9 @@ namespace BitFaster.Caching.Lru`
`8`	`8`	`{`
`9`	`9`	`public interface IHitCounter`
`10`	`10`	`{`
`11`		`- void IncrementTotalCount();`
	`11`	`+ void IncrementMiss();`
`12`	`12`
`13`		`- void IncrementHitCount();`
	`13`	`+ void IncrementHit();`
`14`	`14`
`15`	`15`	`double HitRatio { get; }`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,12 +12,12 @@ public struct NullHitCounter : IHitCounter`
`12`	`12`	`public double HitRatio => 0.0;`
`13`	`13`
`14`	`14`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`15`		`- public void IncrementTotalCount()`
	`15`	`+ public void IncrementMiss()`
`16`	`16`	`{`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`20`		`- public void IncrementHitCount()`
	`20`	`+ public void IncrementHit()`
`21`	`21`	`{`
`22`	`22`	`}`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -94,8 +94,6 @@ public TemplateConcurrentLru(`
`94`	`94`
`95`	`95`	`public bool TryGet(K key, out V value)`
`96`	`96`	`{`
`97`		`- this.hitCounter.IncrementTotalCount();`
`98`		`-`
`99`	`97`	`I item;`
`100`	`98`	`if (dictionary.TryGetValue(key, out item))`
`101`	`99`	`{`
`@@ -108,11 +106,12 @@ public bool TryGet(K key, out V value)`
`108`	`106`
`109`	`107`	`value = item.Value;`
`110`	`108`	`this.policy.Touch(item);`
`111`		`- this.hitCounter.IncrementHitCount();`
	`109`	`+ this.hitCounter.IncrementHit();`
`112`	`110`	`return true;`
`113`	`111`	`}`
`114`	`112`
`115`	`113`	`value = default(V);`
	`114`	`+ this.hitCounter.IncrementMiss();`
`116`	`115`	`return false;`
`117`	`116`	`}`
`118`	`117`
`@@ -124,7 +123,7 @@ public V GetOrAdd(K key, Func<K, V> valueFactory)`
`124`	`123`	`}`
`125`	`124`
`126`	`125`	`// The value factory may be called concurrently for the same key, but the first write to the dictionary wins.`
`127`		`- // This is identical logic to the ConcurrentDictionary.GetOrAdd method.`
	`126`	`+ // This is identical logic in ConcurrentDictionary.GetOrAdd method.`
`128`	`127`	`var newItem = this.policy.CreateItem(key, valueFactory(key));`
`129`	`128`
`130`	`129`	`if (this.dictionary.TryAdd(key, newItem))`
`@@ -146,7 +145,7 @@ public async Task<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)`
`146`	`145`	`}`
`147`	`146`
`148`	`147`	`// The value factory may be called concurrently for the same key, but the first write to the dictionary wins.`
`149`		`- // This is identical logic to the ConcurrentDictionary.GetOrAdd method.`
	`148`	`+ // This is identical logic in ConcurrentDictionary.GetOrAdd method.`
`150`	`149`	`var newItem = this.policy.CreateItem(key, await valueFactory(key).ConfigureAwait(false));`
`151`	`150`
`152`	`151`	`if (this.dictionary.TryAdd(key, newItem))`