Fix MultiQueueMultiDevice param tests.

Author: aarongreig

test/conformance/enqueue/CMakeLists.txt

@@ -10,7 +10,7 @@ add_conformance_test_with_kernels_environment(enqueue
     urEnqueueEventsWaitMultiDevice.cpp
     urEnqueueEventsWaitWithBarrier.cpp
     urEnqueueKernelLaunch.cpp
-    #urEnqueueKernelLaunchAndMemcpyInOrder.cpp
+    urEnqueueKernelLaunchAndMemcpyInOrder.cpp
     urEnqueueMemBufferCopyRect.cpp
     urEnqueueMemBufferCopy.cpp
     urEnqueueMemBufferFill.cpp

test/conformance/enqueue/helpers.h

@@ -154,8 +154,17 @@ printFillTestString(const testing::TestParamInfo<typename T::ParamType> &info) {
     return test_name.str();
 }
 
-struct urMultiQueueMultiDeviceTest : uur::urMultiDeviceContextTestTemplate<1> {
-    void initQueues(size_t minDevices) {
+// Similar to urMultiDeviceContextTestWithParam this fixture allows a min
+// device count to be specified, but in this case we duplicate existing
+// devices to reach the min device count rather than skipping if it isn't met.
+template <size_t minDevices>
+struct urMultiQueueMultiDeviceTest : uur::urAllDevicesTest {
+    void SetUp() override {
+        UUR_RETURN_ON_FATAL_FAILURE(uur::urAllDevicesTest::SetUp());
+
+        ASSERT_SUCCESS(
+            urContextCreate(devices.size(), devices.data(), nullptr, &context));
+
         // Duplicate our devices until we hit the minimum size specified.
         auto srcDevices = devices;
         while (devices.size() < minDevices) {
@@ -169,31 +178,49 @@ struct urMultiQueueMultiDeviceTest : uur::urMultiDeviceContextTestTemplate<1> {
         }
     }
 
-    // Default implementation that uses all available devices
-    void SetUp() override {
-        UUR_RETURN_ON_FATAL_FAILURE(
-            uur::urMultiDeviceContextTestTemplate<1>::SetUp());
-        initQueues(1);
+    void TearDown() override {
+        for (auto &queue : queues) {
+            EXPECT_SUCCESS(urQueueRelease(queue));
+        }
+        UUR_RETURN_ON_FATAL_FAILURE(uur::urAllDevicesTest::TearDown());
     }
 
-    // Specialized implementation that duplicates all devices and queues
-    void SetUp(size_t numDuplicate) {
-        UUR_RETURN_ON_FATAL_FAILURE(
-            uur::urMultiDeviceContextTestTemplate<1>::SetUp());
-        initQueues(numDuplicate);
+    ur_context_handle_t context;
+    std::vector<ur_queue_handle_t> queues;
+};
+
+template <size_t minDevices, class T>
+struct urMultiQueueMultiDeviceTestWithParam
+    : uur::urAllDevicesTestWithParam<T> {
+    using uur::urAllDevicesTestWithParam<T>::devices;
+    void SetUp() override {
+        UUR_RETURN_ON_FATAL_FAILURE(uur::urAllDevicesTestWithParam<T>::SetUp());
+
+        ASSERT_SUCCESS(
+            urContextCreate(devices.size(), devices.data(), nullptr, &context));
+
+        // Duplicate our devices until we hit the minimum size specified.
+        auto srcDevices = devices;
+        while (devices.size() < minDevices) {
+            devices.insert(devices.end(), srcDevices.begin(), srcDevices.end());
+        }
+
+        for (auto &device : devices) {
+            ur_queue_handle_t queue = nullptr;
+            ASSERT_SUCCESS(urQueueCreate(context, device, nullptr, &queue));
+            queues.push_back(queue);
+        }
     }
 
     void TearDown() override {
         for (auto &queue : queues) {
             EXPECT_SUCCESS(urQueueRelease(queue));
         }
         UUR_RETURN_ON_FATAL_FAILURE(
-            uur::urMultiDeviceContextTestTemplate<1>::TearDown());
+            uur::urAllDevicesTestWithParam<T>::TearDown());
     }
-    std::function<std::tuple<std::vector<ur_device_handle_t>,
-                             std::vector<ur_queue_handle_t>>(void)>
-        makeQueues;
 
+    ur_context_handle_t context;
     std::vector<ur_queue_handle_t> queues;
 };
 

test/conformance/enqueue/urEnqueueEventsWaitMultiDevice.cpp

@@ -10,21 +10,25 @@
 #include <uur/fixtures.h>
 #include <uur/raii.h>
 
-struct urEnqueueEventsWaitMultiDeviceTest : uur::urMultiQueueMultiDeviceTest {
-    void SetUp() override { SetUp(2); /* we need at least 2 devices */ }
+void checkDevicesSupportSharedUSM(
+    const std::vector<ur_device_handle_t> &devices) {
+    for (auto device : devices) {
+        ur_device_usm_access_capability_flags_t shared_usm_single = 0;
+        EXPECT_SUCCESS(
+            uur::GetDeviceUSMSingleSharedSupport(device, shared_usm_single));
+        if (!shared_usm_single) {
+            GTEST_SKIP() << "Shared USM is not supported by the device.";
+        }
+    }
+}
 
-    void SetUp(size_t minDevices) {
+struct urEnqueueEventsWaitMultiDeviceTest
+    : uur::urMultiQueueMultiDeviceTest<2> {
+    void SetUp() override {
         UUR_RETURN_ON_FATAL_FAILURE(
-            uur::urMultiQueueMultiDeviceTest::SetUp(minDevices));
-
-        for (auto device : devices) {
-            ur_device_usm_access_capability_flags_t shared_usm_single = 0;
-            EXPECT_SUCCESS(uur::GetDeviceUSMSingleSharedSupport(
-                device, shared_usm_single));
-            if (!shared_usm_single) {
-                GTEST_SKIP() << "Shared USM is not supported by the device.";
-            }
-        }
+            uur::urMultiQueueMultiDeviceTest<2>::SetUp());
+
+        checkDevicesSupportSharedUSM(devices);
 
         ptrs.resize(devices.size());
         for (size_t i = 0; i < devices.size(); i++) {
@@ -40,7 +44,7 @@ struct urEnqueueEventsWaitMultiDeviceTest : uur::urMultiQueueMultiDeviceTest {
             }
         }
         UUR_RETURN_ON_FATAL_FAILURE(
-            uur::urMultiQueueMultiDeviceTest::TearDown());
+            uur::urMultiQueueMultiDeviceTest<2>::TearDown());
     }
 
     void initData() {
@@ -98,12 +102,11 @@ TEST_P(urEnqueueEventsWaitMultiDeviceTest, EnqueueWaitOnADifferentQueue) {
 
     verifyData(ptrs[1], pattern);
 }
-/*
+
 struct urEnqueueEventsWaitMultiDeviceMTTest
-    : urEnqueueEventsWaitMultiDeviceTest,
-      testing::WithParamInterface<uur::BoolTestParam> {
+    : uur::urMultiQueueMultiDeviceTestWithParam<8, uur::BoolTestParam> {
     void doComputation(std::function<void(size_t)> work) {
-        auto multiThread = GetParam().value;
+        auto multiThread = getParam().value;
         std::vector<std::thread> threads;
         for (size_t i = 0; i < devices.size(); i++) {
             if (multiThread) {
@@ -118,29 +121,50 @@ struct urEnqueueEventsWaitMultiDeviceMTTest
     }
 
     void SetUp() override {
-        const size_t minDevices = 8;
-        UUR_RETURN_ON_FATAL_FAILURE(
-            urEnqueueEventsWaitMultiDeviceTest::SetUp(minDevices));
+        UUR_RETURN_ON_FATAL_FAILURE(uur::urMultiQueueMultiDeviceTestWithParam<
+                                    8, uur::BoolTestParam>::SetUp());
+        checkDevicesSupportSharedUSM(devices);
+
+        ptrs.resize(devices.size());
+        for (size_t i = 0; i < devices.size(); i++) {
+            EXPECT_SUCCESS(urUSMSharedAlloc(context, devices[i], nullptr,
+                                            nullptr, size, &ptrs[i]));
+        }
     }
 
-    void TearDown() override { urEnqueueEventsWaitMultiDeviceTest::TearDown(); }
-};
+    void TearDown() override {
+        for (auto ptr : ptrs) {
+            if (ptr) {
+                EXPECT_SUCCESS(urUSMFree(context, ptr));
+            }
+        }
+        UUR_RETURN_ON_FATAL_FAILURE(uur::urMultiQueueMultiDeviceTestWithParam<
+                                    8, uur::BoolTestParam>::TearDown());
+    }
+
+    void initData() {
+        EXPECT_SUCCESS(urEnqueueUSMFill(queues[0], ptrs[0], sizeof(pattern),
+                                        &pattern, size, 0, nullptr, nullptr));
+        EXPECT_SUCCESS(urQueueFinish(queues[0]));
+    }
 
-template <typename T>
-inline std::string
-printParams(const testing::TestParamInfo<typename T::ParamType> &info) {
-    std::stringstream ss;
+    void verifyData(void *ptr, uint32_t pattern) {
+        for (size_t i = 0; i < count; i++) {
+            ASSERT_EQ(reinterpret_cast<uint32_t *>(ptr)[i], pattern);
+        }
+    }
 
-    auto param1 = info.param;
-    ss << (param1.value ? "" : "No") << param1.name;
+    uint32_t pattern = 42;
+    const size_t count = 1024;
+    const size_t size = sizeof(uint32_t) * count;
 
-    return ss.str();
-}
+    std::vector<void *> ptrs;
+};
 
-INSTANTIATE_TEST_SUITE_P(
-    , urEnqueueEventsWaitMultiDeviceMTTest,
+UUR_PLATFORM_TEST_SUITE_P(
+    urEnqueueEventsWaitMultiDeviceMTTest,
     testing::ValuesIn(uur::BoolTestParam::makeBoolParam("MultiThread")),
-    printParams<urEnqueueEventsWaitMultiDeviceMTTest>);
+    uur::platformTestWithParamPrinter<uur::BoolTestParam>);
 
 TEST_P(urEnqueueEventsWaitMultiDeviceMTTest, EnqueueWaitSingleQueueMultiOps) {
     std::vector<uint32_t> data(count, pattern);
@@ -216,4 +240,4 @@ TEST_P(urEnqueueEventsWaitMultiDeviceMTTest,
     }
 
     verifyData(ptrs[0], pattern);
-}*/
+}