Rescuture code

examples/cpm/CMakeLists.txt

@@ -12,6 +12,7 @@ CPMAddPackage(
   OPTIONS
      "build_tests OFF"
      "build_benchmarks OFF"
+     "build_examples OFF"
 )
 
 set(CUDA_ARCHS 70)

examples/custom_types_example.cu

@@ -31,10 +31,10 @@
 #include <bght/p2bht.hpp>
 
 template <class K, class V>
-using iht16_80 = iht16<K, V, 12>;
+using iht16_80 = bght::iht16<K, V, 12>;
 
 template <class K, class V>
-using iht32_80 = iht32<K, V, 25>;
+using iht32_80 = bght::iht32<K, V, 25>;
 
 template <typename T1, typename T2>
 void CHECK(T1 t1, T2 t2) {
@@ -441,22 +441,22 @@ int main() {
   test_custom_type();
   std::cout << "Testing vec3-like type\n";
   test_vec3_like();
-  std::cout << "Testing bcht8\n";
-  test_scheme<bcht8>();
-  std::cout << "Testing bcht16\n";
-  test_scheme<bcht16>();
-  std::cout << "Testing bcht32\n";
-  test_scheme<bcht32>();
-
-  std::cout << "Testing iht16_80\n";
+  std::cout << "Testing bght::bcht8\n";
+  test_scheme<bght::bcht8>();
+  std::cout << "Testing bght::bcht16\n";
+  test_scheme<bght::bcht16>();
+  std::cout << "Testing bght::bcht32\n";
+  test_scheme<bght::bcht32>();
+
+  std::cout << "Testing bght::iht16_80\n";
   test_scheme<iht16_80>();
-  std::cout << "Testing iht32_80\n";
+  std::cout << "Testing bght::iht32_80\n";
   test_scheme<iht32_80>();
 
-  std::cout << "Testing p2bht16\n";
-  test_scheme<p2bht16>();
-  std::cout << "Testing p2bht32\n";
-  test_scheme<p2bht32>();
+  std::cout << "Testing bght::p2bht16\n";
+  test_scheme<bght::p2bht16>();
+  std::cout << "Testing bght::p2bht32\n";
+  test_scheme<bght::p2bht32>();
 
   std::cout << "Success\n";
 

examples/iht_example.cu

@@ -126,21 +126,21 @@ int main(int argc, char** argv) {
 
   if (threshold == 0) {
     if (bucket_size == 8) {
-      do_test<iht8, 0>(argc, argv);
+      do_test<bght::iht8, 0>(argc, argv);
     } else if (bucket_size == 16) {
-      do_test<iht16, 0>(argc, argv);
+      do_test<bght::iht16, 0>(argc, argv);
     } else if (bucket_size == 32) {
-      do_test<iht32, 0>(argc, argv);
+      do_test<bght::iht32, 0>(argc, argv);
     } else {
       std::cout << "Not supported bucket size\n";
     }
   } else {
     if (bucket_size == 8) {
-      do_test<iht8, 6>(argc, argv);
+      do_test<bght::iht8, 6>(argc, argv);
     } else if (bucket_size == 16) {
-      do_test<iht16, 12>(argc, argv);
+      do_test<bght::iht16, 12>(argc, argv);
     } else if (bucket_size == 32) {
-      do_test<iht32, 25>(argc, argv);
+      do_test<bght::iht32, 25>(argc, argv);
     } else {
       std::cout << "Not supported bucket size\n";
     }

include/bght/bcht.hpp

@@ -17,8 +17,8 @@
 #pragma once
 #include <bght/detail/allocator.hpp>
 #include <bght/detail/cuda_helpers.cuh>
-#include <bght/detail/hash_functions.cuh>
 #include <bght/detail/kernels.cuh>
+#include <bght/hash_functions.hpp>
 #include <bght/pair.cuh>
 #include <cuda/atomic>
 #include <cuda/std/utility>
@@ -218,8 +218,6 @@ struct bcht {
   std::size_t num_buckets_;
 };
 
-}  // namespace bght
-
 template <typename Key, typename T>
 using bcht8 = typename bght::bcht<Key,
                                   T,
@@ -247,4 +245,6 @@ using bcht32 = typename bght::bcht<Key,
                                    bght::cuda_allocator<char>,
                                    32>;
 
+}  // namespace bght
+
 #include <bght/detail/bcht_impl.cuh>

include/bght/cht.hpp

@@ -17,8 +17,8 @@
 #pragma once
 #include <bght/detail/allocator.hpp>
 #include <bght/detail/cuda_helpers.cuh>
-#include <bght/detail/hash_functions.cuh>
 #include <bght/detail/kernels.cuh>
+#include <bght/hash_functions.hpp>
 #include <bght/pair.cuh>
 #include <cuda/atomic>
 #include <cuda/std/utility>

include/bght/iht.hpp

@@ -17,9 +17,9 @@
 #pragma once
 #include <bght/detail/allocator.hpp>
 #include <bght/detail/cuda_helpers.cuh>
-#include <bght/detail/hash_functions.cuh>
 #include <bght/detail/kernels.cuh>
 #include <bght/detail/prime.hpp>
+#include <bght/hash_functions.hpp>
 #include <bght/pair.cuh>
 #include <cuda/atomic>
 #include <memory>
@@ -270,7 +270,6 @@ struct iht {
 
   std::size_t num_buckets_;
 };
-}  // namespace bght
 
 template <typename Key, typename T, int Threshold = 6>
 using iht8 = typename bght::iht<Key,
@@ -301,4 +300,6 @@ using iht32 = typename bght::iht<Key,
                                  32,
                                  Threshold>;
 
+}  // namespace bght
+
 #include <bght/detail/iht_impl.cuh>

include/bght/p2bht.hpp

@@ -17,8 +17,8 @@
 #pragma once
 #include <bght/detail/allocator.hpp>
 #include <bght/detail/cuda_helpers.cuh>
-#include <bght/detail/hash_functions.cuh>
 #include <bght/detail/kernels.cuh>
+#include <bght/hash_functions.hpp>
 #include <bght/pair.cuh>
 #include <cuda/atomic>
 #include <cuda/std/utility>
@@ -214,8 +214,6 @@ struct p2bht {
   std::size_t num_buckets_;
 };
 
-}  // namespace bght
-
 template <typename Key, typename T>
 using p2bht8 = typename bght::p2bht<Key,
                                     T,
@@ -243,4 +241,6 @@ using p2bht32 = typename bght::p2bht<Key,
                                      bght::cuda_allocator<char>,
                                      32>;
 
+}  // namespace bght
+
 #include <bght/detail/p2bht_impl.cuh>

test/gtest_map.cu

@@ -15,11 +15,14 @@
  */
 
 #include <gtest/gtest.h>
-#include <bcht.hpp>
+
+#include <bght/cht.hpp>
+
+#include <bght/bcht.hpp>
+#include <bght/iht.hpp>
+#include <bght/p2bht.hpp>
 #include <cstdint>
-#include <iht.hpp>
 #include <limits>
-#include <p2bht.hpp>
 #include <type_traits>
 
 // Based on sample6_unittest