Xor 13: using 39 of 40 bits

Author: thomasmueller

benchmarks/bulk-insert-and-query.cc

@@ -23,6 +23,7 @@
 #include "cuckoofilter_stable.h"
 #include "xorfilter.h"
 #include "xorfilter_10bit.h"
+#include "xorfilter_13bit.h"
 #include "xorfilter_10_666bit.h"
 #include "xorfilter_2.h"
 #include "xorfilter_2n.h"
@@ -279,6 +280,23 @@ struct FilterAPI<XorFilter10<ItemType, HashFamily>> {
   }
 };
 
+template <typename ItemType, typename HashFamily>
+struct FilterAPI<XorFilter13<ItemType, HashFamily>> {
+  using Table = XorFilter13<ItemType, HashFamily>;
+  static Table ConstructFromAddCount(size_t add_count) { return Table(add_count); }
+  static void Add(uint64_t key, Table* table) {
+      throw std::runtime_error("Unsupported");
+  }
+  static void AddAll(const vector<ItemType> keys, const size_t start, const size_t end, Table* table) {
+    table->AddAll(keys, start, end);
+  }
+
+  CONTAIN_ATTRIBUTES
+  static bool Contain(uint64_t key, const Table * table) {
+    return (0 == table->Contain(key));
+  }
+};
+
 template <typename ItemType, typename HashFamily>
 struct FilterAPI<XorFilter10_666<ItemType, HashFamily>> {
   using Table = XorFilter10_666<ItemType, HashFamily>;
@@ -965,6 +983,12 @@ int main(int argc, char * argv[]) {
       cout << setw(NAME_WIDTH) << "Xor10.666" << cf << endl;
   }
 
+  if (algorithmId == 27 || (algos.find(27) != algos.end())) {
+      auto cf = FilterBenchmark<
+          XorFilter13<uint64_t, SimpleMixSplit>>(
+          add_count, to_add, distinct_add, to_lookup, distinct_lookup, intersectionsize, hasduplicates, mixed_sets, seed, true);
+      cout << setw(NAME_WIDTH) << "Xor13" << cf << endl;
+  }
 
   if (algorithmId == 37 || algorithmId < 0 || (algos.find(37) != algos.end())) {
       auto cf = FilterBenchmark<

src/xorfilter_13bit.h

@@ -0,0 +1,291 @@
+#ifndef XOR_FILTER13_XOR_FILTER_H_
+#define XOR_FILTER13_XOR_FILTER_H_
+
+#include <assert.h>
+#include <algorithm>
+#include <xorfilter_10bit.h>
+#include "hashutil.h"
+
+using namespace std;
+using namespace hashing;
+
+namespace xorfilter {
+
+template <typename ItemType, typename HashFamily = TwoIndependentMultiplyShift>
+class XorFilter13 {
+
+  size_t size;
+  size_t arrayLength;
+  size_t blockLength;
+  size_t byteCount;
+  uint8_t *fingerprints;
+
+  HashFamily* hasher;
+
+  inline uint32_t fingerprint(const uint64_t hash) const {
+    return (uint32_t) (hash ^ (hash >> 32));
+  }
+
+ public:
+  explicit XorFilter13(const size_t size) {
+    hasher = new HashFamily();
+    this->size = size;
+    this->arrayLength = 32 + 1.23 * size;
+    this->blockLength = arrayLength / 3;
+    byteCount = blockLength * 5 + 4;
+    fingerprints = new uint8_t[byteCount]();
+  }
+
+  ~XorFilter13() {
+    delete[] fingerprints;
+    delete hasher;
+  }
+
+  Status AddAll(const vector<ItemType> data, const size_t start, const size_t end);
+
+  // Report if the item is inserted, with false positive rate.
+  Status Contain(const ItemType &item) const;
+
+  // number of current inserted items;
+  size_t Size() const { return size; }
+
+  // size of the filter in bytes.
+  size_t SizeInBytes() const { return byteCount; }
+};
+
+#define COPY sizeof(uint64_t)
+//#define COPY 5
+
+template <typename ItemType, typename HashFamily>
+Status XorFilter13<ItemType, HashFamily>::AddAll(
+    const vector<ItemType> keys, const size_t start, const size_t end) {
+
+    int m = arrayLength;
+    uint64_t* reverseOrder = new uint64_t[size];
+    uint8_t* reverseH = new uint8_t[size];
+    size_t reverseOrderPos;
+    int hashIndex = 0;
+    t2val_t * t2vals = new t2val_t[m];
+    while (true) {
+        memset(t2vals, 0, sizeof(t2val_t[m]));
+        int blocks = 1 + ((3 * blockLength) >> blockShift);
+        uint64_t* tmp = new uint64_t[blocks << blockShift];
+        int* tmpc = new int[blocks]();
+        for(size_t i = start; i < end; i++) {
+            uint64_t k = keys[i];
+            uint64_t hash = (*hasher)(k);
+            for (int hi = 0; hi < 3; hi++) {
+                int index = getHashFromHash(hash, hi, blockLength);
+                int b = index >> blockShift;
+                int i2 = tmpc[b];
+                tmp[(b << blockShift) + i2] = hash;
+                tmp[(b << blockShift) + i2 + 1] = index;
+                tmpc[b] += 2;
+                if (i2 + 2 == (1 << blockShift)) {
+                    applyBlock(tmp, b, i2 + 2, t2vals);
+                    tmpc[b] = 0;
+                }
+            }
+
+        }
+        for (int b = 0; b < blocks; b++) {
+            applyBlock(tmp, b, tmpc[b], t2vals);
+        }
+        delete[] tmp;
+        delete[] tmpc;
+        reverseOrderPos = 0;
+
+        int* alone = new int[arrayLength];
+        int alonePos = 0;
+        for (size_t i = 0; i < arrayLength; i++) {
+            if (t2vals[i].t2count == 1) {
+                alone[alonePos++] = i;
+            }
+        }
+        tmp = new uint64_t[blocks << blockShift];
+        tmpc = new int[blocks]();
+        reverseOrderPos = 0;
+        int bestBlock = -1;
+        while (reverseOrderPos < size) {
+            if (alonePos == 0) {
+                // we need to apply blocks until we have an entry that is alone
+                // (that is, until alonePos > 0)
+                // so, find a large block (the larger the better)
+                // but don't need to search very long
+                // start searching where we stopped the last time
+                // (to make it more even)
+                for (int i = 0, b = bestBlock + 1, best = -1; i < blocks; i++) {
+                    if (b >= blocks) {
+                        b = 0;
+                    }
+                    if (tmpc[b] > best) {
+                        best = tmpc[b];
+                        bestBlock = b;
+                        if (best > (1 << (blockShift - 1))) {
+                            // sufficiently large: stop
+                            break;
+                        }
+                    }
+                }
+                if (tmpc[bestBlock] > 0) {
+                    alonePos = applyBlock2(tmp, bestBlock, tmpc[bestBlock], t2vals, alone, alonePos);
+                    tmpc[bestBlock] = 0;
+                }
+                // applying a block may not actually result in a new entry that is alone
+                if (alonePos == 0) {
+                    for (int b = 0; b < blocks && alonePos == 0; b++) {
+                        if (tmpc[b] > 0) {
+                            alonePos = applyBlock2(tmp, b, tmpc[b], t2vals, alone, alonePos);
+                            tmpc[b] = 0;
+                        }
+                    }
+                }
+            }
+            if (alonePos == 0) {
+                break;
+            }
+            int i = alone[--alonePos];
+            int b = i >> blockShift;
+            if (tmpc[b] > 0) {
+                alonePos = applyBlock2(tmp, b, tmpc[b], t2vals, alone, alonePos);
+                tmpc[b] = 0;
+            }
+            uint8_t found = -1;
+            if (t2vals[i].t2count == 0) {
+                continue;
+            }
+            long hash = t2vals[i].t2;
+            for (int hi = 0; hi < 3; hi++) {
+                int h = getHashFromHash(hash, hi, blockLength);
+                if (h == i) {
+                    found = (uint8_t) hi;
+                    t2vals[i].t2count = 0;
+                } else {
+                    int b = h >> blockShift;
+                    int i2 = tmpc[b];
+                    tmp[(b << blockShift) + i2] = hash;
+                    tmp[(b << blockShift) + i2 + 1] = h;
+                    tmpc[b] += 2;
+                    if (tmpc[b] >= 1 << blockShift) {
+                        alonePos = applyBlock2(tmp, b, tmpc[b], t2vals, alone, alonePos);
+                        tmpc[b] = 0;
+                    }
+                }
+            }
+            reverseOrder[reverseOrderPos] = hash;
+            reverseH[reverseOrderPos] = found;
+            reverseOrderPos++;
+        }
+        delete[] tmp;
+        delete[] tmpc;
+        delete[] alone;
+
+/*
+
+        int* alone = new int[arrayLength];
+        int alonePos = 0;
+        for (size_t i = 0; i < arrayLength; i++) {
+            if (t2vals[i].t2count == 1) {
+                alone[alonePos++] = i;
+            }
+        }
+        reverseOrderPos = 0;
+        while (alonePos > 0 && reverseOrderPos < size) {
+            int i = alone[--alonePos];
+            if (t2vals[i].t2count == 0) {
+                continue;
+            }
+            long hash = t2vals[i].t2;
+            uint8_t found = -1;
+            for (int hi = 0; hi < 3; hi++) {
+                int h = getHashFromHash(hash, hi, blockLength);
+                int newCount =  --t2vals[h].t2count;
+                if (newCount == 0) {
+                    found = (uint8_t) hi;
+                } else {
+                    if (newCount == 1) {
+                        alone[alonePos++] = h;
+                    }
+                    t2vals[h].t2 ^= hash;
+                }
+            }
+            reverseOrder[reverseOrderPos] = hash;
+            reverseH[reverseOrderPos] = found;
+            reverseOrderPos++;
+        }
+        delete [] alone;
+*/
+
+        if (reverseOrderPos == size) {
+            break;
+        }
+
+        std::cout << "WARNING: hashIndex " << hashIndex << "\n";
+        if (hashIndex >= 0) {
+            std::cout << (end - start) << " keys; arrayLength " << arrayLength
+                << " blockLength " << blockLength
+                << " reverseOrderPos " << reverseOrderPos << "\n";
+        }
+
+        hashIndex++;
+
+        // use a new random numbers
+        delete hasher;
+        hasher = new HashFamily();
+
+    }
+
+    for (int i = reverseOrderPos - 1; i >= 0; i--) {
+        // the hash of the key we insert next
+        uint64_t hash = reverseOrder[i];
+        int found = reverseH[i];
+        // which entry in the table we can change
+        int change = -1;
+        // we set table[change] to the fingerprint of the key,
+        // unless the other two entries are already occupied
+        uint64_t xor2 = fingerprint(hash);
+        for (int hi = 0; hi < 3; hi++) {
+            size_t h = getHashFromHash10(hash, hi, blockLength);
+            if (found == hi) {
+                change = h;
+            } else {
+                // this is different from BDZ: using xor to calculate the
+                // fingerprint
+                uint64_t x;
+                memcpy(&x, fingerprints + 5 * h, COPY);
+                xor2 ^= x >> (0 + 13 * hi);
+            }
+        }
+        uint64_t x = 0;
+        memcpy(&x, fingerprints + 5 * change, COPY);
+        x |= (xor2 & 0x1fff) << (0 + 13 * found);
+        memcpy(fingerprints + 5 * change, &x, COPY);
+    }
+    delete [] t2vals;
+    delete [] reverseOrder;
+    delete [] reverseH;
+
+    return Ok;
+}
+
+template <typename ItemType, typename HashFamily>
+Status XorFilter13<ItemType, HashFamily>::Contain(
+    const ItemType &key) const {
+    uint64_t hash = (*hasher)(key);
+    uint64_t f = fingerprint(hash);
+    uint32_t r0 = (uint32_t) hash;
+    uint32_t r1 = (uint32_t) rotl64(hash, 21);
+    uint32_t r2 = (uint32_t) rotl64(hash, 42);
+    uint32_t h0 = reduce(r0, blockLength);
+    uint32_t h1 = reduce(r1, blockLength);
+    uint32_t h2 = reduce(r2, blockLength);
+    uint64_t x0, x1, x2;
+    memcpy(&x0, fingerprints + 5 * h0, COPY);
+    memcpy(&x1, fingerprints + 5 * h1, COPY);
+    memcpy(&x2, fingerprints + 5 * h2, COPY);
+    f ^= x0 ^ (x1 >> 13) ^ (x2 >> 26);
+    return (f & 0x1fff) == 0 ? Ok : NotFound;
+}
+
+}  // namespace xorfilter
+#endif  // XOR_FILTER13_XOR_FILTER_H_