block sketch (#271)

* block

* cleanup

* fix xml doc warning

* block2

* tests

* rem thru

* runner

* segblock

* stackalloc

* seg block avx

* reconcile

* use segment

* cleanup

* remarks

* cleanup2

Author: bitfaster

BitFaster.Caching.Benchmarks/Lfu/SketchFrequency.cs

@@ -11,9 +11,11 @@ namespace BitFaster.Caching.Benchmarks.Lfu
     [HideColumns("Job", "Median", "RatioSD", "Alloc Ratio")]
     public class SketchFrequency
     {
-        const int iterations = 512;
-        private static CmSketch<int, DisableHardwareIntrinsics> std = new CmSketch<int, DisableHardwareIntrinsics>(10, EqualityComparer<int>.Default);
-        private static CmSketch<int, DetectIsa> avx = new CmSketch<int, DetectIsa>(10, EqualityComparer<int>.Default);
+        const int sketchSize = 1_048_576;
+        const int iterations = 1_048_576;
+        
+        private static CmSketch<int, DisableHardwareIntrinsics> std = new CmSketch<int, DisableHardwareIntrinsics>(sketchSize, EqualityComparer<int>.Default);
+        private static CmSketch<int, DetectIsa> avx = new CmSketch<int, DetectIsa>(sketchSize, EqualityComparer<int>.Default);
 
         [GlobalSetup]
         public void Setup()
@@ -28,16 +30,24 @@ public void Setup()
             }
         }
 
-        [Benchmark(Baseline = true)]
-        public bool EstimateFrequency()
+        [Benchmark(Baseline = true, OperationsPerInvoke = iterations)]
+        public int EstimateFrequency()
         {
-            return std.EstimateFrequency(1) > std.EstimateFrequency(2);
+            int count = 0;
+            for (int i = 0; i < iterations; i++)
+                count += std.EstimateFrequency(i) > std.EstimateFrequency(i + 1) ? 1: 0;
+
+            return count;
         }
 
-        [Benchmark()]
-        public bool EstimateFrequencyAvx()
+        [Benchmark(OperationsPerInvoke = iterations)]
+        public int EstimateFrequencyAvx()
         {
-            return avx.EstimateFrequency(1) > avx.EstimateFrequency(2);
+            int count = 0;
+            for (int i = 0; i < iterations; i++)
+                count += avx.EstimateFrequency(i) > avx.EstimateFrequency(i + 1) ? 1 : 0;
+
+            return count;
         }
     }
 }

BitFaster.Caching.Benchmarks/Lfu/SketchIncrement.cs

@@ -11,11 +11,12 @@ namespace BitFaster.Caching.Benchmarks.Lfu
     [HideColumns("Job", "Median", "RatioSD", "Alloc Ratio")]
     public class SketchIncrement
     {
-        const int iterations = 1024;
-        private static CmSketch<int, DisableHardwareIntrinsics> std = new CmSketch<int, DisableHardwareIntrinsics>(10, EqualityComparer<int>.Default);
-        private static CmSketch<int, DetectIsa> avx = new CmSketch<int, DetectIsa>(10, EqualityComparer<int>.Default);
+        const int sketchSize = 1_048_576;
+        const int iterations = 1_048_576;
+        private static CmSketch<int, DisableHardwareIntrinsics> std = new CmSketch<int, DisableHardwareIntrinsics>(sketchSize, EqualityComparer<int>.Default);
+        private static CmSketch<int, DetectIsa> avx = new CmSketch<int, DetectIsa>(sketchSize, EqualityComparer<int>.Default);
 
-        [Benchmark(Baseline = true)]
+        [Benchmark(Baseline = true, OperationsPerInvoke = iterations)]
         public void Inc()
         {
             for (int i = 0; i < iterations; i++)
@@ -24,7 +25,7 @@ public void Inc()
             }
         }
 
-        [Benchmark()]
+        [Benchmark(OperationsPerInvoke = iterations)]
         public void IncAvx()
         {
             for (int i = 0; i < iterations; i++)

BitFaster.Caching.ThroughputAnalysis/Runner.cs

@@ -24,6 +24,7 @@ public static void Run(Mode mode, int cacheSize)
 
         private static void RunTest(Mode mode, int cacheSize)
         {
+            Console.WriteLine();
             Console.WriteLine("Generating input distribution...");
 
             var (bench, dataConfig, capacity) = ConfigFactory.Create(mode, cacheSize, maxThreads);

BitFaster.Caching.UnitTests/Intrinsics.cs

@@ -0,0 +1,15 @@
+
+using System.Runtime.Intrinsics.X86;
+using Xunit;
+
+namespace BitFaster.Caching.UnitTests
+{
+    public static class Intrinsics
+    {
+        public static void SkipAvxIfNotSupported<I>()
+        {
+            // when we are trying to test Avx2, skip the test if it's not supported
+            Skip.If(typeof(I) == typeof(DetectIsa) && !Avx2.IsSupported);
+        }
+    }
+}

BitFaster.Caching.UnitTests/Lfu/CmSketchTests.cs

@@ -1,8 +1,7 @@
 
+using System.Collections.Generic;
 using BitFaster.Caching.Lfu;
 using FluentAssertions;
-using System.Collections.Generic;
-using System.Runtime.Intrinsics.X86;
 using Xunit;
 
 namespace BitFaster.Caching.UnitTests.Lfu
@@ -23,9 +22,24 @@ public abstract class CmSketchTestBase<I> where I : struct, IsaProbe
 
         public CmSketchTestBase()
         {
-            SkipAvxIfNotSupported();
+            Intrinsics.SkipAvxIfNotSupported<I>();
+        }
+
+        [SkippableFact]
+        public void Repro()
+        {
+            sketch = new CmSketch<int, I>(1_048_576, EqualityComparer<int>.Default);
+
+            for (int i = 0; i < 1_048_576; i++)
+            {
+                if (i % 3 == 0)
+                {
+                    sketch.Increment(i);
+                }
+            }
         }
 
+
         [SkippableFact]
         public void WhenCapacityIsZeroDefaultsSelected()
         {
@@ -100,10 +114,48 @@ public void WhenClearedCountIsReset()
             sketch.EstimateFrequency(2).Should().Be(0);
         }
 
-        private static void SkipAvxIfNotSupported()
+        [SkippableFact]
+        public void HeavyHitters()
         {
-            // when we are trying to test Avx2, skip the test if it's not supported
-            Skip.If(typeof(I) == typeof(DetectIsa) && !Avx2.IsSupported);
+            for (int i = 100; i < 100_000; i++)
+            {
+                sketch.Increment(i);
+            }
+            for (int i = 0; i < 10; i += 2)
+            {
+                for (int j = 0; j < i; j++)
+                {
+                    sketch.Increment(i);
+                }
+            }
+
+            // A perfect popularity count yields an array [0, 0, 2, 0, 4, 0, 6, 0, 8, 0]
+            int[] popularity = new int[10];
+
+            for (int i = 0; i < 10; i++)
+            {
+                popularity[i] = sketch.EstimateFrequency(i);
+            }
+
+            for (int i = 0; i < popularity.Length; i++)
+            {
+                if ((i == 0) || (i == 1) || (i == 3) || (i == 5) || (i == 7) || (i == 9))
+                {
+                    popularity[i].Should().BeLessThanOrEqualTo(popularity[2]);
+                }
+                else if (i == 2)
+                {
+                    popularity[2].Should().BeLessThanOrEqualTo(popularity[4]);
+                }
+                else if (i == 4)
+                {
+                    popularity[4].Should().BeLessThanOrEqualTo(popularity[6]);
+                }
+                else if (i == 6)
+                {
+                    popularity[6].Should().BeLessThanOrEqualTo(popularity[8]);
+                }
+            }
         }
     }
 }