device/cuda/mask_store_cuda.cpp

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 // Detray test include(s)
0010 #include "mask_store_cuda_kernel.hpp"
0011
0012 // Vecmem include(s)
0013 #include <vecmem/memory/cuda/managed_memory_resource.hpp>
0014
0015 // GTest include(s)
0016 #include <gtest/gtest.h>
0017
0018 // System include(s)
0019 #include <climits>
0020 #include <cstdlib>
0021 #include <random>
0022
0023 using namespace detray;
0024
0025 TEST(mask_store_cuda, mask_store) {
0026   // memory resource
0027   vecmem::cuda::managed_memory_resource mng_mr;
0028
0029   // Types must be sorted according to their id (here: masks/mask_identifier)
0030   host_store_type store(mng_mr);
0031
0032   ASSERT_TRUE(store.template empty<mask_id::e_annulus2D>());
0033   ASSERT_TRUE(store.template empty<mask_id::e_cylinder2D>());
0034   ASSERT_TRUE(store.template empty<mask_id::e_rectangle2D>());
0035   ASSERT_TRUE(store.template empty<mask_id::e_ring2D>());
0036   ASSERT_TRUE(store.template empty<mask_id::e_single3D>());
0037   ASSERT_TRUE(store.template empty<mask_id::e_trapezoid2D>());
0038
0039   store.template emplace_back<mask_id::e_rectangle2D>(empty_context{}, 0u, 1.0f,
0040                                                       2.0f);
0041   store.template emplace_back<mask_id::e_trapezoid2D>(empty_context{}, 0u, 0.5f,
0042                                                       1.5f, 4.0f, 1.f / 8.f);
0043   store.template emplace_back<mask_id::e_ring2D>(empty_context{}, 0u, 1.0f,
0044                                                  10.0f);
0045   store.template emplace_back<mask_id::e_cylinder2D>(empty_context{}, 0u, 1.f,
0046                                                      0.5f, 2.0f);
0047   store.template emplace_back<mask_id::e_annulus2D>(
0048       empty_context{}, 0u, 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f);
0049
0050   ASSERT_FALSE(store.empty<mask_id::e_annulus2D>());
0051   ASSERT_FALSE(store.empty<mask_id::e_cylinder2D>());
0052   ASSERT_FALSE(store.empty<mask_id::e_rectangle2D>());
0053   ASSERT_FALSE(store.empty<mask_id::e_ring2D>());
0054   ASSERT_TRUE(store.empty<mask_id::e_single3D>());
0055   ASSERT_FALSE(store.empty<mask_id::e_trapezoid2D>());
0056
0057   // Generate random points for test
0058   vecmem::vector<point3> input_point3(n_points, &mng_mr);
0059
0060   std::random_device rd;
0061   std::mt19937_64 gen(rd());
0062   std::uniform_real_distribution<dscalar<test_algebra>> dist(0.f, 9.9f);
0063   for (unsigned int i = 0u; i < n_points; i++) {
0064     point3 rand_point3 = {dist(gen), dist(gen), dist(gen)};
0065     input_point3[i] = rand_point3;
0066   }
0067
0068   // host output for intersection status
0069   vecmem::jagged_vector<int> output_host(5, &mng_mr);
0070
0071   // get mask objects
0072   const auto& rectangle_mask = store.get<mask_id::e_rectangle2D>()[0];
0073   const auto& trapezoid_mask = store.get<mask_id::e_trapezoid2D>()[0];
0074   const auto& ring_mask = store.get<mask_id::e_ring2D>()[0];
0075   const auto& cylinder_mask = store.get<mask_id::e_cylinder2D>()[0];
0076   const auto& annulus_mask = store.get<mask_id::e_annulus2D>()[0];
0077
0078   // get host results from is_inside function
0079   for (unsigned int i = 0u; i < n_points; i++) {
0080     output_host[0].push_back(rectangle_mask.is_inside(input_point3[i]));
0081     output_host[1].push_back(trapezoid_mask.is_inside(input_point3[i]));
0082     output_host[2].push_back(ring_mask.is_inside(input_point3[i]));
0083     output_host[3].push_back(cylinder_mask.is_inside(input_point3[i]));
0084     output_host[4].push_back(annulus_mask.is_inside(input_point3[i]));
0085   }
0086
0087   // Helper object for performing memory copies
0088   vecmem::cuda::copy copy;
0089
0090   // device output for intersection status
0091   vecmem::data::jagged_vector_buffer<int> output_buffer(
0092       {n_points, n_points, n_points, n_points, n_points}, mng_mr, nullptr,
0093       vecmem::data::buffer_type::resizable);
0094
0095   copy.setup(output_buffer)->wait();
0096
0097   auto input_point3_data = vecmem::get_data(input_point3);
0098   auto store_data = get_data(store);
0099
0100   // run the kernel
0101   mask_test(store_data, input_point3_data, output_buffer);
0102
0103   vecmem::jagged_vector<int> output_device(&mng_mr);
0104   copy(output_buffer, output_device)->wait();
0105
0106   // Compare the values
0107   for (unsigned int i = 0u; i < n_points; i++) {
0108     ASSERT_EQ(output_host[0][i], output_device[0][i]);
0109     ASSERT_EQ(output_host[0][i], output_device[0][i]);
0110     ASSERT_EQ(output_host[2][i], output_device[2][i]);
0111     ASSERT_EQ(output_host[3][i], output_device[3][i]);
0112     ASSERT_EQ(output_host[4][i], output_device[4][i]);
0113   }
0114 }