moved cleanup logic to when zeEventPoolCreate to make the cleanup deterministic

Signed-off-by: Zhang, Winston <[email protected]>

Author: winstonzhang-intel

unified-runtime/source/adapters/level_zero/context.cpp

@@ -406,7 +406,7 @@ ur_result_t ur_context_handle_t_::getFreeSlotInExistingOrNewPool(
     ze_event_pool_handle_t &Pool, size_t &Index, bool HostVisible,
     bool ProfilingEnabled, ur_device_handle_t Device,
     bool CounterBasedEventEnabled, bool UsingImmCmdList,
-    bool InterruptBasedEventEnabled) {
+    bool InterruptBasedEventEnabled, ur_queue_handle_t Queue) {
 
   ze_device_handle_t ZeDevice = nullptr;
   if (Device) {
@@ -461,8 +461,21 @@ ur_result_t ur_context_handle_t_::getFreeSlotInExistingOrNewPool(
                     });
     }
 
-    ZE2UR_CALL(zeEventPoolCreate, (ZeContext, &ZeEventPoolDesc,
-                                   ZeDevices.size(), &ZeDevices[0], &Pool));
+    ze_result_t Result = ZE_CALL_NOCHECK(
+        zeEventPoolCreate,
+        (ZeContext, &ZeEventPoolDesc, ZeDevices.size(), &ZeDevices[0], &Pool));
+    if (ze2urResult(Result) == UR_RESULT_ERROR_OUT_OF_RESOURCES &&
+        !Queue->isInOrderQueue()) {
+      if (Queue->UsingImmCmdLists) {
+        UR_CALL(CleanupEventsInImmCmdLists(Queue, true /*QueueLocked*/,
+                                           false /*QueueSynced*/,
+                                           nullptr /*CompletedEvent*/));
+      } else {
+        UR_CALL(resetCommandLists(Queue));
+      }
+      ZE2UR_CALL(zeEventPoolCreate, (ZeContext, &ZeEventPoolDesc,
+                                     ZeDevices.size(), &ZeDevices[0], &Pool));
+    }
     Index = 0;
     NumEventsAvailableInEventPool[Pool] = MaxNumEventsPerPool - 1;
     NumEventsUnreleasedInEventPool[Pool] = 1;
@@ -546,8 +559,21 @@ ur_result_t ur_context_handle_t_::getFreeSlotInExistingOrNewPool(
                     });
     }
 
-    ZE2UR_CALL(zeEventPoolCreate, (ZeContext, &ZeEventPoolDesc,
-                                   ZeDevices.size(), &ZeDevices[0], ZePool));
+    ze_result_t Result = ZE_CALL_NOCHECK(
+        zeEventPoolCreate,
+        (ZeContext, &ZeEventPoolDesc, ZeDevices.size(), &ZeDevices[0], &Pool));
+    if (ze2urResult(Result) == UR_RESULT_ERROR_OUT_OF_RESOURCES &&
+        !Queue->isInOrderQueue()) {
+      if (Queue->UsingImmCmdLists) {
+        UR_CALL(CleanupEventsInImmCmdLists(Queue, true /*QueueLocked*/,
+                                           false /*QueueSynced*/,
+                                           nullptr /*CompletedEvent*/));
+      } else {
+        UR_CALL(resetCommandLists(Queue));
+      }
+      ZE2UR_CALL(zeEventPoolCreate, (ZeContext, &ZeEventPoolDesc,
+                                     ZeDevices.size(), &ZeDevices[0], &Pool));
+    }
     NumEventsAvailableInEventPool[*ZePool] = MaxNumEventsPerPool - 1;
     NumEventsUnreleasedInEventPool[*ZePool] = 1;
   } else {

unified-runtime/source/adapters/level_zero/context.hpp

@@ -202,13 +202,11 @@ struct ur_context_handle_t_ : ur_object {
   // pool then create new one. The HostVisible parameter tells if we need a
   // slot for a host-visible event. The ProfilingEnabled tells is we need a
   // slot for an event with profiling capabilities.
-  ur_result_t getFreeSlotInExistingOrNewPool(ze_event_pool_handle_t &, size_t &,
-                                             bool HostVisible,
-                                             bool ProfilingEnabled,
-                                             ur_device_handle_t Device,
-                                             bool CounterBasedEventEnabled,
-                                             bool UsingImmCmdList,
-                                             bool InterruptBasedEventEnabled);
+  ur_result_t getFreeSlotInExistingOrNewPool(
+      ze_event_pool_handle_t &, size_t &, bool HostVisible,
+      bool ProfilingEnabled, ur_device_handle_t Device,
+      bool CounterBasedEventEnabled, bool UsingImmCmdList,
+      bool InterruptBasedEventEnabled, ur_queue_handle_t Queue);
 
   // Get ur_event_handle_t from cache.
   ur_event_handle_t getEventFromContextCache(bool HostVisible,

unified-runtime/source/adapters/level_zero/event.cpp

@@ -1380,7 +1380,7 @@ ur_result_t EventCreate(ur_context_handle_t Context, ur_queue_handle_t Queue,
   if (auto Res = Context->getFreeSlotInExistingOrNewPool(
           ZeEventPool, Index, HostVisible, ProfilingEnabled, Device,
           CounterBasedEventEnabled, UsingImmediateCommandlists,
-          InterruptBasedEventEnabled))
+          InterruptBasedEventEnabled, Queue))
     return Res;
 
   ZeStruct<ze_event_desc_t> ZeEventDesc;

unified-runtime/source/adapters/level_zero/kernel.cpp

@@ -9,9 +9,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "kernel.hpp"
-#include "common.hpp"
 #include "logger/ur_logger.hpp"
-#include "queue.hpp"
 #include "ur_api.h"
 #include "ur_interface_loader.hpp"
 
@@ -223,25 +221,6 @@ ur_result_t urEnqueueKernelLaunch(
   UR_CALL(Queue->executeCommandList(CommandList, false /*IsBlocking*/,
                                     true /*OKToBatchCommand*/));
 
-  // For internal events only, occasionally trigger cleanup to prevent event
-  // pool exhaustion, but avoid doing this for in-order queues which are
-  // commonly used in multi-threaded scenarios and may have stricter
-  // synchronization requirements
-  if (IsInternal && !Queue->isInOrderQueue()) {
-    // Use a probabilistic approach - only cleanup 1 in 128 internal events
-    // to minimize performance impact and reduce chances of race conditions
-    static thread_local uint32_t CleanupCounter = 0;
-    if ((++CleanupCounter & 127) == 0) {
-      if (Queue->UsingImmCmdLists) {
-        UR_CALL(CleanupEventsInImmCmdLists(Queue, true /*QueueLocked*/,
-                                           false /*QueueSynced*/,
-                                           nullptr /*CompletedEvent*/));
-      } else {
-        UR_CALL(resetCommandLists(Queue));
-      }
-    }
-  }
-
   return UR_RESULT_SUCCESS;
 }
 

unified-runtime/source/adapters/level_zero/kernel.hpp

@@ -14,7 +14,6 @@
 #include "common.hpp"
 #include "common/ur_ref_count.hpp"
 #include "memory.hpp"
-#include "queue.hpp"
 
 struct ur_kernel_handle_t_ : ur_object {
   ur_kernel_handle_t_(bool OwnZeHandle, ur_program_handle_t Program)