[SYCL] Do not take any locks in submit for in-order queue (#18687)

in NoEvents mode.

The lock was mainly needed to protect storing LastEvent, which is no
longer necessary.

Since the lock also provided a memory barrier, change memory order for
load/stores on MNoEventMode to acquire/release to match the guarantees.

Author: igchor

sycl/source/detail/queue_impl.cpp

@@ -351,17 +351,11 @@ queue_impl::submit_impl(const detail::type_erased_cgfo_ty &CGF,
 
   auto requiresPostProcess = SubmitInfo.PostProcessorFunc() || Streams.size();
   auto noLastEventPath = !isHostTask && !isGraphSubmission &&
-                         MNoLastEventMode.load(std::memory_order_relaxed) &&
+                         MNoLastEventMode.load(std::memory_order_acquire) &&
                          !requiresPostProcess;
 
   if (noLastEventPath) {
-    std::unique_lock<std::mutex> Lock(MMutex);
-
-    // Check if we are still in no last event mode. There could
-    // have been a concurrent submit.
-    if (MNoLastEventMode.load(std::memory_order_relaxed)) {
-      return finalizeHandlerInOrderNoEventsUnlocked(Handler);
-    }
+    return finalizeHandlerInOrderNoEventsUnlocked(Handler);
   }
 
   detail::EventImplPtr EventImpl;
@@ -751,10 +745,11 @@ ur_native_handle_t queue_impl::getNative(int32_t &NativeHandleDesc) const {
 bool queue_impl::queue_empty() const {
   // If we have in-order queue with non-empty last event, just check its status.
   if (isInOrder()) {
-    std::lock_guard<std::mutex> Lock(MMutex);
-    if (MEmpty)
+    if (MEmpty.load(std::memory_order_acquire))
       return true;
 
+    std::lock_guard<std::mutex> Lock(MMutex);
+
     if (MDefaultGraphDeps.LastEventPtr &&
         !MDefaultGraphDeps.LastEventPtr->isDiscarded())
       return MDefaultGraphDeps.LastEventPtr

sycl/source/detail/queue_impl.hpp

@@ -735,11 +735,8 @@ class queue_impl : public std::enable_shared_from_this<queue_impl> {
   detail::EventImplPtr
   finalizeHandlerInOrderNoEventsUnlocked(HandlerType &Handler) {
     assert(isInOrder());
-    assert(MGraph.expired());
-    assert(MDefaultGraphDeps.LastEventPtr == nullptr);
-    assert(MNoLastEventMode);
 
-    MEmpty = false;
+    MEmpty.store(false, std::memory_order_release);
 
     synchronizeWithExternalEvent(Handler);
 
@@ -826,7 +823,7 @@ class queue_impl : public std::enable_shared_from_this<queue_impl> {
     const CGType Type = getSyclObjImpl(Handler)->MCGType;
     std::lock_guard<std::mutex> Lock{MMutex};
 
-    MEmpty = false;
+    MEmpty.store(false, std::memory_order_release);
 
     // The following code supports barrier synchronization if host task is
     // involved in the scenario. Native barriers cannot handle host task
@@ -1048,7 +1045,7 @@ class queue_impl : public std::enable_shared_from_this<queue_impl> {
   std::atomic<bool> MNoLastEventMode = false;
 
   // Used exclusively in getLastEvent and queue_empty() implementations
-  bool MEmpty = true;
+  std::atomic<bool> MEmpty = true;
 
   std::vector<EventImplPtr> MStreamsServiceEvents;
   std::mutex MStreamsServiceEventsMutex;