[llvm] [offload][level_zero] Remove async queues (PR #222267)

via llvm-commits llvm-commits at lists.llvm.org
Wed Sep 9 01:41:14 PDT 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-offload

Author: Alex Duran (adurang)

<details>
<summary>Changes</summary>

Remove old queues now that new inorder queues seems stable enough (and more in line with what is needed for liboffload).

---
Full diff: https://github.com/llvm/llvm-project/pull/222267.diff


4 Files Affected:

- (modified) offload/plugins-nextgen/level_zero/include/L0Options.h (+1-1) 
- (modified) offload/plugins-nextgen/level_zero/include/L0Queue.h (-68) 
- (modified) offload/plugins-nextgen/level_zero/src/L0Options.cpp (+2-21) 
- (modified) offload/plugins-nextgen/level_zero/src/L0Queue.cpp (-267) 


``````````diff
diff --git a/offload/plugins-nextgen/level_zero/include/L0Options.h b/offload/plugins-nextgen/level_zero/include/L0Options.h
index 00f4689e8cef4..2ac5b9399d18d 100644
--- a/offload/plugins-nextgen/level_zero/include/L0Options.h
+++ b/offload/plugins-nextgen/level_zero/include/L0Options.h
@@ -22,7 +22,7 @@
 
 namespace llvm::omp::target::plugin {
 /// Command submission mode.
-enum class CommandModeTy { Sync = 0, Async, AsyncOrdered, InOrder };
+enum class CommandModeTy { Sync = 0, InOrder };
 
 /// Specialization constants used for a module compilation.
 class SpecConstantsTy {
diff --git a/offload/plugins-nextgen/level_zero/include/L0Queue.h b/offload/plugins-nextgen/level_zero/include/L0Queue.h
index 3be454c032ac5..d55d7d5af2ee3 100644
--- a/offload/plugins-nextgen/level_zero/include/L0Queue.h
+++ b/offload/plugins-nextgen/level_zero/include/L0Queue.h
@@ -168,74 +168,6 @@ class L0QueueTy {
                                 size_t PatternSize, size_t Size);
 };
 
-class L0AsyncQueueTy : public L0QueueTy {
-protected:
-  /// List of events attached to submitted commands.
-  llvm::SmallVector<ze_event_handle_t> WaitEvents;
-  /// Kernel event not signaled.
-  ze_event_handle_t KernelEvent = nullptr;
-
-  /// Contains information about pending memory copies.
-  struct PendingCopyDescTy {
-    const void *Src;
-    void *Dst;
-    size_t Size;
-  };
-
-  /// Pending staging buffer to host copies.
-  llvm::SmallVector<PendingCopyDescTy> H2MList;
-  /// Pending USM memory copy commands that must wait for kernel completion.
-  llvm::SmallVector<PendingCopyDescTy> USM2MList;
-
-  virtual std::tuple<size_t, ze_event_handle_t *> getMemCopyEvents();
-  virtual std::tuple<size_t, ze_event_handle_t *> getLaunchKernelEvents();
-  void processCopyQueues();
-
-public:
-  L0AsyncQueueTy(L0DeviceTy &Device) : L0QueueTy(Device, /*IsInorder*/ false) {}
-  virtual ~L0AsyncQueueTy() {}
-
-  L0AsyncQueueTy(const L0AsyncQueueTy &) = delete;
-  L0AsyncQueueTy(const L0AsyncQueueTy &&) = delete;
-  L0AsyncQueueTy &operator=(const L0AsyncQueueTy &) = delete;
-  L0AsyncQueueTy &operator=(const L0AsyncQueueTy &&) = delete;
-
-  Error deinitImpl() override;
-  void resetImpl() override;
-  Error synchronizeImpl() override;
-  Expected<bool> hasPendingWorkImpl() override;
-  bool hasPendingMemoryCopies() override {
-    return !H2MList.empty() || !USM2MList.empty();
-  }
-  Error memoryCopyImpl(void *Dst, const void *Src, size_t Size) override;
-  Error dataRetrieveImpl(void *HstPtr, const void *TgtPtr,
-                         int64_t Size) override;
-  Error dataSubmitImpl(void *TgtPtr, const void *HstPtr, int64_t Size) override;
-  Error launchKernelImpl(ze_kernel_handle_t Kernel,
-                         L0LaunchEnvTy &KEnv) override;
-  Error hostCallImpl(void (*Callback)(void *), void *UserData) override;
-  Error memoryFillImpl(void *Ptr, const void *Pattern, size_t PatternSize,
-                       size_t Size) override;
-  Error dataFenceImpl() override;
-};
-
-class L0AsyncOrderedQueueTy : public L0AsyncQueueTy {
-public:
-  L0AsyncOrderedQueueTy(L0DeviceTy &Device) : L0AsyncQueueTy(Device) {}
-  virtual ~L0AsyncOrderedQueueTy() {}
-
-  L0AsyncOrderedQueueTy(const L0AsyncOrderedQueueTy &) = delete;
-  L0AsyncOrderedQueueTy(const L0AsyncOrderedQueueTy &&) = delete;
-  L0AsyncOrderedQueueTy &operator=(const L0AsyncOrderedQueueTy &) = delete;
-  L0AsyncOrderedQueueTy &operator=(const L0AsyncOrderedQueueTy &&) = delete;
-
-  Error synchronizeImpl() override;
-  std::tuple<size_t, ze_event_handle_t *> getMemCopyEvents() override;
-  std::tuple<size_t, ze_event_handle_t *> getLaunchKernelEvents() override;
-  Error hostCallImpl(void (*Callback)(void *), void *UserData) override;
-  Error dataFenceImpl() override { return Plugin::success(); }
-};
-
 class L0InorderQueueTy : public L0QueueTy {
 public:
   L0InorderQueueTy(L0DeviceTy &Device) : L0QueueTy(Device) {}
diff --git a/offload/plugins-nextgen/level_zero/src/L0Options.cpp b/offload/plugins-nextgen/level_zero/src/L0Options.cpp
index 63b29c0f759fd..01c62173ee719 100644
--- a/offload/plugins-nextgen/level_zero/src/L0Options.cpp
+++ b/offload/plugins-nextgen/level_zero/src/L0Options.cpp
@@ -160,32 +160,13 @@ void L0OptionsTy::processEnvironmentVars() {
   }
 
   // LIBOMPTARGET_LEVEL_ZERO_COMMAND_MODE=<Fmt>.
-  // <Fmt> := sync | async | async_ordered
+  // <Fmt> := inorder | sync
+  // inorder: use level zero command queue in-order mode. This is the default.
   // sync: perform synchronization after each command.
-  // async: perform synchronization when it is required.
-  // async_ordered: same as "async", but command is ordered.
-  // This option is ignored unless IMM is fully enabled on compute and copy.
-  // On Intel PVC GPU, when used with immediate command lists over Level Zero
-  // backend, a target region may involve multiple command submissions to the
-  // L0 copy queue and compute queue. L0 events are used for each submission
-  // (data transfer of a single item or kernel execution). When "async" is
-  // specified, a) each data transfer to device is submitted with an event.
-  // b) The kernel is submitted next with a dependence on all the previous
-  // data transfer events. The kernel also has an event associated with it.
-  // c) The data transfer from device will be submitted with a dependence on
-  // the kernel event. d) Finally wait on the host for all the events
-  // associated with the data transfer from device.
-  // The env-var also affects any "target update" constructs as well.
-  // The env-var only affects the L0 copy/  compute commands issued from a
-  // single target construct execution, not across multiple invocations.
   const StringEnvar CommandModeVar("LIBOMPTARGET_LEVEL_ZERO_COMMAND_MODE");
   if (CommandModeVar.isPresent()) {
     if (match(CommandModeVar, "sync"))
       CommandMode = CommandModeTy::Sync;
-    else if (match(CommandModeVar, "async"))
-      CommandMode = CommandModeTy::Async;
-    else if (match(CommandModeVar, "async_ordered"))
-      CommandMode = CommandModeTy::AsyncOrdered;
     else if (match(CommandModeVar, "inorder"))
       CommandMode = CommandModeTy::InOrder;
     else
diff --git a/offload/plugins-nextgen/level_zero/src/L0Queue.cpp b/offload/plugins-nextgen/level_zero/src/L0Queue.cpp
index ee27d6e517857..489726046503b 100644
--- a/offload/plugins-nextgen/level_zero/src/L0Queue.cpp
+++ b/offload/plugins-nextgen/level_zero/src/L0Queue.cpp
@@ -195,267 +195,6 @@ Error L0QueueTy::memoryFillReplicateImpl(void *Ptr, const void *Pattern,
   return Plugin::success();
 }
 
-// L0AsyncQueueTy implementation.
-
-Error L0AsyncQueueTy::deinitImpl() {
-  Error AllErrors = Plugin::success();
-  for (auto &Event : WaitEvents) {
-    if (auto Err = Device.releaseEvent(Event))
-      AllErrors = joinErrors(std::move(AllErrors), std::move(Err));
-  }
-  WaitEvents.clear();
-  return AllErrors;
-}
-
-void L0AsyncQueueTy::resetImpl() {
-  WaitEvents.clear();
-  KernelEvent = nullptr;
-  H2MList.clear();
-  USM2MList.clear();
-}
-
-void L0AsyncQueueTy::processCopyQueues() {
-  auto ProcessQueue = [](auto &Queue) {
-    for (auto &[Src, Dst, Size] : Queue)
-      std::copy_n(static_cast<const char *>(Src), Size,
-                  static_cast<char *>(Dst));
-    Queue.clear();
-  };
-
-  ProcessQueue(USM2MList);
-  ProcessQueue(H2MList);
-}
-
-Error L0AsyncQueueTy::synchronizeImpl() {
-  Error SyncErrors = Plugin::success();
-
-  // Wait for all events. We should wait and reset events in reverse order
-  // to avoid premature event reset. If we have a kernel event in the
-  // queue, it is the last event to wait for since all wait events of the
-  // kernel are signaled before the kernel is invoked. We always invoke
-  // synchronization on kernel event to support printf().
-  bool WaitDone = false;
-  for (auto Itr = WaitEvents.rbegin(); Itr != WaitEvents.rend(); Itr++) {
-    if (!WaitDone) {
-      SyncErrors = joinErrors(std::move(SyncErrors),
-                              CmdList->eventHostSynchronize(*Itr));
-      if (*Itr == KernelEvent)
-        WaitDone = true;
-    }
-    if (auto Err = Device.releaseEvent(*Itr))
-      SyncErrors = joinErrors(std::move(SyncErrors), std::move(Err));
-  }
-  WaitEvents.clear();
-  KernelEvent = nullptr;
-
-  processCopyQueues();
-
-  return SyncErrors;
-}
-
-Expected<bool> L0AsyncQueueTy::hasPendingWorkImpl() {
-  if (!WaitEvents.empty())
-    return true;
-
-  processCopyQueues();
-  return false;
-}
-
-std::tuple<size_t, ze_event_handle_t *> L0AsyncQueueTy::getMemCopyEvents() {
-  return KernelEvent ? std::make_tuple(1, &KernelEvent)
-                     : std::make_tuple(0, nullptr);
-}
-
-std::tuple<size_t, ze_event_handle_t *>
-L0AsyncQueueTy::getLaunchKernelEvents() {
-  return WaitEvents.empty()
-             ? std::make_tuple(0, nullptr)
-             : std::make_tuple(WaitEvents.size(), WaitEvents.data());
-}
-
-Error L0AsyncQueueTy::memoryCopyImpl(void *Dst, const void *Src, size_t Size) {
-  auto EventOrErr = Device.getEvent();
-  if (!EventOrErr)
-    return EventOrErr.takeError();
-  ze_event_handle_t SignalEvent = *EventOrErr;
-  auto [NumWaitEvents, WaitEventsPtr] = getMemCopyEvents();
-
-  Error AllErrors = CmdList->appendMemoryCopy(Dst, Src, Size, SignalEvent,
-                                              NumWaitEvents, WaitEventsPtr);
-  if (!AllErrors) {
-    WaitEvents.push_back(SignalEvent);
-  } else {
-    if (auto Err = Device.releaseEvent(SignalEvent))
-      AllErrors = joinErrors(std::move(AllErrors), std::move(Err));
-  }
-  return AllErrors;
-}
-
-Error L0AsyncQueueTy::dataRetrieveImpl(void *HstPtr, const void *TgtPtr,
-                                       int64_t Size) {
-  auto TgtPtrType = Device.getMemAllocType(TgtPtr);
-  if (TgtPtrType == ZE_MEMORY_TYPE_HOST ||
-      TgtPtrType == ZE_MEMORY_TYPE_SHARED) {
-    bool CopyNow = true;
-    if (KernelEvent) {
-      // Delay Host/Shared USM to host memory copy since it must wait for
-      // kernel completion.
-      USM2MList.emplace_back(
-          PendingCopyDescTy{TgtPtr, HstPtr, static_cast<size_t>(Size)});
-      CopyNow = false;
-    }
-    if (CopyNow) {
-      std::copy_n(static_cast<const char *>(TgtPtr), Size,
-                  static_cast<char *>(HstPtr));
-    }
-    return Plugin::success();
-  }
-
-  void *DstPtr = HstPtr;
-  if (Device.isDiscreteDevice() &&
-      static_cast<size_t>(Size) <=
-          Device.getPlugin().getOptions().StagingBufferSize &&
-      Device.getMemAllocType(HstPtr) != ZE_MEMORY_TYPE_HOST) {
-    auto PtrOrErr = Device.getStagingBuffer().get(/*IsAsync*/ true);
-    if (!PtrOrErr)
-      return PtrOrErr.takeError();
-    DstPtr = *PtrOrErr;
-  }
-
-  if (auto Err = memoryCopy(DstPtr, TgtPtr, Size))
-    return Err;
-
-  if (DstPtr != HstPtr)
-    H2MList.emplace_back(
-        PendingCopyDescTy{DstPtr, HstPtr, static_cast<size_t>(Size)});
-  return Plugin::success();
-}
-
-Error L0AsyncQueueTy::dataSubmitImpl(void *TgtPtr, const void *HstPtr,
-                                     int64_t Size) {
-  const auto TgtPtrType = Device.getMemAllocType(TgtPtr);
-  if (TgtPtrType == ZE_MEMORY_TYPE_SHARED ||
-      TgtPtrType == ZE_MEMORY_TYPE_HOST) {
-    std::copy_n(static_cast<const char *>(HstPtr), Size,
-                static_cast<char *>(TgtPtr));
-    return Plugin::success();
-  }
-
-  const void *SrcPtr = HstPtr;
-
-  if (Device.isDiscreteDevice() &&
-      static_cast<size_t>(Size) <=
-          Device.getPlugin().getOptions().StagingBufferSize &&
-      Device.getMemAllocType(HstPtr) != ZE_MEMORY_TYPE_HOST) {
-    auto PtrOrErr = Device.getStagingBuffer().get(/*IsAsync*/ true);
-    if (!PtrOrErr)
-      return PtrOrErr.takeError();
-    SrcPtr = *PtrOrErr;
-    std::copy_n(static_cast<const char *>(HstPtr), Size,
-                static_cast<char *>(const_cast<void *>(SrcPtr)));
-  }
-
-  return memoryCopy(TgtPtr, SrcPtr, Size);
-}
-
-Error L0AsyncQueueTy::dataFenceImpl() {
-  return CmdList->appendBarrier(/*SignalEvent*/ nullptr, /*NumWaitEvents*/ 0,
-                                /*WaitEvents*/ nullptr);
-}
-
-Error L0AsyncQueueTy::launchKernelImpl(ze_kernel_handle_t Kernel,
-                                       L0LaunchEnvTy &KEnv) {
-  auto EventOrError = Device.getEvent();
-  if (!EventOrError)
-    return EventOrError.takeError();
-  ze_event_handle_t SignalEvent = *EventOrError;
-  auto [NumWaitEvents, WaitEventsPtr] = getLaunchKernelEvents();
-  INFO(OMP_INFOTYPE_PLUGIN_KERNEL, Device.getDeviceId(),
-       "Kernel depends on %zu data copying events.\n", NumWaitEvents);
-  Error AllErrors = dispatchLaunchKernel(Kernel, KEnv, SignalEvent,
-                                         NumWaitEvents, WaitEventsPtr);
-  if (AllErrors) {
-    if (auto Err = Device.releaseEvent(SignalEvent))
-      AllErrors = joinErrors(std::move(AllErrors), std::move(Err));
-    return AllErrors;
-  }
-  WaitEvents.push_back(SignalEvent);
-  KernelEvent = SignalEvent;
-  return Plugin::success();
-}
-
-Error L0AsyncQueueTy::hostCallImpl(void (*Callback)(void *), void *UserData) {
-  return Plugin::error(ErrorCode::UNIMPLEMENTED,
-                       "Host function callbacks are not yet implemented for "
-                       "out-of-order async queues");
-}
-
-Error L0AsyncQueueTy::memoryFillImpl(void *Ptr, const void *Pattern,
-                                     size_t PatternSize, size_t Size) {
-  auto EventOrErr = Device.getEvent();
-  if (!EventOrErr)
-    return EventOrErr.takeError();
-  auto [NumWaitEvents, WaitEventsPtr] = getMemCopyEvents();
-  ze_event_handle_t SignalEvent = *EventOrErr;
-  if (auto Err = CmdList->appendMemoryFill(Ptr, Pattern, PatternSize, Size,
-                                           SignalEvent, NumWaitEvents,
-                                           WaitEventsPtr)) {
-    if (auto ReleaseErr = Device.releaseEvent(SignalEvent))
-      return joinErrors(std::move(Err), std::move(ReleaseErr));
-    return Err;
-  }
-  WaitEvents.push_back(SignalEvent);
-  return Plugin::success();
-}
-
-// L0AsyncOrderedQueue implementation.
-Error L0AsyncOrderedQueueTy::synchronizeImpl() {
-  Error SyncErrors = Plugin::success();
-
-  ze_event_handle_t LastEvent =
-      WaitEvents.empty() ? nullptr : WaitEvents.back();
-  // Only need to wait for the last event.
-  if (LastEvent) {
-    SyncErrors = joinErrors(std::move(SyncErrors),
-                            CmdList->eventHostSynchronize(LastEvent));
-  }
-  // Synchronize on kernel event to support printf().
-  ze_event_handle_t KE = KernelEvent;
-  if (KE && KE != LastEvent && !SyncErrors) {
-    SyncErrors =
-        joinErrors(std::move(SyncErrors), CmdList->eventHostSynchronize(KE));
-  }
-  for (auto &Event : WaitEvents) {
-    if (auto Err = Device.releaseEvent(Event))
-      SyncErrors = joinErrors(std::move(SyncErrors), std::move(Err));
-  }
-
-  processCopyQueues();
-  WaitEvents.clear();
-  KernelEvent = nullptr;
-
-  return SyncErrors;
-}
-
-std::tuple<size_t, ze_event_handle_t *>
-L0AsyncOrderedQueueTy::getMemCopyEvents() {
-  return WaitEvents.empty() ? std::make_tuple(0, nullptr)
-                            : std::make_tuple(1, &WaitEvents.back());
-}
-
-std::tuple<size_t, ze_event_handle_t *>
-L0AsyncOrderedQueueTy::getLaunchKernelEvents() {
-  return WaitEvents.empty() ? std::make_tuple(0, nullptr)
-                            : std::make_tuple(1, &WaitEvents.back());
-}
-
-Error L0AsyncOrderedQueueTy::hostCallImpl(void (*Callback)(void *),
-                                          void *UserData) {
-  return Plugin::error(ErrorCode::UNIMPLEMENTED,
-                       "Host function callbacks are not yet implemented for "
-                       "ordered async queues");
-}
-
 // L0InorderQueueTy implementation.
 Error L0InorderQueueTy::synchronizeImpl() { return CmdList->hostSynchronize(); }
 
@@ -518,12 +257,6 @@ Expected<L0QueueTy *> L0QueueCacheTy::getQueue(L0DeviceTy &Device) {
   }
   L0QueueTy *Queue = nullptr;
   switch (Device.getPlugin().getOptions().CommandMode) {
-  case CommandModeTy::Async:
-    Queue = new L0AsyncQueueTy(Device);
-    break;
-  case CommandModeTy::AsyncOrdered:
-    Queue = new L0AsyncOrderedQueueTy(Device);
-    break;
   case CommandModeTy::Sync:
     Queue = new L0SyncQueueTy(Device);
     break;

``````````

</details>


https://github.com/llvm/llvm-project/pull/222267


More information about the llvm-commits mailing list