[L0] uint_32 change

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

Author: winstonzhang-intel

source/adapters/level_zero/common.hpp

@@ -218,13 +218,14 @@ enum {
   UrL0SerializeBlock =
       2, // blocking UR calls, where supported (usually in enqueue commands)
 };
-typedef enum {
-  COUNTER_BASED = 1 << 0,
-  USING_IMM_CMDLIST = 1 << 1,
-  HOST_VISIBLE = 1 << 2,
-  ENABLE_PROFILER = 1 << 3,
-  MULTIDEVICE = 1 << 4
-} EventFlags;
+typedef uint32_t ur_event_flags_t;
+typedef enum ur_event_flag_t {
+  COUNTER_BASED = UR_BIT(0),
+  USING_IMM_CMDLIST = UR_BIT(1),
+  HOST_VISIBLE = UR_BIT(2),
+  ENABLE_PROFILER = UR_BIT(3),
+  MULTIDEVICE = UR_BIT(4)
+} ur_event_flag_t;
 
 static const uint32_t UrL0Serialize = [] {
   const char *ZeSerializeMode = std::getenv("ZE_SERIALIZE");

source/adapters/level_zero/context.cpp

@@ -470,7 +470,7 @@ static const uint32_t MaxNumEventsPerPool = [] {
 }();
 
 ur_result_t ur_context_handle_t_::getFreeSlotInExistingOrNewPool(
-    ze_event_pool_handle_t &Pool, size_t &Index, EventFlags Flags,
+    ze_event_pool_handle_t &Pool, size_t &Index, enum ur_event_flag_t Flags,
     ur_device_handle_t Device) {
   // Lock while updating event pool machinery.
   std::scoped_lock<ur_mutex> Lock(ZeEventPoolCacheMutex);
@@ -552,7 +552,7 @@ ur_result_t ur_context_handle_t_::getFreeSlotInExistingOrNewPool(
 }
 
 ur_event_handle_t
-ur_context_handle_t_::getEventFromContextCache(EventFlags Flags,
+ur_context_handle_t_::getEventFromContextCache(enum ur_event_flag_t Flags,
                                                ur_device_handle_t Device) {
   std::scoped_lock<ur_mutex> Lock(EventCacheMutex);
   auto Cache = getEventCache(Flags, Device);
@@ -578,7 +578,7 @@ void ur_context_handle_t_::addEventToContextCache(ur_event_handle_t Event) {
     Device = Event->UrQueue->Device;
   }
 
-  EventFlags Flags = static_cast<EventFlags>(
+  enum ur_event_flag_t Flags = static_cast<enum ur_event_flag_t>(
       Event->isHostVisible()            ? HOST_VISIBLE
       : 0 | Event->isProfilingEnabled() ? ENABLE_PROFILER
                                         : 0);
@@ -605,7 +605,7 @@ ur_context_handle_t_::decrementUnreleasedEventsInPool(ur_event_handle_t Event) {
     ZeDevice = Event->UrQueue->Device->ZeDevice;
   }
 
-  EventFlags Flags = static_cast<EventFlags>(
+  enum ur_event_flag_t Flags = static_cast<enum ur_event_flag_t>(
       Event->isHostVisible()                 ? HOST_VISIBLE
       : 0 | Event->isProfilingEnabled()      ? ENABLE_PROFILER
       : 0 | Event->CounterBasedEventsEnabled ? COUNTER_BASED

source/adapters/level_zero/context.hpp

@@ -197,11 +197,11 @@ 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 &,
-                                             EventFlags Flags,
+                                             enum ur_event_flag_t Flags,
                                              ur_device_handle_t Device);
 
   // Get ur_event_handle_t from cache.
-  ur_event_handle_t getEventFromContextCache(EventFlags Flags,
+  ur_event_handle_t getEventFromContextCache(enum ur_event_flag_t Flags,
                                              ur_device_handle_t Device);
 
   // Add ur_event_handle_t to cache.
@@ -217,7 +217,7 @@ struct ur_context_handle_t_ : _ur_object {
   };
 
   std::list<ze_event_pool_handle_t> *
-  getZeEventPoolCache(EventFlags Flags, ze_device_handle_t ZeDevice) {
+  getZeEventPoolCache(enum ur_event_flag_t Flags, ze_device_handle_t ZeDevice) {
     EventPoolCacheType CacheType;
 
     calculateCacheIndex(Flags, CacheType);
@@ -238,7 +238,7 @@ struct ur_context_handle_t_ : _ur_object {
     }
   }
 
-  ur_result_t calculateCacheIndex(EventFlags Flags,
+  ur_result_t calculateCacheIndex(enum ur_event_flag_t Flags,
                                   EventPoolCacheType &CacheType) {
     if (Flags & COUNTER_BASED && Flags & HOST_VISIBLE &&
         !(Flags & USING_IMM_CMDLIST)) {
@@ -296,7 +296,7 @@ struct ur_context_handle_t_ : _ur_object {
 
 private:
   // Get the cache of events for a provided scope and profiling mode.
-  auto getEventCache(EventFlags Flags, ur_device_handle_t Device) {
+  auto getEventCache(enum ur_event_flag_t Flags, ur_device_handle_t Device) {
     if (Flags & HOST_VISIBLE) {
       if (Device) {
         auto EventCachesMap = Flags & ENABLE_PROFILER

source/adapters/level_zero/event.cpp

@@ -1230,7 +1230,7 @@ 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;
-  EventFlags Flags = static_cast<EventFlags>(
+  enum ur_event_flag_t Flags = static_cast<enum ur_event_flag_t>(
       ProfilingEnabled                 ? ENABLE_PROFILER
       : 0 | UsingImmediateCommandlists ? USING_IMM_CMDLIST
       : 0 | HostVisible                ? HOST_VISIBLE

source/adapters/level_zero/event.hpp

@@ -132,7 +132,7 @@ struct ur_event_handle_t_ : _ur_object {
     OwnNativeHandle = OwnZeEvent;
   }
 
-  EventFlags flags;
+  enum ur_event_flag_t flags;
   // Level Zero event handle.
   ze_event_handle_t ZeEvent;