add tests for batched queue submissions

Author: EuphoricThinking

unified-runtime/source/adapters/level_zero/v2/queue_batched.cpp

@@ -18,7 +18,6 @@
 #include "kernel.hpp"
 #include "lockable.hpp"
 #include "memory.hpp"
-#include "ur.hpp"
 
 #include "../common/latency_tracker.hpp"
 #include "../helpers/kernel_helpers.hpp"
@@ -123,10 +122,10 @@ ur_result_t batch_manager::renewRegularUnlocked(
 ur_result_t
 ur_queue_batched_t::renewBatchUnlocked(locked<batch_manager> &batchLocked) {
   if (batchLocked->isLimitOfUsedCommandListsReached()) {
-    UR_CALL(queueFinishUnlocked(batchLocked));
+    return queueFinishUnlocked(batchLocked);
+  } else {
+    return batchLocked->renewRegularUnlocked(getNewRegularCmdList());
   }
-
-  return batchLocked->renewRegularUnlocked(getNewRegularCmdList());
 }
 
 ur_result_t batch_manager::enqueueCurrentBatchUnlocked() {
@@ -214,20 +213,26 @@ ur_result_t batch_manager::batchFinish() {
 
   UR_CALL(activeBatch.releaseSubmittedKernels());
 
-  {
+  if (!isActiveBatchEmpty()) {
+    // Should have been enqueued as part of queueFinishUnlocked
     TRACK_SCOPE_LATENCY("ur_queue_batched_t::resetRegCmdlist");
     ZE2UR_CALL(zeCommandListReset, (activeBatch.getZeCommandList()));
+
+    setBatchEmpty();
+    regularGenerationNumber++;
   }
 
   runBatches.clear();
-  setBatchEmpty();
 
   return UR_RESULT_SUCCESS;
 }
 
 ur_result_t
 ur_queue_batched_t::queueFinishUnlocked(locked<batch_manager> &batchLocked) {
-  UR_CALL(batchLocked->enqueueCurrentBatchUnlocked());
+  if (!batchLocked->isActiveBatchEmpty()) {
+    UR_CALL(batchLocked->enqueueCurrentBatchUnlocked());
+  }
+
   UR_CALL(batchLocked->hostSynchronize());
 
   UR_CALL(queueFinishPoolsUnlocked());
@@ -1070,7 +1075,12 @@ ur_queue_batched_t::queueFlushUnlocked(locked<batch_manager> &batchLocked) {
 
 ur_result_t ur_queue_batched_t::queueFlush() {
   auto batchLocked = currentCmdLists.lock();
-  return queueFlushUnlocked(batchLocked);
+
+  if (batchLocked->isActiveBatchEmpty()) {
+    return UR_RESULT_SUCCESS;
+  } else {
+    return queueFlushUnlocked(batchLocked);
+  }
 }
 
 } // namespace v2

unified-runtime/source/adapters/level_zero/v2/queue_batched.hpp

@@ -47,6 +47,14 @@
 
 namespace v2 {
 
+// The limit of regular command lists stored for execution; if exceeded, the
+// vector is cleared as part of queueFinish and slots are renewed.
+inline constexpr uint64_t initialSlotsForBatches = 10;
+
+// For the explanation of the purpose of generation numbers, see the comment for
+// regularGenerationNumber below
+inline constexpr ur_event_generation_t initialGenerationNumber = 0;
+
 struct batch_manager {
 private:
   // The currently active regular command list, which may be replaced in the
@@ -75,9 +83,6 @@ struct batch_manager {
   // associated with the event has already been submitted for execution and
   // additional submission of the current batch is not needed.
   ur_event_generation_t regularGenerationNumber;
-  // The limit of regular command lists stored for execution; if exceeded, the
-  // vector is cleared as part of queueFinish and slots are renewed.
-  static constexpr uint64_t initialSlotsForBatches = 10;
   // Whether any operation has been enqueued on the current batch
   bool isEmpty = true;
 
@@ -91,7 +96,7 @@ struct batch_manager {
         immediateList(context, device,
                       std::forward<v2::raii::command_list_unique_handle>(
                           commandListImmediate)),
-        regularGenerationNumber(0) {
+        regularGenerationNumber(initialGenerationNumber) {
     runBatches.reserve(initialSlotsForBatches);
   }
 

unified-runtime/source/adapters/level_zero/v2/queue_create.cpp

@@ -15,6 +15,7 @@
 #include "queue_batched.hpp"
 #include "queue_handle.hpp"
 #include "queue_immediate_in_order.hpp"
+#include "ur_api.h"
 
 static const bool ForceBatched = getenv_tobool("UR_L0_V2_FORCE_BATCHED");
 
@@ -67,56 +68,55 @@ ur_result_t urQueueCreate(ur_context_handle_t hContext,
 
   TRACK_SCOPE_LATENCY("queueCreate");
 
+  bool isImmediate = true;
+  bool isOutOfOrder = false;
+  bool isBatched = false;
+
   ur_queue_flags_t flags = 0;
   if (pProperties) {
     flags = pProperties->flags;
+
+    isImmediate = flags & UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE;
+    isOutOfOrder = flags & UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE;
+    isBatched = flags & UR_QUEUE_FLAG_SUBMISSION_BATCHED;
   }
 
   if (ForceBatched) {
     flags |= UR_QUEUE_FLAG_SUBMISSION_BATCHED;
-  }
-
-  auto zeIndex = v2::getZeIndex(pProperties);
-
-  bool immediate = true;
-  bool outOfOrder = false;
+    isBatched = true;
 
-  if (flags & UR_QUEUE_FLAG_SUBMISSION_BATCHED) {
-    immediate = false;
-  }
-
-  if (flags & UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE) {
-    outOfOrder = true;
-  }
-
-  if (flags & UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE) {
-    if (!immediate) {
-      UR_LOG(WARN,
-             "urQueueCreate called with both UR_QUEUE_FLAG_SUBMISSION_BATCHED "
-             "and UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE in ur_queue_flags_t. "
-             "Defaulting to the immediate submission mode.");
+    if (isImmediate) {
+      flags &= ~UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE;
+      isImmediate = false;
     }
+  } else {
 
-    immediate = true;
+    if (pProperties && isImmediate && isBatched) {
+      return UR_RESULT_ERROR_INVALID_QUEUE_PROPERTIES;
+    }
   }
 
-  if (immediate) {
-    if (outOfOrder) {
+  auto zeIndex = v2::getZeIndex(pProperties);
+
+  if (isBatched) {
+    // out of order not supported
+    *phQueue = ur_queue_handle_t_::create<v2::ur_queue_batched_t>(
+        hContext, hDevice, v2::getZeOrdinal(hDevice), v2::getZePriority(flags),
+        zeIndex, v2::eventFlagsFromQueueFlags(flags), flags);
+  } else {
+    if (isOutOfOrder) {
       *phQueue =
           ur_queue_handle_t_::create<v2::ur_queue_immediate_out_of_order_t>(
               hContext, hDevice, v2::getZeOrdinal(hDevice),
               v2::getZePriority(flags), zeIndex,
               v2::eventFlagsFromQueueFlags(flags), flags);
     } else {
+      // immediate
       *phQueue = ur_queue_handle_t_::create<v2::ur_queue_immediate_in_order_t>(
           hContext, hDevice, v2::getZeOrdinal(hDevice),
           v2::getZePriority(flags), zeIndex,
           v2::eventFlagsFromQueueFlags(flags), flags);
     }
-  } else {
-    *phQueue = ur_queue_handle_t_::create<v2::ur_queue_batched_t>(
-        hContext, hDevice, v2::getZeOrdinal(hDevice), v2::getZePriority(flags),
-        zeIndex, v2::eventFlagsFromQueueFlags(flags), flags);
   }
 
   return UR_RESULT_SUCCESS;

unified-runtime/test/adapters/level_zero/enqueue_alloc.cpp

@@ -10,6 +10,7 @@
 #include <thread>
 
 #include "ur_api.h"
+#include "uur/utils.h"
 #include <uur/fixtures.h>
 
 struct EnqueueAllocTestParam {
@@ -81,6 +82,7 @@ struct urL0EnqueueAllocMultiQueueSameDeviceTest
     for (size_t i = 0; i < param.numQueues; i++) {
       ur_queue_handle_t queue = nullptr;
       ASSERT_SUCCESS(urQueueCreate(context, device, 0, &queue));
+      SKIP_IF_BATCHED_QUEUE(queue);
       queues.push_back(queue);
     }
   }
@@ -343,6 +345,10 @@ TEST_P(urL0EnqueueAllocMultiQueueSameDeviceTest, SuccessMt) {
   const auto checkUSMSupportFunc =
       std::get<1>(this->GetParam()).funcParams.checkUSMSupportFunc;
 
+  if (numQueues > 0) {
+    SKIP_IF_BATCHED_QUEUE(queues[0]);
+  }
+
   ur_device_usm_access_capability_flags_t USMSupport = 0;
   ASSERT_SUCCESS(checkUSMSupportFunc(device, USMSupport));
   if (!(USMSupport & UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS)) {

unified-runtime/test/adapters/level_zero/v2/CMakeLists.txt

@@ -67,6 +67,22 @@ add_l0_v2_devices_test(memory_residency
     ${PROJECT_SOURCE_DIR}/source/adapters/level_zero/ur_level_zero.cpp
 )
 
+add_l0_v2_devices_test(batched_queue
+    batched_queue_test.cpp
+   ${PROJECT_SOURCE_DIR}/source/adapters/level_zero/adapter.cpp
+    ${PROJECT_SOURCE_DIR}/source/adapters/level_zero/common.cpp
+    ${PROJECT_SOURCE_DIR}/source/adapters/level_zero/device.cpp
+    ${PROJECT_SOURCE_DIR}/source/adapters/level_zero/platform.cpp
+    ${PROJECT_SOURCE_DIR}/source/adapters/level_zero/ur_level_zero.cpp
+    ${PROJECT_SOURCE_DIR}/source/adapters/level_zero/v2/event_pool_cache.cpp
+    ${PROJECT_SOURCE_DIR}/source/adapters/level_zero/v2/event_pool.cpp
+    ${PROJECT_SOURCE_DIR}/source/adapters/level_zero/v2/event_provider_counter.cpp
+    ${PROJECT_SOURCE_DIR}/source/adapters/level_zero/v2/event_provider_normal.cpp
+    ${PROJECT_SOURCE_DIR}/source/adapters/level_zero/v2/event.cpp
+    ${PROJECT_SOURCE_DIR}/source/ur/ur.cpp
+     ${PROJECT_SOURCE_DIR}/source/adapters/level_zero/v2/command_list_cache.cpp
+)
+
 if(NOT UR_FOUND_DPCXX)
     # Tests that require kernels can't be used if we aren't generating
     # device binaries