[L0] Fix hang on counter based events when regular commandlist from cache resets.

Due to the dependency of commandlist on counter based events.
When a commmandlist is reset there is still a chance that an associated counter
based event is still linked to another commandlist. This causes a hang.
For now, we will disable regular commandlist cache and create a new
commandlist instead.

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

Author: winstonzhang-intel

source/adapters/level_zero/context.cpp

@@ -716,100 +716,110 @@ ur_result_t ur_context_handle_t_::getAvailableCommandList(
   // command list is available for reuse.
   ur_result_t ur_result = UR_RESULT_ERROR_OUT_OF_RESOURCES;
 
-  // Initally, we need to check if a command list has already been created
-  // on this device that is available for use. If so, then reuse that
-  // Level-Zero Command List and Fence for this PI call.
-  {
-    // Make sure to acquire the lock before checking the size, or there
-    // will be a race condition.
-    std::scoped_lock<ur_mutex> Lock(Queue->Context->ZeCommandListCacheMutex);
-    // Under mutex since operator[] does insertion on the first usage for every
-    // unique ZeDevice.
-    auto &ZeCommandListCache =
-        UseCopyEngine
-            ? Queue->Context->ZeCopyCommandListCache[Queue->Device->ZeDevice]
-            : Queue->Context
-                  ->ZeComputeCommandListCache[Queue->Device->ZeDevice];
-
-    for (auto ZeCommandListIt = ZeCommandListCache.begin();
-         ZeCommandListIt != ZeCommandListCache.end(); ++ZeCommandListIt) {
+  // As a limitation of regular command list, when counter based events are used
+  // the command list in the cache still has the potential of having events that
+  // are still associated with another command list. We disable cache for
+  // regular command list when counter based events are enabled to avoid race
+  // condition.
+  if (!Queue->CounterBasedEventsEnabled) {
+    // Initally, we need to check if a command list has already been created
+    // on this device that is available for use. If so, then reuse that
+    // Level-Zero Command List and Fence for this PI call.
+    {
+      // Make sure to acquire the lock before checking the size, or there
+      // will be a race condition.
+      std::scoped_lock<ur_mutex> Lock(Queue->Context->ZeCommandListCacheMutex);
+      // Under mutex since operator[] does insertion on the first usage for
+      // every unique ZeDevice.
+      auto &ZeCommandListCache =
+          UseCopyEngine
+              ? Queue->Context->ZeCopyCommandListCache[Queue->Device->ZeDevice]
+              : Queue->Context
+                    ->ZeComputeCommandListCache[Queue->Device->ZeDevice];
+
+      for (auto ZeCommandListIt = ZeCommandListCache.begin();
+           ZeCommandListIt != ZeCommandListCache.end(); ++ZeCommandListIt) {
+        // If this is an InOrder Queue, then only allow lists which are in
+        // order.
+        if (Queue->Device->useDriverInOrderLists() && Queue->isInOrderQueue() &&
+            !(ZeCommandListIt->second.InOrderList)) {
+          continue;
+        }
+        auto &ZeCommandList = ZeCommandListIt->first;
+        auto it = Queue->CommandListMap.find(ZeCommandList);
+        if (it != Queue->CommandListMap.end()) {
+          if (ForcedCmdQueue && *ForcedCmdQueue != it->second.ZeQueue)
+            continue;
+          CommandList = it;
+          if (CommandList->second.ZeFence != nullptr)
+            CommandList->second.ZeFenceInUse = true;
+        } else {
+          // If there is a command list available on this context, but it
+          // wasn't yet used in this queue then create a new entry in this
+          // queue's map to hold the fence and other associated command
+          // list information.
+          auto &QGroup = Queue->getQueueGroup(UseCopyEngine);
+          uint32_t QueueGroupOrdinal;
+          auto &ZeCommandQueue = ForcedCmdQueue
+                                     ? *ForcedCmdQueue
+                                     : QGroup.getZeQueue(&QueueGroupOrdinal);
+          if (ForcedCmdQueue)
+            QueueGroupOrdinal = QGroup.getCmdQueueOrdinal(ZeCommandQueue);
+
+          ze_fence_handle_t ZeFence;
+          ZeStruct<ze_fence_desc_t> ZeFenceDesc;
+          ZE2UR_CALL(zeFenceCreate, (ZeCommandQueue, &ZeFenceDesc, &ZeFence));
+          ZeStruct<ze_command_queue_desc_t> ZeQueueDesc;
+          ZeQueueDesc.ordinal = QueueGroupOrdinal;
+          CommandList =
+              Queue->CommandListMap
+                  .emplace(ZeCommandList,
+                           ur_command_list_info_t{ZeFence, true, false,
+                                                  ZeCommandQueue, ZeQueueDesc})
+                  .first;
+        }
+        ZeCommandListCache.erase(ZeCommandListIt);
+        if (auto Res =
+                Queue->insertStartBarrierIfDiscardEventsMode(CommandList))
+          return Res;
+        if (auto Res = Queue->insertActiveBarriers(CommandList, UseCopyEngine))
+          return Res;
+        return UR_RESULT_SUCCESS;
+      }
+    }
+
+    // If there are no available command lists in the cache, then we check for
+    // command lists that have already signalled, but have not been added to the
+    // available list yet. Each command list has a fence associated which tracks
+    // if a command list has completed dispatch of its commands and is ready for
+    // reuse. If a command list is found to have been signalled, then the
+    // command list & fence are reset and we return.
+    for (auto it = Queue->CommandListMap.begin();
+         it != Queue->CommandListMap.end(); ++it) {
+      // Make sure this is the command list type needed.
+      if (UseCopyEngine != it->second.isCopy(Queue))
+        continue;
+
       // If this is an InOrder Queue, then only allow lists which are in order.
       if (Queue->Device->useDriverInOrderLists() && Queue->isInOrderQueue() &&
-          !(ZeCommandListIt->second.InOrderList)) {
+          !(it->second.IsInOrderList)) {
         continue;
       }
-      auto &ZeCommandList = ZeCommandListIt->first;
-      auto it = Queue->CommandListMap.find(ZeCommandList);
-      if (it != Queue->CommandListMap.end()) {
-        if (ForcedCmdQueue && *ForcedCmdQueue != it->second.ZeQueue)
-          continue;
+
+      ze_result_t ZeResult =
+          ZE_CALL_NOCHECK(zeFenceQueryStatus, (it->second.ZeFence));
+      if (ZeResult == ZE_RESULT_SUCCESS) {
+        std::vector<ur_event_handle_t> EventListToCleanup;
+        Queue->resetCommandList(it, false, EventListToCleanup);
+        CleanupEventListFromResetCmdList(EventListToCleanup,
+                                         true /* QueueLocked */);
         CommandList = it;
-        if (CommandList->second.ZeFence != nullptr)
-          CommandList->second.ZeFenceInUse = true;
-      } else {
-        // If there is a command list available on this context, but it
-        // wasn't yet used in this queue then create a new entry in this
-        // queue's map to hold the fence and other associated command
-        // list information.
-        auto &QGroup = Queue->getQueueGroup(UseCopyEngine);
-        uint32_t QueueGroupOrdinal;
-        auto &ZeCommandQueue = ForcedCmdQueue
-                                   ? *ForcedCmdQueue
-                                   : QGroup.getZeQueue(&QueueGroupOrdinal);
-        if (ForcedCmdQueue)
-          QueueGroupOrdinal = QGroup.getCmdQueueOrdinal(ZeCommandQueue);
-
-        ze_fence_handle_t ZeFence;
-        ZeStruct<ze_fence_desc_t> ZeFenceDesc;
-        ZE2UR_CALL(zeFenceCreate, (ZeCommandQueue, &ZeFenceDesc, &ZeFence));
-        ZeStruct<ze_command_queue_desc_t> ZeQueueDesc;
-        ZeQueueDesc.ordinal = QueueGroupOrdinal;
-        CommandList =
-            Queue->CommandListMap
-                .emplace(ZeCommandList,
-                         ur_command_list_info_t{ZeFence, true, false,
-                                                ZeCommandQueue, ZeQueueDesc})
-                .first;
+        CommandList->second.ZeFenceInUse = true;
+        if (auto Res =
+                Queue->insertStartBarrierIfDiscardEventsMode(CommandList))
+          return Res;
+        return UR_RESULT_SUCCESS;
       }
-      ZeCommandListCache.erase(ZeCommandListIt);
-      if (auto Res = Queue->insertStartBarrierIfDiscardEventsMode(CommandList))
-        return Res;
-      if (auto Res = Queue->insertActiveBarriers(CommandList, UseCopyEngine))
-        return Res;
-      return UR_RESULT_SUCCESS;
-    }
-  }
-
-  // If there are no available command lists in the cache, then we check for
-  // command lists that have already signalled, but have not been added to the
-  // available list yet. Each command list has a fence associated which tracks
-  // if a command list has completed dispatch of its commands and is ready for
-  // reuse. If a command list is found to have been signalled, then the
-  // command list & fence are reset and we return.
-  for (auto it = Queue->CommandListMap.begin();
-       it != Queue->CommandListMap.end(); ++it) {
-    // Make sure this is the command list type needed.
-    if (UseCopyEngine != it->second.isCopy(Queue))
-      continue;
-
-    // If this is an InOrder Queue, then only allow lists which are in order.
-    if (Queue->Device->useDriverInOrderLists() && Queue->isInOrderQueue() &&
-        !(it->second.IsInOrderList)) {
-      continue;
-    }
-
-    ze_result_t ZeResult =
-        ZE_CALL_NOCHECK(zeFenceQueryStatus, (it->second.ZeFence));
-    if (ZeResult == ZE_RESULT_SUCCESS) {
-      std::vector<ur_event_handle_t> EventListToCleanup;
-      Queue->resetCommandList(it, false, EventListToCleanup);
-      CleanupEventListFromResetCmdList(EventListToCleanup,
-                                       true /* QueueLocked */);
-      CommandList = it;
-      CommandList->second.ZeFenceInUse = true;
-      if (auto Res = Queue->insertStartBarrierIfDiscardEventsMode(CommandList))
-        return Res;
-      return UR_RESULT_SUCCESS;
     }
   }