CUDA Throughput Improvement, main branch (2024.05.06.) (#576)

* Made I/O functions use traccc::io::get_absolute_path(...) during reading.

This is to make it possible to pick up files from anywhere, as long
as the user provides an absolute file name.

* Returning a reduced amount of info about the fitted tracks.

This is to avoid the (currently) very expensive copy of the jagged
vector of track states back to the host.

* Fixed the geometry file locations for the tests.

So that they would not be treated as absolute path names
by the updated I/O code.

* Removed the comparison of chi2 values from the fit results.

This is a temporary measure, until the chi2 values "start behaving".
But for now it's not completely ridiculous that the CPU and GPU
code would produce different values for that parameter.

examples/run/cuda/full_chain_algorithm.cpp

@@ -62,7 +62,6 @@ full_chain_algorithm::full_chain_algorithm(
       m_fitting(fitting_config,
                 memory_resource{*m_cached_device_mr, &m_host_mr}, m_copy,
                 m_stream),
-      m_result_copy(memory_resource{*m_cached_device_mr, &m_host_mr}, m_copy),
       m_finder_config(finder_config),
       m_grid_config(grid_config),
       m_filter_config(filter_config),
@@ -113,7 +112,6 @@ full_chain_algorithm::full_chain_algorithm(const full_chain_algorithm& parent)
       m_fitting(parent.m_fitting_config,
                 memory_resource{*m_cached_device_mr, &m_host_mr}, m_copy,
                 m_stream),
-      m_result_copy(memory_resource{*m_cached_device_mr, &m_host_mr}, m_copy),
       m_finder_config(parent.m_finder_config),
       m_grid_config(parent.m_grid_config),
       m_filter_config(parent.m_filter_config),
@@ -179,8 +177,10 @@ full_chain_algorithm::output_type full_chain_algorithm::operator()(
             m_fitting(m_device_detector_view, m_field, navigation_buffer,
                       track_candidates);
 
-        // Return the final container, copied back to the host.
-        return m_result_copy(track_states);
+        // Copy a limited amount of result data back to the host.
+        output_type result{&m_host_mr};
+        m_copy(track_states.headers, result)->wait();
+        return result;
 
     }
     // If not, copy the track parameters back to the host, and return a dummy

examples/run/cuda/full_chain_algorithm.hpp

@@ -16,7 +16,6 @@
 #include "traccc/cuda/seeding/seeding_algorithm.hpp"
 #include "traccc/cuda/seeding/track_params_estimation.hpp"
 #include "traccc/cuda/utils/stream.hpp"
-#include "traccc/device/container_d2h_copy_alg.hpp"
 #include "traccc/edm/cell.hpp"
 #include "traccc/edm/track_state.hpp"
 #include "traccc/fitting/kalman_filter/kalman_fitter.hpp"
@@ -30,6 +29,7 @@
 #include "detray/propagator/rk_stepper.hpp"
 
 // VecMem include(s).
+#include <vecmem/containers/vector.hpp>
 #include <vecmem/memory/binary_page_memory_resource.hpp>
 #include <vecmem/memory/cuda/device_memory_resource.hpp>
 #include <vecmem/memory/memory_resource.hpp>
@@ -44,9 +44,10 @@ namespace traccc::cuda {
 ///
 /// At least as much as is implemented in the project at any given moment.
 ///
-class full_chain_algorithm : public algorithm<track_state_container_types::host(
-                                 const cell_collection_types::host&,
-                                 const cell_module_collection_types::host&)> {
+class full_chain_algorithm
+    : public algorithm<vecmem::vector<fitting_result<default_algebra>>(
+          const cell_collection_types::host&,
+          const cell_module_collection_types::host&)> {
 
     public:
     /// @name Type declaration(s)
@@ -161,9 +162,6 @@ class full_chain_algorithm : public algorithm<track_state_container_types::host(
     /// Track fitting algorithm
     fitting_algorithm m_fitting;
 
-    /// Algorithm copying the result container back to the host
-    device::container_d2h_copy_alg<track_state_container_types> m_result_copy;
-
     /// @}
 
     /// @name Algorithm configurations

io/src/event_map2.cpp

@@ -1,6 +1,6 @@
 /** TRACCC library, part of the ACTS project (R&D line)
  *
- * (c) 2022 CERN for the benefit of the ACTS project
+ * (c) 2022-2024 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -13,26 +13,37 @@
 #include "traccc/io/csv/make_measurement_reader.hpp"
 #include "traccc/io/csv/make_particle_reader.hpp"
 #include "traccc/io/utils.hpp"
+
+// System include(s).
+#include <filesystem>
+
 namespace traccc {
 
 event_map2::event_map2(std::size_t event, const std::string& measurement_dir,
                        const std::string& hit_dir,
                        const std::string particle_dir) {
 
     std::string io_measurement_hit_id_file =
-        io::data_directory() + hit_dir +
-        io::get_event_filename(event, "-measurement-simhit-map.csv");
+        io::get_absolute_path((std::filesystem::path(hit_dir) /
+                               std::filesystem::path(io::get_event_filename(
+                                   event, "-measurement-simhit-map.csv")))
+                                  .native());
 
-    std::string io_particle_file =
-        io::data_directory() + particle_dir +
-        io::get_event_filename(event, "-particles.csv");
+    std::string io_particle_file = io::get_absolute_path(
+        (std::filesystem::path(particle_dir) /
+         std::filesystem::path(io::get_event_filename(event, "-particles.csv")))
+            .native());
 
-    std::string io_hit_file = io::data_directory() + hit_dir +
-                              io::get_event_filename(event, "-hits.csv");
+    std::string io_hit_file = io::get_absolute_path(
+        (std::filesystem::path(hit_dir) /
+         std::filesystem::path(io::get_event_filename(event, "-hits.csv")))
+            .native());
 
     std::string io_measurement_file =
-        io::data_directory() + measurement_dir +
-        io::get_event_filename(event, "-measurements.csv");
+        io::get_absolute_path((std::filesystem::path(measurement_dir) /
+                               std::filesystem::path(io::get_event_filename(
+                                   event, "-measurements.csv")))
+                                  .native());
 
     auto mreader = io::csv::make_measurement_reader(io_measurement_file);
 

io/src/mapper.cpp

@@ -22,6 +22,9 @@
 #include "traccc/clusterization/measurement_creation_algorithm.hpp"
 #include "traccc/clusterization/sparse_ccl_algorithm.hpp"
 
+// System include(s).
+#include <filesystem>
+
 namespace traccc {
 
 particle_map generate_particle_map(std::size_t event,
@@ -31,8 +34,10 @@ particle_map generate_particle_map(std::size_t event,
 
     // Read the particles from the relevant event file
     std::string io_particles_file =
-        io::data_directory() + particle_dir +
-        io::get_event_filename(event, "-particles_initial.csv");
+        io::get_absolute_path((std::filesystem::path(particle_dir) /
+                               std::filesystem::path(io::get_event_filename(
+                                   event, "-particles_initial.csv")))
+                                  .native());
 
     auto preader = io::csv::make_particle_reader(io_particles_file);
 
@@ -61,8 +66,10 @@ hit_particle_map generate_hit_particle_map(std::size_t event,
     auto pmap = generate_particle_map(event, particle_dir);
 
     // Read the hits from the relevant event file
-    std::string io_hits_file = io::data_directory() + hits_dir +
-                               io::get_event_filename(event, "-hits.csv");
+    std::string io_hits_file = io::get_absolute_path(
+        (std::filesystem::path(hits_dir) /
+         std::filesystem::path(io::get_event_filename(event, "-hits.csv")))
+            .native());
 
     auto hreader = io::csv::make_hit_reader(io_hits_file);
 
@@ -93,17 +100,21 @@ hit_map generate_hit_map(std::size_t event, const std::string& hits_dir) {
     hit_map result;
 
     // Read the hits from the relevant event file
-    std::string io_hits_file = io::data_directory() + hits_dir +
-                               io::get_event_filename(event, "-hits.csv");
+    std::string io_hits_file = io::get_absolute_path(
+        (std::filesystem::path(hits_dir) /
+         std::filesystem::path(io::get_event_filename(event, "-hits.csv")))
+            .native());
 
     auto hreader = io::csv::make_hit_reader(io_hits_file);
 
     io::csv::hit iohit;
 
     // Read the hits from the relevant event file
     std::string io_measurement_hit_id_file =
-        io::data_directory() + hits_dir +
-        io::get_event_filename(event, "-measurement-simhit-map.csv");
+        io::get_absolute_path((std::filesystem::path(hits_dir) /
+                               std::filesystem::path(io::get_event_filename(
+                                   event, "-measurement-simhit-map.csv")))
+                                  .native());
 
     auto mhid_reader =
         io::csv::make_measurement_hit_id_reader(io_measurement_hit_id_file);
@@ -141,8 +152,10 @@ hit_cell_map generate_hit_cell_map(std::size_t event,
     auto hmap = generate_hit_map(event, hits_dir);
 
     // Read the cells from the relevant event file
-    std::string io_cells_file = io::data_directory() + cells_dir +
-                                io::get_event_filename(event, "-cells.csv");
+    std::string io_cells_file = io::get_absolute_path(
+        (std::filesystem::path(cells_dir) /
+         std::filesystem::path(io::get_event_filename(event, "-cells.csv")))
+            .native());
 
     auto creader = io::csv::make_cell_reader(io_cells_file);
 

io/src/read_cells.cpp

@@ -12,6 +12,9 @@
 #include "read_binary.hpp"
 #include "traccc/io/utils.hpp"
 
+// System include(s).
+#include <filesystem>
+
 namespace traccc::io {
 
 void read_cells(
@@ -23,19 +26,28 @@ void read_cells(
 
     switch (format) {
         case data_format::csv: {
-            read_cells(out,
-                       data_directory() + directory.data() +
-                           get_event_filename(event, "-cells.csv"),
-                       format, geom, dconfig, barcode_map, deduplicate);
+            read_cells(
+                out,
+                get_absolute_path((std::filesystem::path(directory) /
+                                   std::filesystem::path(
+                                       get_event_filename(event, "-cells.csv")))
+                                      .native()),
+                format, geom, dconfig, barcode_map, deduplicate);
             break;
         }
         case data_format::binary: {
             details::read_binary_collection<cell_collection_types::host>(
-                out.cells, data_directory() + directory.data() +
-                               get_event_filename(event, "-cells.dat"));
+                out.cells,
+                get_absolute_path((std::filesystem::path(directory) /
+                                   std::filesystem::path(
+                                       get_event_filename(event, "-cells.dat")))
+                                      .native()));
             details::read_binary_collection<cell_module_collection_types::host>(
-                out.modules, data_directory() + directory.data() +
-                                 get_event_filename(event, "-modules.dat"));
+                out.modules,
+                get_absolute_path((std::filesystem::path(directory) /
+                                   std::filesystem::path(get_event_filename(
+                                       event, "-modules.dat")))
+                                      .native()));
             break;
         }
         default:

io/src/read_digitization_config.cpp

@@ -1,6 +1,6 @@
 /** TRACCC library, part of the ACTS project (R&D line)
  *
- * (c) 2022 CERN for the benefit of the ACTS project
+ * (c) 2022-2024 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -64,7 +64,7 @@ digitization_config read_digitization_config(std::string_view filename,
                                              data_format format) {
 
     // Construct the full filename.
-    std::string full_filename = data_directory() + filename.data();
+    std::string full_filename = get_absolute_path(filename);
 
     // Decide how to read the file.
     switch (format) {

io/src/read_geometry.cpp

@@ -67,7 +67,7 @@ std::pair<geometry,
 read_geometry(std::string_view filename, data_format format) {
 
     // Construct the full file name.
-    const std::string full_filename = data_directory() + filename.data();
+    const std::string full_filename = get_absolute_path(filename);
 
     // Decide how to read the file.
     switch (format) {

io/src/read_measurements.cpp

@@ -1,6 +1,6 @@
 /** TRACCC library, part of the ACTS project (R&D line)
  *
- * (c) 2022 CERN for the benefit of the ACTS project
+ * (c) 2022-2024 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -12,6 +12,9 @@
 #include "read_binary.hpp"
 #include "traccc/io/utils.hpp"
 
+// System include(s).
+#include <filesystem>
+
 namespace traccc::io {
 
 void read_measurements(measurement_reader_output& out, std::size_t event,
@@ -21,20 +24,27 @@ void read_measurements(measurement_reader_output& out, std::size_t event,
         case data_format::csv: {
             read_measurements(
                 out,
-                data_directory() + directory.data() +
-                    get_event_filename(event, "-measurements.csv"),
+                get_absolute_path((std::filesystem::path(directory) /
+                                   std::filesystem::path(get_event_filename(
+                                       event, "-measurements.csv")))
+                                      .native()),
                 format);
             break;
         }
         case data_format::binary: {
 
             details::read_binary_collection<measurement_collection_types::host>(
                 out.measurements,
-                data_directory() + directory.data() +
-                    get_event_filename(event, "-measurements.dat"));
+                get_absolute_path((std::filesystem::path(directory) /
+                                   std::filesystem::path(get_event_filename(
+                                       event, "-measurements.dat")))
+                                      .native()));
             details::read_binary_collection<cell_module_collection_types::host>(
-                out.modules, data_directory() + directory.data() +
-                                 get_event_filename(event, "-modules.dat"));
+                out.modules,
+                get_absolute_path((std::filesystem::path(directory) /
+                                   std::filesystem::path(get_event_filename(
+                                       event, "-modules.dat")))
+                                      .native()));
             break;
         }
         default:

io/src/read_particles.cpp

@@ -1,6 +1,6 @@
 /** TRACCC library, part of the ACTS project (R&D line)
  *
- * (c) 2022 CERN for the benefit of the ACTS project
+ * (c) 2022-2024 CERN for the benefit of the ACTS project
  *
  * Mozilla Public License Version 2.0
  */
@@ -11,6 +11,9 @@
 #include "csv/read_particles.hpp"
 #include "traccc/io/utils.hpp"
 
+// System include(s).
+#include <filesystem>
+
 namespace traccc::io {
 
 particle_collection_types::host read_particles(std::size_t event,
@@ -21,8 +24,10 @@ particle_collection_types::host read_particles(std::size_t event,
     switch (format) {
         case data_format::csv:
             return read_particles(
-                data_directory() + directory.data() +
-                    get_event_filename(event, "-particles.csv"),
+                get_absolute_path((std::filesystem::path(directory) /
+                                   std::filesystem::path(get_event_filename(
+                                       event, "-particles.csv")))
+                                      .native()),
                 format, mr);
         default:
             throw std::invalid_argument("Unsupported data format");