[UR] Add initial graph record & replay tests

Author: kswiecicki

unified-runtime/test/conformance/CMakeLists.txt

@@ -70,6 +70,7 @@ add_subdirectory(queue)
 add_subdirectory(sampler)
 add_subdirectory(virtual_memory)
 add_subdirectory(exp_usm_context_memcpy)
+add_subdirectory(exp_graph)
 
 set(TEST_SUBDIRECTORIES_DPCXX
     "device_code"

unified-runtime/test/conformance/exp_graph/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Copyright (C) 2025 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
+
+add_conformance_devices_test(exp_graph
+  urEnqueueGraphExp.cpp
+  urGraphCreateExp.cpp
+  urGraphInstantiateGraphExp.cpp
+  urGraphIsEmptyExp.cpp
+  urQueueBeginCaptureIntoGraphExp.cpp
+  urQueueBeginGraphCaptureExp.cpp
+  urQueueIsGraphCaptureEnabledExp.cpp)

unified-runtime/test/conformance/exp_graph/fixtures.h

@@ -0,0 +1,117 @@
+// Copyright (C) 2025 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
+
+#ifndef UR_CONFORMANCE_GRAPH_FIXTURES_H
+#define UR_CONFORMANCE_GRAPH_FIXTURES_H
+
+#include "uur/fixtures.h"
+#include "uur/known_failure.h"
+#include "uur/raii.h"
+
+namespace uur {
+
+struct urGraphSupportedExpTest : uur::urQueueTest {
+  void SetUp() override {
+    UUR_KNOWN_FAILURE_ON(uur::CUDA{}, uur::HIP{}, uur::NativeCPU{},
+                         uur::OpenCL{}, uur::LevelZero{}, uur::LevelZeroV2{});
+    UUR_RETURN_ON_FATAL_FAILURE(urQueueTest::SetUp());
+  }
+};
+
+struct urGraphExpTest : urGraphSupportedExpTest {
+  void SetUp() override {
+    UUR_RETURN_ON_FATAL_FAILURE(urGraphSupportedExpTest::SetUp());
+
+    ASSERT_SUCCESS(urGraphCreateExp(context, &graph));
+  }
+
+  void TearDown() override {
+    ASSERT_SUCCESS(urGraphDestroyExp(graph));
+    UUR_RETURN_ON_FATAL_FAILURE(urGraphSupportedExpTest::TearDown());
+  }
+
+  ur_exp_graph_handle_t graph = nullptr;
+};
+
+struct urGraphPopulatedExpTest : urGraphExpTest {
+  void SetUp() override {
+    UUR_RETURN_ON_FATAL_FAILURE(urGraphExpTest::SetUp());
+
+    ur_device_usm_access_capability_flags_t deviceUSMSupport = 0;
+    ASSERT_SUCCESS(uur::GetDeviceUSMDeviceSupport(device, deviceUSMSupport));
+    if (!deviceUSMSupport) {
+      GTEST_SKIP() << "Device USM is not supported";
+    }
+    uur::generateMemFillPattern(pattern);
+
+    ASSERT_SUCCESS(urUSMDeviceAlloc(context, device, nullptr, nullptr,
+                                    allocationSize, &deviceMem));
+
+    ASSERT_SUCCESS(urQueueBeginCaptureIntoGraphExp(queue, graph));
+
+    ASSERT_SUCCESS(urEnqueueUSMFill(queue, deviceMem, patternSize,
+                                    pattern.data(), allocationSize, 0, nullptr,
+                                    fillEvent.ptr()));
+    ASSERT_SUCCESS(urQueueFinish(queue));
+
+    ur_exp_graph_handle_t sameGraph = nullptr;
+    ASSERT_SUCCESS(urQueueEndGraphCaptureExp(queue, &sameGraph));
+    ASSERT_EQ(graph, sameGraph);
+
+    ASSERT_NO_FATAL_FAILURE(verifyData(false));
+  }
+
+  void TearDown() override {
+    if (deviceMem) {
+      ASSERT_SUCCESS(urUSMFree(context, deviceMem));
+    }
+
+    UUR_RETURN_ON_FATAL_FAILURE(urGraphExpTest::TearDown());
+  }
+
+  void verifyData(const bool shouldMatch) {
+    ASSERT_SUCCESS(urEnqueueUSMMemcpy(queue, true, hostMem.data(), deviceMem,
+                                      allocationSize, 0, nullptr, nullptr));
+
+    size_t patternIdx = 0;
+    for (size_t i = 0; i < allocationSize; ++i) {
+      uint8_t *hostPtr = hostMem.data();
+      ASSERT_EQ((*(hostPtr + i) == pattern[patternIdx]), shouldMatch);
+
+      ++patternIdx;
+      if (patternIdx % pattern.size() == 0) {
+        patternIdx = 0;
+      }
+    }
+  }
+
+  const size_t allocationSize = 256;
+  void *deviceMem{nullptr};
+  std::vector<uint8_t> hostMem = std::vector<uint8_t>(allocationSize);
+  const size_t patternSize = 64;
+  std::vector<uint8_t> pattern = std::vector<uint8_t>(patternSize);
+  uur::raii::Event fillEvent = nullptr;
+};
+
+struct urGraphExecutableExpTest : urGraphPopulatedExpTest {
+  void SetUp() override {
+    UUR_RETURN_ON_FATAL_FAILURE(urGraphPopulatedExpTest::SetUp());
+
+    ASSERT_SUCCESS(urGraphInstantiateGraphExp(graph, &exGraph));
+  }
+
+  void TearDown() override {
+    ASSERT_SUCCESS(urGraphExecutableGraphDestroyExp(exGraph));
+
+    UUR_RETURN_ON_FATAL_FAILURE(urGraphPopulatedExpTest::TearDown());
+  }
+
+  ur_exp_executable_graph_handle_t exGraph = nullptr;
+};
+
+} // namespace uur
+
+#endif // UR_CONFORMANCE_GRAPH_FIXTURES_H

unified-runtime/test/conformance/exp_graph/urEnqueueGraphExp.cpp

@@ -0,0 +1,47 @@
+// Copyright (C) 2025 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 "uur/raii.h"
+
+using urEnqueueGraphExpTest = uur::urGraphExecutableExpTest;
+
+TEST_P(urEnqueueGraphExpTest, Success) {
+  verifyData(false);
+  ASSERT_SUCCESS(urEnqueueGraphExp(queue, exGraph, 0, nullptr, nullptr));
+  ASSERT_SUCCESS(urQueueFinish(queue));
+
+  ASSERT_NO_FATAL_FAILURE(verifyData(true));
+}
+
+TEST_P(urEnqueueGraphExpTest, SuccessWithEvent) {
+  uur::raii::Event graphEvent = nullptr;
+  ASSERT_SUCCESS(
+      urEnqueueGraphExp(queue, exGraph, 0, nullptr, graphEvent.ptr()));
+  ASSERT_SUCCESS(urQueueFlush(queue));
+  ASSERT_SUCCESS(urEventWait(1, graphEvent.ptr()));
+}
+
+TEST_P(urEnqueueGraphExpTest, InvalidNullHandleQueue) {
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
+                   urEnqueueGraphExp(nullptr, exGraph, 0, nullptr, nullptr));
+}
+
+TEST_P(urEnqueueGraphExpTest, InvalidNullHandleExGraph) {
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
+                   urEnqueueGraphExp(queue, nullptr, 0, nullptr, nullptr));
+}
+
+TEST_P(urEnqueueGraphExpTest, InvalidEventWaitListArray) {
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST,
+                   urEnqueueGraphExp(queue, nullptr, 1, nullptr, nullptr));
+}
+
+TEST_P(urEnqueueGraphExpTest, InvalidEventWaitListSize) {
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST,
+                   urEnqueueGraphExp(queue, nullptr, 0,
+                                     (ur_event_handle_t *)0xC0FFEE, nullptr));
+}

unified-runtime/test/conformance/exp_graph/urGraphCreateExp.cpp

@@ -0,0 +1,28 @@
+// Copyright (C) 2025 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"
+
+using urGraphCreateExpTest = uur::urGraphSupportedExpTest;
+
+UUR_INSTANTIATE_DEVICE_TEST_SUITE(urGraphCreateExpTest);
+
+TEST_P(urGraphCreateExpTest, Success) {
+  ur_exp_graph_handle_t graph = nullptr;
+  ASSERT_SUCCESS(urGraphCreateExp(context, &graph));
+  ASSERT_SUCCESS(urGraphDestroyExp(graph));
+}
+
+TEST_P(urGraphCreateExpTest, InvalidNullHandleContext) {
+  ur_exp_graph_handle_t graph = nullptr;
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
+                   urGraphCreateExp(nullptr, &graph));
+}
+
+TEST_P(urGraphCreateExpTest, InvalidNullHandleGraph) {
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
+                   urGraphCreateExp(context, nullptr));
+}

unified-runtime/test/conformance/exp_graph/urGraphInstantiateGraphExp.cpp

@@ -0,0 +1,28 @@
+// Copyright (C) 2025 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"
+
+using urGraphInstantiateGraphExpTest = uur::urGraphExpTest;
+
+UUR_INSTANTIATE_DEVICE_TEST_SUITE(urGraphInstantiateGraphExpTest);
+
+TEST_P(urGraphInstantiateGraphExpTest, InvalidEmptyGraph) {
+  ur_exp_executable_graph_handle_t exGraph = nullptr;
+  ASSERT_SUCCESS(urGraphInstantiateGraphExp(graph, &exGraph));
+  ASSERT_SUCCESS(urGraphExecutableGraphDestroyExp(exGraph));
+}
+
+TEST_P(urGraphInstantiateGraphExpTest, InvalidNullHandleGraph) {
+  ur_exp_executable_graph_handle_t exGraph = nullptr;
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
+                   urGraphInstantiateGraphExp(nullptr, &exGraph));
+}
+
+TEST_P(urGraphInstantiateGraphExpTest, InvalidNullHandleExGraph) {
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
+                   urGraphInstantiateGraphExp(graph, nullptr));
+}

unified-runtime/test/conformance/exp_graph/urGraphIsEmptyExp.cpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2025 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"
+
+using urGraphNonEmptyExpTest = uur::urGraphPopulatedExpTest;
+
+TEST_P(urGraphNonEmptyExpTest, SuccessFalse) {
+  bool isEmpty = false;
+  ASSERT_SUCCESS(urGraphIsEmptyExp(graph, &isEmpty));
+  ASSERT_TRUE(isEmpty);
+}
+
+using urGraphEmptyExpTest = uur::urGraphExpTest;
+
+TEST_P(urGraphEmptyExpTest, SuccessTrue) {
+  bool isEmpty = false;
+  ASSERT_SUCCESS(urGraphIsEmptyExp(graph, &isEmpty));
+  ASSERT_FALSE(isEmpty);
+}
+
+TEST_P(urGraphEmptyExpTest, InvalidNullHandleQueue) {
+  bool isEmpty = false;
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
+                   urGraphIsEmptyExp(nullptr, &isEmpty));
+}
+
+TEST_P(urGraphEmptyExpTest, InvalidNullPtrResult) {
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
+                   urGraphIsEmptyExp(graph, nullptr));
+}

unified-runtime/test/conformance/exp_graph/urQueueBeginCaptureIntoGraphExp.cpp

@@ -0,0 +1,24 @@
+// Copyright (C) 2025 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"
+
+using urQueueBeginCaptureIntoGraphExpTest = uur::urGraphExpTest;
+UUR_INSTANTIATE_DEVICE_TEST_SUITE(urQueueBeginCaptureIntoGraphExpTest);
+
+TEST_P(urQueueBeginCaptureIntoGraphExpTest, Success) {
+  ASSERT_SUCCESS(urQueueBeginCaptureIntoGraphExp(queue, graph));
+}
+
+TEST_P(urQueueBeginCaptureIntoGraphExpTest, InvalidNullHandleQueue) {
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
+                   urQueueBeginCaptureIntoGraphExp(nullptr, graph));
+}
+
+TEST_P(urQueueBeginCaptureIntoGraphExpTest, InvalidNullHandleGraph) {
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
+                   urQueueBeginCaptureIntoGraphExp(queue, nullptr));
+}

unified-runtime/test/conformance/exp_graph/urQueueBeginGraphCaptureExp.cpp

@@ -0,0 +1,24 @@
+// Copyright (C) 2025 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 "uur/fixtures.h"
+#include "uur/known_failure.h"
+
+using urQueueBeginGraphCaptureExpTest = uur::urQueueTest;
+UUR_INSTANTIATE_DEVICE_TEST_SUITE(urQueueBeginGraphCaptureExpTest);
+
+TEST_P(urQueueBeginGraphCaptureExpTest, Success) {
+  ASSERT_SUCCESS(urQueueBeginGraphCaptureExp(queue));
+
+  ur_exp_graph_handle_t graph = nullptr;
+  ASSERT_SUCCESS(urQueueEndGraphCaptureExp(queue, &graph));
+  ASSERT_SUCCESS(urGraphDestroyExp(graph));
+}
+
+TEST_P(urQueueBeginGraphCaptureExpTest, InvalidNullHandleQueue) {
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
+                   urQueueBeginGraphCaptureExp(nullptr));
+}

unified-runtime/test/conformance/exp_graph/urQueueIsGraphCaptureEnabledExp.cpp

@@ -0,0 +1,55 @@
+// Copyright (C) 2025 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"
+
+struct urQueueIsGraphCaptureEnabledExpTest : uur::urGraphSupportedExpTest {
+  void SetUp() override {
+    UUR_RETURN_ON_FATAL_FAILURE(urQueueTest::SetUp());
+    ASSERT_SUCCESS(urQueueBeginGraphCaptureExp(queue));
+  }
+
+  void TearDown() override {
+    UUR_RETURN_ON_FATAL_FAILURE(urQueueTest::TearDown());
+    endGraphCapture();
+    ASSERT_SUCCESS(urGraphDestroyExp(graph));
+  }
+
+  void endGraphCapture() {
+    if (!graph) {
+      ASSERT_SUCCESS(urQueueEndGraphCaptureExp(queue, &graph));
+    }
+  }
+
+  ur_exp_graph_handle_t graph = nullptr;
+};
+
+UUR_INSTANTIATE_DEVICE_TEST_SUITE(urQueueIsGraphCaptureEnabledExpTest);
+
+TEST_P(urQueueIsGraphCaptureEnabledExpTest, SuccessEnabled) {
+  bool isEnabled = false;
+  ASSERT_SUCCESS(urQueueIsGraphCaptureEnabledExp(queue, &isEnabled));
+  ASSERT_TRUE(isEnabled);
+}
+
+TEST_P(urQueueIsGraphCaptureEnabledExpTest, SuccessDisabled) {
+  endGraphCapture();
+
+  bool isEnabled = false;
+  ASSERT_SUCCESS(urQueueIsGraphCaptureEnabledExp(queue, &isEnabled));
+  ASSERT_FALSE(isEnabled);
+}
+
+TEST_P(urQueueIsGraphCaptureEnabledExpTest, InvalidNullHandleQueue) {
+  bool isEnabled = false;
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
+                   urQueueIsGraphCaptureEnabledExp(nullptr, &isEnabled));
+}
+
+TEST_P(urQueueIsGraphCaptureEnabledExpTest, InvalidNullPtrResult) {
+  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
+                   urQueueIsGraphCaptureEnabledExp(queue, nullptr));
+}