[L0] Consolidated event_flags into v2/event_provider.hpp

Signed-off-by: Zhang, Winston <[email protected]>

Author: winstonzhang-intel

source/adapters/level_zero/common.hpp

@@ -240,18 +240,6 @@ enum {
       2, // blocking UR calls, where supported (usually in enqueue commands)
 };
 
-using ur_event_flags_t = uint32_t;
-enum ur_event_flag_t {
-  EVENT_FLAG_HOST_VISIBLE = UR_BIT(0),
-  EVENT_FLAG_WITH_PROFILING = UR_BIT(1),
-  EVENT_FLAG_COUNTER = UR_BIT(2),
-  EVENT_FLAG_INTERRUPT = UR_BIT(3),
-  EVENT_FLAG_IMM_CMDLIST = UR_BIT(4),
-  EVENT_FLAG_MULTIDEVICE = UR_BIT(6),
-  EVENT_FLAG_DEVICE = UR_BIT(7), // if set, subsequent bits are device id
-  MAX_EVENT_FLAG_BITS = 8,
-};
-
 static const uint32_t UrL0Serialize = [] {
   const char *ZeSerializeMode = std::getenv("ZE_SERIALIZE");
   const char *UrL0SerializeMode = std::getenv("UR_L0_SERIALIZE");

source/adapters/level_zero/context.cpp

@@ -494,7 +494,7 @@ static const uint32_t MaxNumEventsPerPool = [] {
 }();
 
 ur_result_t ur_context_handle_t_::getFreeSlotInExistingOrNewPool(
-    ze_event_pool_handle_t &Pool, size_t &Index, ur_event_flags_t Flags,
+    ze_event_pool_handle_t &Pool, size_t &Index, v2::event_flags_t Flags,
     ur_device_handle_t Device) {
   // Lock while updating event pool machinery.
   std::scoped_lock<ur_mutex> Lock(ZeEventPoolCacheMutex);
@@ -543,14 +543,14 @@ ur_result_t ur_context_handle_t_::getFreeSlotInExistingOrNewPool(
     ZeEventPoolDesc.count = MaxNumEventsPerPool;
     ZeEventPoolDesc.flags = 0;
     ZeEventPoolDesc.pNext = nullptr;
-    if (Flags & EVENT_FLAG_HOST_VISIBLE)
+    if (Flags & v2::EVENT_FLAGS_HOST_VISIBLE)
       ZeEventPoolDesc.flags |= ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
-    if (Flags & EVENT_FLAG_WITH_PROFILING)
+    if (Flags & v2::EVENT_FLAGS_PROFILING_ENABLED)
       ZeEventPoolDesc.flags |= ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
     logger::debug("ze_event_pool_desc_t flags set to: {}",
                   ZeEventPoolDesc.flags);
-    if (Flags & EVENT_FLAG_COUNTER) {
-      if (Flags & EVENT_FLAG_IMM_CMDLIST) {
+    if (Flags & v2::EVENT_FLAGS_COUNTER) {
+      if (Flags & v2::EVENT_FLAGS_IMM_CMDLIST) {
         counterBasedExt.flags = ZE_EVENT_POOL_COUNTER_BASED_EXP_FLAG_IMMEDIATE;
       } else {
         counterBasedExt.flags =
@@ -590,16 +590,17 @@ ur_result_t ur_context_handle_t_::getFreeSlotInExistingOrNewPool(
 }
 
 ur_event_handle_t
-ur_context_handle_t_::getEventFromContextCache(ur_event_flags_t Flags,
+ur_context_handle_t_::getEventFromContextCache(v2::event_flags_t Flags,
                                                ur_device_handle_t Device) {
   std::scoped_lock<ur_mutex> Lock(EventCacheMutex);
   auto Cache = getEventCache(Flags, Device);
   if (Cache->empty()) {
-    logger::info(
-        "Cache empty (Host Visible: {}, Profiling: {}, Counter: {}, "
-        "Interrupt: {}, Device: {})",
-        (Flags & EVENT_FLAG_HOST_VISIBLE), (Flags & EVENT_FLAG_WITH_PROFILING),
-        (Flags & EVENT_FLAG_COUNTER), (Flags & EVENT_FLAG_INTERRUPT), Device);
+    logger::info("Cache empty (Host Visible: {}, Profiling: {}, Counter: {}, "
+                 "Interrupt: {}, Device: {})",
+                 (Flags & v2::EVENT_FLAGS_HOST_VISIBLE),
+                 (Flags & v2::EVENT_FLAGS_PROFILING_ENABLED),
+                 (Flags & v2::EVENT_FLAGS_COUNTER),
+                 (Flags & v2::EVENT_FLAGS_INTERRUPT), Device);
     return nullptr;
   }
 
@@ -627,15 +628,15 @@ void ur_context_handle_t_::addEventToContextCache(ur_event_handle_t Event) {
     Device = Event->UrQueue->Device;
   }
 
-  ur_event_flags_t Flags = 0;
+  v2::event_flags_t Flags = 0;
   if (Event->HostVisibleEvent)
-    Flags |= EVENT_FLAG_HOST_VISIBLE;
+    Flags |= v2::EVENT_FLAGS_HOST_VISIBLE;
   if (Event->isProfilingEnabled())
-    Flags |= EVENT_FLAG_WITH_PROFILING;
+    Flags |= v2::EVENT_FLAGS_PROFILING_ENABLED;
   if (Event->CounterBasedEventsEnabled)
-    Flags |= EVENT_FLAG_COUNTER;
+    Flags |= v2::EVENT_FLAGS_COUNTER;
   if (Event->InterruptBasedEventsEnabled)
-    Flags |= EVENT_FLAG_INTERRUPT;
+    Flags |= v2::EVENT_FLAGS_INTERRUPT;
   auto Cache = getEventCache(Flags, Device);
   logger::info("Inserting {} event (Host Visible: {}, Profiling: {}, Counter: "
                "{}, Device: {}) into cache {}",
@@ -663,7 +664,7 @@ ur_context_handle_t_::decrementUnreleasedEventsInPool(ur_event_handle_t Event) {
     ZeDevice = Event->UrQueue->Device->ZeDevice;
   }
   if (UsingImmediateCommandlists)
-    Event->Flags |= EVENT_FLAG_IMM_CMDLIST;
+    Event->Flags |= v2::EVENT_FLAGS_IMM_CMDLIST;
 
   std::list<ze_event_pool_handle_t> *ZePoolCache =
       getZeEventPoolCache(Event->Flags, ZeDevice);

source/adapters/level_zero/context.hpp

@@ -22,6 +22,7 @@
 #include <ze_api.h>
 #include <zes_api.h>
 
+#include "./v2/event_provider.hpp"
 #include "common.hpp"
 #include "queue.hpp"
 
@@ -218,21 +219,21 @@ struct ur_context_handle_t_ : _ur_object {
   // slot for a host-visible event. The ProfilingEnabled tells is we need a
   // slot for an event with profiling capabilities.
   ur_result_t getFreeSlotInExistingOrNewPool(ze_event_pool_handle_t &, size_t &,
-                                             ur_event_flags_t Flags,
+                                             v2::event_flags_t Flags,
                                              ur_device_handle_t Device);
 
   // Get ur_event_handle_t from cache.
-  ur_event_handle_t getEventFromContextCache(ur_event_flags_t Flags,
+  ur_event_handle_t getEventFromContextCache(v2::event_flags_t Flags,
                                              ur_device_handle_t Device);
 
   // Add ur_event_handle_t to cache.
   void addEventToContextCache(ur_event_handle_t);
 
   std::list<ze_event_pool_handle_t> *
-  getZeEventPoolCache(ur_event_flags_t Flags, ze_device_handle_t ZeDevice) {
+  getZeEventPoolCache(v2::event_flags_t Flags, ze_device_handle_t ZeDevice) {
     size_t index = 0;
     index |= Flags;
-    bool WithProfiling = Flags & EVENT_FLAG_WITH_PROFILING;
+    bool WithProfiling = Flags & v2::EVENT_FLAGS_PROFILING_ENABLED;
 
     if (ZeDevice) {
       auto ZeEventPoolCacheMap =
@@ -296,12 +297,14 @@ struct ur_context_handle_t_ : _ur_object {
   std::vector<EventCache> EventCaches;
 
   // Get the cache of events for a provided scope and profiling mode.
-  EventCache *getEventCache(ur_event_flags_t Flags, ur_device_handle_t Device) {
+  EventCache *getEventCache(v2::event_flags_t Flags,
+                            ur_device_handle_t Device) {
 
     size_t index = 0;
     index |= Flags;
     if (Device) {
-      index |= EVENT_FLAG_DEVICE | (*Device->Id << MAX_EVENT_FLAG_BITS);
+      index |=
+          v2::EVENT_FLAGS_DEVICE | (*Device->Id << v2::MAX_EVENT_FLAG_BITS);
     }
 
     if (index >= EventCaches.size()) {

source/adapters/level_zero/event.cpp

@@ -1334,19 +1334,19 @@ ur_result_t EventCreate(ur_context_handle_t Context, ur_queue_handle_t Queue,
   bool ProfilingEnabled =
       ForceDisableProfiling ? false : (!Queue || Queue->isProfilingEnabled());
   bool UsingImmediateCommandlists = !Queue || Queue->UsingImmCmdLists;
-  ur_event_flags_t Flags = 0;
+  v2::event_flags_t Flags = 0;
   if (ProfilingEnabled)
-    Flags |= EVENT_FLAG_WITH_PROFILING;
+    Flags |= v2::EVENT_FLAGS_PROFILING_ENABLED;
   if (UsingImmediateCommandlists)
-    Flags |= EVENT_FLAG_IMM_CMDLIST;
+    Flags |= v2::EVENT_FLAGS_IMM_CMDLIST;
   if (HostVisible)
-    Flags |= EVENT_FLAG_HOST_VISIBLE;
+    Flags |= v2::EVENT_FLAGS_HOST_VISIBLE;
   if (IsMultiDevice)
-    Flags |= EVENT_FLAG_MULTIDEVICE;
+    Flags |= v2::EVENT_FLAGS_MULTIDEVICE;
   if (CounterBasedEventEnabled)
-    Flags |= EVENT_FLAG_COUNTER;
+    Flags |= v2::EVENT_FLAGS_COUNTER;
   if (InterruptBasedEventEnabled)
-    Flags |= EVENT_FLAG_INTERRUPT;
+    Flags |= v2::EVENT_FLAGS_INTERRUPT;
 
   ur_device_handle_t Device = nullptr;
 

source/adapters/level_zero/event.hpp

@@ -24,6 +24,7 @@
 #include <ze_api.h>
 #include <zes_api.h>
 
+#include "./v2/event_provider.hpp"
 #include "common.hpp"
 #include "queue.hpp"
 
@@ -139,7 +140,7 @@ struct ur_event_handle_t_ : _ur_object {
   // Level Zero event pool handle.
   ze_event_pool_handle_t ZeEventPool;
 
-  ur_event_flags_t Flags;
+  v2::event_flags_t Flags;
 
   // In case we use device-only events this holds their host-visible
   // counterpart. If this event is itself host-visble then HostVisibleEvent

source/adapters/level_zero/v2/event_provider.hpp

@@ -23,10 +23,16 @@ namespace v2 {
 
 using event_flags_t = uint32_t;
 enum event_flag_t {
-  EVENT_FLAGS_COUNTER = UR_BIT(0),
+  EVENT_FLAGS_HOST_VISIBLE = UR_BIT(0),
   EVENT_FLAGS_PROFILING_ENABLED = UR_BIT(1),
+  EVENT_FLAGS_COUNTER = UR_BIT(2),
+  EVENT_FLAGS_INTERRUPT = UR_BIT(3),
+  EVENT_FLAGS_IMM_CMDLIST = UR_BIT(4),
+  EVENT_FLAGS_MULTIDEVICE = UR_BIT(6),
+  EVENT_FLAGS_DEVICE = UR_BIT(7), // if set, subsequent bits are device id
+  MAX_EVENT_FLAG_BITS = 8,
 };
-static constexpr size_t EVENT_FLAGS_USED_BITS = 2;
+static constexpr size_t EVENT_FLAGS_USED_BITS = 9;
 
 class event_provider;