Add logging to all traccc algorithms

This commit adds ACTS-style loggers to all existing traccc algorithms,
and requires that all future algorithms have the same. It also carefully
threads logger objects through the computation chain. Currently, little
is added in the way of useful logging outputs, as that can happen in a
future commit: this is just infrastructure.

Author: stephenswat

benchmarks/cpu/toy_detector_cpu.cpp

@@ -38,6 +38,9 @@
 #include <benchmark/benchmark.h>
 
 BENCHMARK_F(ToyDetectorBenchmark, CPU)(benchmark::State& state) {
+    std::unique_ptr<const Acts::Logger> _logger =
+        Acts::getDefaultLogger("TracccBenchmark", Acts::Logging::Level::INFO);
+    ACTS_LOCAL_LOGGER(std::move(_logger));
 
     // Type declarations
     using host_detector_type = traccc::default_detector::host;
@@ -53,11 +56,13 @@ BENCHMARK_F(ToyDetectorBenchmark, CPU)(benchmark::State& state) {
     auto field = detray::bfield::create_const_field<scalar_type>(B);
 
     // Algorithms
-    traccc::seeding_algorithm sa(seeding_cfg, grid_cfg, filter_cfg, host_mr);
-    traccc::track_params_estimation tp(host_mr);
+    traccc::seeding_algorithm sa(seeding_cfg, grid_cfg, filter_cfg, host_mr,
+                                 logger().clone());
+    traccc::track_params_estimation tp(host_mr, logger().clone());
     traccc::host::combinatorial_kalman_filter_algorithm host_finding(
-        finding_cfg);
-    traccc::host::kalman_fitting_algorithm host_fitting(fitting_cfg, host_mr);
+        finding_cfg, logger().clone());
+    traccc::host::kalman_fitting_algorithm host_fitting(fitting_cfg, host_mr,
+                                                        logger().clone());
 
     for (auto _ : state) {
 

benchmarks/cuda/toy_detector_cuda.cpp

@@ -41,6 +41,9 @@
 #include <benchmark/benchmark.h>
 
 BENCHMARK_F(ToyDetectorBenchmark, CUDA)(benchmark::State& state) {
+    std::unique_ptr<const Acts::Logger> _logger =
+        Acts::getDefaultLogger("TracccTest", Acts::Logging::Level::INFO);
+    ACTS_LOCAL_LOGGER(std::move(_logger));
 
     // Type declarations
     using rk_stepper_type = detray::rk_stepper<
@@ -77,19 +80,21 @@ BENCHMARK_F(ToyDetectorBenchmark, CUDA)(benchmark::State& state) {
 
     // Algorithms
     traccc::cuda::seeding_algorithm sa_cuda(seeding_cfg, grid_cfg, filter_cfg,
-                                            mr, async_copy, stream);
-    traccc::cuda::track_params_estimation tp_cuda(mr, async_copy, stream);
+                                            mr, async_copy, stream,
+                                            logger().clone());
+    traccc::cuda::track_params_estimation tp_cuda(mr, async_copy, stream,
+                                                  logger().clone());
     traccc::cuda::finding_algorithm<rk_stepper_type, device_navigator_type>
-        device_finding(finding_cfg, mr, async_copy, stream);
+        device_finding(finding_cfg, mr, async_copy, stream, logger().clone());
     traccc::cuda::fitting_algorithm<device_fitter_type> device_fitting(
-        fitting_cfg, mr, async_copy, stream);
+        fitting_cfg, mr, async_copy, stream, logger().clone());
 
     // Detector view object
     auto det_view = detray::get_data(det);
 
     // D2H copy object
     traccc::device::container_d2h_copy_alg<traccc::track_state_container_types>
-        track_state_d2h{{device_mr, &host_mr}, copy};
+        track_state_d2h{{device_mr, &host_mr}, copy, logger().clone()};
 
     for (auto _ : state) {
 

core/CMakeLists.txt

@@ -116,7 +116,7 @@ traccc_add_library( traccc_core core TYPE SHARED
   "src/ambiguity_resolution/greedy_ambiguity_resolution_algorithm.cpp" )
 target_link_libraries( traccc_core
   PUBLIC Eigen3::Eigen vecmem::core detray::core detray::detectors
-         traccc::algebra )
+         traccc::algebra ActsCore )
 
 # Prevent Eigen from getting confused when building code for a
 # CUDA or HIP backend with SYCL.

core/include/traccc/ambiguity_resolution/greedy_ambiguity_resolution_algorithm.hpp

@@ -8,6 +8,7 @@
 #pragma once
 
 // System include
+#include <Acts/Utilities/Logger.hpp>
 #include <algorithm>
 #include <initializer_list>
 #include <iostream>
@@ -110,8 +111,9 @@ class greedy_ambiguity_resolution_algorithm
     /// @param cfg  Configuration object
     // greedy_ambiguity_resolution_algorithm(const config_type& cfg) :
     // _config(cfg) {}
-    greedy_ambiguity_resolution_algorithm(const config_t cfg = {})
-        : _config{cfg} {}
+    greedy_ambiguity_resolution_algorithm(
+        const config_t cfg, std::unique_ptr<const Acts::Logger> logger)
+        : _config{cfg}, _logger{std::move(logger)} {}
 
     /// Run the algorithm
     ///
@@ -156,6 +158,10 @@ class greedy_ambiguity_resolution_algorithm
         state_t& final_state) const;
 
     config_t _config;
+
+    std::unique_ptr<const Acts::Logger> _logger;
+
+    const Acts::Logger& logger() const override { return *_logger; }
 };
 
 }  // namespace traccc

core/include/traccc/clusterization/clusterization_algorithm.hpp

@@ -41,7 +41,8 @@ class clusterization_algorithm
     ///
     /// @param mr The memory resource to use for the result objects
     ///
-    clusterization_algorithm(vecmem::memory_resource& mr);
+    clusterization_algorithm(vecmem::memory_resource& mr,
+                             std::unique_ptr<const Acts::Logger> logger);
 
     /// Construct measurements for each detector module
     ///
@@ -68,6 +69,14 @@ class clusterization_algorithm
     /// Reference to the host-accessible memory resource
     std::reference_wrapper<vecmem::memory_resource> m_mr;
 
+    /// Algorithm-specific logger object
+    std::unique_ptr<const Acts::Logger> m_logger;
+
+    /// Logger access method
+    const Acts::Logger& logger() const override {
+        assert(m_logger.get() != nullptr);
+        return *m_logger;
+    }
 };  // class clusterization_algorithm
 
 }  // namespace traccc::host

core/include/traccc/clusterization/measurement_creation_algorithm.hpp

@@ -39,7 +39,8 @@ class measurement_creation_algorithm
     ///
     /// @param mr The memory resource to use in the algorithm
     ///
-    measurement_creation_algorithm(vecmem::memory_resource &mr);
+    measurement_creation_algorithm(vecmem::memory_resource &mr,
+                                   std::unique_ptr<const Acts::Logger> logger);
 
     /// Callable operator for the connected component, based on one single
     /// module
@@ -58,6 +59,15 @@ class measurement_creation_algorithm
     /// The memory resource used by the algorithm
     std::reference_wrapper<vecmem::memory_resource> m_mr;
 
+    /// Algorithm-specific logger object
+    std::unique_ptr<const Acts::Logger> m_logger;
+
+    /// Logger access method
+    const Acts::Logger &logger() const override {
+        assert(m_logger.get() != nullptr);
+        return *m_logger;
+    }
+
 };  // class measurement_creation_algorithm
 
 }  // namespace traccc::host

core/include/traccc/clusterization/measurement_sorting_algorithm.hpp

@@ -36,6 +36,14 @@ class measurement_sorting_algorithm
     output_type operator()(const measurement_collection_types::view&
                                measurements_view) const override;
 
+    /// Algorithm-specific logger object
+    std::unique_ptr<const Acts::Logger> m_logger;
+
+    /// Logger access method
+    const Acts::Logger& logger() const override {
+        assert(m_logger.get() != nullptr);
+        return *m_logger;
+    }
 };  // class measurement_sorting_algorithm
 
 }  // namespace traccc::host

core/include/traccc/clusterization/sparse_ccl_algorithm.hpp

@@ -34,7 +34,8 @@ class sparse_ccl_algorithm
     ///
     /// @param mr is the memory resource
     ///
-    sparse_ccl_algorithm(vecmem::memory_resource& mr);
+    sparse_ccl_algorithm(vecmem::memory_resource& mr,
+                         std::unique_ptr<const Acts::Logger> logger);
 
     /// @name Operator(s) to use in host code
     /// @{
@@ -54,6 +55,14 @@ class sparse_ccl_algorithm
     /// The memory resource used by the algorithm
     std::reference_wrapper<vecmem::memory_resource> m_mr;
 
+    /// Algorithm-specific logger object
+    std::unique_ptr<const Acts::Logger> m_logger;
+
+    /// Logger access method
+    const Acts::Logger& logger() const override {
+        assert(m_logger.get() != nullptr);
+        return *m_logger;
+    }
 };  // class sparse_ccl_algorithm
 
 }  // namespace traccc::host

core/include/traccc/finding/combinatorial_kalman_filter_algorithm.hpp

@@ -46,7 +46,8 @@ class combinatorial_kalman_filter_algorithm
     using output_type = track_candidate_container_types::host;
 
     /// Constructor with the algorithm's configuration
-    explicit combinatorial_kalman_filter_algorithm(const config_type& config);
+    explicit combinatorial_kalman_filter_algorithm(
+        const config_type& config, std::unique_ptr<const Acts::Logger> logger);
 
     /// Execute the algorithm
     ///
@@ -88,6 +89,14 @@ class combinatorial_kalman_filter_algorithm
     /// Algorithm configuration
     config_type m_config;
 
+    /// Algorithm-specific logger object
+    std::unique_ptr<const Acts::Logger> m_logger;
+
+    /// Logger access method
+    const Acts::Logger& logger() const override {
+        assert(m_logger.get() != nullptr);
+        return *m_logger;
+    }
 };  // class combinatorial_kalman_filter_algorithm
 
 }  // namespace traccc::host

core/include/traccc/fitting/kalman_fitting_algorithm.hpp

@@ -48,8 +48,9 @@ class kalman_fitting_algorithm
     ///
     /// @param config The configuration object
     ///
-    explicit kalman_fitting_algorithm(const config_type& config,
-                                      vecmem::memory_resource& mr);
+    explicit kalman_fitting_algorithm(
+        const config_type& config, vecmem::memory_resource& mr,
+        std::unique_ptr<const Acts::Logger> logger);
 
     /// Execute the algorithm
     ///
@@ -87,6 +88,14 @@ class kalman_fitting_algorithm
     /// Memory resource to use in the algorithm
     std::reference_wrapper<vecmem::memory_resource> m_mr;
 
+    /// Algorithm-specific logger object
+    std::unique_ptr<const Acts::Logger> m_logger;
+
+    /// Logger access method
+    const Acts::Logger& logger() const override {
+        assert(m_logger.get() != nullptr);
+        return *m_logger;
+    }
 };  // class kalman_fitting_algorithm
 
 }  // namespace traccc::host

core/include/traccc/seeding/doublet_finding.hpp

@@ -32,7 +32,9 @@ struct doublet_finding
     ///
     /// @param seedfinder_config is the configuration parameters
     /// @param isp_container is the internal spacepoint container
-    doublet_finding(const seedfinder_config& config) : m_config(config) {}
+    doublet_finding(const seedfinder_config& config,
+                    std::unique_ptr<const Acts::Logger> logger)
+        : m_config(config), m_logger(std::move(logger)) {}
 
     /// Callable operator for doublet finding per middle spacepoint
     ///
@@ -99,6 +101,15 @@ struct doublet_finding
 
     private:
     seedfinder_config m_config;
+
+    /// Algorithm-specific logger object
+    std::unique_ptr<const Acts::Logger> m_logger;
+
+    /// Logger access method
+    const Acts::Logger& logger() const override {
+        assert(m_logger.get() != nullptr);
+        return *m_logger;
+    }
 };
 
 }  // namespace traccc

core/include/traccc/seeding/seed_filtering.hpp

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <Acts/Utilities/Logger.hpp>
+
 // Library include(s).
 #include "traccc/edm/seed.hpp"
 #include "traccc/edm/spacepoint.hpp"
@@ -21,7 +23,8 @@ class seed_filtering {
 
     public:
     /// Constructor with the seed filter configuration
-    seed_filtering(const seedfilter_config& config);
+    seed_filtering(const seedfilter_config& config,
+                   std::unique_ptr<const Acts::Logger> logger);
 
     /// Callable operator for the seed filtering
     ///
@@ -40,6 +43,14 @@ class seed_filtering {
     /// Seed filter configuration
     seedfilter_config m_filter_config;
 
+    /// Algorithm-specific logger object
+    std::unique_ptr<const Acts::Logger> m_logger;
+
+    /// Logger access method
+    const Acts::Logger& logger() const {
+        assert(m_logger.get() != nullptr);
+        return *m_logger;
+    }
 };  // class seed_filtering
 
 }  // namespace traccc

core/include/traccc/seeding/seed_finding.hpp

@@ -31,7 +31,8 @@ class seed_finding
     /// @param filter_config is the seed filter configuration
     ///
     seed_finding(const seedfinder_config& find_config,
-                 const seedfilter_config& filter_config);
+                 const seedfilter_config& filter_config,
+                 std::unique_ptr<const Acts::Logger> logger);
 
     /// Callable operator for the seed finding
     ///
@@ -53,6 +54,14 @@ class seed_finding
     /// Algorithm performing the seed selection
     seed_filtering m_seed_filtering;
 
+    /// Algorithm-specific logger object
+    std::unique_ptr<const Acts::Logger> m_logger;
+
+    /// Logger access method
+    const Acts::Logger& logger() const override {
+        assert(m_logger.get() != nullptr);
+        return *m_logger;
+    }
 };  // class seed_finding
 
 }  // namespace traccc

core/include/traccc/seeding/seeding_algorithm.hpp

@@ -31,7 +31,8 @@ class seeding_algorithm : public algorithm<seed_collection_types::host(
     seeding_algorithm(const seedfinder_config& finder_config,
                       const spacepoint_grid_config& grid_config,
                       const seedfilter_config& filter_config,
-                      vecmem::memory_resource& mr);
+                      vecmem::memory_resource& mr,
+                      std::unique_ptr<const Acts::Logger> logger);
 
     /// Operator executing the algorithm.
     ///
@@ -47,6 +48,15 @@ class seeding_algorithm : public algorithm<seed_collection_types::host(
     /// Sub-algorithm performing the seed finding
     seed_finding m_seed_finding;
 
+    /// Algorithm-specific logger object
+    std::unique_ptr<const Acts::Logger> m_logger;
+
+    /// Logger access method
+    const Acts::Logger& logger() const override {
+        assert(m_logger.get() != nullptr);
+        return *m_logger;
+    }
+
 };  // class seeding_algorithm
 
 }  // namespace traccc

core/include/traccc/seeding/silicon_pixel_spacepoint_formation_algorithm.hpp

@@ -42,7 +42,9 @@ class silicon_pixel_spacepoint_formation_algorithm
     ///
     /// @param mr is the memory resource
     ///
-    silicon_pixel_spacepoint_formation_algorithm(vecmem::memory_resource& mr);
+    silicon_pixel_spacepoint_formation_algorithm(
+        vecmem::memory_resource& mr,
+        std::unique_ptr<const Acts::Logger> logger);
 
     /// Construct spacepoints from 2D silicon pixel measurements
     ///
@@ -70,6 +72,14 @@ class silicon_pixel_spacepoint_formation_algorithm
     /// Memory resource to use for the output container
     std::reference_wrapper<vecmem::memory_resource> m_mr;
 
+    /// Algorithm-specific logger object
+    std::unique_ptr<const Acts::Logger> m_logger;
+
+    /// Logger access method
+    const Acts::Logger& logger() const override {
+        assert(m_logger.get() != nullptr);
+        return *m_logger;
+    }
 };  // class silicon_pixel_spacepoint_formation_algorithm
 
 }  // namespace traccc::host