tests/sycl/test_dpl.sycl

0001 /** TRACCC library, part of the ACTS project (R&D line)
0002  *
0003  * (c) 2024-2026 CERN for the benefit of the ACTS project
0004  *
0005  * Mozilla Public License Version 2.0
0006  */
0007
0008 // SYCL include(s).
0009 #include <sycl/sycl.hpp>
0010
0011 // DPL include(s).
0012 #pragma clang diagnostic push
0013 #pragma clang diagnostic ignored "-Wshadow"
0014 #pragma clang diagnostic ignored "-Wunused-parameter"
0015 #pragma clang diagnostic ignored "-Wshorten-64-to-32"
0016 #pragma clang diagnostic ignored "-Wsign-conversion"
0017 #pragma clang diagnostic ignored "-Wimplicit-int-conversion"
0018 #pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
0019 #pragma clang diagnostic ignored "-Wdeprecated-copy-with-user-provided-copy"
0020 #pragma clang diagnostic ignored "-Wsign-compare"
0021 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
0022 #pragma clang diagnostic ignored "-Wunknown-pragmas"
0023 #pragma clang diagnostic ignored "-Wunused-variable"
0024 #include <oneapi/dpl/algorithm>
0025 #include <oneapi/dpl/execution>
0026 #pragma clang diagnostic pop
0027
0028 // VecMem include(s).
0029 #include <vecmem/containers/data/vector_buffer.hpp>
0030 #include <vecmem/containers/device_vector.hpp>
0031 #include <vecmem/memory/host_memory_resource.hpp>
0032 #include <vecmem/memory/sycl/device_memory_resource.hpp>
0033 #include <vecmem/utils/sycl/copy.hpp>
0034
0035 // GTest include(s).
0036 #include <gtest/gtest.h>
0037
0038 namespace {
0039
0040 // Simple asynchronous handler function
0041 auto handle_async_error = [](::sycl::exception_list elist) {
0042   for (auto& e : elist) {
0043     try {
0044       std::rethrow_exception(e);
0045     } catch (::sycl::exception& e) {
0046       std::cout << "ASYNC EXCEPTION!!\n";
0047       std::cout << e.what() << "\n";
0048     }
0049   }
0050 };
0051
0052 }  // namespace
0053
0054 TEST(dpl, sort) {
0055   ::sycl::queue q(handle_async_error);
0056   vecmem::sycl::copy copy{&q};
0057   vecmem::host_memory_resource host_resource;
0058   vecmem::sycl::device_memory_resource device_resource{&q};
0059
0060   vecmem::vector<unsigned int> host_vector{{3, 2, 1, 8, 4}, &host_resource};
0061
0062   auto host_buffer = vecmem::get_data(host_vector);
0063   auto device_buffer = copy.to(vecmem::get_data(host_vector), device_resource,
0064                                vecmem::copy::type::host_to_device);
0065
0066   vecmem::device_vector<unsigned int> device_vector(device_buffer);
0067
0068   oneapi::dpl::sort(oneapi::dpl::execution::device_policy{q},
0069                     device_vector.begin(), device_vector.end());
0070
0071   copy(device_buffer, host_buffer, vecmem::copy::type::device_to_host)->wait();
0072
0073   ASSERT_EQ(host_vector[0], 1);
0074   ASSERT_EQ(host_vector[1], 2);
0075   ASSERT_EQ(host_vector[2], 3);
0076   ASSERT_EQ(host_vector[3], 4);
0077   ASSERT_EQ(host_vector[4], 8);
0078 }
0079
0080 TEST(dpl, scan) {
0081   ::sycl::queue q(handle_async_error);
0082   vecmem::sycl::copy copy{&q};
0083   vecmem::host_memory_resource host_resource;
0084   vecmem::sycl::device_memory_resource device_resource{&q};
0085
0086   vecmem::vector<unsigned int> host_vector{{3, 2, 1, 8, 4}, &host_resource};
0087
0088   auto host_buffer = vecmem::get_data(host_vector);
0089   auto device_buffer = copy.to(vecmem::get_data(host_vector), device_resource,
0090                                vecmem::copy::type::host_to_device);
0091
0092   vecmem::device_vector<unsigned int> device_vector(device_buffer);
0093
0094   oneapi::dpl::inclusive_scan(oneapi::dpl::execution::device_policy{q},
0095                               device_vector.begin(), device_vector.end(),
0096                               device_vector.begin());
0097
0098   copy(device_buffer, host_buffer, vecmem::copy::type::device_to_host)->wait();
0099
0100   ASSERT_EQ(host_vector[0], 3);
0101   ASSERT_EQ(host_vector[1], 5);
0102   ASSERT_EQ(host_vector[2], 6);
0103   ASSERT_EQ(host_vector[3], 14);
0104   ASSERT_EQ(host_vector[4], 18);
0105 }
0106
0107 TEST(dpl, fill) {
0108   ::sycl::queue q(handle_async_error);
0109   vecmem::sycl::copy copy{&q};
0110   vecmem::host_memory_resource host_resource;
0111   vecmem::sycl::device_memory_resource device_resource{&q};
0112
0113   vecmem::vector<unsigned int> host_vector{{1, 1, 1, 1, 1, 1, 1},
0114                                            &host_resource};
0115
0116   auto host_buffer = vecmem::get_data(host_vector);
0117   auto device_buffer = copy.to(vecmem::get_data(host_vector), device_resource,
0118                                vecmem::copy::type::host_to_device);
0119
0120   vecmem::device_vector<unsigned int> device_vector(device_buffer);
0121
0122   oneapi::dpl::fill(oneapi::dpl::execution::device_policy{q},
0123                     device_vector.begin(), device_vector.end(), 112);
0124
0125   copy(device_buffer, host_buffer, vecmem::copy::type::device_to_host)->wait();
0126
0127   ASSERT_EQ(host_vector[0], 112);
0128   ASSERT_EQ(host_vector[1], 112);
0129   ASSERT_EQ(host_vector[2], 112);
0130   ASSERT_EQ(host_vector[3], 112);
0131   ASSERT_EQ(host_vector[4], 112);
0132   ASSERT_EQ(host_vector[5], 112);
0133   ASSERT_EQ(host_vector[6], 112);
0134 }