[NFC][SYCL] Remove Self from event_impl::wait* (#19376)

Author: aelovikov-intel

sycl/source/detail/accessor_impl.cpp

@@ -36,7 +36,7 @@ void AccessorImplHost::resize(size_t GlobalSize) {
 void addHostAccessorAndWait(Requirement *Req) {
   detail::EventImplPtr Event =
       detail::Scheduler::getInstance().addHostAccessor(Req);
-  Event->wait(Event);
+  Event->wait();
 }
 
 void addHostUnsampledImageAccessorAndWait(UnsampledImageAccessorImplHost *Req) {

sycl/source/detail/event_impl.cpp

@@ -85,11 +85,11 @@ void event_impl::waitInternal(bool *Success) {
 
   // Wait for connected events(e.g. streams prints)
   for (const EventImplPtr &Event : MPostCompleteEvents)
-    Event->wait(Event);
+    Event->wait();
   for (const std::weak_ptr<event_impl> &WeakEventPtr :
        MWeakPostCompleteEvents) {
     if (EventImplPtr Event = WeakEventPtr.lock())
-      Event->wait(Event);
+      Event->wait();
   }
 }
 
@@ -278,8 +278,7 @@ void event_impl::instrumentationEpilog(void *TelemetryEvent,
 #endif
 }
 
-void event_impl::wait(std::shared_ptr<sycl::detail::event_impl> Self,
-                      bool *Success) {
+void event_impl::wait(bool *Success) {
   if (MState == HES_Discarded)
     throw sycl::exception(make_error_code(errc::invalid),
                           "wait method cannot be used for a discarded event.");
@@ -304,16 +303,15 @@ void event_impl::wait(std::shared_ptr<sycl::detail::event_impl> Self,
     // need to go via the slow path event waiting in the scheduler
     waitInternal(Success);
   else if (MCommand)
-    detail::Scheduler::getInstance().waitForEvent(Self, Success);
+    detail::Scheduler::getInstance().waitForEvent(*this, Success);
 
 #ifdef XPTI_ENABLE_INSTRUMENTATION
   instrumentationEpilog(TelemetryEvent, Name, StreamID, IId);
 #endif
 }
 
-void event_impl::wait_and_throw(
-    std::shared_ptr<sycl::detail::event_impl> Self) {
-  wait(Self);
+void event_impl::wait_and_throw() {
+  wait();
 
   if (std::shared_ptr<queue_impl> SubmittedQueue = MSubmittedQueue.lock())
     SubmittedQueue->throw_asynchronous();

sycl/source/detail/event_impl.hpp

@@ -110,25 +110,19 @@ class event_impl {
 
   /// Waits for the event.
   ///
-  /// Self is needed in order to pass shared_ptr to Scheduler.
-  ///
-  /// \param Self is a pointer to this event.
   /// \param Success is an optional parameter that, when set to a non-null
   ///        pointer, indicates that failure is a valid outcome for this wait
   ///        (e.g., in case of a non-blocking read from a pipe), and the value
   ///        it's pointing to is then set according to the outcome.
-  void wait(std::shared_ptr<sycl::detail::event_impl> Self,
-            bool *Success = nullptr);
+  void wait(bool *Success = nullptr);
 
   /// Waits for the event.
   ///
   /// If any uncaught asynchronous errors occurred on the context that the
   /// event is waiting on executions from, then call that context's
   /// asynchronous error handler with those errors. Self is needed in order to
   /// pass shared_ptr to Scheduler.
-  ///
-  /// \param Self is a pointer to this event.
-  void wait_and_throw(std::shared_ptr<sycl::detail::event_impl> Self);
+  void wait_and_throw();
 
   /// Queries this event for profiling information.
   ///

sycl/source/detail/graph/graph_impl.cpp

@@ -1490,7 +1490,7 @@ void exec_graph_impl::update(
       // needed because HostTask nodes (and all the nodes that depend on
       // HostTasks), are scheduled using a separate thread. This wait call
       // acts as a synchronization point for that thread.
-      UpdateEvent->wait(UpdateEvent);
+      UpdateEvent->wait();
     }
   } else {
     // For each partition in the executable graph, call UR update on the

sycl/source/detail/pipes.cpp

@@ -29,9 +29,8 @@ pipe_base::get_pipe_name_impl(const void *HostPipePtr) {
 
 __SYCL_EXPORT bool pipe_base::wait_non_blocking(const event &E) {
   bool Success = false;
-  std::shared_ptr<sycl::detail::event_impl> EImpl =
-      sycl::detail::getSyclObjImpl(E);
-  EImpl->wait(EImpl, &Success);
+  sycl::detail::event_impl &EImpl = *sycl::detail::getSyclObjImpl(E);
+  EImpl.wait(&Success);
   return Success;
 }
 

sycl/source/detail/queue_impl.cpp

@@ -626,7 +626,7 @@ void queue_impl::wait(const detail::code_location &CodeLoc) {
       LastEvent = MDefaultGraphDeps.LastEventPtr;
     }
     if (LastEvent) {
-      LastEvent->wait(LastEvent);
+      LastEvent->wait();
     }
   } else if (!isInOrder()) {
     std::vector<std::weak_ptr<event_impl>> WeakEvents;
@@ -651,7 +651,7 @@ void queue_impl::wait(const detail::code_location &CodeLoc) {
         // A nullptr UR event indicates that urQueueFinish will not cover it,
         // either because it's a host task event or an unenqueued one.
         if (nullptr == EventImplSharedPtr->getHandle()) {
-          EventImplSharedPtr->wait(EventImplSharedPtr);
+          EventImplSharedPtr->wait();
         }
       }
     }
@@ -666,7 +666,7 @@ void queue_impl::wait(const detail::code_location &CodeLoc) {
       StreamsServiceEvents.swap(MStreamsServiceEvents);
     }
     for (const EventImplPtr &Event : StreamsServiceEvents)
-      Event->wait(Event);
+      Event->wait();
   }
 
 #ifdef XPTI_ENABLE_INSTRUMENTATION

sycl/source/detail/scheduler/graph_processor.cpp

@@ -17,11 +17,11 @@ namespace sycl {
 inline namespace _V1 {
 namespace detail {
 
-void Scheduler::GraphProcessor::waitForEvent(const EventImplPtr &Event,
+void Scheduler::GraphProcessor::waitForEvent(event_impl &Event,
                                              ReadLockT &GraphReadLock,
                                              std::vector<Command *> &ToCleanUp,
                                              bool LockTheLock, bool *Success) {
-  Command *Cmd = Event->getCommand();
+  Command *Cmd = Event.getCommand();
   // Command can be nullptr if user creates sycl::event explicitly or the
   // event has been waited on by another thread
   if (!Cmd)
@@ -34,10 +34,10 @@ void Scheduler::GraphProcessor::waitForEvent(const EventImplPtr &Event,
     // TODO: Reschedule commands.
     throw exception(make_error_code(errc::runtime), "Enqueue process failed.");
 
-  assert(Cmd->getEvent() == Event);
+  assert(Cmd->getEvent().get() == &Event);
 
   GraphReadLock.unlock();
-  Event->waitInternal(Success);
+  Event.waitInternal(Success);
 
   if (LockTheLock)
     GraphReadLock.lock();

sycl/source/detail/scheduler/scheduler.cpp

@@ -67,7 +67,7 @@ void Scheduler::waitForRecordToFinish(MemObjRecord *Record,
     // Capture the dependencies
     DepCommands.insert(Cmd);
 #endif
-    GraphProcessor::waitForEvent(Cmd->getEvent(), GraphReadLock, ToCleanUp);
+    GraphProcessor::waitForEvent(*Cmd->getEvent(), GraphReadLock, ToCleanUp);
   }
   for (Command *Cmd : Record->MWriteLeaves) {
     if (Cmd->MEnqueueStatus == EnqueueResultT::SyclEnqueueFailed)
@@ -82,7 +82,7 @@ void Scheduler::waitForRecordToFinish(MemObjRecord *Record,
 #ifdef XPTI_ENABLE_INSTRUMENTATION
     DepCommands.insert(Cmd);
 #endif
-    GraphProcessor::waitForEvent(Cmd->getEvent(), GraphReadLock, ToCleanUp);
+    GraphProcessor::waitForEvent(*Cmd->getEvent(), GraphReadLock, ToCleanUp);
   }
   for (AllocaCommandBase *AllocaCmd : Record->MAllocaCommands) {
     Command *ReleaseCmd = AllocaCmd->getReleaseCmd();
@@ -97,7 +97,7 @@ void Scheduler::waitForRecordToFinish(MemObjRecord *Record,
     // reported as edges
     ReleaseCmd->resolveReleaseDependencies(DepCommands);
 #endif
-    GraphProcessor::waitForEvent(ReleaseCmd->getEvent(), GraphReadLock,
+    GraphProcessor::waitForEvent(*ReleaseCmd->getEvent(), GraphReadLock,
                                  ToCleanUp);
   }
 }
@@ -278,12 +278,12 @@ bool Scheduler::isInstanceAlive() {
   return GlobalHandler::instance().isSchedulerAlive();
 }
 
-void Scheduler::waitForEvent(const EventImplPtr &Event, bool *Success) {
+void Scheduler::waitForEvent(event_impl &Event, bool *Success) {
   ReadLockT Lock = acquireReadLock();
   // It's fine to leave the lock unlocked upon return from waitForEvent as
   // there's no more actions to do here with graph
   std::vector<Command *> ToCleanUp;
-  GraphProcessor::waitForEvent(std::move(Event), Lock, ToCleanUp,
+  GraphProcessor::waitForEvent(Event, Lock, ToCleanUp,
                                /*LockTheLock=*/false, Success);
   cleanupCommands(ToCleanUp);
 }

sycl/source/detail/scheduler/scheduler.hpp

@@ -404,7 +404,7 @@ class Scheduler {
   ///        (e.g., in case of a non-blocking read from a pipe), and the value
   ///        it's pointing to is then set according to the outcome.
 
-  void waitForEvent(const EventImplPtr &Event, bool *Success = nullptr);
+  void waitForEvent(event_impl &Event, bool *Success = nullptr);
 
   /// Removes buffer from the graph.
   ///
@@ -831,8 +831,7 @@ class Scheduler {
     ///
     /// The function may unlock and lock GraphReadLock as needed. Upon return
     /// the lock is left in locked state if and only if LockTheLock is true.
-    static void waitForEvent(const EventImplPtr &Event,
-                             ReadLockT &GraphReadLock,
+    static void waitForEvent(event_impl &Event, ReadLockT &GraphReadLock,
                              std::vector<Command *> &ToCleanUp,
                              bool LockTheLock = true, bool *Success = nullptr);
 

sycl/source/detail/sycl_mem_obj_t.cpp

@@ -137,7 +137,7 @@ void SYCLMemObjT::updateHostMemory(void *const Ptr) {
 
   EventImplPtr Event = Scheduler::getInstance().addCopyBack(&Req);
   if (Event)
-    Event->wait(Event);
+    Event->wait();
 }
 
 void SYCLMemObjT::updateHostMemory() {