cpu/core/containers.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 include(s)
0010 #include "detray/core/detail/multi_store.hpp"
0011 #include "detray/core/detail/single_store.hpp"
0012 #include "detray/core/detail/tuple_container.hpp"
0013
0014 // Vecmem include(s)
0015 #include <vecmem/containers/vector.hpp>
0016 #include <vecmem/memory/host_memory_resource.hpp>
0017
0018 // GTest include(s)
0019 #include <gtest/gtest.h>
0020
0021 // System include(s)
0022 #include <array>
0023 #include <tuple>
0024 #include <vector>
0025
0026 using namespace detray;
0027
0028 constexpr float tol_single{1e-7f};
0029 constexpr double tol_double{1e-31f};
0030
0031 struct test_func {
0032   template <typename container_t>
0033   auto operator()(const container_t& coll, const unsigned int /*index*/) {
0034     return coll.size();
0035   }
0036 };
0037
0038 GTEST_TEST(detray_core, single_store) {
0039   // Vecmem memory resource
0040   vecmem::host_memory_resource resource;
0041
0042   // Create store for double values
0043   single_store<double, vecmem::vector, geometry_context> store(resource);
0044
0045   // Base store function check
0046   EXPECT_TRUE(store.empty());
0047   EXPECT_EQ(store.size(), 0u);
0048
0049   // Add elements to the container
0050   geometry_context ctx{};
0051   store.reserve(4, ctx);
0052   store.emplace_back(ctx, 1.);
0053   store.push_back(2., ctx);
0054   store.insert(vecmem::vector<double>{10.5, 7.6}, ctx);
0055
0056   EXPECT_FALSE(store.empty());
0057   EXPECT_EQ(store.size(), 4u);
0058
0059   // Check  access to the data
0060   EXPECT_NEAR(store.at(0, ctx), 1., tol_double);
0061   EXPECT_NEAR(store.at(2, ctx), 10.5, tol_double);
0062   EXPECT_NEAR(store.at(1, ctx), 2., tol_double);
0063   EXPECT_NEAR(store.at(3, ctx), 7.6, tol_double);
0064 }
0065
0066 GTEST_TEST(detray_core, tuple_container) {
0067   // Vecmem memory resource
0068   vecmem::host_memory_resource resource;
0069
0070   using host_tuple_t =
0071       detail::tuple_container<std::tuple, vecmem::vector<float>,
0072                               vecmem::vector<std::size_t>,
0073                               vecmem::vector<int*>>;
0074
0075   using device_tuple_t =
0076       detail::tuple_container<tuple, vecmem::device_vector<float>,
0077                               vecmem::device_vector<std::size_t>,
0078                               vecmem::device_vector<int*>>;
0079
0080   vecmem::vector<float> vec1{};
0081   vecmem::vector<std::size_t> vec2{};
0082   vecmem::vector<int*> vec3{};
0083
0084   host_tuple_t container(resource, vec1, vec2, vec3);
0085
0086   static_assert(
0087       std::is_same_v<typename host_tuple_t::view_type,
0088                      dmulti_view<dvector_view<float>, dvector_view<std::size_t>,
0089                                  dvector_view<int*>>>,
0090       "View type incorrectly assembled");
0091
0092   static_assert(std::is_same_v<typename host_tuple_t::const_view_type,
0093                                dmulti_view<dvector_view<const float>,
0094                                            dvector_view<const std::size_t>,
0095                                            dvector_view<int* const>>>,
0096                 "Const view type incorrectly assembled");
0097
0098   typename host_tuple_t::view_type view = get_data(container);
0099   device_tuple_t dev_container(view);
0100
0101   // Base container function check
0102   EXPECT_EQ(container.size(), 3u);
0103   EXPECT_EQ(dev_container.size(), 3u);
0104
0105   EXPECT_TRUE(container.get<0>().empty());
0106   EXPECT_TRUE(container.get<1>().empty());
0107   EXPECT_TRUE(detail::get<2>(container).empty());
0108 }
0109
0110 GTEST_TEST(detray_core, vector_multi_store) {
0111   enum class type_ids : std::uint_least8_t {
0112     e_size = 0u,
0113     e_float = 1u,
0114     e_double = 2u,
0115   };
0116
0117   using enum type_ids;
0118
0119   using container_t =
0120       regular_multi_store<type_ids, empty_context, std::tuple, vecmem::vector,
0121                           std::size_t, float, double>;
0122
0123   // Vecmem memory resource
0124   vecmem::host_memory_resource resource;
0125
0126   // Create tuple vector container
0127   container_t vector_store(resource);
0128
0129   // Base container function check
0130   EXPECT_EQ(vector_store.n_collections(), 3u);
0131   EXPECT_EQ(vector_store.empty<e_size>(), true);
0132   EXPECT_EQ(vector_store.empty<e_float>(), true);
0133   EXPECT_EQ(vector_store.empty<e_double>(), true);
0134   EXPECT_EQ(vector_store.size<e_size>(), 0u);
0135   EXPECT_EQ(vector_store.size<e_float>(), 0u);
0136   EXPECT_EQ(vector_store.size<e_double>(), 0u);
0137
0138   // Add elements to the container
0139   vector_store.push_back<e_size>(1u);
0140   vector_store.emplace_back<e_size>(empty_context{}, 2u);
0141   vector_store.push_back<e_float>(3.1f);
0142   vector_store.emplace_back<e_float>(empty_context{}, 4.5f);
0143   vector_store.push_back<e_double>(5.5);
0144   vector_store.emplace_back<e_double>(empty_context{}, 6.f);
0145
0146   EXPECT_EQ(vector_store.empty<e_size>(), false);
0147   EXPECT_EQ(vector_store.empty<e_float>(), false);
0148   EXPECT_EQ(vector_store.empty<e_double>(), false);
0149   EXPECT_EQ(vector_store.size<e_size>(), 2u);
0150   EXPECT_EQ(vector_store.size<e_float>(), 2u);
0151   EXPECT_EQ(vector_store.size<e_double>(), 2u);
0152
0153   vecmem::vector<std::size_t> int_vec{3u, 4u, 5u};
0154   vector_store.insert(int_vec);
0155
0156   vecmem::vector<float> float_vec{12.1f};
0157   vector_store.insert(float_vec);
0158
0159   vector_store.insert(vecmem::vector<double>{10.5, 7.6});
0160
0161   // int collectiont
0162   EXPECT_EQ(vector_store.size<e_size>(), 5u);
0163   EXPECT_EQ(vector_store.get<e_size>()[0], 1u);
0164   EXPECT_EQ(vector_store.get<e_size>()[1], 2u);
0165   EXPECT_EQ(vector_store.get<e_size>()[2], 3u);
0166   EXPECT_EQ(vector_store.get<e_size>()[3], 4u);
0167   EXPECT_EQ(vector_store.get<e_size>()[4], 5u);
0168
0169   // float collectiont
0170   EXPECT_EQ(vector_store.size<e_float>(), 3u);
0171   EXPECT_NEAR(vector_store.get<e_float>()[0], 3.1f, tol_single);
0172   EXPECT_NEAR(vector_store.get<e_float>()[1], 4.5f, tol_single);
0173   EXPECT_NEAR(vector_store.get<e_float>()[2], 12.1f, tol_single);
0174
0175   // double collectiont
0176   EXPECT_EQ(vector_store.size<e_double>(), 4u);
0177   EXPECT_NEAR(vector_store.get<e_double>()[0], 5.5, tol_double);
0178   EXPECT_NEAR(vector_store.get<e_double>()[1], 6., tol_double);
0179   EXPECT_NEAR(vector_store.get<e_double>()[2], 10.5, tol_double);
0180   EXPECT_NEAR(vector_store.get<e_double>()[3], 7.6, tol_double);
0181
0182   // call functor
0183   container_t::single_link l0{e_size, 0u};
0184   container_t::single_link l1{e_float, 0u};
0185   container_t::single_link l2{e_double, 0u};
0186   EXPECT_EQ(vector_store.visit<test_func>(l0), 5u);
0187   EXPECT_EQ(vector_store.visit<test_func>(l1), 3u);
0188   EXPECT_EQ(vector_store.visit<test_func>(l2), 4u);
0189 }