Fix for aarch64 (ARM NEON) version.

Author: lemire

benchmarks/Makefile

@@ -2,7 +2,14 @@
 OPT = -O3 -DNDEBUG
 #OPT = -g -ggdb
 
-CXXFLAGS += -fno-strict-aliasing -Wall -std=c++11 -I. -I../src/ $(OPT) -march=native
+CXXFLAGS += -fno-strict-aliasing -Wall -std=c++11 -I. -I../src/ $(OPT) 
+
+UNAME_P := $(shell uname -p)
+ifeq ($(UNAME_P),aarch64)
+        CXXFLAGS += 
+else
+	CXXFLAGS += -march=native
+endif
 
 LDFLAGS = -Wall 
 

benchmarks/bulk-insert-and-query.cc

@@ -32,12 +32,10 @@
 #include "gcs.h"
 #ifdef __AVX2__
 #include "gqf_cpp.h"
+#include "simd-block.h"
 #endif
 #include "random.h"
-#ifdef __AVX2__
-#include "simd-block.h"
 #include "simd-block-fixed-fpp.h"
-#endif
 #include "timing.h"
 #ifdef __linux__
 #include "linux-perf-events.h"
@@ -169,6 +167,30 @@ struct FilterAPI<CuckooFilterStable<ItemType, bits_per_item, TableType, HashFami
   }
 };
 
+
+#ifdef __aarch64__
+template <typename HashFamily>
+struct FilterAPI<SimdBlockFilterFixed<HashFamily>> {
+  using Table = SimdBlockFilterFixed<HashFamily>;
+  static Table ConstructFromAddCount(size_t add_count) {
+    Table ans(ceil(add_count * 8.0 / CHAR_BIT));
+    return ans;
+  }
+  static void Add(uint64_t key, Table* table) {
+    table->Add(key);
+  }
+  static void AddAll(const vector<uint64_t> 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 table->Find(key);
+  }
+};
+
+#endif
+
 #ifdef __AVX2__
 template <typename HashFamily>
 struct FilterAPI<SimdBlockFilter<HashFamily>> {
@@ -695,6 +717,18 @@ int main() {
 */
 
 int main(int argc, char * argv[]) {
+#ifdef __aarch64__
+  std::map<int,std::string> names = {{0,"Xor8"},{1,"Xor12"},
+   {2,"Xor16"}, {3,"Cuckoo8"}, {4,"Cuckoo12"},
+   {5,"Cuckoo16"}, {6,"CuckooSemiSort13" }, {7,"Bloom8"},
+   {8,"Bloom12" }, {9,"Bloom16"}, {10,"BlockedBloom"},
+   {11,"sort"}, {12,"Xor+8"}, {13,"Xor+16"},
+   {14,"GCS"},  {22, "Xor10 (NBitArray)"}, {23, "Xor14 (NBitArray)"},
+   {25, "Xor10"},{26, "Xor10.666"}, {37,"Bloom8 (addall)"},
+   {38,"Bloom12 (addall)"},
+   {40,"BlockedBloom (addall)"}
+  };
+#elif defined( __AVX2__)
   std::map<int,std::string> names = {{0,"Xor8"},{1,"Xor12"},
    {2,"Xor16"}, {3,"Cuckoo8"}, {4,"Cuckoo12"},
    {5,"Cuckoo16"}, {6,"CuckooSemiSort13" }, {7,"Bloom8"},
@@ -705,6 +739,18 @@ int main(int argc, char * argv[]) {
    {38,"Bloom12 (addall)"},{39,"Bloom16 (addall)"},
    {40,"BlockedBloom (addall)"}, {63,"BlockedBloom16"}, {64,"BlockedBloom64"}
   };
+#else
+  std::map<int,std::string> names = {{0,"Xor8"},{1,"Xor12"},
+   {2,"Xor16"}, {3,"Cuckoo8"}, {4,"Cuckoo12"},
+   {5,"Cuckoo16"}, {6,"CuckooSemiSort13" }, {7,"Bloom8"},
+   {8,"Bloom12" }, {9,"Bloom16"}, 
+   {11,"sort"}, {12,"Xor+8"}, {13,"Xor+16"},
+   {14,"GCS"}, {22, "Xor10 (NBitArray)"}, {23, "Xor14 (NBitArray)"},
+   {25, "Xor10"},{26, "Xor10.666"}, {37,"Bloom8 (addall)"},
+   {38,"Bloom12 (addall)"},{39,"Bloom16 (addall)"}
+  };
+#endif
+
 
   if (argc < 2) {
     cout << "Usage: " << argv[0] << " <numberOfEntries> [<algorithmId> [<seed>]]" << endl;
@@ -736,6 +782,10 @@ int main(int argc, char * argv[]) {
         // we have a list of algos
         algorithmId = 9999999; // disabling
         parse_comma_separated(argv[2], algos);
+        if(algos.size() == 0) {
+           cerr<< " no algo selected " << endl;
+           return -3;
+        }
       } else {
         // we select just one
         stringstream input_string_2(argv[2]);
@@ -914,6 +964,14 @@ int main(int argc, char * argv[]) {
       cout << setw(NAME_WIDTH) << names[9] << cf << endl;
   }
 
+#ifdef __aarch64__
+  if (algorithmId == 10 || algorithmId < 0 || (algos.find(10) != algos.end())) {
+      auto cf = FilterBenchmark<SimdBlockFilterFixed<>>(
+          add_count, to_add, distinct_add, to_lookup, distinct_lookup, intersectionsize, hasduplicates, mixed_sets, seed);
+      cout << setw(NAME_WIDTH) << names[10] << cf << endl;
+  }
+#endif 
+
 #ifdef __AVX2__
   if (algorithmId == 10 || algorithmId < 0 || (algos.find(10) != algos.end())) {
       auto cf = FilterBenchmark<SimdBlockFilterFixed<>>(
@@ -1091,8 +1149,13 @@ int main(int argc, char * argv[]) {
       cout << setw(NAME_WIDTH) << names[40] << cf << endl;
   }
 #endif
-
-
+#ifdef __aarch64__
+  if (algorithmId == 40 || algorithmId < 0 || (algos.find(40) != algos.end())) {
+      auto cf = FilterBenchmark<SimdBlockFilterFixed<SimpleMixSplit>>(
+          add_count, to_add, distinct_add, to_lookup, distinct_lookup, intersectionsize, hasduplicates, mixed_sets, seed, true);
+      cout << setw(NAME_WIDTH) << names[40] << cf << endl;
+  }
+#endif
 
 // broken algorithms (don't always find all key)
 /*

src/simd-block-fixed-fpp.h

@@ -18,7 +18,6 @@
 #include <algorithm>
 #include <new>
 
-#include <x86intrin.h>
 
 #include "hashutil.h"
 
@@ -40,6 +39,7 @@ inline uint64_t rotl64(uint64_t n, unsigned int c) {
 }
 
 #ifdef __AVX2__
+#include <x86intrin.h>
 
 template<typename HashFamily = ::hashing::TwoIndependentMultiplyShift>
 class SimdBlockFilterFixed {
@@ -293,7 +293,7 @@ SimdBlockFilterFixed64<HashFamily>::Find(const uint64_t key) const noexcept {
 // 32-bit version ARM
 //////////////////
 #ifdef __aarch64__
-
+#include <arm_neon.h>
 struct mask32bytes {
     uint32x4_t first;
     uint32x4_t second;
@@ -366,19 +366,16 @@ template <typename HashFamily>
 [[gnu::always_inline]] inline mask32bytes_t
 SimdBlockFilterFixed<HashFamily>::MakeMask(const uint32_t hash) noexcept {
   const uint32x4_t ones = {1,1,1,1};
-  // Odd contants for hashing:
   const uint32x4_t rehash1 = {0x47b6137bU, 0x44974d91U, 0x8824ad5bU,
       0xa2b7289dU};
   const uint32x4_t rehash2 = {0x705495c7U, 0x2df1424bU, 0x9efc4947U, 0x5c6bfb31U};
   uint32x4_t hash_data = {hash,hash,hash,hash};
-  // Multiply-shift hashing ala Dietzfelbinger et al.: multiply 'hash' by eight different
-  // odd constants, then keep the 5 most significant bits from each product.
   uint32x4_t part1 = vmulq_u32(hash_data,rehash1);
   uint32x4_t part2 = vmulq_u32(hash_data,rehash2);
   part1 = vshrq_n_u32(part1, 27);
   part2 = vshrq_n_u32(part2, 27);
-  vshlq_u32(ones, part1);
-  vshlq_u32(ones, part2);
+  part1 = vshlq_u32(ones, vreinterpretq_s32_u32(part1));
+  part2 = vshlq_u32(ones, vreinterpretq_s32_u32(part2));
   mask32bytes_t answer;
   answer.first = part1;
   answer.second = part2;
@@ -448,13 +445,13 @@ SimdBlockFilterFixed<HashFamily>::Find(const uint64_t key) const noexcept {
   const uint32_t bucket_idx = reduce(rotl64(hash, 32), bucketCount);
   const mask32bytes_t mask = MakeMask(hash);
   const mask32bytes_t bucket = directory_[bucket_idx];
-  uint32x4_t an1 = vbicq_u32(bucket.first,mask.first);
-  uint32x4_t an2 = vbicq_u32(bucket.second,mask.second);
+  uint32x4_t an1 = vbicq_u32(mask.first, bucket.first);
+  uint32x4_t an2 = vbicq_u32(mask.second,bucket.second);
   uint32x4_t an = vorrq_u32(an1, an2);
   uint64x2_t v64 = vreinterpretq_u64_u32(an);
   uint32x2_t v32 = vqmovn_u64(v64);
   uint64x1_t result = vreinterpret_u64_u32(v32);
-  return vget_lane_u64(result, 0);
+  return vget_lane_u64(result, 0) == 0;
 }
 
 
@@ -551,4 +548,4 @@ SimdBlockFilterFixed16<HashFamily>::Find(const uint64_t key) const noexcept {
   return _mm_testc_si128(bucketvalue,mask);
 }
 
-#endif // #ifdef __SSSE3__
+#endif // #ifdef __SSSE3__