[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