fixes

Author: igchor

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

@@ -69,13 +69,12 @@ ur_result_t urQueueCreate(ur_context_handle_t hContext,
 
   auto zeIndex = v2::getZeIndex(pProperties);
 
-  if ((flags & UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE) != 0 &&
-      !zeIndex.has_value()) {
+  if ((flags & UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE) != 0) {
     *phQueue =
         ur_queue_handle_t_::create<v2::ur_queue_immediate_out_of_order_t>(
             hContext, hDevice, v2::getZeOrdinal(hDevice),
-            v2::getZePriority(flags), v2::eventFlagsFromQueueFlags(flags),
-            flags);
+            v2::getZePriority(flags), zeIndex,
+            v2::eventFlagsFromQueueFlags(flags), flags);
   } else {
     *phQueue = ur_queue_handle_t_::create<v2::ur_queue_immediate_in_order_t>(
         hContext, hDevice, v2::getZeOrdinal(hDevice), v2::getZePriority(flags),

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

@@ -1,6 +1,6 @@
 //===--------- queue_immediate_in_order.cpp - Level Zero Adapter ---------===//
 //
-// Copyright (C) 2024 Intel Corporation
+// Copyright (C) 2025 Intel Corporation
 //
 // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
 // Exceptions. See LICENSE.TXT
@@ -14,40 +14,29 @@
 
 namespace v2 {
 
-// Helper function to intialize std::array of command list manager.
-// This is needed because command list manager does not have a default
-// constructor.
-template <size_t... Is>
-std::array<ur_command_list_manager, sizeof...(Is)> createCommandListManagers(
-    ur_context_handle_t hContext, ur_device_handle_t hDevice, uint32_t ordinal,
-    ze_command_queue_priority_t priority, std::index_sequence<Is...>) {
-  return {
-      ((void)Is, ur_command_list_manager(
-                     hContext, hDevice,
-                     hContext->getCommandListCache().getImmediateCommandList(
-                         hDevice->ZeDevice,
-                         {true, ordinal, true /* always enable copy offload */},
-                         ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS, priority)))...};
-}
-
 template <size_t N>
-std::array<ur_command_list_manager, N>
-createCommandListManagers(ur_context_handle_t hContext,
-                          ur_device_handle_t hDevice, uint32_t ordinal,
-                          ze_command_queue_priority_t priority) {
-  return createCommandListManagers(hContext, hDevice, ordinal, priority,
-                                   std::make_index_sequence<N>{});
+std::array<ur_command_list_manager, N> createCommandListManagers(
+    ur_context_handle_t hContext, ur_device_handle_t hDevice, uint32_t ordinal,
+    ze_command_queue_priority_t priority, std::optional<int32_t> index) {
+  return createArrayOf<ur_command_list_manager, numCommandLists>([&](size_t) {
+    return ur_command_list_manager(
+        hContext, hDevice,
+        hContext->getCommandListCache().getImmediateCommandList(
+            hDevice->ZeDevice,
+            {true, ordinal, true /* always enable copy offload */},
+            ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS, priority, index));
+  });
 }
 
 ur_queue_immediate_out_of_order_t::ur_queue_immediate_out_of_order_t(
     ur_context_handle_t hContext, ur_device_handle_t hDevice, uint32_t ordinal,
-    ze_command_queue_priority_t priority, event_flags_t eventFlags,
-    ur_queue_flags_t flags)
+    ze_command_queue_priority_t priority, std::optional<int32_t> index,
+    event_flags_t eventFlags, ur_queue_flags_t flags)
     : hContext(hContext), hDevice(hDevice),
       eventPool(hContext->getEventPoolCache(PoolCacheType::Immediate)
                     .borrow(hDevice->Id.value(), eventFlags)),
       commandListManagers(createCommandListManagers<numCommandLists>(
-          hContext, hDevice, ordinal, priority)),
+          hContext, hDevice, ordinal, priority, index)),
       flags(flags) {
   for (size_t i = 0; i < numCommandLists; i++) {
     barrierEvents[i] = eventPool->allocate();
@@ -153,11 +142,11 @@ ur_result_t ur_queue_immediate_out_of_order_t::enqueueEventsWaitWithBarrier(
     ur_event_handle_t *phEvent) {
   TRACK_SCOPE_LATENCY(
       "ur_queue_immediate_out_of_order_t::enqueueEventsWaitWithBarrier");
-  // For in-order queue we don't need a real L0 barrier, just wait for
-  // requested events in potentially different queues and add a "barrier"
-  // event signal because it is already guaranteed that previous commands
-  // in this queue are completed when the signal is started. However, we do
-  // need to use barrier if profiling is enabled: see
+  // Since we use L0 in-order command lists, we don't need a real L0 barrier,
+  // just wait for requested events in potentially different queues and add a
+  // "barrier" event signal because it is already guaranteed that previous
+  // commands in this queue are completed when the signal is started. However,
+  // we do need to use barrier if profiling is enabled: see
   // zeCommandListAppendWaitOnEvents
   bool needsRealBarrier = (flags & UR_QUEUE_FLAG_PROFILING_ENABLE) != 0;
   auto appendEventsWaitFn =

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

@@ -1,6 +1,6 @@
 //===--------- queue_immediate_in_order.hpp - Level Zero Adapter ---------===//
 //
-// Copyright (C) 2024 Intel Corporation
+// Copyright (C) 2025 Intel Corporation
 //
 // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
 // Exceptions. See LICENSE.TXT
@@ -25,6 +25,10 @@ namespace v2 {
 
 struct ur_queue_immediate_out_of_order_t : ur_object, ur_queue_t_ {
 private:
+  // Number of command lists was chosen experimentally as a compromise
+  // between number of allowed concurrent launches and overhead of
+  // iterating over the command lists to synchronize them.
+  // This might need to be changed for future hardware.
   static constexpr size_t numCommandLists = 4;
 
   ur_context_handle_t hContext;
@@ -49,6 +53,7 @@ struct ur_queue_immediate_out_of_order_t : ur_object, ur_queue_t_ {
   ur_queue_immediate_out_of_order_t(ur_context_handle_t, ur_device_handle_t,
                                     uint32_t ordinal,
                                     ze_command_queue_priority_t priority,
+                                    std::optional<int32_t> index,
                                     event_flags_t eventFlags,
                                     ur_queue_flags_t flags);
 

unified-runtime/source/common/ur_util.hpp

@@ -553,4 +553,19 @@ inline bool isPointerAlignedTo(uint32_t Alignment, void *Ptr) {
          reinterpret_cast<std::uintptr_t>(Ptr) % Alignment == 0;
 }
 
+template <typename T, typename F, size_t... Is>
+std::array<T, sizeof...(Is)> createArrayOfHelper(F &&f,
+                                                 std::index_sequence<Is...>) {
+  return {(f(Is))...};
+}
+
+// Helper function to intialize std::array of non-default constructible
+// types. Calls provided ctor function (passing index to the array) to create
+// each element of the array.
+template <typename T, size_t N, typename F>
+std::array<T, N> createArrayOf(F &&ctor) {
+  return createArrayOfHelper<T, F>(std::forward<F>(f),
+                                   std::make_index_sequence<N>{});
+}
+
 #endif /* UR_UTIL_H */