[SYCL] WA for stream events cross dependency elimination (intel#14797)

Current stream implementation has a problem with cross dependency for
inorder queue case. Both stream commands: kernel which writes and host
task which prints are submitted to the same queue now, inorder queue
mechanism of synchronization will add explicit dependency on kernel to
the host task (this approach helps up to provide synchronization for
kernel vs host tasks since no native sync is supported). Although kernel
will add flush host task to its post-complete events storage to be able
to wait for its completion in its own wait. This brings cross dependency
that prevents event release.
Current WA stores host task using weak reference that works in the same
way but prevents cross dependency. Host task doesn't support (and not
planned to support) post enqueue cleanup that means that its Command
instance could be deleted only after host task completion and later.
That means that absence of object in stored weak pointer is a solid sign
of host task completion and we have no need to wait on it. If it is
present we will try to wait on it if it is requested.
This should be a temporal solution. Solution to be implemented later is
elimination of forward references for stream and implementing a kind of
aggregated events.

---------

Signed-off-by: Tikhomirova, Kseniya <[email protected]>
Co-authored-by: Sergey Semenov <[email protected]>

Author: KseniyaTikhomirova

sycl/source/detail/event_impl.cpp

@@ -81,6 +81,11 @@ void event_impl::waitInternal(bool *Success) {
   // Wait for connected events(e.g. streams prints)
   for (const EventImplPtr &Event : MPostCompleteEvents)
     Event->wait(Event);
+  for (const std::weak_ptr<event_impl> &WeakEventPtr :
+       MWeakPostCompleteEvents) {
+    if (EventImplPtr Event = WeakEventPtr.lock())
+      Event->wait(Event);
+  }
 }
 
 void event_impl::setComplete() {

sycl/source/detail/event_impl.hpp

@@ -270,6 +270,11 @@ class event_impl {
     MPostCompleteEvents.push_back(Event);
   }
 
+  void attachEventToCompleteWeak(const std::weak_ptr<event_impl> &Event) {
+    std::lock_guard<std::mutex> Lock(MMutex);
+    MWeakPostCompleteEvents.push_back(Event);
+  }
+
   bool isDefaultConstructed() const noexcept { return MIsDefaultConstructed; }
 
   ContextImplPtr getContextImplPtr() {
@@ -358,6 +363,16 @@ class event_impl {
   std::vector<EventImplPtr> MPreparedHostDepsEvents;
 
   std::vector<EventImplPtr> MPostCompleteEvents;
+  // short term WA for stream:
+  // MPostCompleteEvents is split into two storages now. Original storage is
+  // used by graph extension and represents backward links.
+  // MWeakPostCompleteEvents represents weak forward references (used in stream
+  // only). Used only for host tasks now since they do not support post enqueue
+  // cleanup and event == nullptr could happen only when host task is completed
+  // (and Command that holding reference to its event is deleted). TO DO: to
+  // eliminate forward references from stream implementation and remove this
+  // storage.
+  std::vector<std::weak_ptr<event_impl>> MWeakPostCompleteEvents;
 
   /// Indicates that the task associated with this event has been submitted by
   /// the queue to the device.

sycl/source/detail/queue_impl.cpp

@@ -396,7 +396,7 @@ event queue_impl::submit_impl(const std::function<void(handler &)> &CGF,
     event FlushEvent = submit_impl(
         [&](handler &ServiceCGH) { Stream->generateFlushCommand(ServiceCGH); },
         Self, PrimaryQueue, SecondaryQueue, /*CallerNeedsEvent*/ true, Loc, {});
-    EventImpl->attachEventToComplete(detail::getSyclObjImpl(FlushEvent));
+    EventImpl->attachEventToCompleteWeak(detail::getSyclObjImpl(FlushEvent));
     registerStreamServiceEvent(detail::getSyclObjImpl(FlushEvent));
   }
 

sycl/unittests/scheduler/CommandsWaitForEvents.cpp

@@ -130,6 +130,7 @@ class EventImplProxyT : public sycl::detail::event_impl {
 public:
   using sycl::detail::event_impl::MPostCompleteEvents;
   using sycl::detail::event_impl::MState;
+  using sycl::detail::event_impl::MWeakPostCompleteEvents;
 };
 
 class QueueImplProxyT : public sycl::detail::queue_impl {
@@ -165,7 +166,7 @@ TEST_F(SchedulerTest, StreamAUXCmdsWait) {
 
     auto EventImplProxy = std::static_pointer_cast<EventImplProxyT>(EventImpl);
 
-    ASSERT_EQ(EventImplProxy->MPostCompleteEvents.size(), 1u)
+    ASSERT_EQ(EventImplProxy->MWeakPostCompleteEvents.size(), 1u)
         << "Expected 1 post complete event";
 
     Q.wait();