[UR] Fix record & replay tests

Author: kswiecicki

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

@@ -18,7 +18,8 @@ struct urGraphSupportedExpTest : uur::urQueueTest {
     UUR_RETURN_ON_FATAL_FAILURE(urQueueTest::SetUp());
 
     UUR_KNOWN_FAILURE_ON(uur::CUDA{}, uur::HIP{}, uur::NativeCPU{},
-                         uur::OpenCL{}, uur::LevelZero{}, uur::LevelZeroV2{});
+                         uur::OpenCL{}, uur::LevelZero{},
+                         /* uur::LevelZeroV2{} */);
   }
 };
 
@@ -58,38 +59,29 @@ struct urGraphPopulatedExpTest : urGraphExpTest {
 
     ASSERT_SUCCESS(urEnqueueUSMFill(queue, deviceMem, patternSize,
                                     pattern.data(), allocationSize, 0, nullptr,
-                                    fillEvent.ptr()));
-    ASSERT_SUCCESS(urQueueFinish(queue));
+                                    nullptr));
 
     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));
     }
 
+    resetData();
+
     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;
-      }
-    }
+    int cmpResult = memcmp(hostMem.data(), pattern.data(), pattern.size());
+    ASSERT_EQ(cmpResult == 0, shouldMatch);
   }
 
   void resetData() {
@@ -104,7 +96,6 @@ struct urGraphPopulatedExpTest : urGraphExpTest {
   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 {

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

@@ -14,7 +14,7 @@ using urEnqueueGraphExpTest = uur::urGraphExecutableExpTest;
 UUR_INSTANTIATE_DEVICE_TEST_SUITE(urEnqueueGraphExpTest);
 
 TEST_P(urEnqueueGraphExpTest, Success) {
-  verifyData(false);
+  ASSERT_NO_FATAL_FAILURE(verifyData(false));
   ASSERT_SUCCESS(urEnqueueGraphExp(queue, exGraph, 0, nullptr, nullptr));
   ASSERT_SUCCESS(urQueueFinish(queue));
 
@@ -41,12 +41,12 @@ TEST_P(urEnqueueGraphExpTest, InvalidNullHandleExGraph) {
 
 TEST_P(urEnqueueGraphExpTest, InvalidEventWaitListArray) {
   ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST,
-                   urEnqueueGraphExp(queue, nullptr, 1, nullptr, nullptr));
+                   urEnqueueGraphExp(queue, exGraph, 1, nullptr, nullptr));
 }
 
 TEST_P(urEnqueueGraphExpTest, InvalidEventWaitListSize) {
   ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST,
-                   urEnqueueGraphExp(queue, nullptr, 0,
+                   urEnqueueGraphExp(queue, exGraph, 0,
                                      (ur_event_handle_t *)0xC0FFEE, nullptr));
 }
 

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

@@ -12,8 +12,8 @@ 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));
+  ASSERT_EQ(urGraphInstantiateGraphExp(graph, &exGraph),
+            UR_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
 TEST_P(urGraphInstantiateGraphExpTest, InvalidNullHandleGraph) {

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

@@ -10,20 +10,20 @@ using urGraphNonEmptyExpTest = uur::urGraphPopulatedExpTest;
 
 UUR_INSTANTIATE_DEVICE_TEST_SUITE(urGraphNonEmptyExpTest);
 
-TEST_P(urGraphNonEmptyExpTest, SuccessFalse) {
+TEST_P(urGraphNonEmptyExpTest, Success) {
   bool isEmpty = false;
   ASSERT_SUCCESS(urGraphIsEmptyExp(graph, &isEmpty));
-  ASSERT_TRUE(isEmpty);
+  ASSERT_FALSE(isEmpty);
 }
 
 using urGraphEmptyExpTest = uur::urGraphExpTest;
 
 UUR_INSTANTIATE_DEVICE_TEST_SUITE(urGraphEmptyExpTest);
 
-TEST_P(urGraphEmptyExpTest, SuccessTrue) {
+TEST_P(urGraphEmptyExpTest, Success) {
   bool isEmpty = false;
   ASSERT_SUCCESS(urGraphIsEmptyExp(graph, &isEmpty));
-  ASSERT_FALSE(isEmpty);
+  ASSERT_TRUE(isEmpty);
 }
 
 TEST_P(urGraphEmptyExpTest, InvalidNullHandleQueue) {

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

@@ -23,3 +23,13 @@ TEST_P(urQueueBeginCaptureIntoGraphExpTest, InvalidNullHandleGraph) {
   ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
                    urQueueBeginCaptureIntoGraphExp(queue, nullptr));
 }
+
+using urQueueBeginCaptureIntoPupulatedGraphExpTest =
+    uur::urGraphPopulatedExpTest;
+
+UUR_INSTANTIATE_DEVICE_TEST_SUITE(urQueueBeginCaptureIntoPupulatedGraphExpTest);
+
+TEST_P(urQueueBeginCaptureIntoPupulatedGraphExpTest, InvalidNonEmptyGraph) {
+  ASSERT_EQ(urQueueBeginCaptureIntoGraphExp(queue, graph),
+            UR_RESULT_ERROR_INVALID_ARGUMENT);
+}

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

@@ -6,11 +6,12 @@
 
 #include "fixtures.h"
 
-using urQueueEndGraphCaptureExpTest = uur::urGraphPopulatedExpTest;
+using urQueueEndGraphCaptureExpTest = uur::urGraphExpTest;
 
 UUR_INSTANTIATE_DEVICE_TEST_SUITE(urQueueEndGraphCaptureExpTest);
 
 TEST_P(urQueueEndGraphCaptureExpTest, SuccessSameGraph) {
+  ASSERT_SUCCESS(urQueueBeginCaptureIntoGraphExp(queue, graph));
   ur_exp_graph_handle_t sameGraph = nullptr;
   ASSERT_SUCCESS(urQueueEndGraphCaptureExp(queue, &sameGraph));
   ASSERT_EQ(graph, sameGraph);

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

@@ -23,7 +23,7 @@ struct urQueueIsGraphCaptureEnabledExpTest : uur::urGraphSupportedExpTest {
   }
 
   void endGraphCapture() {
-    if (graph) {
+    if (!graph) {
       ASSERT_SUCCESS(urQueueEndGraphCaptureExp(queue, &graph));
     }
   }