Move point cloud functions into ArborXBenchmark namespace

aprokop · May 3, 2024 · 170087a · 170087a
1 parent 1fbee14
commit 170087a
Show file tree

Hide file tree

Showing 4 changed files with 33 additions and 15 deletions.
diff --git a/benchmarks/bvh_driver/benchmark_registration.hpp b/benchmarks/bvh_driver/benchmark_registration.hpp
@@ -25,6 +25,8 @@
 
 struct Spec
 {
+  using PointCloudType = ArborXBenchmark::PointCloudType;
+
   std::string backends;
   int n_values;
   int n_queries;
@@ -98,7 +100,7 @@ struct Spec
 
 template <typename DeviceType>
 Kokkos::View<ArborX::Point *, DeviceType>
-constructPoints(int n_values, PointCloudType point_cloud_type)
+constructPoints(int n_values, ArborXBenchmark::PointCloudType point_cloud_type)
 {
   Kokkos::View<ArborX::Point *, DeviceType> random_points(
       Kokkos::view_alloc(Kokkos::WithoutInitializing,
@@ -109,22 +111,23 @@ constructPoints(int n_values, PointCloudType point_cloud_type)
   // boxes 2x2x2 centered around a random point) will remain constant as
   // problem size is changed.
   auto const a = std::cbrt(n_values);
-  generatePointCloud(point_cloud_type, a, random_points);
+  ArborXBenchmark::generatePointCloud(point_cloud_type, a, random_points);
 
   return random_points;
 }
 
 template <typename DeviceType>
 Kokkos::View<decltype(ArborX::intersects(ArborX::Sphere{})) *, DeviceType>
 makeSpatialQueries(int n_values, int n_queries, int n_neighbors,
-                   PointCloudType target_point_cloud_type)
+                   ArborXBenchmark::PointCloudType target_point_cloud_type)
 {
   Kokkos::View<ArborX::Point *, DeviceType> random_points(
       Kokkos::view_alloc(Kokkos::WithoutInitializing,
                          "Benchmark::random_points"),
       n_queries);
   auto const a = std::cbrt(n_values);
-  generatePointCloud(target_point_cloud_type, a, random_points);
+  ArborXBenchmark::generatePointCloud(target_point_cloud_type, a,
+                                      random_points);
 
   Kokkos::View<decltype(ArborX::intersects(ArborX::Sphere{})) *, DeviceType>
       queries(
@@ -147,14 +150,15 @@ makeSpatialQueries(int n_values, int n_queries, int n_neighbors,
 template <typename DeviceType>
 Kokkos::View<ArborX::Nearest<ArborX::Point> *, DeviceType>
 makeNearestQueries(int n_values, int n_queries, int n_neighbors,
-                   PointCloudType target_point_cloud_type)
+                   ArborXBenchmark::PointCloudType target_point_cloud_type)
 {
   Kokkos::View<ArborX::Point *, DeviceType> random_points(
       Kokkos::view_alloc(Kokkos::WithoutInitializing,
                          "Benchmark::random_points"),
       n_queries);
   auto const a = std::cbrt(n_values);
-  generatePointCloud(target_point_cloud_type, a, random_points);
+  ArborXBenchmark::generatePointCloud(target_point_cloud_type, a,
+                                      random_points);
 
   Kokkos::View<ArborX::Nearest<ArborX::Point> *, DeviceType> queries(
       Kokkos::view_alloc(Kokkos::WithoutInitializing, "Benchmark::queries"),

diff --git a/benchmarks/bvh_driver/bvh_driver.cpp b/benchmarks/bvh_driver/bvh_driver.cpp
@@ -21,6 +21,7 @@
 #include <iostream>
 
 #include "benchmark_registration.hpp"
+#include <point_clouds.hpp>
 
 #ifdef ARBORX_PERFORMANCE_TESTING
 #include <mpi.h>
@@ -275,8 +276,10 @@ int main(int argc, char *argv[])
   if (vm.count("exact-spec") == 0)
   {
     single_spec.backends = "all";
-    single_spec.source_point_cloud_type = to_point_cloud_enum(source_pt_cloud);
-    single_spec.target_point_cloud_type = to_point_cloud_enum(target_pt_cloud);
+    single_spec.source_point_cloud_type =
+        ArborXBenchmark::to_point_cloud_enum(source_pt_cloud);
+    single_spec.target_point_cloud_type =
+        ArborXBenchmark::to_point_cloud_enum(target_pt_cloud);
     specs.push_back(single_spec);
   }
 

diff --git a/benchmarks/triangulated_surface_distance/triangulated_surface_distance.cpp b/benchmarks/triangulated_surface_distance/triangulated_surface_distance.cpp
@@ -294,7 +294,8 @@ int main(int argc, char *argv[])
       Kokkos::view_alloc(space, Kokkos::WithoutInitializing,
                          "Benchmark::points"),
       n);
-  generatePointCloud(PointCloudType::filled_box, std::cbrt(n), random_points);
+  ArborXBenchmark::generatePointCloud(
+      ArborXBenchmark::PointCloudType::filled_box, std::cbrt(n), random_points);
   Kokkos::Profiling::popRegion();
 
   std::cout << "#triangles        : " << triangles.size() << '\n';

diff --git a/benchmarks/utils/point_clouds.hpp b/benchmarks/utils/point_clouds.hpp
@@ -9,8 +9,8 @@
  * SPDX-License-Identifier: BSD-3-Clause                                    *
  ****************************************************************************/
 
-#ifndef ARBORX_POINT_CLOUDS_HPP
-#define ARBORX_POINT_CLOUDS_HPP
+#ifndef ARBORX_BENCHMARK_POINT_CLOUDS_HPP
+#define ARBORX_BENCHMARK_POINT_CLOUDS_HPP
 
 #include <ArborX_DetailsKokkosExtAccessibilityTraits.hpp>
 #include <ArborX_Exception.hpp>
@@ -21,6 +21,9 @@
 #include <fstream>
 #include <random>
 
+namespace ArborXBenchmark
+{
+
 enum class PointCloudType
 {
   filled_box,
@@ -43,6 +46,9 @@ inline PointCloudType to_point_cloud_enum(std::string const &str)
                            " doesn't correspond to any known PointCloudType!");
 }
 
+namespace Details
+{
+
 template <class Point, typename... ViewProperties>
 void filledBoxCloud(double const half_edge,
                     Kokkos::View<Point *, ViewProperties...> random_points)
@@ -167,6 +173,8 @@ void hollowSphereCloud(double const radius,
   }
 }
 
+} // namespace Details
+
 template <class Point, typename DeviceType>
 void generatePointCloud(PointCloudType const point_cloud_type,
                         double const length,
@@ -180,21 +188,23 @@ void generatePointCloud(PointCloudType const point_cloud_type,
   switch (point_cloud_type)
   {
   case PointCloudType::filled_box:
-    filledBoxCloud(length, random_points_host);
+    Details::filledBoxCloud(length, random_points_host);
     break;
   case PointCloudType::hollow_box:
-    hollowBoxCloud(length, random_points_host);
+    Details::hollowBoxCloud(length, random_points_host);
     break;
   case PointCloudType::filled_sphere:
-    filledSphereCloud(length, random_points_host);
+    Details::filledSphereCloud(length, random_points_host);
     break;
   case PointCloudType::hollow_sphere:
-    hollowSphereCloud(length, random_points_host);
+    Details::hollowSphereCloud(length, random_points_host);
     break;
   default:
     throw ArborX::SearchException("not implemented");
   }
   Kokkos::deep_copy(random_points, random_points_host);
 }
 
+} // namespace ArborXBenchmark
+
 #endif