Alpaka: Clustering + Throughput

core/include/traccc/definitions/hints.hpp

@@ -0,0 +1,24 @@
+/**
+ * TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2024 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+#if not defined __has_builtin
+#define TRACCC_ASSUME(...)
+#elif __has_builtin(__builtin_assume)
+#define TRACCC_ASSUME(...) __builtin_assume(__VA_ARGS__)
+#else
+#define TRACCC_ASSUME(...)
+#endif
+
+#if defined(__CUDACC__) || defined(__HIP__) || defined(__OPENMP) || \
+    defined(__SYCL__) || defined(__clang__)
+#define TRACCC_PRAGMA_UNROLL _Pragma("unroll")
+#else
+#define TRACCC_PRAGMA_UNROLL
+#endif

device/alpaka/CMakeLists.txt

@@ -9,7 +9,7 @@ include( traccc-alpaka-functions )
 include( traccc-compiler-options-cpp )
 
 set(PUBLIC_LIBRARIES traccc::core detray::core detray::utils vecmem::core covfie::core)
-set(PRIVATE_LIBRARIES traccc::device_common alpaka::alpaka)
+set(PRIVATE_LIBRARIES traccc::device_common alpaka::alpaka traccc::Thrust)
 
 if(alpaka_ACC_GPU_CUDA_ENABLE)
   enable_language(CUDA)
@@ -26,11 +26,18 @@ traccc_add_alpaka_library( traccc_alpaka alpaka TYPE SHARED
   # Utility definitions.
   "include/traccc/alpaka/utils/make_prefix_sum_buff.hpp"
   "src/utils/make_prefix_sum_buff.cpp"
-  # Seed finding includes
+  # Seed finding code.
   "include/traccc/alpaka/seeding/spacepoint_binning.hpp"
   "include/traccc/alpaka/seeding/seed_finding.hpp"
   "include/traccc/alpaka/seeding/seeding_algorithm.hpp"
   "include/traccc/alpaka/seeding/track_params_estimation.hpp"
+  # Clusterization
+  "include/traccc/alpaka/clusterization/clusterization_algorithm.hpp"
+  "src/clusterization/clusterization_algorithm.cpp"
+  "include/traccc/alpaka/clusterization/measurement_sorting_algorithm.hpp"
+  "src/clusterization/measurement_sorting_algorithm.cpp"
+  "include/traccc/alpaka/clusterization/spacepoint_formation_algorithm.hpp"
+  "src/clusterization/spacepoint_formation_algorithm.cpp"
   # Seeding code
   "src/seeding/spacepoint_binning.cpp"
   "src/seeding/seed_finding.cpp"

device/alpaka/include/traccc/alpaka/clusterization/clusterization_algorithm.hpp

@@ -0,0 +1,68 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2023 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "traccc/edm/cell.hpp"
+#include "traccc/edm/measurement.hpp"
+#include "traccc/edm/spacepoint.hpp"
+#include "traccc/utils/algorithm.hpp"
+#include "traccc/utils/memory_resource.hpp"
+
+// VecMem include(s).
+#include <vecmem/utils/copy.hpp>
+
+namespace traccc::alpaka {
+
+/// Algorithm performing hit clusterization
+///
+/// This algorithm implements hit clusterization in a massively-parallel
+/// approach. Each thread handles a pre-determined number of detector cells.
+///
+/// This algorithm returns a buffer which is not necessarily filled yet. A
+/// synchronisation statement is required before destroying this buffer.
+///
+class clusterization_algorithm
+    : public algorithm<measurement_collection_types::buffer(
+          const cell_collection_types::const_view&,
+          const cell_module_collection_types::const_view&)> {
+
+    public:
+    /// Constructor for clusterization algorithm
+    ///
+    /// @param mr The memory resource(s) to use in the algorithm
+    /// @param copy The copy object to use for copying data between device
+    ///             and host memory blocks
+    /// @param target_cells_per_partition the average number of cells in each
+    /// partition
+    ///
+    clusterization_algorithm(const traccc::memory_resource& mr,
+                             vecmem::copy& copy,
+                             const unsigned short target_cells_per_partition);
+
+    /// Callable operator for clusterization algorithm
+    ///
+    /// @param cells        a collection of cells
+    /// @param modules      a collection of modules
+    /// @return a spacepoint collection (buffer) and a collection (buffer) of
+    /// links from cells to the spacepoints they belong to.
+    output_type operator()(
+        const cell_collection_types::const_view& cells,
+        const cell_module_collection_types::const_view& modules) const override;
+
+    private:
+    /// The average number of cells in each partition
+    using config_type = unsigned short;
+    config_type m_target_cells_per_partition;
+    /// The memory resource(s) to use
+    traccc::memory_resource m_mr;
+    /// The copy object to use
+    std::reference_wrapper<vecmem::copy> m_copy;
+};
+
+}  // namespace traccc::alpaka

device/alpaka/include/traccc/alpaka/clusterization/measurement_sorting_algorithm.hpp

@@ -0,0 +1,54 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2024 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "traccc/edm/measurement.hpp"
+#include "traccc/utils/algorithm.hpp"
+
+// VecMem include(s).
+#include <vecmem/utils/copy.hpp>
+
+// System include(s).
+#include <functional>
+
+namespace traccc::alpaka {
+
+/// Algorithm sorting the reconstructed measurements in their container
+///
+/// The track finding algorithm expects measurements belonging to a single
+/// detector module to be consecutive in memory. But
+/// @c traccc::alpaka::clusterization_algorithm does not (currently) produce the
+/// measurements in such an ordered state. This is where this algorithm comes
+/// to the rescue.
+///
+class measurement_sorting_algorithm
+    : public algorithm<measurement_collection_types::view(
+          const measurement_collection_types::view&)> {
+
+    public:
+    /// Constructor for the algorithm
+    ///
+    /// @param copy The copy object to use in the algorithm
+    ///
+    measurement_sorting_algorithm(vecmem::copy& copy);
+
+    /// Callable operator performing the sorting on a container
+    ///
+    /// @param measurements The measurements to sort
+    ///
+    output_type operator()(const measurement_collection_types::view&
+                               measurements_view) const override;
+
+    private:
+    /// Copy object to use in the algorithm
+    std::reference_wrapper<vecmem::copy> m_copy;
+
+};  // class measurement_sorting_algorithm
+
+}  // namespace traccc::alpaka

device/alpaka/include/traccc/alpaka/clusterization/spacepoint_formation_algorithm.hpp

@@ -0,0 +1,63 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2024 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Project include(s).
+#include "traccc/edm/cell.hpp"
+#include "traccc/edm/measurement.hpp"
+#include "traccc/edm/spacepoint.hpp"
+#include "traccc/utils/algorithm.hpp"
+#include "traccc/utils/memory_resource.hpp"
+
+// VecMem include(s).
+#include <vecmem/utils/copy.hpp>
+
+// System include(s).
+#include <functional>
+
+namespace traccc::alpaka {
+
+/// Algorithm forming space points out of measurements
+///
+/// This algorithm performs the local-to-global transformation of the 2D
+/// measurements made on every detector module, into 3D spacepoint coordinates.
+///
+class spacepoint_formation_algorithm
+    : public algorithm<spacepoint_collection_types::buffer(
+          const measurement_collection_types::const_view&,
+          const cell_module_collection_types::const_view&)> {
+
+    public:
+    /// Constructor for spacepoint_formation
+    ///
+    /// @param mr is the memory resource
+    ///
+    spacepoint_formation_algorithm(const traccc::memory_resource& mr,
+                                   vecmem::copy& copy);
+
+    /// Callable operator for the space point formation, based on one single
+    /// module
+    ///
+    /// @param measurements_view A collection of measurements
+    /// @param modules_view A collection of modules the measurements link to
+    /// @return A spacepoint container, with one spacepoint for every
+    ///         measurement
+    ///
+    output_type operator()(
+        const measurement_collection_types::const_view& measurements_view,
+        const cell_module_collection_types::const_view& modules_view)
+        const override;
+
+    private:
+    /// The memory resource(s) to use
+    traccc::memory_resource m_mr;
+    /// The copy object to use
+    std::reference_wrapper<vecmem::copy> m_copy;
+};  // class spacepoint_formation_algorithm
+
+}  // namespace traccc::alpaka

device/alpaka/include/traccc/alpaka/seeding/track_params_estimation.hpp

@@ -15,17 +15,13 @@
 #include "traccc/utils/algorithm.hpp"
 #include "traccc/utils/memory_resource.hpp"
 
-// VecMem include(s).
-#include <vecmem/utils/copy.hpp>
-
 namespace traccc::alpaka {
 
 /// track parameter estimation for alpaka
 struct track_params_estimation
     : public algorithm<bound_track_parameters_collection_types::buffer(
           const spacepoint_collection_types::const_view&,
-          const seed_collection_types::const_view&,
-          const cell_module_collection_types::const_view&, const vector3&,
+          const seed_collection_types::const_view&, const vector3&,
           const std::array<traccc::scalar, traccc::e_bound_size>&)> {
 
     public:
@@ -50,7 +46,6 @@ struct track_params_estimation
     output_type operator()(
         const spacepoint_collection_types::const_view& spacepoints_view,
         const seed_collection_types::const_view& seeds_view,
-        const cell_module_collection_types::const_view& modules_view,
         const vector3& bfield,
         const std::array<traccc::scalar, traccc::e_bound_size>& = {
             0.02 * detray::unit<traccc::scalar>::mm,