add batch queues workarounds and skips

Author: EuphoricThinking

unified-runtime/test/adapters/level_zero/v2/command_list_cache_test.cpp

@@ -15,6 +15,7 @@
 
 #include "uur/fixtures.h"
 #include "uur/raii.h"
+#include "uur/utils.h"
 
 #include <gtest/gtest.h>
 #include <map>
@@ -186,6 +187,7 @@ TEST_P(CommandListCacheTest, ImmediateCommandListsHaveProperAttributes) {
 TEST_P(CommandListCacheTest, CommandListsAreReusedByQueues) {
   static constexpr int NumQueuesPerType = 5;
   size_t NumUniqueQueueTypes = 0;
+  bool isBatched = false;
 
   for (int I = 0; I < NumQueuesPerType; I++) {
     NumUniqueQueueTypes = 0;
@@ -216,6 +218,8 @@ TEST_P(CommandListCacheTest, CommandListsAreReusedByQueues) {
           ASSERT_EQ(urQueueCreate(context, device, &QueueProps, Queue.ptr()),
                     UR_RESULT_SUCCESS);
 
+          ASSERT_NO_FATAL_FAILURE(uur::isQueueBatched(Queue, &isBatched));
+
           Queues.emplace_back(Queue);
         }
       }
@@ -227,7 +231,13 @@ TEST_P(CommandListCacheTest, CommandListsAreReusedByQueues) {
 
     ASSERT_EQ(context->getCommandListCache().getNumImmediateCommandLists(),
               NumUniqueQueueTypes);
-    ASSERT_EQ(context->getCommandListCache().getNumRegularCommandLists(), 0);
+
+    if (isBatched) {
+      ASSERT_EQ(context->getCommandListCache().getNumRegularCommandLists(),
+                NumUniqueQueueTypes);
+    } else {
+      ASSERT_EQ(context->getCommandListCache().getNumRegularCommandLists(), 0);
+    }
   }
 }
 

unified-runtime/test/adapters/level_zero/v2/event_pool_test.cpp

@@ -24,6 +24,7 @@
 #include "event_provider_counter.hpp"
 #include "event_provider_normal.hpp"
 #include "queue_handle.hpp"
+#include "uur/checks.h"
 #include "uur/fixtures.h"
 #include "ze_api.h"
 
@@ -277,6 +278,13 @@ TEST_P(EventPoolTestWithQueue, WithTimestamp) {
     GTEST_SKIP() << "Profiling needs to be enabled";
   }
 
+  // bool isBatched = false;
+  // ASSERT_NO_FATAL_FAILURE(isBatchedQueue(&isBatched));
+  // if (isBatched) {
+  //   UUR_KNOWN_FAILURE_ON(uur::LevelZeroV2{});
+  // }
+  SKIP_IF_BATCHED_QUEUE(queue);
+  ASSERT_TRUE(false);
   auto zeEvent = createZeEvent(context, device);
 
   ur_event_handle_t hEvent;

unified-runtime/test/conformance/enqueue/urEnqueueTimestampRecording.cpp

@@ -4,22 +4,32 @@
 //
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+#include "uur/checks.h"
+#include <gtest/gtest.h>
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
 
 struct urEnqueueTimestampRecordingExpTest : uur::urQueueTest {
   void SetUp() override {
     UUR_RETURN_ON_FATAL_FAILURE(urQueueTest::SetUp());
 
-    ur_queue_flags_t queueFlags{};
-    ASSERT_SUCCESS(urQueueGetInfo(queue, UR_QUEUE_INFO_FLAGS,
-                                  sizeof(ur_queue_flags_t), &queueFlags,
-                                  nullptr));
-
-    if (queueFlags & UR_QUEUE_FLAG_SUBMISSION_BATCHED) {
-      UUR_KNOWN_FAILURE_ON(uur::LevelZeroV2{});
-    }
-
+    // ur_queue_flags_t queueFlags{};
+    // ASSERT_SUCCESS(urQueueGetInfo(queue, UR_QUEUE_INFO_FLAGS,
+    //                               sizeof(ur_queue_flags_t), &queueFlags,
+    //                               nullptr));
+
+    // if (queueFlags & UR_QUEUE_FLAG_SUBMISSION_BATCHED) {
+    //   UUR_KNOWN_FAILURE_ON(uur::LevelZeroV2{});
+    // }
+    // bool isBatched = false;
+    // ASSERT_NO_FATAL_FAILURE(isBatchedQueue(&isBatched));
+    // // ASSERT_FALSE(true);
+    // if (isBatched) {
+    //   UUR_KNOWN_FAILURE_ON(uur::LevelZeroV2{});
+    // }
+    //  ASSERT_TRUE(false);
+    SKIP_IF_BATCHED_QUEUE(queue);
+    // ASSERT_TRUE(false);
     bool timestamp_recording_support = false;
     ASSERT_SUCCESS(
         uur::GetTimestampRecordingSupport(device, timestamp_recording_support));

unified-runtime/test/conformance/testing/include/uur/fixtures.h

@@ -407,6 +407,21 @@ struct urQueueTest : urContextTest {
   ur_queue_properties_t queue_properties = {UR_STRUCTURE_TYPE_QUEUE_PROPERTIES,
                                             nullptr, 0};
   ur_queue_handle_t queue = nullptr;
+
+  // void isBatchedQueue(bool *info) {
+  //   ur_queue_flags_t queueFlags{};
+  //   // ASSERT_TRUE(false);
+  //   ASSERT_SUCCESS(urQueueGetInfo(queue, UR_QUEUE_INFO_FLAGS,
+  //                                 sizeof(ur_queue_flags_t), &queueFlags,
+  //                                 nullptr));
+
+  //   if (queueFlags & UR_QUEUE_FLAG_SUBMISSION_BATCHED) {
+  //     // UUR_KNOWN_FAILURE_ON(uur::LevelZeroV2{});
+  //     *info = true;
+  //   } else {
+  //     *info = false;
+  //   }
+  // }
 };
 
 struct urHostPipeTest : urQueueTest {
@@ -478,6 +493,21 @@ template <class T> struct urQueueTestWithParam : urContextTestWithParam<T> {
   ur_queue_properties_t queue_properties = {UR_STRUCTURE_TYPE_QUEUE_PROPERTIES,
                                             nullptr, 0};
   ur_queue_handle_t queue = nullptr;
+
+  // void isBatchedQueue(bool *info) {
+  //   ur_queue_flags_t queueFlags{};
+  //   // ASSERT_TRUE(false);
+  //   ASSERT_SUCCESS(urQueueGetInfo(queue, UR_QUEUE_INFO_FLAGS,
+  //                                 sizeof(ur_queue_flags_t), &queueFlags,
+  //                                 nullptr));
+
+  //   if (queueFlags & UR_QUEUE_FLAG_SUBMISSION_BATCHED) {
+  //     // UUR_KNOWN_FAILURE_ON(uur::LevelZeroV2{});
+  //     *info = true;
+  //   } else {
+  //     *info = false;
+  //   }
+  // }
 };
 
 template <class T>

unified-runtime/test/conformance/testing/include/uur/utils.h

@@ -489,6 +489,31 @@ getDriverVersion(ur_device_handle_t hDevice) {
     }                                                                          \
   } while (0)
 
+#define SKIP_IF_BATCHED_QUEUE(queue)                                           \
+  do {                                                                         \
+    ur_queue_flags_t queueFlags{};                                             \
+    ASSERT_EQ(urQueueGetInfo(queue, UR_QUEUE_INFO_FLAGS,                       \
+                             sizeof(ur_queue_flags_t), &queueFlags, nullptr),  \
+              UR_RESULT_SUCCESS);                                              \
+                                                                               \
+    if (queueFlags & UR_QUEUE_FLAG_SUBMISSION_BATCHED) {                       \
+      UUR_KNOWN_FAILURE_ON(uur::LevelZeroV2{});                                \
+    } else {                                                                   \
+    }                                                                          \
+  } while (0)
+
+inline void isQueueBatched(ur_queue_handle_t queue, bool *info) {
+  ur_queue_flags_t queueFlags{};
+  ASSERT_EQ(urQueueGetInfo(queue, UR_QUEUE_INFO_FLAGS, sizeof(ur_queue_flags_t),
+                           &queueFlags, nullptr),
+            UR_RESULT_SUCCESS);
+  if (queueFlags & UR_QUEUE_FLAG_SUBMISSION_BATCHED) {
+    *info = true;
+  } else {
+    *info = false;
+  }
+}
+
 // Is this a Data Center GPU Max series (aka PVC)?
 // TODO: change to use
 // https://spec.oneapi.io/level-zero/latest/core/api.html#ze-device-ip-version-ext-t