jmh module

Author: richardstartin

fastfilter/src/main/java/org/fastfilter/bloom/count/SuccinctCountingBlockedBloomRanked.java

@@ -63,7 +63,7 @@ public long getBitCount() {
         this.seed = Hash.randomSeed();
         long bits = (long) entryCount * bitsPerKey;
         this.buckets = (int) bits / 64;
-        int arrayLength = (int) (buckets + 16);
+        int arrayLength = buckets + 16;
         data = new long[arrayLength];
         counts = new long[arrayLength];
         overflow = new long[100 + arrayLength * 10 / 100];

jmh/src/main/java/org/fastfilter/ConstructionBenchmark.java

@@ -0,0 +1,16 @@
+package org.fastfilter;
+
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+
+import java.util.concurrent.TimeUnit;
+
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+public class ConstructionBenchmark {
+
+    @Benchmark
+    public Filter construct(FilterConstructionState state) {
+        return state.getConstructor().construct(state.getKeys(), 64);
+    }
+}

jmh/src/main/java/org/fastfilter/Environment.java

@@ -0,0 +1,5 @@
+package org.fastfilter;
+
+public class Environment {
+    public static int SEED = Integer.parseInt(System.getProperty("org.fastfilter.seed", "0"));
+}

jmh/src/main/java/org/fastfilter/FilterConstructionState.java

@@ -0,0 +1,50 @@
+package org.fastfilter;
+
+import org.openjdk.jmh.annotations.*;
+
+@State(Scope.Benchmark)
+public class FilterConstructionState {
+
+    @Param({"1048576", "2097152"})
+    int size;
+
+    @Param({"RANDOM32", "RANDOM64"})
+    KeyGenerationStrategy kgs;
+
+    @Param({"BLOOM",
+            "COUNTING_BLOOM",
+            "SUCCINCT_COUNTING_BLOOM",
+            "SUCCINCT_COUNTING_BLOOM_RANKED",
+            "BLOCKED_BLOOM",
+            "SUCCINCT_COUNTING_BLOCKED_BLOOM",
+            "SUCCINCT_COUNTING_BLOCKED_BLOOM_RANKED",
+            "XOR_SIMPLE",
+            "XOR_SIMPLE_2",
+            "XOR_8",
+            "XOR_16",
+            "XOR_PLUS_8",
+            "CUCKOO_8",
+            "CUCKOO_16",
+            "CUCKOO_PLUS_8",
+            "CUCKOO_PLUS_16",
+            "GCS",
+            "GCS2",
+            "MPHF"})
+    FilterType type;
+
+    long[] keys;
+
+    public long[] getKeys() {
+        return keys;
+    }
+
+    public FilterType getConstructor() {
+        return type;
+    }
+
+    @Setup(Level.Trial)
+    public void init() {
+        this.keys = new long[size];
+        kgs.fill(keys);
+    }
+}

jmh/src/main/java/org/fastfilter/FilterQueryState.java

@@ -0,0 +1,60 @@
+package org.fastfilter;
+
+import org.openjdk.jmh.annotations.*;
+
+@State(Scope.Benchmark)
+public class FilterQueryState extends FilterConstructionState {
+
+    @AuxCounters
+    static class Counters {
+        private final long bitCount;
+        int workDone;
+        int found;
+        int notFound;
+
+        Counters(Filter filter) {
+            this.bitCount = filter.getBitCount();
+        }
+    }
+
+    @Param({"10", "15", "20", "25"})
+    int logDistinctLookups;
+
+    @Param({"0.1", "0.5", "0.9"})
+    float trueMatchProbability;
+
+    private long[] keysToFind;
+    private Counters counters;
+
+    public void found() {
+        ++counters.found;
+    }
+
+    public void notFound() {
+        ++counters.notFound;
+    }
+
+    Filter filter;
+
+    public Filter getFilter() {
+        return filter;
+    }
+
+    public long nextKey() {
+        return keysToFind[(counters.workDone++) & (keysToFind.length - 1)];
+    }
+
+    @Override
+    @Setup(Level.Trial)
+    public void init() {
+        super.init();
+        filter = type.construct(keys, 64);
+        keysToFind = new long[1 << logDistinctLookups];
+        int memberCount = (int)(trueMatchProbability * keysToFind.length);
+        if (memberCount > keys.length) {
+            throw new AssertionError("Benchmark setup error: expect at least "
+                    + memberCount + " keys  but have " + keys.length);
+        }
+        System.arraycopy(keys, 0, keysToFind, 0, memberCount);
+    }
+}

jmh/src/main/java/org/fastfilter/KeyGenerationStrategy.java

@@ -0,0 +1,26 @@
+package org.fastfilter;
+
+import java.util.SplittableRandom;
+
+public enum KeyGenerationStrategy {
+    RANDOM64 {
+        SplittableRandom random = new SplittableRandom(Environment.SEED);
+        @Override
+        void fill(long[] keys) {
+            for (int i = 0; i < keys.length; ++i) {
+                keys[i] = random.nextLong();
+            }
+        }
+    },
+    RANDOM32 {
+        SplittableRandom random = new SplittableRandom(Environment.SEED);
+        @Override
+        void fill(long[] keys) {
+            for (int i = 0; i < keys.length; ++i) {
+                keys[i] = random.nextInt();
+            }
+        }
+    };
+
+    abstract void fill(long[] keys);
+}