[L0] fixes cache map insert and add enum to make code more readable

Signed-off-by: Winston Zhang <winston.zhang@intel.com>

Author: winstonzhang-intel

source/adapters/level_zero/context.hpp

@@ -311,62 +311,73 @@ struct ur_context_handle_t_ : _ur_object {
   ze_context_handle_t getZeHandle() const;
 
 private:
+  enum EventCacheType {
+    HostVisibleProfilingCacheType,
+    HostVisibleRegularCacheType,
+    HostInvisibleProfilingCacheType,
+    HostInvisibleRegularCacheType,
+    CounterBasedRegularCacheType,
+    CounterBasedImmediateCacheType
+  };
   // Get the cache of events for a provided scope and profiling mode.
   auto getEventCache(bool HostVisible, bool WithProfiling,
                      ur_device_handle_t Device) {
     if (HostVisible) {
       if (Device) {
         auto EventCachesMap =
-            WithProfiling ? &EventCachesDeviceMap[0] : &EventCachesDeviceMap[1];
+            WithProfiling ? &EventCachesDeviceMap[HostVisibleProfilingCacheType]
+                          : &EventCachesDeviceMap[HostVisibleRegularCacheType];
         if (EventCachesMap->find(Device) == EventCachesMap->end()) {
           EventCaches.emplace_back();
-          EventCachesMap->insert(
-              std::make_pair(Device, EventCaches.size() - 1));
+          EventCaches.insert(std::make_pair(Device, EventCaches.size() - 1));
         }
         return &EventCaches[(*EventCachesMap)[Device]];
       } else {
-        return WithProfiling ? &EventCaches[0] : &EventCaches[1];
+        return WithProfiling ? &EventCaches[HostVisibleProfilingCacheType]
+                             : &EventCaches[HostVisibleRegularCacheType];
       }
     } else {
       if (Device) {
         auto EventCachesMap =
-            WithProfiling ? &EventCachesDeviceMap[2] : &EventCachesDeviceMap[3];
+            WithProfiling
+                ? &EventCachesDeviceMap[HostInvisibleProfilingCacheType]
+                : &EventCachesDeviceMap[HostInvisibleRegularCacheType];
         if (EventCachesMap->find(Device) == EventCachesMap->end()) {
           EventCaches.emplace_back();
-          EventCachesMap->insert(
-              std::make_pair(Device, EventCaches.size() - 1));
+          EventCaches.insert(std::make_pair(Device, EventCaches.size() - 1));
         }
         return &EventCaches[(*EventCachesMap)[Device]];
       } else {
-        return WithProfiling ? &EventCaches[2] : &EventCaches[3];
+        return WithProfiling ? &EventCaches[HostInvisibleProfilingCacheType]
+                             : &EventCaches[HostInvisibleRegularCacheType];
       }
     }
   };
   auto getCounterBasedEventCache(bool UsingImmediateCmdList,
                                  ur_device_handle_t Device) {
     if (UsingImmediateCmdList) {
       if (Device) {
-        auto EventCachesMap = &EventCachesDeviceMap[4];
+        auto EventCachesMap =
+            &EventCachesDeviceMap[CounterBasedImmediateCacheType];
         if (EventCachesMap->find(Device) == EventCachesMap->end()) {
           EventCaches.emplace_back();
-          EventCachesMap->insert(
-              std::make_pair(Device, EventCaches.size() - 1));
+          EventCaches.insert(std::make_pair(Device, EventCaches.size() - 1));
         }
         return &EventCaches[(*EventCachesMap)[Device]];
       } else {
-        return &EventCaches[4];
+        return &EventCaches[CounterBasedImmediateCacheType];
       }
     } else {
       if (Device) {
-        auto EventCachesMap = &EventCachesDeviceMap[5];
+        auto EventCachesMap =
+            &EventCachesDeviceMap[CounterBasedRegularCacheType];
         if (EventCachesMap->find(Device) == EventCachesMap->end()) {
           EventCaches.emplace_back();
-          EventCachesMap->insert(
-              std::make_pair(Device, EventCaches.size() - 1));
+          EventCaches.insert(std::make_pair(Device, EventCaches.size() - 1));
         }
         return &EventCaches[(*EventCachesMap)[Device]];
       } else {
-        return &EventCaches[5];
+        return &EventCaches[CounterBasedRegularCacheType];
       }
     }
   }

source/adapters/level_zero/event.cpp

@@ -833,7 +833,7 @@ urEventRetain(ur_event_handle_t Event ///< [in] handle of the event object
 ur_result_t
 urEventRelease(ur_event_handle_t Event ///< [in] handle of the event object
 ) {
-  if (Event->CounterBasedEventsEnabled && --Event->RefCountExternal == 0) {
+  if (--Event->RefCountExternal == 0 && Event->CounterBasedEventsEnabled) {
     Event->Context->addEventToContextCache(Event);
   } else {
     UR_CALL(urEventReleaseInternal(Event));