fix ctor rounding (#71)

Author: bitfaster

BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs

@@ -49,6 +49,34 @@ public void WhenComparerIsNullCtorThrows()
             constructor.Should().Throw<ArgumentNullException>();
         }
 
+        [Fact]
+        public void WhenCapacityIs4HotHasCapacity1AndColdHasCapacity2()
+        {
+            var lru = new ConcurrentLru<int, int>(4);
+
+            for (int i = 0; i < 5; i++)
+            {
+                lru.GetOrAdd(i, x => x);
+            }
+
+            lru.HotCount.Should().Be(1);
+            lru.ColdCount.Should().Be(2);
+        }
+
+        [Fact]
+        public void WhenCapacityIs5HotHasCapacity2AndColdHasCapacity2()
+        {
+            var lru = new ConcurrentLru<int, int>(5);
+
+            for (int i = 0; i < 5; i++)
+            {
+                lru.GetOrAdd(i, x => x);
+            }
+
+            lru.HotCount.Should().Be(2);
+            lru.ColdCount.Should().Be(2);
+        }
+
         [Fact]
         public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue()
         {

BitFaster.Caching/Lru/TemplateConcurrentLru.cs

@@ -68,11 +68,12 @@ public TemplateConcurrentLru(
             if (comparer == null)
             {
                 throw new ArgumentNullException(nameof(comparer));
-            }    
-
-            this.hotCapacity = capacity / 3;
-            this.warmCapacity = capacity / 3;
-            this.coldCapacity = capacity / 3;
+            }
+
+            var queueCapacity = ComputeQueueCapacity(capacity);
+            this.hotCapacity = queueCapacity.hot;
+            this.warmCapacity = queueCapacity.warm;
+            this.coldCapacity = queueCapacity.cold;
 
             this.hotQueue = new ConcurrentQueue<I>();
             this.warmQueue = new ConcurrentQueue<I>();
@@ -387,5 +388,27 @@ private void Move(I item, ItemDestination where)
                     break;
             }
         }
+
+        private static (int hot, int warm, int cold) ComputeQueueCapacity(int capacity)
+        {
+            int hotCapacity = capacity / 3;
+            int warmCapacity = capacity / 3;
+            int coldCapacity = capacity / 3;
+
+            int remainder = capacity % 3;
+
+            switch (remainder)
+            {
+                case 1:
+                    coldCapacity++;
+                    break;
+                case 2:
+                    hotCapacity++;
+                    coldCapacity++;
+                    break;
+            }
+
+            return (hotCapacity, warmCapacity, coldCapacity);
+        }
     }
 }