[SYCL] Reset signalled command list if there no available command list (#6314)

Resetting command lists only in synchronization points caused
performance regression because we reuse less command lists and
new command lists are getting created more often which adds
performance overhead.

Return the old behavior back: reset signalled command lists
in the getAvailableCommandList.

Author: againull

sycl/plugins/level_zero/pi_level_zero.cpp

@@ -1118,7 +1118,28 @@ _pi_queue::_pi_queue(std::vector<ze_command_queue_handle_t> &ComputeQueues,
   CopyCommandBatch.QueueBatchSize = ZeCommandListBatchCopyConfig.startSize();
 }
 
-static pi_result CleanupCompletedEvent(pi_event);
+static pi_result CleanupCompletedEvent(pi_event Event,
+                                       bool QueueLocked = false);
+
+// Helper function to perform the necessary cleanup of the events from reset cmd
+// list.
+static pi_result
+CleanupEventListFromResetCmdList(std::vector<pi_event> &EventListToCleanup,
+                                 bool QueueLocked = false) {
+  for (auto Event : EventListToCleanup) {
+    // We don't need to synchronize the events since the fence associated with
+    // the command list was synchronized.
+    {
+      std::scoped_lock EventLock(Event->Mutex);
+      Event->Completed = true;
+    }
+    PI_CALL(CleanupCompletedEvent(Event, QueueLocked));
+    // This event was removed from the command list, so decrement ref count
+    // (it was incremented when they were added to the command list).
+    PI_CALL(piEventRelease(Event));
+  }
+  return PI_SUCCESS;
+}
 
 // Reset signalled command lists in the queue and put them to the cache of
 // command lists. A caller must not lock the queue mutex.
@@ -1150,18 +1171,7 @@ pi_result resetCommandLists(pi_queue Queue) {
       }
     }
   }
-  for (auto Event : EventListToCleanup) {
-    // We don't need to synchronize the events since the fence
-    // synchronized above already does that.
-    {
-      std::scoped_lock EventLock(Event->Mutex);
-      Event->Completed = true;
-    }
-    PI_CALL(CleanupCompletedEvent(Event));
-    // This event was removed from the command list, so decrement ref count
-    // (it was incremented when they were added to the command list).
-    PI_CALL(piEventRelease(Event));
-  }
+  CleanupEventListFromResetCmdList(EventListToCleanup);
   return PI_SUCCESS;
 }
 
@@ -1245,6 +1255,31 @@ _pi_context::getAvailableCommandList(pi_queue Queue,
     }
   }
 
+  // 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;
+
+    ze_result_t ZeResult =
+        ZE_CALL_NOCHECK(zeFenceQueryStatus, (it->second.ZeFence));
+    if (ZeResult == ZE_RESULT_SUCCESS) {
+      std::vector<pi_event> EventListToCleanup;
+      Queue->resetCommandList(it, false, EventListToCleanup);
+      CleanupEventListFromResetCmdList(EventListToCleanup,
+                                       true /* QueueLocked */);
+      CommandList = it;
+      CommandList->second.ZeFenceInUse = true;
+      return PI_SUCCESS;
+    }
+  }
+
   // If there are no available command lists nor signalled command lists, then
   // we must create another command list.
   // Once created, this command list & fence are added to the command list fence
@@ -5452,8 +5487,8 @@ pi_result piEventGetProfilingInfo(pi_event Event, pi_profiling_info ParamName,
 // This currently makes sure to release any kernel that may have been used by
 // the event, updates the last command event in the queue and cleans up all dep
 // events of the event.
-// The caller must not lock any mutexes.
-static pi_result CleanupCompletedEvent(pi_event Event) {
+// If the caller locks queue mutex then it must pass 'true' to QueueLocked.
+static pi_result CleanupCompletedEvent(pi_event Event, bool QueueLocked) {
   pi_kernel AssociatedKernel = nullptr;
   // List of dependent events.
   std::list<pi_event> EventsToBeReleased;
@@ -5489,7 +5524,9 @@ static pi_result CleanupCompletedEvent(pi_event Event) {
   if (AssociatedQueue) {
     {
       // Lock automatically releases when this goes out of scope.
-      std::scoped_lock Lock(AssociatedQueue->Mutex);
+      std::unique_lock QueueLock(AssociatedQueue->Mutex, std::defer_lock);
+      if (!QueueLocked)
+        QueueLock.lock();
 
       // If this event was the LastCommandEvent in the queue, being used
       // to make sure that commands were executed in-order, remove this.