Reorganize the code: use SimpleMixSplit instead of TwoIndependentMultiplyShift #18

Author: thomasmueller

benchmarks/bulk-insert-and-query.cc

@@ -276,7 +276,7 @@ struct FilterAPI<SimdBlockFilterFixed<HashFamily>> {
 #endif
 
 
-#ifdef __SSE4_1__
+#ifdef __SSE41__
 
 template <typename HashFamily>
 struct FilterAPI<SimdBlockFilterFixed16<HashFamily>> {
@@ -990,7 +990,7 @@ int main(int argc, char * argv[]) {
     {52, "BlockedBloom (addall)"},
     {53, "BlockedBloom64"},
 #endif
-#ifdef __SSE4_1__
+#ifdef __SSE41__
     {54, "BlockedBloom16"},
 #endif
 
@@ -1423,7 +1423,7 @@ int main(int argc, char * argv[]) {
       cout << setw(NAME_WIDTH) << names[a] << cf << endl;
   }
 #endif
-#ifdef __SSE4_1__
+#ifdef __SSE41__
   a = 54;
   if (algorithmId == a || (algos.find(a) != algos.end())) {
       auto cf = FilterBenchmark<SimdBlockFilterFixed16<SimpleMixSplit>>(

src/bloom/bloom.h

@@ -85,14 +85,14 @@ static inline size_t fastrangesize(uint64_t word, size_t p) {
 #endif // SIZE_MAX == UINT32_MAX
 }
 
-static size_t getBestK(size_t bitsPerItem) {
+static inline size_t getBestK(size_t bitsPerItem) {
   return max(1, (int)round((double)bitsPerItem * log(2)));
 }
 
 inline uint64_t getBit(uint32_t index) { return 1L << (index & 63); }
 
 template <typename ItemType, size_t bits_per_item, bool branchless,
-          typename HashFamily = TwoIndependentMultiplyShift,
+          typename HashFamily = SimpleMixSplit,
           int k = (int)((double)bits_per_item * 0.693147180559945 + 0.5)>
 class BloomFilter {
 public:
@@ -121,7 +121,7 @@ class BloomFilter {
   Status Add(const ItemType &item);
 
   // Add multiple items to the filter.
-  Status AddAll(const vector<ItemType> data, const size_t start,
+  Status AddAll(const vector<ItemType>& data, const size_t start,
                 const size_t end) {
     return AddAll(data.data(),start,end);
 
@@ -269,7 +269,7 @@ BloomFilter<ItemType, bits_per_item, branchless, HashFamily, k>::Info() const {
  ***************/
 
 template <size_t blocksize, int k,
-          typename HashFamily = ::hashing::TwoIndependentMultiplyShift>
+          typename HashFamily = ::hashing::SimpleMixSplit>
 class SimpleBlockFilter {
 private:
   const size_t arrayLength;
@@ -296,7 +296,7 @@ SimpleBlockFilter<blocksize, k, HashFamily>::SimpleBlockFilter(
 
 template <size_t blocksize, int k, typename HashFamily>
 SimpleBlockFilter<blocksize, k, HashFamily>::~SimpleBlockFilter() noexcept {
-  delete[] data;
+  free(data);
   data = nullptr;
 }
 

src/bloom/counting_bloom.h

@@ -201,7 +201,7 @@ inline uint32_t reduce(uint32_t hash, uint32_t n) {
 // CountingBloomFilter --------------------------------------------------------------------------------------
 
 template <typename ItemType, size_t bits_per_item, bool branchless,
-          typename HashFamily = TwoIndependentMultiplyShift,
+          typename HashFamily = SimpleMixSplit,
           int k = (int)((double)bits_per_item * 0.693147180559945 + 0.5)>
 class CountingBloomFilter {
 
@@ -221,7 +221,7 @@ class CountingBloomFilter {
   }
   ~CountingBloomFilter() { delete[] data; }
   Status Add(const ItemType &item);
-  Status AddAll(const vector<ItemType> data, const size_t start, const size_t end);
+  Status AddAll(const vector<ItemType>& data, const size_t start, const size_t end);
   Status Remove(const ItemType &item);
   Status Contain(const ItemType &item) const;
   size_t SizeInBytes() const { return arrayLength * 8; }
@@ -255,7 +255,7 @@ void CountingBloomFilter<ItemType, bits_per_item, branchless, HashFamily, k>::
 template <typename ItemType, size_t bits_per_item, bool branchless,
           typename HashFamily, int k>
 Status CountingBloomFilter<ItemType, bits_per_item, branchless, HashFamily, k>::
-    AddAll(const vector<ItemType> keys, const size_t start, const size_t end) {
+    AddAll(const vector<ItemType>& keys, const size_t start, const size_t end) {
   int blocks = 1 + arrayLength / blockLen;
   uint32_t *tmp = new uint32_t[blocks * blockLen];
   int *tmpLen = new int[blocks]();
@@ -323,7 +323,7 @@ Status CountingBloomFilter<ItemType, bits_per_item, branchless, HashFamily, k>::
 // #define VERIFY_COUNT
 
 template <typename ItemType, size_t bits_per_item, bool branchless,
-          typename HashFamily = TwoIndependentMultiplyShift,
+          typename HashFamily = SimpleMixSplit,
           int k = (int)((double)bits_per_item * 0.693147180559945 + 0.5)>
 class SuccinctCountingBloomFilter {
 
@@ -363,7 +363,7 @@ class SuccinctCountingBloomFilter {
   }
   ~SuccinctCountingBloomFilter() { delete[] data; delete[] counts; delete[] overflow; }
   Status Add(const ItemType &item);
-  Status AddAll(const vector<ItemType> data, const size_t start, const size_t end);
+  Status AddAll(const vector<ItemType>& data, const size_t start, const size_t end);
   Status Remove(const ItemType &item);
   Status Contain(const ItemType &item) const;
   size_t SizeInBytes() const { return arrayLength * 8 * 2 + overflowLength * 8; }
@@ -413,7 +413,7 @@ Status SuccinctCountingBloomFilter<ItemType, bits_per_item, branchless, HashFami
 template <typename ItemType, size_t bits_per_item, bool branchless,
           typename HashFamily, int k>
 Status SuccinctCountingBloomFilter<ItemType, bits_per_item, branchless, HashFamily, k>::
-    AddAll(const vector<ItemType> keys, const size_t start, const size_t end) {
+    AddAll(const vector<ItemType>& keys, const size_t start, const size_t end) {
   int blocks = 1 + arrayLength / blockLen;
   uint32_t *tmp = new uint32_t[blocks * blockLen];
   int *tmpLen = new int[blocks]();
@@ -968,15 +968,11 @@ void SuccinctCountingBlockedBloomRankFilter<ItemType, bits_per_item, HashFamily,
     Increment(bucket_start + ((a >> 0) & 7), (a >> 3) & 0x3f);
     Increment(bucket_start + ((a >> 9) & 7), (a >> 12) & 0x3f);
     Increment(bucket_start + ((a >> 18) & 7), (a >> 21) & 0x3f);
-//    data[bucket_start + ((a >> 0) & 7)] |= 1ULL << ((a >> 3) & 0x3f);
-//    data[bucket_start + ((a >> 9) & 7)] |= 1ULL << ((a >> 12) & 0x3f);
-//    data[bucket_start + ((a >> 18) & 7)] |= 1ULL << ((a >> 21) & 0x3f);
   }
   uint32_t b = (uint32_t)(hash >> 32);
   for (int i = 3; i < k; i++) {
     a += b;
     Increment(bucket_start + (a & 7), (a >> 3) & 0x3f);
-//    data[bucket_start + (a & 7)] |= 1ULL << ((a >> 3) & 0x3f);
   }
 }
 
@@ -1046,7 +1042,6 @@ void SuccinctCountingBlockedBloomRankFilter<ItemType, bits_per_item, HashFamily,
     c = (left << 1) | right;
     if (insertAt >= 64 || (c & 0x8000000000000000L) != 0) {
         // an overflow entry, or overflowing now
-        // int index = allocateOverflow();
         int index = nextFreeOverflow;
         nextFreeOverflow = (int) overflow[index];
         for (int i = 0; i < 8; i++) {

src/bloom/simd-block-fixed-fpp.h

@@ -41,7 +41,7 @@ static inline uint64_t rotl64(uint64_t n, unsigned int c) {
 #ifdef __AVX2__
 #include <x86intrin.h>
 
-template<typename HashFamily = ::hashing::TwoIndependentMultiplyShift>
+template<typename HashFamily = ::hashing::SimpleMixSplit>
 class SimdBlockFilterFixed {
  private:
   // The filter is divided up into Buckets:
@@ -201,7 +201,7 @@ struct mask64bytes {
 
 typedef struct mask64bytes mask64bytes_t;
 
-template<typename HashFamily = ::hashing::TwoIndependentMultiplyShift>
+template<typename HashFamily = ::hashing::SimpleMixSplit>
 class SimdBlockFilterFixed64 {
  private:
   // The filter is divided up into Buckets:
@@ -298,7 +298,7 @@ SimdBlockFilterFixed64<HashFamily>::Find(const uint64_t key) const noexcept {
 #ifdef __aarch64__
 #include <arm_neon.h>
 
-template<typename HashFamily = ::hashing::TwoIndependentMultiplyShift>
+template<typename HashFamily = ::hashing::SimpleMixSplit>
 class SimdBlockFilterFixed {
  private:
   // The filter is divided up into Buckets:
@@ -398,11 +398,11 @@ SimdBlockFilterFixed<HashFamily>::Find(const uint64_t key) const noexcept {
 /// 16-byte version (not very good)
 ///////////////////////////////////////////////////////////////////
 
-#ifdef __SSE4_1__
+#ifdef __SSE41__
 
 #include <smmintrin.h>
 
-template<typename HashFamily = ::hashing::TwoIndependentMultiplyShift>
+template<typename HashFamily = ::hashing::SimpleMixSplit>
 class SimdBlockFilterFixed16 {
  private:
   // The filter is divided up into Buckets:

src/bloom/simd-block.h

@@ -25,7 +25,7 @@
 using uint32_t = ::std::uint32_t;
 using uint64_t = ::std::uint64_t;
 
-template<typename HashFamily = ::hashing::TwoIndependentMultiplyShift>
+template<typename HashFamily = ::hashing::SimpleMixSplit>
 class SimdBlockFilter {
  private:
   // The filter is divided up into Buckets:

src/cuckoo/cuckoofilter.h

@@ -31,7 +31,7 @@ const size_t kMaxCuckooCount = 500;
 // PackedTable to enable semi-sorting
 template <typename ItemType, size_t bits_per_item,
           template <size_t> class TableType = SingleTable,
-          typename HashFamily = hashing::TwoIndependentMultiplyShift>
+          typename HashFamily = hashing::SimpleMixSplit>
 class CuckooFilter {
   // Storage of items
   TableType<bits_per_item> *table_;

src/cuckoo/cuckoofilter_stable.h

@@ -26,7 +26,7 @@ inline uint32_t reduce(uint64_t hash, uint32_t n) {
 // PackedTable to enable semi-sorting
 template <typename ItemType, size_t bits_per_item,
           template <size_t> class TableType = SingleTable,
-          typename HashFamily = hashing::TwoIndependentMultiplyShift>
+          typename HashFamily = hashing::SimpleMixSplit>
 class CuckooFilterStable {
   // Storage of items
   TableType<bits_per_item> *table_;

src/gcs/gcs.h

@@ -235,7 +235,7 @@ inline uint32_t MultiStageMonotoneList_get(const MultiStageMonotoneList* list, u
 }
 
 template <typename ItemType, size_t bits_per_item,
-          typename HashFamily = TwoIndependentMultiplyShift>
+          typename HashFamily = SimpleMixSplit>
 class GcsFilter {
 
   int golombShift;
@@ -252,15 +252,15 @@ class GcsFilter {
   double BitsPerItem() const { return 8.0; }
 
  public:
-  explicit GcsFilter(const size_t len) : hasher() {
+  explicit GcsFilter(const size_t ) : hasher() {
   }
 
   ~GcsFilter() {
     delete[] bucketData;
     delete[] monotoneList.data;
   }
 
-  Status AddAll(const vector<ItemType> data, const size_t start, const size_t end);
+  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;
@@ -285,7 +285,7 @@ int compare_uint64(const void* a, const void* b) {
 template <typename ItemType, size_t bits_per_item,
           typename HashFamily>
 Status GcsFilter<ItemType, bits_per_item, HashFamily>::AddAll(
-    const vector<ItemType> keys, const size_t start, const size_t end) {
+    const vector<ItemType>& keys, const size_t start, const size_t end) {
 
     int len = end - start;
     // this was found experimentally

src/hashutil.h

@@ -12,7 +12,9 @@
 namespace hashing {
 // See Martin Dietzfelbinger, "Universal hashing and k-wise independent random
 // variables via integer arithmetic without primes".
+/*
 class TwoIndependentMultiplyShift {
+
   unsigned __int128 multiply_, add_;
 
  public:
@@ -30,7 +32,9 @@ class TwoIndependentMultiplyShift {
   inline uint64_t operator()(uint64_t key) const {
     return (add_ + multiply_ * static_cast<decltype(multiply_)>(key)) >> 64;
   }
+  
 };
+*/
 
 class SimpleMixSplit {
 

src/morton/compressed_cuckoo_filter.h

@@ -50,8 +50,6 @@ Author: Alex D. Breslow
 #define INLINE __attribute__((always_inline)) inline
 #endif
 
-#define UNROLL __attribute__((optimize("unroll-loops")))
-
 struct Tester; // Forward declaration
 std::ostream& operator<<(std::ostream& os, __uint128_t integer);
 
@@ -780,7 +778,6 @@ namespace CompressedCuckoo{
 
   // Exclusive reduction on counters that are one or more bits
   // wide but which fit into a 64-bit word
-  //UNROLL
   INLINE uint16_t exclusive_reduce_with_popcount64(const block_t& b,
     uint8_t counter_index) const{
     constexpr atom_t one = 1;
@@ -797,7 +794,6 @@ namespace CompressedCuckoo{
     // about.
     counters &= mask;
     atom_t popcount_mask = _popcount_masks[0];
-    //#pragma unroll
     for(uint8_t i = 0; i < _fullness_counter_width; i++){
       sum += __builtin_popcountll(counters & popcount_mask) << i;
       popcount_mask <<= 1;
@@ -1780,7 +1776,6 @@ namespace CompressedCuckoo{
     }
 
     if(_handle_conflicts && conflict_vector.any()){
-      //std::cout << "CONFLICT exists!\n";
       for(uint32_t i = 0; i < batch_size; i++){
         statuses[offset + i] = first_level_store(bucket_ids_1[i],
           fingerprints[i], c1[i]);
@@ -1848,7 +1843,6 @@ namespace CompressedCuckoo{
     }
 
     if(__builtin_expect(_handle_conflicts && conflict_vector.any(), 0)){
-      //std::cout << "CONFLICT exists!\n";
       for(uint32_t i = 0; i < batch_size; i++){
         statuses[offset + i] = first_level_store(bucket_ids[i],
           fingerprints[i], c1[i]);
@@ -2162,7 +2156,7 @@ namespace CompressedCuckoo{
 
   // Set OTA bit on overflow if not already set
   inline void set_overflow_status(const hash_t bucket_id,
-    const atom_t fingerprint, const hash_t block_id, const hash_t lbi){
+    const atom_t fingerprint, const hash_t block_id, const hash_t){
     // Bloom filter
     if(_use_bloom_ota){ // Not yet implemented for selective Morton filter
       return set_bloom_filter_ota(bucket_id, fingerprint, block_id);
@@ -2311,7 +2305,6 @@ namespace CompressedCuckoo{
       } // End of block overflow resolution
       count ++;
     } // End of while loop
-    //std::cout << "MAX LOOP COUNT EXCEEDED\n";
     // If you exit the while loop here, it means that the max count has been
     // exceeded.
     return false;