Add CTS tests

Introduce command-buffer CTS tests for command event
synchronization

Author: Ewan Crawford

test/conformance/exp_command_buffer/CMakeLists.txt

@@ -12,4 +12,5 @@ add_conformance_test_with_kernels_environment(exp_command_buffer
   release.cpp
   retain.cpp
   invalid_update.cpp
+  event_sync_kernel_command.cpp
 )

test/conformance/exp_command_buffer/event_sync_kernel_command.cpp

@@ -0,0 +1,340 @@
+// Copyright (C) 2024 Intel Corporation
+// Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions.
+// See LICENSE.TXT
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "fixtures.h"
+#include <cstring>
+
+// Tests kernel commands using ur events for synchronization work as expected
+struct KernelCommandEventSyncTest
+    : uur::command_buffer::urCommandBufferExpExecutionTest {
+
+    void SetUp() override {
+        program_name = "saxpy_usm";
+        UUR_RETURN_ON_FATAL_FAILURE(urCommandBufferExpExecutionTest::SetUp());
+
+        ur_bool_t event_support = false;
+        ASSERT_SUCCESS(urDeviceGetInfo(
+            device, UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP,
+            sizeof(ur_bool_t), &event_support, nullptr));
+        if (!event_support) {
+            GTEST_SKIP() << "External event sync is not supported by device.";
+        }
+
+        for (auto &device_ptr : device_ptrs) {
+            ASSERT_SUCCESS(urUSMDeviceAlloc(context, device, nullptr, nullptr,
+                                            allocation_size, &device_ptr));
+            ASSERT_NE(device_ptr, nullptr);
+        }
+
+        // Index 0 is output
+        ASSERT_SUCCESS(
+            urKernelSetArgPointer(kernel, 0, nullptr, device_ptrs[2]));
+        // Index 1 is A
+        ASSERT_SUCCESS(urKernelSetArgValue(kernel, 1, sizeof(A), nullptr, &A));
+        // Index 2 is X
+        ASSERT_SUCCESS(
+            urKernelSetArgPointer(kernel, 2, nullptr, device_ptrs[0]));
+        // Index 3 is Y
+        ASSERT_SUCCESS(
+            urKernelSetArgPointer(kernel, 3, nullptr, device_ptrs[1]));
+
+        // Create second command-buffer
+        ASSERT_SUCCESS(urCommandBufferCreateExp(context, device, nullptr,
+                                                &second_cmd_buf_handle));
+        ASSERT_NE(second_cmd_buf_handle, nullptr);
+    }
+
+    virtual void TearDown() override {
+        for (auto &device_ptr : device_ptrs) {
+            if (device_ptr) {
+                EXPECT_SUCCESS(urUSMFree(context, device_ptr));
+            }
+        }
+
+        for (auto &event : external_events) {
+            if (event) {
+                EXPECT_SUCCESS(urEventRelease(event));
+            }
+        }
+
+        if (second_cmd_buf_handle) {
+            EXPECT_SUCCESS(urCommandBufferReleaseExp(second_cmd_buf_handle));
+        }
+
+        UUR_RETURN_ON_FATAL_FAILURE(
+            urCommandBufferExpExecutionTest::TearDown());
+    }
+
+    // First two shared points are inputs to be tested, last is an output
+    // generated by test command.
+    std::array<void *, 3> device_ptrs = {nullptr, nullptr, nullptr};
+    std::array<ur_event_handle_t, 2> external_events = {nullptr, nullptr};
+    std::array<ur_exp_command_buffer_sync_point_t, 2> sync_points = {0, 0};
+    ur_exp_command_buffer_handle_t second_cmd_buf_handle = nullptr;
+    static constexpr size_t elements = 64;
+    static constexpr size_t allocation_size = sizeof(uint32_t) * elements;
+    static constexpr size_t A = 2;
+};
+
+UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(KernelCommandEventSyncTest);
+
+// Tests a Saxpy kernel as follows:
+// 1. Enqueue work initializing X data on a queue to get an external ur event
+//    to wait on.
+// 2. Append a command-buffer command initializing Y data, to be a dependency
+//    of kernel command to test.
+// 3. Append a kernel command with both sync point and external
+//    event dependencies on initialization of X and Y. Returning both a sync
+//    point and event to synchronize with completion of command.
+// 4. Append a command-buffer command that depends on sync point from
+//    tested command.
+// 5. Finalize and enqueue command-buffer.
+// 6. Enqueue a queue command waiting on event returned from command.
+// 7. Verify results.
+TEST_P(KernelCommandEventSyncTest, Basic) {
+    // Initialize data X with queue submission
+    uint32_t patternX = 42;
+    ASSERT_SUCCESS(urEnqueueUSMFill(queue, device_ptrs[0], sizeof(patternX),
+                                    &patternX, allocation_size, 0, nullptr,
+                                    &external_events[0]));
+
+    // Initialize data Y with command-buffer command
+    uint32_t patternY = 0xA;
+    ASSERT_SUCCESS(urCommandBufferAppendUSMFillExp(
+        cmd_buf_handle, device_ptrs[1], &patternY, sizeof(patternY),
+        allocation_size, 0, nullptr, 0, nullptr, &sync_points[0], nullptr,
+        nullptr));
+
+    // Kernel command for SAXPY waiting on command and signal event
+    ASSERT_SUCCESS(urCommandBufferAppendKernelLaunchExp(
+        cmd_buf_handle, kernel, 1, nullptr, &elements, nullptr, 1,
+        &sync_points[0], 1, &external_events[0], &sync_points[1], nullptr,
+        nullptr));
+
+    // command-buffer command that reads output to host
+    std::array<uint32_t, elements> host_command_ptr{};
+    ASSERT_SUCCESS(urCommandBufferAppendUSMMemcpyExp(
+        cmd_buf_handle, host_command_ptr.data(), device_ptrs[2],
+        allocation_size, 1, &sync_points[1], 0, nullptr, nullptr, nullptr,
+        nullptr));
+    ASSERT_SUCCESS(urCommandBufferFinalizeExp(cmd_buf_handle));
+
+    ASSERT_SUCCESS(
+        urCommandBufferEnqueueExp(cmd_buf_handle, queue, 0, nullptr, nullptr));
+
+    // Queue command that reads output to host
+    std::array<uint32_t, elements> host_enqueue_ptr{};
+    ASSERT_SUCCESS(urEnqueueUSMMemcpy(queue, false, host_enqueue_ptr.data(),
+                                      device_ptrs[2], allocation_size, 1,
+                                      &external_events[1], nullptr));
+
+    ASSERT_SUCCESS(urQueueFinish(queue));
+
+    for (size_t i = 0; i < elements; i++) {
+        auto ref = (patternX * A) + patternY;
+        ASSERT_EQ(host_command_ptr[i], ref);
+        ASSERT_EQ(host_enqueue_ptr[i], ref);
+    }
+}
+
+// Tests using events to synchronize between command-buffers:
+// 1. Initialize data in command-buffer A, returning event 1.
+// 2. Use data in command-buffer B, waiting on event 1 and signaling event 2
+// 3. Read back data to host in command-buffer A, waiting on event 1.
+// 4. Finalize and submit command-buffer, verify results
+TEST_P(KernelCommandEventSyncTest, InterCommandBuffer) {
+    // Initialize data Y with command-buffer A command
+    uint32_t patternX = 42;
+    ASSERT_SUCCESS(urCommandBufferAppendUSMFillExp(
+        cmd_buf_handle, device_ptrs[0], &patternX, sizeof(patternX),
+        allocation_size, 0, nullptr, 0, nullptr, &sync_points[0], nullptr,
+        nullptr));
+
+    // Initialize data Y with command-buffer A command
+    uint32_t patternY = 0xA;
+    ASSERT_SUCCESS(urCommandBufferAppendUSMFillExp(
+        cmd_buf_handle, device_ptrs[1], &patternY, sizeof(patternY),
+        allocation_size, 1, &sync_points[0], 0, nullptr, &sync_points[1],
+        &external_events[0], nullptr));
+
+    // Run SAXPY kernel with command-buffer B command, waiting on an event.
+    ASSERT_SUCCESS(urCommandBufferAppendKernelLaunchExp(
+        second_cmd_buf_handle, kernel, 1, nullptr, &elements, nullptr, 0,
+        nullptr, 1, &external_events[0], nullptr, &external_events[1],
+        nullptr));
+
+    // Command-buffer A command that reads output to host, waiting on an event
+    std::array<uint32_t, elements> host_command_ptr{};
+    ASSERT_SUCCESS(urCommandBufferAppendUSMMemcpyExp(
+        cmd_buf_handle, host_command_ptr.data(), device_ptrs[2],
+        allocation_size, 1, &sync_points[1], 1, &external_events[1], nullptr,
+        nullptr, nullptr));
+
+    // Finalize command-buffers
+    ASSERT_SUCCESS(urCommandBufferFinalizeExp(cmd_buf_handle));
+    ASSERT_SUCCESS(urCommandBufferFinalizeExp(second_cmd_buf_handle));
+
+    // Submit command-buffers
+    ASSERT_SUCCESS(urCommandBufferEnqueueExp(second_cmd_buf_handle, queue, 0,
+                                             nullptr, nullptr));
+    ASSERT_SUCCESS(
+        urCommandBufferEnqueueExp(cmd_buf_handle, queue, 0, nullptr, nullptr));
+
+    // Verify execution
+    ASSERT_SUCCESS(urQueueFinish(queue));
+    for (size_t i = 0; i < elements; i++) {
+        auto ref = (patternX * A) + patternY;
+        ASSERT_EQ(host_command_ptr[i], ref);
+    }
+}
+
+struct KernelCommandEventSyncUpdateTest
+    : uur::command_buffer::urUpdatableCommandBufferExpExecutionTest {
+    void SetUp() override {
+        program_name = "saxpy_usm";
+        UUR_RETURN_ON_FATAL_FAILURE(
+            urUpdatableCommandBufferExpExecutionTest::SetUp());
+
+        ur_bool_t event_support = false;
+        ASSERT_SUCCESS(urDeviceGetInfo(
+            device, UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP,
+            sizeof(ur_bool_t), &event_support, nullptr));
+        if (!event_support) {
+            GTEST_SKIP() << "External event sync is not supported by device.";
+        }
+
+        for (auto &device_ptr : device_ptrs) {
+            ASSERT_SUCCESS(urUSMDeviceAlloc(context, device, nullptr, nullptr,
+                                            allocation_size, &device_ptr));
+            ASSERT_NE(device_ptr, nullptr);
+        }
+
+        // Index 0 is output
+        ASSERT_SUCCESS(
+            urKernelSetArgPointer(kernel, 0, nullptr, device_ptrs[2]));
+        // Index 1 is A
+        ASSERT_SUCCESS(urKernelSetArgValue(kernel, 1, sizeof(A), nullptr, &A));
+        // Index 2 is X
+        ASSERT_SUCCESS(
+            urKernelSetArgPointer(kernel, 2, nullptr, device_ptrs[0]));
+        // Index 3 is Y
+        ASSERT_SUCCESS(
+            urKernelSetArgPointer(kernel, 3, nullptr, device_ptrs[1]));
+    }
+
+    virtual void TearDown() override {
+        for (auto &device_ptr : device_ptrs) {
+            if (device_ptr) {
+                EXPECT_SUCCESS(urUSMFree(context, device_ptr));
+            }
+        }
+
+        for (auto &event : external_events) {
+            if (event) {
+                EXPECT_SUCCESS(urEventRelease(event));
+            }
+        }
+
+        if (command_handle) {
+            EXPECT_SUCCESS(urCommandBufferReleaseCommandExp(command_handle));
+        }
+
+        UUR_RETURN_ON_FATAL_FAILURE(
+            urUpdatableCommandBufferExpExecutionTest::TearDown());
+    }
+
+    // First two shared points are inputs to be tested, last is an output
+    // generated by test command.
+    std::array<void *, 3> device_ptrs = {nullptr, nullptr, nullptr};
+    std::array<ur_event_handle_t, 4> external_events = {nullptr, nullptr,
+                                                        nullptr, nullptr};
+    std::array<ur_exp_command_buffer_sync_point_t, 2> sync_points = {0, 0};
+    ur_exp_command_buffer_command_handle_t command_handle = nullptr;
+    static constexpr size_t elements = 64;
+    static constexpr size_t allocation_size = sizeof(uint32_t) * elements;
+    static constexpr size_t A = 2;
+};
+
+UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(KernelCommandEventSyncUpdateTest);
+
+// Tests updating the signal and wait event dependencies of the saxpy
+// command in a command-buffer.
+TEST_P(KernelCommandEventSyncUpdateTest, Basic) {
+    // Initialize data X with queue submission
+    uint32_t patternX = 42;
+    ASSERT_SUCCESS(urEnqueueUSMFill(queue, device_ptrs[0], sizeof(patternX),
+                                    &patternX, allocation_size, 0, nullptr,
+                                    &external_events[0]));
+
+    // Initialize data Y with command-buffer command
+    uint32_t patternY = 0xA;
+    ASSERT_SUCCESS(urCommandBufferAppendUSMFillExp(
+        updatable_cmd_buf_handle, device_ptrs[1], &patternY, sizeof(patternY),
+        allocation_size, 0, nullptr, 0, nullptr, &sync_points[0], nullptr,
+        nullptr));
+
+    // Kernel command for SAXPY waiting on command and signal event
+    ASSERT_SUCCESS(urCommandBufferAppendKernelLaunchExp(
+        updatable_cmd_buf_handle, kernel, 1, nullptr, &elements, nullptr, 1,
+        &sync_points[0], 1, &external_events[0], &sync_points[1], nullptr,
+        &command_handle));
+
+    // command-buffer command that reads output to host
+    std::array<uint32_t, elements> host_command_ptr{};
+    ASSERT_SUCCESS(urCommandBufferAppendUSMMemcpyExp(
+        updatable_cmd_buf_handle, host_command_ptr.data(), device_ptrs[2],
+        allocation_size, 1, &sync_points[1], 0, nullptr, nullptr, nullptr,
+        nullptr));
+    ASSERT_SUCCESS(urCommandBufferFinalizeExp(updatable_cmd_buf_handle));
+
+    ASSERT_SUCCESS(urCommandBufferEnqueueExp(updatable_cmd_buf_handle, queue, 0,
+                                             nullptr, nullptr));
+
+    // Queue command that reads output to host
+    std::array<uint32_t, elements> host_enqueue_ptr{};
+    ASSERT_SUCCESS(urEnqueueUSMMemcpy(queue, false, host_enqueue_ptr.data(),
+                                      device_ptrs[2], allocation_size, 1,
+                                      &external_events[1], nullptr));
+
+    ASSERT_SUCCESS(urQueueFinish(queue));
+
+    for (size_t i = 0; i < elements; i++) {
+        auto ref = (patternX * A) + patternY;
+        ASSERT_EQ(host_command_ptr[i], ref);
+        ASSERT_EQ(host_enqueue_ptr[i], ref);
+    }
+
+    // Reset output data
+    std::memset(host_command_ptr.data(), 0, allocation_size);
+    std::memset(host_enqueue_ptr.data(), 0, allocation_size);
+
+    // Set data X to new value with queue submission
+    patternX = -42;
+    ASSERT_SUCCESS(urEnqueueUSMFill(queue, device_ptrs[0], sizeof(patternX),
+                                    &patternX, allocation_size, 0, nullptr,
+                                    &external_events[2]));
+
+    // Update kernel command-wait event to wait on fill of new x value
+    ASSERT_SUCCESS(urCommandBufferUpdateWaitEventsExp(command_handle, 1,
+                                                      &external_events[2]));
+
+    // Get a new signal event for command-buffer
+    ASSERT_SUCCESS(urCommandBufferUpdateSignalEventExp(command_handle,
+                                                       &external_events[3]));
+
+    // Read data back with a queue operation waiting on updated kernel command
+    // signal event.
+    ASSERT_SUCCESS(urEnqueueUSMMemcpy(queue, false, host_enqueue_ptr.data(),
+                                      device_ptrs[2], allocation_size, 1,
+                                      &external_events[3], nullptr));
+
+    // Verify results
+    ASSERT_SUCCESS(urQueueFinish(queue));
+    for (size_t i = 0; i < elements; i++) {
+        auto ref = (patternX * A) + patternY;
+        ASSERT_EQ(host_command_ptr[i], ref);
+        ASSERT_EQ(host_enqueue_ptr[i], ref);
+    }
+}