device/cuda/material_validation.hpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 #pragma once
0010
0011 // Project include(s)
0012 #include "detray/core/detector.hpp"
0013 #include "detray/tracks/tracks.hpp"
0014
0015 // Detray test include(s)
0016 #include "detray/test/cpu/material_validation.hpp"
0017 #include "detray/test/validation/material_validation_utils.hpp"
0018
0019 // Vecmem include(s)
0020 #include <vecmem/memory/cuda/device_memory_resource.hpp>
0021 #include <vecmem/memory/host_memory_resource.hpp>
0022 #include <vecmem/memory/memory_resource.hpp>
0023 #include <vecmem/utils/cuda/copy.hpp>
0024
0025 // System include
0026 #include <string_view>
0027
0028 namespace detray::cuda {
0029
0030 /// Launch the material validation kernel
0031 ///
0032 /// @param[in] det_view the detector vecmem view
0033 /// @param[in] cfg the propagation configuration
0034 /// @param[in] tracks_view the initial track parameter of every test track
0035 /// @param[out] mat_records_view the accumulated material per track
0036 template <typename detector_t>
0037 void material_validation_device(
0038     typename detector_t::view_type det_view, const propagation::config &cfg,
0039     vecmem::data::vector_view<
0040         free_track_parameters<typename detector_t::algebra_type>> &tracks_view,
0041     vecmem::data::vector_view<
0042         material_validator::material_record<typename detector_t::scalar_type>>
0043         &mat_records_view,
0044     vecmem::data::jagged_vector_view<
0045         material_validator::material_params<typename detector_t::scalar_type>>
0046         &mat_steps_view);
0047
0048 /// Prepare data for device material trace run
0049 struct run_material_validation {
0050   static constexpr std::string_view name = "cuda";
0051
0052   template <typename detector_t>
0053   auto operator()(
0054       vecmem::memory_resource *host_mr, vecmem::memory_resource *dev_mr,
0055       const detector_t &det, const propagation::config &cfg,
0056       const vecmem::vector<
0057           free_track_parameters<typename detector_t::algebra_type>> &tracks,
0058       const std::vector<std::size_t> &capacities) {
0059     using algebra_t = typename detector_t::algebra_type;
0060     using scalar_t = dscalar<algebra_t>;
0061     using track_t = free_track_parameters<algebra_t>;
0062     using material_record_t = material_validator::material_record<scalar_t>;
0063     using material_params_t = material_validator::material_params<scalar_t>;
0064
0065     // Helper object for performing memory copies (to CUDA devices)
0066     vecmem::cuda::copy cuda_cpy;
0067
0068     // Copy the detector to device and get its view
0069     auto det_buffer = detray::get_buffer(det, *dev_mr, cuda_cpy);
0070     auto det_view = detray::get_data(det_buffer);
0071
0072     // Move the track parameters to device
0073     auto tracks_buffer = cuda_cpy.to(vecmem::get_data(tracks), *dev_mr,
0074                                      vecmem::copy::type::host_to_device);
0075     vecmem::data::vector_view<track_t> tracks_view =
0076         vecmem::get_data(tracks_buffer);
0077
0078     vecmem::data::vector_buffer<material_record_t> mat_records_buffer(
0079         static_cast<unsigned int>(tracks.size()), *dev_mr,
0080         vecmem::data::buffer_type::fixed_size);
0081     cuda_cpy.setup(mat_records_buffer)->wait();
0082     auto mat_records_view = vecmem::get_data(mat_records_buffer);
0083
0084     // Buffer for the material parameters at every surface per track
0085     vecmem::data::jagged_vector_buffer<material_params_t> mat_steps_buffer(
0086         capacities, *dev_mr, host_mr, vecmem::data::buffer_type::resizable);
0087     cuda_cpy.setup(mat_steps_buffer)->wait();
0088     auto mat_steps_view = vecmem::get_data(mat_steps_buffer);
0089
0090     // Run the material tracing on device
0091     material_validation_device<detector_t>(det_view, cfg, tracks_view,
0092                                            mat_records_view, mat_steps_view);
0093
0094     // Get the results back to the host and pass them on to be checked
0095     vecmem::vector<material_record_t> mat_records(host_mr);
0096     cuda_cpy(mat_records_buffer, mat_records)->wait();
0097
0098     vecmem::jagged_vector<material_params_t> mat_steps(host_mr);
0099     cuda_cpy(mat_steps_buffer, mat_steps)->wait();
0100
0101     return std::make_tuple(mat_records, mat_steps);
0102   }
0103 };
0104
0105 template <typename detector_t>
0106 using material_validation = detray::test::material_validation_impl<
0107     detector_t, detray::cuda::run_material_validation>;
0108
0109 }  // namespace detray::cuda