Rename things and improved analysis tools

Author: thomasmueller

src/main/java/org/fastfilter/FilterType.java

@@ -1,13 +1,12 @@
 package org.fastfilter;
 
 import org.fastfilter.bloom.BlockedBloom;
-import org.fastfilter.bloom.BlockedBloomV2;
 import org.fastfilter.bloom.Bloom;
-import org.fastfilter.bloom.CountingBloom;
-import org.fastfilter.bloom.SuccinctCountingBlockedBloom;
-import org.fastfilter.bloom.SuccinctCountingBlockedBloomRankedV2;
-import org.fastfilter.bloom.SuccinctCountingBlockedBloomV2;
-import org.fastfilter.bloom.SuccinctCountingBloom;
+import org.fastfilter.bloom.count.CountingBloom;
+import org.fastfilter.bloom.count.SuccinctCountingBlockedBloom;
+import org.fastfilter.bloom.count.SuccinctCountingBlockedBloomRanked;
+import org.fastfilter.bloom.count.SuccinctCountingBloom;
+import org.fastfilter.bloom.count.SuccinctCountingBloomRanked;
 import org.fastfilter.cuckoo.Cuckoo16;
 import org.fastfilter.cuckoo.Cuckoo8;
 import org.fastfilter.cuckoo.CuckooPlus16;
@@ -43,16 +42,16 @@ public Filter construct(long[] keys, int setting) {
             return SuccinctCountingBloom.construct(keys, setting);
         }
     },
-    BLOCKED_BLOOM {
+    SUCCINCT_COUNTING_BLOOM_RANKED {
         @Override
         public Filter construct(long[] keys, int setting) {
-            return BlockedBloom.construct(keys, setting);
+            return SuccinctCountingBloomRanked.construct(keys, setting);
         }
     },
-    BLOCKED_BLOOM_V2 {
+    BLOCKED_BLOOM {
         @Override
         public Filter construct(long[] keys, int setting) {
-            return BlockedBloomV2.construct(keys, setting);
+            return BlockedBloom.construct(keys, setting);
         }
     },
     SUCCINCT_COUNTING_BLOCKED_BLOOM {
@@ -61,16 +60,10 @@ public Filter construct(long[] keys, int setting) {
             return SuccinctCountingBlockedBloom.construct(keys, setting);
         }
     },
-    SUCCINCT_COUNTING_BLOCKED_BLOOM_V2 {
-        @Override
-        public Filter construct(long[] keys, int setting) {
-            return SuccinctCountingBlockedBloomV2.construct(keys, setting);
-        }
-    },
-    SUCCINCT_COUNTING_BLOCKED_BLOOM_RANKED_V2 {
+    SUCCINCT_COUNTING_BLOCKED_BLOOM_RANKED {
         @Override
         public Filter construct(long[] keys, int setting) {
-            return SuccinctCountingBlockedBloomRankedV2.construct(keys, setting);
+            return SuccinctCountingBlockedBloomRanked.construct(keys, setting);
         }
     },
     XOR_SIMPLE {

src/main/java/org/fastfilter/bloom/BlockedBloom.java

@@ -4,50 +4,37 @@
 import org.fastfilter.utils.Hash;
 
 /**
- * A blocked Bloom filter. Compared to a regular Bloom filter, it is little bit
- * faster, but needs more space. Not that useful beyond about 20 bits per key,
- * as fpp doesn't decreased further.
+ * A special kind of blocked Bloom filter. It sets 2 to 4 (usually 4) bits in
+ * two 64-bit words; 1 or 2 (usually 2) per word. It is faster than a regular
+ * Bloom filter, but needs slightly more space / has a slightly worse false
+ * positive rate.
  */
 public class BlockedBloom implements Filter {
 
-    // TODO not cache line aligned
-
-    // Should match the size of a cache line
-    private static final int BITS_PER_BLOCK = 64 * 8;
-    private static final int LONGS_PER_BLOCK = BITS_PER_BLOCK / 64;
-    private static final int BLOCK_MASK = BITS_PER_BLOCK - 1;
-
     public static BlockedBloom construct(long[] keys, int bitsPerKey) {
         long n = keys.length;
-        long m = n * bitsPerKey;
-        int k = getBestK(m, n);
-        BlockedBloom f = new BlockedBloom((int) n, bitsPerKey, k);
+        BlockedBloom f = new BlockedBloom((int) n, bitsPerKey);
         for(long x : keys) {
             f.add(x);
         }
         return f;
     }
 
-    private static int getBestK(long m, long n) {
-        return Math.max(1, (int) Math.round((double) m / n * Math.log(2)));
-    }
-
-    private final int k;
-    private final int blocks;
+    private final int buckets;
     private final long seed;
     private final long[] data;
 
     public long getBitCount() {
         return data.length * 64L;
     }
 
-    BlockedBloom(int entryCount, int bitsPerKey, int k) {
+    BlockedBloom(int entryCount, int bitsPerKey) {
+        // bitsPerKey = 11;
         entryCount = Math.max(1, entryCount);
-        this.k = k;
         this.seed = Hash.randomSeed();
         long bits = (long) entryCount * bitsPerKey;
-        this.blocks = (int) (bits + BITS_PER_BLOCK - 1) / BITS_PER_BLOCK;
-        data = new long[(int) (blocks * LONGS_PER_BLOCK) + 8];
+        this.buckets = (int) bits / 64;
+        data = new long[(int) (buckets + 16)];
     }
 
     @Override
@@ -58,32 +45,24 @@ public boolean supportsAdd() {
     @Override
     public void add(long key) {
         long hash = Hash.hash64(key, seed);
-        int start = Hash.reduce((int) hash, blocks) * LONGS_PER_BLOCK;
-        int a = (int) hash;
-        int b = (int) (hash >>> 32);
-        for (int i = 0; i < k; i++) {
-            data[start + ((a & BLOCK_MASK) >>> 6)] |= getBit(a);
-            a += b;
-        }
+        int start = Hash.reduce((int) hash, buckets);
+        hash = hash ^ Long.rotateLeft(hash, 32);
+        long m1 = (1L << hash) | (1L << (hash >> 6));
+        long m2 = (1L << (hash >> 12)) | (1L << (hash >> 18));
+        data[start] |= m1;
+        data[start + 1 + (int) (hash >>> 60)] |= m2;
     }
 
     @Override
     public boolean mayContain(long key) {
         long hash = Hash.hash64(key, seed);
-        int start = Hash.reduce((int) hash, blocks) * LONGS_PER_BLOCK;
-        int a = (int) hash;
-        int b = (int) (hash >>> 32);
-        for (int i = 0; i < k; i++) {
-            if ((data[start + ((a & BLOCK_MASK) >>> 6)] & getBit(a)) == 0) {
-                return false;
-            }
-            a += b;
-        }
-        return true;
-    }
-
-    private static long getBit(int index) {
-        return 1L << index;
+        int start = Hash.reduce((int) hash, buckets);
+        hash = hash ^ Long.rotateLeft(hash, 32);
+        long a = data[start];
+        long b = data[start + 1 + (int) (hash >>> 60)];
+        long m1 = (1L << hash) | (1L << (hash >> 6));
+        long m2 = (1L << (hash >> 12)) | (1L << (hash >> 18));
+        return ((m1 & a) == m1) && ((m2 & b) == m2);
     }
 
 }