Merge remote-tracking branches 'my/queue_impl-misc' and 'my/context_impl-event_impl' into HEAD

aelovikov-intel · aelovikov-intel · commit 4e05ff0c7d16 · 2025-06-17T08:45:33.000-07:00
diff --git a/sycl/source/detail/event_impl.cpp b/sycl/source/detail/event_impl.cpp
@@ -38,8 +38,10 @@ void event_impl::initContextIfNeeded() {
     return;
 
   const device SyclDevice;
-  this->setContextImpl(
-      detail::queue_impl::getDefaultOrNew(*detail::getSyclObjImpl(SyclDevice)));
+  MIsHostEvent = false;
+  MContext =
+      detail::queue_impl::getDefaultOrNew(*detail::getSyclObjImpl(SyclDevice));
+  assert(MContext);
 }
 
 event_impl::~event_impl() {
@@ -140,9 +142,10 @@ void event_impl::setHandle(const ur_event_handle_t &UREvent) {
   MEvent.store(UREvent);
 }
 
-const ContextImplPtr &event_impl::getContextImpl() {
+context_impl &event_impl::getContextImpl() {
   initContextIfNeeded();
-  return MContext;
+  assert(MContext && "Trying to get context from a host event!");
+  return *MContext;
 }
 
 const AdapterPtr &event_impl::getAdapter() {
@@ -152,9 +155,9 @@ const AdapterPtr &event_impl::getAdapter() {
 
 void event_impl::setStateIncomplete() { MState = HES_NotComplete; }
 
-void event_impl::setContextImpl(const ContextImplPtr &Context) {
-  MIsHostEvent = Context == nullptr;
-  MContext = Context;
+void event_impl::setContextImpl(context_impl &Context) {
+  MIsHostEvent = false;
+  MContext = Context.shared_from_this();
 }
 
 event_impl::event_impl(ur_event_handle_t Event, const context &SyclContext,
@@ -178,7 +181,7 @@ event_impl::event_impl(ur_event_handle_t Event, const context &SyclContext,
 event_impl::event_impl(queue_impl &Queue, private_tag)
     : MQueue{Queue.weak_from_this()},
       MIsProfilingEnabled{Queue.MIsProfilingEnabled} {
-  this->setContextImpl(Queue.getContextImplPtr());
+  this->setContextImpl(Queue.getContextImpl());
   MState.store(HES_Complete);
 }
 
diff --git a/sycl/source/detail/event_impl.hpp b/sycl/source/detail/event_impl.hpp
@@ -173,21 +173,17 @@ class event_impl : public std::enable_shared_from_this<event_impl> {
   void setHandle(const ur_event_handle_t &UREvent);
 
   /// Returns context that is associated with this event.
-  ///
-  /// \return a shared pointer to a valid context_impl.
-  const ContextImplPtr &getContextImpl();
+  context_impl &getContextImpl();
 
   /// \return the Adapter associated with the context of this event.
   /// Should be called when this is not a Host Event.
   const AdapterPtr &getAdapter();
 
   /// Associate event with the context.
   ///
-  /// Provided UrContext inside ContextImplPtr must be associated
+  /// Provided UrContext inside Context must be associated
   /// with the UrEvent object stored in this class
-  ///
-  /// @param Context is a shared pointer to an instance of valid context_impl.
-  void setContextImpl(const ContextImplPtr &Context);
+  void setContextImpl(context_impl &Context);
 
   /// Clear the event state
   void setStateIncomplete();
diff --git a/sycl/source/detail/graph_impl.cpp b/sycl/source/detail/graph_impl.cpp
@@ -1037,7 +1037,7 @@ exec_graph_impl::enqueue(sycl::detail::queue_impl &Queue,
 
   auto CreateNewEvent([&]() {
     auto NewEvent = sycl::detail::event_impl::create_device_event(Queue);
-    NewEvent->setContextImpl(Queue.getContextImplPtr());
+    NewEvent->setContextImpl(Queue.getContextImpl());
     NewEvent->setStateIncomplete();
     return NewEvent;
   });
diff --git a/sycl/source/detail/helpers.hpp b/sycl/source/detail/helpers.hpp
@@ -21,7 +21,6 @@ class event;
 namespace detail {
 class CGExecKernel;
 class queue_impl;
-using QueueImplPtr = std::shared_ptr<sycl::detail::queue_impl>;
 class RTDeviceBinaryImage;
 
 #ifdef __INTEL_PREVIEW_BREAKING_CHANGES
diff --git a/sycl/source/detail/memory_manager.hpp b/sycl/source/detail/memory_manager.hpp
@@ -28,7 +28,6 @@ class queue_impl;
 class event_impl;
 class context_impl;
 
-using QueueImplPtr = std::shared_ptr<detail::queue_impl>;
 using EventImplPtr = std::shared_ptr<detail::event_impl>;
 
 // The class contains methods that work with memory. All operations with
diff --git a/sycl/source/detail/queue_impl.cpp b/sycl/source/detail/queue_impl.cpp
@@ -121,7 +121,7 @@ queue_impl::get_backend_info<info::device::backend_version>() const {
 static event prepareSYCLEventAssociatedWithQueue(
     const std::shared_ptr<detail::queue_impl> &QueueImpl) {
   auto EventImpl = detail::event_impl::create_device_event(*QueueImpl);
-  EventImpl->setContextImpl(detail::getSyclObjImpl(QueueImpl->get_context()));
+  EventImpl->setContextImpl(QueueImpl->getContextImpl());
   EventImpl->setStateIncomplete();
   return detail::createSyclObjFromImpl<event>(EventImpl);
 }
diff --git a/sycl/source/detail/reduction.cpp b/sycl/source/detail/reduction.cpp
@@ -208,7 +208,7 @@ __SYCL_EXPORT void
 addCounterInit(handler &CGH, std::shared_ptr<sycl::detail::queue_impl> &Queue,
                std::shared_ptr<int> &Counter) {
   auto EventImpl = detail::event_impl::create_device_event(*Queue);
-  EventImpl->setContextImpl(detail::getSyclObjImpl(Queue->get_context()));
+  EventImpl->setContextImpl(Queue->getContextImpl());
   EventImpl->setStateIncomplete();
   ur_event_handle_t UREvent = nullptr;
   MemoryManager::fill_usm(Counter.get(), *Queue, sizeof(int), {0}, {},
diff --git a/sycl/source/detail/scheduler/commands.cpp b/sycl/source/detail/scheduler/commands.cpp
@@ -533,10 +533,8 @@ void Command::waitForEvents(queue_impl *Queue,
           RequiredEventsPerContext;
 
       for (const EventImplPtr &Event : EventImpls) {
-        ContextImplPtr Context = Event->getContextImpl();
-        assert(Context.get() &&
-               "Only non-host events are expected to be waited for here");
-        RequiredEventsPerContext[Context.get()].push_back(Event);
+        context_impl &Context = Event->getContextImpl();
+        RequiredEventsPerContext[&Context].push_back(Event);
       }
 
       for (auto &CtxWithEvents : RequiredEventsPerContext) {
@@ -576,7 +574,7 @@ Command::Command(
   MEvent->setSubmittedQueue(MWorkerQueue);
   MEvent->setCommand(this);
   if (MQueue)
-    MEvent->setContextImpl(MQueue->getContextImplPtr());
+    MEvent->setContextImpl(MQueue->getContextImpl());
   MEvent->setStateIncomplete();
   MEnqueueStatus = EnqueueResultT::SyclEnqueueReady;
 
@@ -781,9 +779,9 @@ Command *Command::processDepEvent(EventImplPtr DepEvent, const DepDesc &Dep,
 
   Command *ConnectionCmd = nullptr;
 
-  ContextImplPtr DepEventContext = DepEvent->getContextImpl();
+  context_impl &DepEventContext = DepEvent->getContextImpl();
   // If contexts don't match we'll connect them using host task
-  if (DepEventContext != WorkerContext && WorkerContext) {
+  if (&DepEventContext != WorkerContext.get() && WorkerContext) {
     Scheduler::GraphBuilder &GB = Scheduler::getInstance().MGraphBuilder;
     ConnectionCmd = GB.connectDepEvent(this, DepEvent, Dep, ToCleanUp);
   } else
@@ -1298,7 +1296,7 @@ ur_result_t ReleaseCommand::enqueueImp() {
 
     std::shared_ptr<event_impl> UnmapEventImpl =
         event_impl::create_device_event(*Queue);
-    UnmapEventImpl->setContextImpl(Queue->getContextImplPtr());
+    UnmapEventImpl->setContextImpl(Queue->getContextImpl());
     UnmapEventImpl->setStateIncomplete();
     ur_event_handle_t UREvent = nullptr;
 
@@ -1516,7 +1514,7 @@ MemCpyCommand::MemCpyCommand(Requirement SrcReq,
       MSrcReq(std::move(SrcReq)), MSrcAllocaCmd(SrcAllocaCmd),
       MDstReq(std::move(DstReq)), MDstAllocaCmd(DstAllocaCmd) {
   if (MSrcQueue) {
-    MEvent->setContextImpl(MSrcQueue->getContextImplPtr());
+    MEvent->setContextImpl(MSrcQueue->getContextImpl());
   }
 
   MWorkerQueue = !MQueue ? MSrcQueue : MQueue;
@@ -1689,7 +1687,7 @@ MemCpyCommandHost::MemCpyCommandHost(Requirement SrcReq,
       MSrcReq(std::move(SrcReq)), MSrcAllocaCmd(SrcAllocaCmd),
       MDstReq(std::move(DstReq)), MDstPtr(DstPtr) {
   if (MSrcQueue) {
-    MEvent->setContextImpl(MSrcQueue->getContextImplPtr());
+    MEvent->setContextImpl(MSrcQueue->getContextImpl());
   }
 
   MWorkerQueue = !MQueue ? MSrcQueue : MQueue;
diff --git a/sycl/source/detail/scheduler/graph_builder.cpp b/sycl/source/detail/scheduler/graph_builder.cpp
@@ -1221,7 +1221,7 @@ void Scheduler::GraphBuilder::removeRecordForMemObj(SYCLMemObjI *MemObject) {
 Command *Scheduler::GraphBuilder::connectDepEvent(
     Command *const Cmd, const EventImplPtr &DepEvent, const DepDesc &Dep,
     std::vector<Command *> &ToCleanUp) {
-  assert(Cmd->getWorkerContext() != DepEvent->getContextImpl());
+  assert(Cmd->getWorkerContext().get() != &DepEvent->getContextImpl());
 
   // construct Host Task type command manually and make it depend on DepEvent
   ExecCGCommand *ConnectCmd = nullptr;
diff --git a/sycl/source/detail/scheduler/scheduler.cpp b/sycl/source/detail/scheduler/scheduler.cpp
@@ -699,7 +699,7 @@ bool Scheduler::CheckEventReadiness(context_impl &Context,
     return SyclEventImplPtr->isCompleted();
   }
   // Cross-context dependencies can't be passed to the backend directly.
-  if (SyclEventImplPtr->getContextImpl().get() != &Context)
+  if (&SyclEventImplPtr->getContextImpl() != &Context)
     return false;
 
   // A nullptr here means that the commmand does not produce a UR event or it
diff --git a/sycl/source/enqueue_functions.cpp b/sycl/source/enqueue_functions.cpp
@@ -15,26 +15,25 @@ namespace ext::oneapi::experimental {
 
 __SYCL_EXPORT void memcpy(queue Q, void *Dest, const void *Src, size_t NumBytes,
                           const sycl::detail::code_location &CodeLoc) {
-  sycl::detail::tls_code_loc_t TlsCodeLocCapture(CodeLoc);
-  auto QueueImplPtr = sycl::detail::getSyclObjImpl(Q);
-  QueueImplPtr->memcpy(Dest, Src, NumBytes, {},
-                       /*CallerNeedsEvent=*/false, TlsCodeLocCapture.query());
+  detail::tls_code_loc_t TlsCodeLocCapture(CodeLoc);
+  detail::getSyclObjImpl(Q)->memcpy(Dest, Src, NumBytes, {},
+                                    /*CallerNeedsEvent=*/false,
+                                    TlsCodeLocCapture.query());
 }
 
 __SYCL_EXPORT void memset(queue Q, void *Ptr, int Value, size_t NumBytes,
                           const sycl::detail::code_location &CodeLoc) {
-  sycl::detail::tls_code_loc_t TlsCodeLocCapture(CodeLoc);
-  auto QueueImplPtr = sycl::detail::getSyclObjImpl(Q);
-  QueueImplPtr->memset(Ptr, Value, NumBytes, {},
-                       /*CallerNeedsEvent=*/false);
+  detail::tls_code_loc_t TlsCodeLocCapture(CodeLoc);
+  detail::getSyclObjImpl(Q)->memset(Ptr, Value, NumBytes, {},
+                                    /*CallerNeedsEvent=*/false);
 }
 
 __SYCL_EXPORT void mem_advise(queue Q, void *Ptr, size_t NumBytes, int Advice,
                               const sycl::detail::code_location &CodeLoc) {
-  sycl::detail::tls_code_loc_t TlsCodeLocCapture(CodeLoc);
-  auto QueueImplPtr = sycl::detail::getSyclObjImpl(Q);
-  QueueImplPtr->mem_advise(Ptr, NumBytes, ur_usm_advice_flags_t(Advice), {},
-                           /*CallerNeedsEvent=*/false);
+  detail::tls_code_loc_t TlsCodeLocCapture(CodeLoc);
+  detail::getSyclObjImpl(Q)->mem_advise(Ptr, NumBytes,
+                                        ur_usm_advice_flags_t(Advice), {},
+                                        /*CallerNeedsEvent=*/false);
 }
 
 } // namespace ext::oneapi::experimental
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
@@ -610,7 +610,7 @@ event handler::finalize() {
         detail::queue_impl &Queue = impl->get_queue();
         LastEventImpl->setQueue(Queue);
         LastEventImpl->setWorkerQueue(Queue.weak_from_this());
-        LastEventImpl->setContextImpl(impl->get_context().shared_from_this());
+        LastEventImpl->setContextImpl(impl->get_context());
         LastEventImpl->setStateIncomplete();
         LastEventImpl->setSubmissionTime();
 
diff --git a/sycl/source/queue.cpp b/sycl/source/queue.cpp
@@ -328,15 +328,15 @@ void queue::wait_and_throw_proxy(const detail::code_location &CodeLoc) {
 }
 
 static event
-getBarrierEventForInorderQueueHelper(const detail::QueueImplPtr QueueImpl) {
+getBarrierEventForInorderQueueHelper(detail::queue_impl &QueueImpl) {
   // This function should not be called when a queue is recording to a graph,
   // as a graph can record from multiple queues and we cannot guarantee the
   // last node added by an in-order queue will be the last node added to the
   // graph.
-  assert(!QueueImpl->hasCommandGraph() &&
+  assert(!QueueImpl.hasCommandGraph() &&
          "Should not be called in on graph recording.");
 
-  sycl::detail::optional<event> LastEvent = QueueImpl->getLastEvent();
+  sycl::detail::optional<event> LastEvent = QueueImpl.getLastEvent();
   if (LastEvent)
     return *LastEvent;
 
@@ -353,11 +353,7 @@ getBarrierEventForInorderQueueHelper(const detail::QueueImplPtr QueueImpl) {
 /// \return a SYCL event object, which corresponds to the queue the command
 /// group is being enqueued on.
 event queue::ext_oneapi_submit_barrier(const detail::code_location &CodeLoc) {
-  if (is_in_order() && !impl->hasCommandGraph() && !impl->MIsProfilingEnabled) {
-    return getBarrierEventForInorderQueueHelper(impl);
-  }
-
-  return submit([=](handler &CGH) { CGH.ext_oneapi_barrier(); }, CodeLoc);
+  return ext_oneapi_submit_barrier(std::vector<event>{}, CodeLoc);
 }
 
 /// Prevents any commands submitted afterward to this queue from executing
@@ -379,11 +375,14 @@ event queue::ext_oneapi_submit_barrier(const std::vector<event> &WaitList,
       });
   if (is_in_order() && !impl->hasCommandGraph() && !impl->MIsProfilingEnabled &&
       AllEventsEmptyOrNop) {
-    return getBarrierEventForInorderQueueHelper(impl);
+    return getBarrierEventForInorderQueueHelper(*impl);
   }
 
-  return submit([=](handler &CGH) { CGH.ext_oneapi_barrier(WaitList); },
-                CodeLoc);
+  if (WaitList.empty())
+    return submit([=](handler &CGH) { CGH.ext_oneapi_barrier(); }, CodeLoc);
+  else
+    return submit([=](handler &CGH) { CGH.ext_oneapi_barrier(WaitList); },
+                  CodeLoc);
 }
 
 template <typename Param>
diff --git a/sycl/unittests/Extensions/USMMemcpy2D.cpp b/sycl/unittests/Extensions/USMMemcpy2D.cpp
diff --git a/sycl/unittests/program_manager/arg_mask/EliminatedArgMask.cpp b/sycl/unittests/program_manager/arg_mask/EliminatedArgMask.cpp
diff --git a/sycl/unittests/scheduler/QueueFlushing.cpp b/sycl/unittests/scheduler/QueueFlushing.cpp

Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ queue_impl::get_backend_info<info::device::backend_version>() const {`
`121`	`121`	`static event prepareSYCLEventAssociatedWithQueue(`
`122`	`122`	`const std::shared_ptr<detail::queue_impl> &QueueImpl) {`
`123`	`123`	`auto EventImpl = detail::event_impl::create_device_event(*QueueImpl);`
`124`		`- EventImpl->setContextImpl(detail::getSyclObjImpl(QueueImpl->get_context()));`
	`124`	`+ EventImpl->setContextImpl(QueueImpl->getContextImpl());`
`125`	`125`	`EventImpl->setStateIncomplete();`
`126`	`126`	`return detail::createSyclObjFromImpl<event>(EventImpl);`
`127`	`127`	`}`
Original file line number	Diff line number	Diff line change
`@@ -699,7 +699,7 @@ bool Scheduler::CheckEventReadiness(context_impl &Context,`
`699`	`699`	`return SyclEventImplPtr->isCompleted();`
`700`	`700`	`}`
`701`	`701`	`// Cross-context dependencies can't be passed to the backend directly.`
`702`		`- if (SyclEventImplPtr->getContextImpl().get() != &Context)`
	`702`	`+ if (&SyclEventImplPtr->getContextImpl() != &Context)`
`703`	`703`	`return false;`
`704`	`704`
`705`	`705`	`// A nullptr here means that the commmand does not produce a UR event or it`