fast naming convention (#14)

Author: bitfaster

Lightweight.Caching/Lru/ConcurrentLru.cs

@@ -12,5 +12,7 @@ public ConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K> co
             : base(concurrencyLevel, capacity, comparer, new LruPolicy<K, V>(), new HitCounter())
         {
         }
+
+        public double HitRatio => this.hitCounter.HitRatio;
     }
 }

Lightweight.Caching/Lru/ConcurrentLruTemplate.cs

@@ -32,7 +32,7 @@ public class ConcurrentLruTemplate<K, V, I, P, H> : ICache<K, V>
 
 		// Since H is a struct, making it readonly will force the runtime to make defensive copies
 		// if mutate methods are called. Therefore, field must be mutable to maintain count.
-		private H hitCounter;
+		protected H hitCounter;
 
 		public ConcurrentLruTemplate(
 			int concurrencyLevel,
@@ -58,7 +58,7 @@ public ConcurrentLruTemplate(
 
 		public int Count => this.hotCount + this.warmCount + this.coldCount;
 
-		public double HitRatio => this.hitCounter.HitRatio;
+		
 
 		public int HotCount => this.hotCount;
 

Lightweight.Caching/Lru/ConcurrentTLru.cs

@@ -12,5 +12,7 @@ public ConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> c
             : base(concurrencyLevel, capacity, comparer, new TlruPolicy<K, V>(timeToLive), new HitCounter())
         {
         }
+
+        public double HitRatio => this.hitCounter.HitRatio;
     }
 }

Lightweight.Caching/Lru/FastConcurrentLru.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Lightweight.Caching.Lru
+{
+    public sealed class FastConcurrentLru<K, V> : ConcurrentLruTemplate<K, V, LruItem<K, V>, LruPolicy<K, V>, NullHitCounter>
+    {
+        public FastConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)
+            : base(concurrencyLevel, capacity, comparer, new LruPolicy<K, V>(), new NullHitCounter())
+        {
+        }
+    }
+}

Lightweight.Caching/Lru/FastConcurrentTLru.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Lightweight.Caching.Lru
+{
+    public class FastConcurrentTLru<K, V> : ConcurrentLruTemplate<K, V, TimeStampedLruItem<K, V>, TlruPolicy<K, V>, NullHitCounter>
+    {
+        public FastConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)
+            : base(concurrencyLevel, capacity, comparer, new TlruPolicy<K, V>(timeToLive), new NullHitCounter())
+        {
+        }
+    }
+}

README.md

@@ -13,6 +13,7 @@ LRU implementations are intended as an alternative to the System.Runtime.Caching
 | ClassicLru       | Bounded size LRU based with strict ordering.<br><br>Use if ordering is important, but data structures are synchronized with a lock which limits scalability. |
 | ConcurrentLru       |  Bounded size pseudo LRU.<br><br>For when you   want a ConcurrentDictionary, but with bounded size. Maintains psuedo order, but is faster than ClassicLru and not prone to lock contention. |
 | ConcurrentTlru        | Bounded size pseudo LRU, items have TTL.<br><br>Same as ConcurrentLru, but with a [time aware least recently used (TLRU)](https://en.wikipedia.org/wiki/Cache_replacement_policies#Time_aware_least_recently_used_(TLRU)) eviction policy. |
+| FastConcurrentLru/FastConcurrentTLru      | Same as ConcurrentLru/ConcurrentTLru, but with hit counting logic eliminated making them about 10% faster.   |
 | SingletonCache      | Cache singletons by key. Discard when not in use. <br><br> Cache a semaphore per user, where user population is large, but active user count is low.   |
 
 # Performance