Merge pull request #65 from acts-project/tests/expand_cuda_strided_tests

Expand CUDA strided array tests

Author: stephenswat

tests/cuda/CMakeLists.txt

@@ -11,7 +11,7 @@ find_package(CUDAToolkit REQUIRED)
 include(covfie-compiler-options-cuda)
 
 # Create the test executable from the individual test groups.
-add_executable(test_cuda test_cuda_array.cu)
+add_executable(test_cuda test_cuda_strided_array.cu)
 
 # Ensure that the tests are linked against the required libraries.
 target_link_libraries(

tests/cuda/test_cuda_array.cu

@@ -0,0 +1,171 @@
+/*
+ * SPDX-PackageName: "covfie, a part of the ACTS project"
+ * SPDX-FileCopyrightText: 2022 CERN
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+#include <optional>
+#include <utility>
+
+#include <gtest/gtest.h>
+
+#include <covfie/core/backend/primitive/array.hpp>
+#include <covfie/core/backend/transformer/strided.hpp>
+#include <covfie/core/field.hpp>
+#include <covfie/core/field_view.hpp>
+#include <covfie/core/utility/nd_map.hpp>
+#include <covfie/core/vector.hpp>
+#include <covfie/cuda/backend/primitive/cuda_device_array.hpp>
+
+#include "retrieve_vector.hpp"
+
+namespace {
+class NameGenerator
+{
+public:
+    template <typename B>
+    static std::string GetName(int)
+    {
+        using scalar_t = typename B::covariant_output_t::scalar_t;
+        constexpr std::size_t dims = B::covariant_output_t::dimensions;
+
+        if constexpr (std::is_same_v<scalar_t, float>) {
+            return "Float[" + std::to_string(dims) + "]";
+        } else if constexpr (std::is_same_v<scalar_t, std::size_t>) {
+            return "UInt64[" + std::to_string(dims) + "]";
+        }
+    }
+};
+
+template <std::size_t N, std::size_t... Is>
+covfie::array::array<std::size_t, N>
+make_size_array_helper(std::index_sequence<Is...> &&)
+{
+    covfie::array::array<std::size_t, N> rv;
+    ((rv[Is] = 10UL), ...);
+
+    return rv;
+}
+
+template <std::size_t N>
+covfie::array::array<std::size_t, N> make_size_array()
+{
+    return make_size_array_helper<N>(std::make_index_sequence<N>());
+}
+
+template <std::size_t N, typename T, typename U, std::size_t... Is>
+covfie::array::array<U, N>
+convert_array_helper(const covfie::array::array<T, N> & a, std::index_sequence<Is...> &&)
+{
+    covfie::array::array<U, N> rv;
+    ((rv[Is] = static_cast<U>(a[Is])), ...);
+    return rv;
+}
+
+template <std::size_t N, typename T, typename U>
+covfie::array::array<U, N> convert_array(const covfie::array::array<T, N> & a)
+{
+    return convert_array_helper<N, T, U>(a, std::make_index_sequence<N>());
+}
+}
+
+template <std::size_t N, typename B>
+class TestLookupGeneric : public ::testing::Test
+{
+protected:
+    void SetUp() override
+    {
+        using scalar_t = typename B::covariant_output_t::scalar_t;
+
+        using canonical_backend_t = covfie::backend::strided<
+            covfie::vector::vector_d<std::size_t, N>,
+            covfie::backend::array<covfie::vector::vector_d<scalar_t, N>>>;
+
+        m_sizes = make_size_array<N>();
+
+        covfie::field<canonical_backend_t> f(covfie::make_parameter_pack(
+            typename canonical_backend_t::configuration_t(m_sizes)
+        ));
+        covfie::field_view<canonical_backend_t> fv(f);
+
+        covfie::utility::nd_map<decltype(m_sizes)>(
+            [&fv](decltype(m_sizes) t) {
+                fv.at(t) = convert_array<N, std::size_t, scalar_t>(t);
+            },
+            m_sizes
+        );
+
+        m_field = covfie::field<B>(f);
+    }
+
+    covfie::array::array<std::size_t, N> m_sizes;
+    std::optional<covfie::field<B>> m_field;
+};
+
+template <std::size_t N, typename T>
+using CudaStridedArrayBackend = covfie::backend::strided<
+    covfie::vector::vector_d<std::size_t, N>,
+    covfie::backend::cuda_device_array<covfie::vector::vector_d<T, N>>>;
+
+// 1D tests
+template <typename B>
+using TestCudaStrided1D = TestLookupGeneric<1, B>;
+using Backends1D = ::testing::Types<
+    CudaStridedArrayBackend<1, std::size_t>,
+    CudaStridedArrayBackend<1, float>>;
+TYPED_TEST_SUITE(TestCudaStrided1D, Backends1D, NameGenerator);
+TYPED_TEST(TestCudaStrided1D, LookUp)
+{
+    for (std::size_t x = 0; x < this->m_sizes[0]; ++x) {
+        std::decay_t<typename covfie::field<TypeParam>::output_t> o =
+            retrieve_vector<covfie::field<TypeParam>>(*(this->m_field), {x});
+
+        EXPECT_EQ(o[0], x);
+    }
+}
+
+// 2D tests
+template <typename B>
+using TestCudaStrided2D = TestLookupGeneric<2, B>;
+using Backends2D = ::testing::Types<
+    CudaStridedArrayBackend<2, std::size_t>,
+    CudaStridedArrayBackend<2, float>>;
+TYPED_TEST_SUITE(TestCudaStrided2D, Backends2D, NameGenerator);
+TYPED_TEST(TestCudaStrided2D, LookUp)
+{
+    for (std::size_t x = 0; x < this->m_sizes[0]; ++x) {
+        for (std::size_t y = 0; y < this->m_sizes[1]; ++y) {
+            std::decay_t<typename covfie::field<TypeParam>::output_t> o =
+                retrieve_vector<covfie::field<TypeParam>>(
+                    *(this->m_field), {x, y}
+                );
+
+            EXPECT_EQ(o[0], x);
+            EXPECT_EQ(o[1], y);
+        }
+    }
+}
+
+template <typename B>
+using TestCudaStrided3D = TestLookupGeneric<3, B>;
+using Backends3D = ::testing::Types<
+    CudaStridedArrayBackend<3, std::size_t>,
+    CudaStridedArrayBackend<3, float>>;
+TYPED_TEST_SUITE(TestCudaStrided3D, Backends3D, NameGenerator);
+TYPED_TEST(TestCudaStrided3D, LookUp)
+{
+    for (std::size_t x = 0; x < this->m_sizes[0]; ++x) {
+        for (std::size_t y = 0; y < this->m_sizes[1]; ++y) {
+            for (std::size_t z = 0; z < this->m_sizes[2]; ++z) {
+                std::decay_t<typename covfie::field<TypeParam>::output_t> o =
+                    retrieve_vector<covfie::field<TypeParam>>(
+                        *(this->m_field), {x, y, z}
+                    );
+
+                EXPECT_EQ(o[0], x);
+                EXPECT_EQ(o[1], y);
+                EXPECT_EQ(o[2], z);
+            }
+        }
+    }
+}