add parameterised benchmarks for construction and membership tests

Author: richardstartin

jmh/pom.xml

@@ -48,6 +48,28 @@
                     <showDeprecation>true</showDeprecation>
                 </configuration>
             </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.1.0</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <transformers>
+                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                                    <mainClass>org.openjdk.jmh.Main</mainClass>
+                                </transformer>
+                            </transformers>
+                            <finalName>benchmarks</finalName>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 

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

@@ -6,11 +6,11 @@
 
 import java.util.concurrent.TimeUnit;
 
-@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@OutputTimeUnit(TimeUnit.SECONDS)
 public class ConstructionBenchmark {
 
     @Benchmark
-    public Filter construct(FilterConstructionState state) {
+    public Filter construct(ConstructionState state) {
         return state.getConstructor().construct(state.getKeys(), 64);
     }
 }

…/fastfilter/FilterConstructionState.java …va/org/fastfilter/ConstructionState.javajmh/src/main/java/org/fastfilter/FilterConstructionState.java renamed to jmh/src/main/java/org/fastfilter/ConstructionState.java jmh/src/main/java/org/fastfilter/FilterConstructionState.java renamed to jmh/src/main/java/org/fastfilter/ConstructionState.java

@@ -3,7 +3,7 @@
 import org.openjdk.jmh.annotations.*;
 
 @State(Scope.Benchmark)
-public class FilterConstructionState {
+public class ConstructionState {
 
     @Param({"1048576", "2097152"})
     int size;

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

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

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

@@ -1,26 +1,40 @@
 package org.fastfilter;
 
+import java.util.HashSet;
+import java.util.Set;
 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();
-            }
+        long nextKey() {
+            return 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();
-            }
+        long nextKey() {
+            return random.nextInt() & 0xFFFFFFFFL;
         }
     };
 
-    abstract void fill(long[] keys);
+
+    abstract long nextKey();
+    void fill(long[] keys) {
+        Set<Long> distinct = new HashSet<>();
+        for (int i = 0; i < keys.length; ++i) {
+            do {
+                long key = nextKey();
+                if (!distinct.contains(key)) {
+                    keys[i] = key;
+                    distinct.add(key);
+                    break;
+                }
+            } while (true);
+        }
+    }
 }

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

@@ -0,0 +1,19 @@
+package org.fastfilter;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+
+import java.util.concurrent.TimeUnit;
+
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+public class MembershipBenchmark {
+
+    @Benchmark
+    public void mayContain(MembershipState state, MembershipCounters counters) {
+        if (state.getFilter().mayContain(state.nextKey())) {
+            counters.found++;
+        } else {
+            counters.notFound++;
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+package org.fastfilter;
+
+import org.openjdk.jmh.annotations.*;
+
+@State(Scope.Thread)
+@AuxCounters(AuxCounters.Type.EVENTS)
+public class MembershipCounters {
+    public int found;
+    public int notFound;
+
+    public int total() {
+        return notFound + found;
+    }
+
+    @Setup(Level.Iteration)
+    public void reset() {
+        found = 0;
+        notFound = 0;
+    }
+}

…ava/org/fastfilter/FilterQueryState.java …java/org/fastfilter/MembershipState.javajmh/src/main/java/org/fastfilter/FilterQueryState.java renamed to jmh/src/main/java/org/fastfilter/MembershipState.java jmh/src/main/java/org/fastfilter/FilterQueryState.java renamed to jmh/src/main/java/org/fastfilter/MembershipState.java

@@ -2,20 +2,11 @@
 
 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;
+import java.util.HashSet;
+import java.util.Set;
 
-        Counters(Filter filter) {
-            this.bitCount = filter.getBitCount();
-        }
-    }
+@State(Scope.Benchmark)
+public class MembershipState extends ConstructionState {
 
     @Param({"10", "15", "20", "25"})
     int logDistinctLookups;
@@ -24,24 +15,15 @@ static class Counters {
     float trueMatchProbability;
 
     private long[] keysToFind;
-    private Counters counters;
-
-    public void found() {
-        ++counters.found;
-    }
-
-    public void notFound() {
-        ++counters.notFound;
-    }
-
+    int workDone;
     Filter filter;
 
     public Filter getFilter() {
         return filter;
     }
 
     public long nextKey() {
-        return keysToFind[(counters.workDone++) & (keysToFind.length - 1)];
+        return keysToFind[(workDone++) & (keysToFind.length - 1)];
     }
 
     @Override
@@ -56,5 +38,20 @@ public void init() {
                     + memberCount + " keys  but have " + keys.length);
         }
         System.arraycopy(keys, 0, keysToFind, 0, memberCount);
+        Set<Long> present = new HashSet<>();
+        for (long key : keys) {
+            present.add(key);
+        }
+        for (int i = memberCount; i < keysToFind.length; ++i) {
+            do {
+                long key = kgs.nextKey();
+                if (!present.contains(key)) {
+                    present.add(key);
+                    keysToFind[i] = key;
+                    break;
+                }
+            } while (true);
+        }
+
     }
 }