Add a workaround to avoid waiting for events in L0 plugin during submit

Level Zero plugin has recently started to call wait on events during
piEventRelease. With the queue::wait change we started to release some
events during submit, prior to their completion. This introduces
implicit wait on every submit that would produce such an event, which
also interferes with level zero batching.

Work around this by storing such events for level zero only to release
them later.

Author: sergey-semenov

sycl/source/detail/queue_impl.cpp

@@ -62,7 +62,9 @@ event queue_impl::memset(const std::shared_ptr<detail::queue_impl> &Self,
 
   event ResEvent = prepareUSMEvent(Self, NativeEvent);
   // Track only if we won't be able to handle it with piQueueFinish.
-  if (!MSupportOOO)
+  // FIXME these events are stored for level zero until as a workaround, remove
+  // once piEventRelease no longer calls wait on the event in the plugin.
+  if (!MSupportOOO || getPlugin().getBackend() == backend::level_zero)
     addSharedEvent(ResEvent);
   return ResEvent;
 }
@@ -79,7 +81,9 @@ event queue_impl::memcpy(const std::shared_ptr<detail::queue_impl> &Self,
 
   event ResEvent = prepareUSMEvent(Self, NativeEvent);
   // Track only if we won't be able to handle it with piQueueFinish.
-  if (!MSupportOOO)
+  // FIXME these events are stored for level zero until as a workaround, remove
+  // once piEventRelease no longer calls wait on the event in the plugin.
+  if (!MSupportOOO || getPlugin().getBackend() == backend::level_zero)
     addSharedEvent(ResEvent);
   return ResEvent;
 }
@@ -97,7 +101,9 @@ event queue_impl::mem_advise(const std::shared_ptr<detail::queue_impl> &Self,
 
   event ResEvent = prepareUSMEvent(Self, NativeEvent);
   // Track only if we won't be able to handle it with piQueueFinish.
-  if (!MSupportOOO)
+  // FIXME these events are stored for level zero until as a workaround, remove
+  // once piEventRelease no longer calls wait on the event in the plugin.
+  if (!MSupportOOO || getPlugin().getBackend() == backend::level_zero)
     addSharedEvent(ResEvent);
   return ResEvent;
 }
@@ -109,7 +115,11 @@ void queue_impl::addEvent(const event &Event) {
     // if there is no command on the event, we cannot track it with MEventsWeak
     // as that will leave it with no owner. Track in MEventsShared only if we're
     // unable to call piQueueFinish during wait.
-    if (is_host() || !MSupportOOO)
+    // FIXME these events are stored for level zero until as a workaround,
+    // remove once piEventRelease no longer calls wait on the event in the
+    // plugin.
+    if (is_host() || !MSupportOOO ||
+        getPlugin().getBackend() == backend::level_zero)
       addSharedEvent(Event);
   } else {
     std::weak_ptr<event_impl> EventWeakPtr{Eimpl};
@@ -122,7 +132,10 @@ void queue_impl::addEvent(const event &Event) {
 /// but some events have no other owner. In this case,
 /// addSharedEvent will have the queue track the events via a shared pointer.
 void queue_impl::addSharedEvent(const event &Event) {
-  assert(is_host() || !MSupportOOO);
+  // FIXME The assertion should be corrected once the Level Zero workaround is
+  // removed.
+  assert(is_host() || !MSupportOOO ||
+         getPlugin().getBackend() == backend::level_zero);
   std::lock_guard<std::mutex> Lock(MMutex);
   // Events stored in MEventsShared are not released anywhere else aside from
   // calls to queue::wait/wait_and_throw, which a user application might not
@@ -274,6 +287,12 @@ void queue_impl::wait(const detail::code_location &CodeLoc) {
       if (std::shared_ptr<event_impl> EventImplSharedPtr =
               EventImplWeakPtr.lock())
         EventImplSharedPtr->cleanupCommand(EventImplSharedPtr);
+    // FIXME these events are stored for level zero until as a workaround,
+    // remove once piEventRelease no longer calls wait on the event in the
+    // plugin.
+    if (Plugin.getBackend() == backend::level_zero) {
+      SharedEvents.clear();
+    }
     assert(SharedEvents.empty() && "Queues that support calling piQueueFinish "
                                    "shouldn't have shared events");
   } else {

sycl/unittests/queue/Wait.cpp

@@ -8,6 +8,7 @@
 
 #include <CL/sycl.hpp>
 #include <detail/event_impl.hpp>
+#include <detail/platform_impl.hpp>
 #include <detail/scheduler/commands.hpp>
 #include <gtest/gtest.h>
 #include <helpers/PiMock.hpp>
@@ -120,7 +121,12 @@ TEST(QueueWait, QueueWaitTest) {
   TestContext = {};
   Q.memset(HostAlloc, 42, 1);
   // No need to keep the event since we'll use piQueueFinish.
-  ASSERT_EQ(TestContext.EventReferenceCount, 0);
+  // FIXME ... unless the plugin is Level Zero, where there's a workaround that
+  // releases events later.
+  if (detail::getSyclObjImpl(Plt)->getPlugin().getBackend() !=
+      backend::level_zero) {
+    ASSERT_EQ(TestContext.EventReferenceCount, 0);
+  }
   Q.wait();
   ASSERT_EQ(TestContext.NEventsWaitedFor, 0);
   ASSERT_TRUE(TestContext.PiQueueFinishCalled);