[llvm] [OFFLOAD][L0] Use counter-based events for inorder queues (PR #202301)

[via llvm-commits]

llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-offload

Author: Alex Duran (adurang)

<details>
<summary>Changes</summary>

Inorder queues can use counter-based events which have better performance and provide early-reused semantics.

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


3 Files Affected:

- (modified) offload/plugins-nextgen/level_zero/include/L0Event.h (+11-3) 
- (modified) offload/plugins-nextgen/level_zero/src/L0Context.cpp (+13-1) 
- (modified) offload/plugins-nextgen/level_zero/src/L0Event.cpp (+3-2) 


``````````diff
diff --git a/offload/plugins-nextgen/level_zero/include/L0Event.h b/offload/plugins-nextgen/level_zero/include/L0Event.h
index 82361e4c74200..2ea729c821963 100644
--- a/offload/plugins-nextgen/level_zero/include/L0Event.h
+++ b/offload/plugins-nextgen/level_zero/include/L0Event.h
@@ -33,9 +33,10 @@ class L0EventTy {
   ze_event_handle_t getZeEvent() const { return ZeEvent; }
   L0QueueTy *getQueue() const { return Queue; }
 
-  Error reset() {
+  Error reset(bool SkipEventReset) {
     Queue = nullptr;
-    CALL_ZE_RET_ERROR(zeEventHostReset, ZeEvent);
+    if (!SkipEventReset)
+      CALL_ZE_RET_ERROR(zeEventHostReset, ZeEvent);
     return Plugin::success();
   }
 
@@ -71,6 +72,9 @@ class EventPoolTy {
   /// Additional event pool flags common to this pool.
   uint32_t Flags = 0;
 
+  /// Whether counter-based events are being used (don't need reset).
+  bool UseCounterBasedEvents = false;
+
   /// Protection.
   std::unique_ptr<std::mutex> Mtx;
 
@@ -89,9 +93,13 @@ class EventPoolTy {
 
 public:
   /// Initialize context, flags, and mutex.
-  Error init(ze_context_handle_t ContextIn, uint32_t FlagsIn) {
+  Error init(ze_context_handle_t ContextIn, bool UseCounterBased,
+             uint32_t FlagsIn) {
     Context = ContextIn;
     Flags = FlagsIn;
+    UseCounterBasedEvents = UseCounterBased;
+    if (UseCounterBasedEvents)
+      Flags |= ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
     Mtx.reset(new std::mutex);
     return Plugin::success();
   }
diff --git a/offload/plugins-nextgen/level_zero/src/L0Context.cpp b/offload/plugins-nextgen/level_zero/src/L0Context.cpp
index b9c2c97ce31fd..4fe0aa34ecbaf 100644
--- a/offload/plugins-nextgen/level_zero/src/L0Context.cpp
+++ b/offload/plugins-nextgen/level_zero/src/L0Context.cpp
@@ -28,7 +28,19 @@ Error L0ContextTy::init() {
 
   ze_context_desc_t Desc{ZE_STRUCTURE_TYPE_CONTEXT_DESC, nullptr, 0};
   CALL_ZE_RET_ERROR(zeContextCreate, zeDriver, &Desc, &zeContext);
-  if (auto Err = EventPool.init(zeContext, 0)) {
+
+  const auto &Options = Plugin.getOptions();
+  bool UseCounterBasedEvents = Options.CommandMode == CommandModeTy::InOrder ||
+                               Options.CommandMode == CommandModeTy::Sync;
+  if (UseCounterBasedEvents)
+    ODBG(OLDT_Init) << "Using counter-based events for "
+                    << (Options.CommandMode == CommandModeTy::InOrder
+                            ? "InOrder"
+                            : "Sync")
+                    << " command mode";
+
+  if (auto Err = EventPool.init(zeContext, UseCounterBasedEvents,
+                                /* Flags */ 0)) {
     cleanupOnError();
     return Err;
   }
diff --git a/offload/plugins-nextgen/level_zero/src/L0Event.cpp b/offload/plugins-nextgen/level_zero/src/L0Event.cpp
index cb70df71da74d..010c5ba1e0921 100644
--- a/offload/plugins-nextgen/level_zero/src/L0Event.cpp
+++ b/offload/plugins-nextgen/level_zero/src/L0Event.cpp
@@ -62,7 +62,8 @@ Expected<ze_event_handle_t> EventPoolTy::getEventLocked() {
 /// Return an event to the pool.
 Error EventPoolTy::releaseEvent(ze_event_handle_t Event) {
   std::lock_guard<std::mutex> Lock(*Mtx);
-  CALL_ZE_RET_ERROR(zeEventHostReset, Event);
+  if (!UseCounterBasedEvents)
+    CALL_ZE_RET_ERROR(zeEventHostReset, Event);
   Events.push_back(Event);
   return Plugin::success();
 }
@@ -80,7 +81,7 @@ Expected<L0EventTy *> EventPoolTy::getEventObject() {
   }
 
   auto *Ret = EventObjects.back();
-  if (auto Err = Ret->reset())
+  if (auto Err = Ret->reset(/* SkipEventReset */ UseCounterBasedEvents))
     return std::move(Err);
 
   EventObjects.pop_back();

``````````

</details>


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