fixed bulk sizes, provided compile-time-n bulk ops

Author: joaquintides

include/boost/bloom/detail/core.hpp

@@ -217,8 +217,8 @@ class filter_core:empty_value<Allocator,0>
   using difference_type=std::ptrdiff_t;
   using pointer=unsigned char*;
   using const_pointer=const unsigned char*;
-  static constexpr std::size_t bulk_insert_size=(8+prefetched_cachelines-1)/prefetched_cachelines;
-  static constexpr std::size_t bulk_may_contain_size=(8+prefetched_cachelines-1)/prefetched_cachelines;
+  static constexpr std::size_t bulk_insert_size=16;
+  static constexpr std::size_t bulk_may_contain_size=16;
 
   explicit filter_core(std::size_t m=0):filter_core{m,allocator_type{}}{}
 
@@ -392,7 +392,7 @@ class filter_core:empty_value<Allocator,0>
   BOOST_FORCEINLINE void bulk_insert(HashStream h,std::size_t n)
   {
     while(n>=2*bulk_insert_size){
-      bulk_insert_impl(h,bulk_insert_size);
+      bulk_insert_impl<bulk_insert_size>(h);
       n-=bulk_insert_size;
     }
     if(n){
@@ -404,7 +404,7 @@ class filter_core:empty_value<Allocator,0>
   BOOST_FORCEINLINE void bulk_may_contain(HashStream h,std::size_t n,F f)const
   {
     while(n>=2*bulk_may_contain_size){
-      bulk_may_contain_impl(h,bulk_may_contain_size,f);
+      bulk_may_contain_impl<bulk_may_contain_size>(h,f);
       n-=bulk_may_contain_size;
     }
     if(n){
@@ -729,6 +729,34 @@ class filter_core:empty_value<Allocator,0>
     return p;
   }
 
+  template<std::size_t N,typename HashStream>
+  BOOST_FORCEINLINE void bulk_insert_impl(HashStream&& h)
+  {
+    std::uint64_t  hashes[N];
+    unsigned char* positions[N];
+
+    for(auto i=N;i--;){
+      auto& hash=hashes[i]=h();
+      auto& p=positions[i];
+      hs.prepare_hash(hash);
+      p=next_element(hash);
+    }
+    if(BOOST_UNLIKELY(ar.data==nullptr))return;
+    for(auto j=k-1;j--;){
+      for(auto i=N;i--;){
+        auto& hash=hashes[i];
+        auto& p=positions[i];
+        set(p,hash);
+        p=next_element(hash);
+      }
+    }
+    for(auto i=N;i--;){
+      auto& hash=hashes[i];
+      auto& p=positions[i];
+      set(p,hash);
+    }
+  }
+
   template<typename HashStream>
   BOOST_FORCEINLINE void bulk_insert_impl(HashStream&& h,std::size_t n)
   {
@@ -757,6 +785,56 @@ class filter_core:empty_value<Allocator,0>
     }
   }
 
+  template<std::size_t N,typename HashStream,typename F>
+  BOOST_FORCEINLINE void bulk_may_contain_impl(HashStream&& h,F&& f)const
+  {
+    if(k==1){
+      std::uint64_t        hashes[N];
+      const unsigned char* positions[N];
+
+      for(auto i=N;i--;){
+        auto& hash=hashes[i]=h();
+        auto& p=positions[i];
+        hs.prepare_hash(hash);
+        p=next_element(hash);
+      }
+      for(auto i=N;i--;){
+        auto& hash=hashes[i];
+        auto& p=positions[i];
+        f(get(p,hash));
+      }
+    }
+    else{
+      std::uint64_t        hashes[N];
+      const unsigned char* positions[N];
+      bool                 results[N];
+
+      for(auto i=N;i--;){
+        auto& hash=hashes[i]=h();
+        auto& p=positions[i];
+        results[i]=true;
+        hs.prepare_hash(hash);
+        p=next_element(hash);
+      }
+      for(auto j=k-1;j--;){
+        for(auto i=N;i--;){
+          auto& hash=hashes[i];
+          auto& p=positions[i];
+          auto& res=results[i];
+          res&=get(p,hash);
+          p=next_element(hash);
+        }
+      }
+      for(auto i=N;i--;){
+        auto& hash=hashes[i];
+        auto& p=positions[i];
+        auto& res=results[i];
+        res&=get(p,hash);
+        f(res);
+      }
+    }
+  }
+
   template<typename HashStream,typename F>
   BOOST_FORCEINLINE void bulk_may_contain_impl(
     HashStream&& h,std::size_t n,F&& f)const