Merge pull request #2113 from oneapi-src/revert-1698-counter-based-2

pbalcer · web-flow · commit 9ca3ec7a9c1d · 2024-09-23T10:58:51.000+02:00
Revert "[L0] Phase 2 of Counter-Based Event Implementation"
diff --git a/source/adapters/level_zero/context.cpp b/source/adapters/level_zero/context.cpp
@@ -560,12 +560,9 @@ ur_result_t ur_context_handle_t_::getFreeSlotInExistingOrNewPool(
 
 ur_event_handle_t ur_context_handle_t_::getEventFromContextCache(
     bool HostVisible, bool WithProfiling, ur_device_handle_t Device,
-    bool CounterBasedEventEnabled, bool UsingImmCmdList) {
+    bool CounterBasedEventEnabled) {
   std::scoped_lock<ur_mutex> Lock(EventCacheMutex);
   auto Cache = getEventCache(HostVisible, WithProfiling, Device);
-  if (CounterBasedEventEnabled) {
-    Cache = getCounterBasedEventCache(WithProfiling, UsingImmCmdList, Device);
-  }
   if (Cache->empty())
     return nullptr;
 
@@ -588,16 +585,9 @@ void ur_context_handle_t_::addEventToContextCache(ur_event_handle_t Event) {
     Device = Event->UrQueue->Device;
   }
 
-  if (Event->CounterBasedEventsEnabled) {
-    auto Cache = getCounterBasedEventCache(
-        Event->isProfilingEnabled(),
-        !(Event->UrQueue) || (Event->UrQueue)->UsingImmCmdLists, Device);
-    Cache->emplace_back(Event);
-  } else {
-    auto Cache = getEventCache(Event->isHostVisible(),
-                               Event->isProfilingEnabled(), Device);
-    Cache->emplace_back(Event);
-  }
+  auto Cache = getEventCache(Event->isHostVisible(),
+                             Event->isProfilingEnabled(), Device);
+  Cache->emplace_back(Event);
 }
 
 ur_result_t
diff --git a/source/adapters/level_zero/context.hpp b/source/adapters/level_zero/context.hpp
@@ -39,13 +39,6 @@ struct ur_context_handle_t_ : _ur_object {
       : ZeContext{ZeContext}, Devices{Devs, Devs + NumDevices},
         NumDevices{NumDevices} {
     OwnNativeHandle = OwnZeContext;
-    for (const auto &Device : Devices) {
-      for (int i = 0; i < EventCacheTypeCount; i++) {
-        EventCaches.emplace_back();
-        EventCachesDeviceMap[i].insert(
-            std::make_pair(Device, EventCaches.size() - 1));
-      }
-    }
   }
 
   ur_context_handle_t_(ze_context_handle_t ZeContext) : ZeContext{ZeContext} {}
@@ -154,10 +147,9 @@ struct ur_context_handle_t_ : _ur_object {
   // head.
   //
   // Cache of event pools to which host-visible events are added to.
-  std::vector<std::list<ze_event_pool_handle_t>> ZeEventPoolCache{
-      ZeEventPoolCacheTypeCount * 2};
+  std::vector<std::list<ze_event_pool_handle_t>> ZeEventPoolCache{12};
   std::vector<std::unordered_map<ze_device_handle_t, size_t>>
-      ZeEventPoolCacheDeviceMap{ZeEventPoolCacheTypeCount * 2};
+      ZeEventPoolCacheDeviceMap{12};
 
   // This map will be used to determine if a pool is full or not
   // by storing number of empty slots available in the pool.
@@ -179,9 +171,9 @@ struct ur_context_handle_t_ : _ur_object {
 
   // Caches for events.
   using EventCache = std::vector<std::list<ur_event_handle_t>>;
-  EventCache EventCaches{EventCacheTypeCount};
+  EventCache EventCaches{4};
   std::vector<std::unordered_map<ur_device_handle_t, size_t>>
-      EventCachesDeviceMap{EventCacheTypeCount};
+      EventCachesDeviceMap{4};
 
   // Initialize the PI context.
   ur_result_t initialize();
@@ -219,39 +211,25 @@ struct ur_context_handle_t_ : _ur_object {
   ur_event_handle_t getEventFromContextCache(bool HostVisible,
                                              bool WithProfiling,
                                              ur_device_handle_t Device,
-                                             bool CounterBasedEventEnabled,
-                                             bool UsingImmCmdList);
+                                             bool CounterBasedEventEnabled);
 
   // Add ur_event_handle_t to cache.
   void addEventToContextCache(ur_event_handle_t);
 
-  enum ZeEventPoolCacheType {
+  enum EventPoolCacheType {
     HostVisibleCacheType,
     HostInvisibleCacheType,
     HostVisibleCounterBasedRegularCacheType,
     HostInvisibleCounterBasedRegularCacheType,
     HostVisibleCounterBasedImmediateCacheType,
-    HostInvisibleCounterBasedImmediateCacheType,
-    ZeEventPoolCacheTypeCount
-  };
-
-  enum EventCacheType {
-    HostVisibleProfilingCacheType,
-    HostVisibleRegularCacheType,
-    HostInvisibleProfilingCacheType,
-    HostInvisibleRegularCacheType,
-    CounterBasedImmediateCacheType,
-    CounterBasedRegularCacheType,
-    CounterBasedImmediateProfilingCacheType,
-    CounterBasedRegularProfilingCacheType,
-    EventCacheTypeCount
+    HostInvisibleCounterBasedImmediateCacheType
   };
 
   std::list<ze_event_pool_handle_t> *
   getZeEventPoolCache(bool HostVisible, bool WithProfiling,
                       bool CounterBasedEventEnabled, bool UsingImmediateCmdList,
                       ze_device_handle_t ZeDevice) {
-    ZeEventPoolCacheType CacheType;
+    EventPoolCacheType CacheType;
 
     calculateCacheIndex(HostVisible, CounterBasedEventEnabled,
                         UsingImmediateCmdList, CacheType);
@@ -274,7 +252,7 @@ struct ur_context_handle_t_ : _ur_object {
   ur_result_t calculateCacheIndex(bool HostVisible,
                                   bool CounterBasedEventEnabled,
                                   bool UsingImmediateCmdList,
-                                  ZeEventPoolCacheType &CacheType) {
+                                  EventPoolCacheType &CacheType) {
     if (CounterBasedEventEnabled && HostVisible && !UsingImmediateCmdList) {
       CacheType = HostVisibleCounterBasedRegularCacheType;
     } else if (CounterBasedEventEnabled && !HostVisible &&
@@ -338,57 +316,34 @@ struct ur_context_handle_t_ : _ur_object {
     if (HostVisible) {
       if (Device) {
         auto EventCachesMap =
-            WithProfiling ? &EventCachesDeviceMap[HostVisibleProfilingCacheType]
-                          : &EventCachesDeviceMap[HostVisibleRegularCacheType];
-        return &EventCaches[(*EventCachesMap)[Device]];
-      } else {
-        return WithProfiling ? &EventCaches[HostVisibleProfilingCacheType]
-                             : &EventCaches[HostVisibleRegularCacheType];
-      }
-    } else {
-      if (Device) {
-        auto EventCachesMap =
-            WithProfiling
-                ? &EventCachesDeviceMap[HostInvisibleProfilingCacheType]
-                : &EventCachesDeviceMap[HostInvisibleRegularCacheType];
-        return &EventCaches[(*EventCachesMap)[Device]];
-      } else {
-        return WithProfiling ? &EventCaches[HostInvisibleProfilingCacheType]
-                             : &EventCaches[HostInvisibleRegularCacheType];
-      }
-    }
-  };
-  auto getCounterBasedEventCache(bool WithProfiling, bool UsingImmediateCmdList,
-                                 ur_device_handle_t Device) {
-    if (UsingImmediateCmdList) {
-      if (Device) {
-        auto EventCachesMap =
-            WithProfiling
-                ? &EventCachesDeviceMap[CounterBasedImmediateProfilingCacheType]
-                : &EventCachesDeviceMap[CounterBasedImmediateCacheType];
+            WithProfiling ? &EventCachesDeviceMap[0] : &EventCachesDeviceMap[1];
+        if (EventCachesMap->find(Device) == EventCachesMap->end()) {
+          EventCaches.emplace_back();
+          EventCachesMap->insert(
+              std::make_pair(Device, EventCaches.size() - 1));
+        }
         return &EventCaches[(*EventCachesMap)[Device]];
       } else {
-        return WithProfiling
-                   ? &EventCaches[CounterBasedImmediateProfilingCacheType]
-                   : &EventCaches[CounterBasedImmediateCacheType];
+        return WithProfiling ? &EventCaches[0] : &EventCaches[1];
       }
     } else {
       if (Device) {
         auto EventCachesMap =
-            WithProfiling
-                ? &EventCachesDeviceMap[CounterBasedRegularProfilingCacheType]
-                : &EventCachesDeviceMap[CounterBasedRegularCacheType];
+            WithProfiling ? &EventCachesDeviceMap[2] : &EventCachesDeviceMap[3];
+        if (EventCachesMap->find(Device) == EventCachesMap->end()) {
+          EventCaches.emplace_back();
+          EventCachesMap->insert(
+              std::make_pair(Device, EventCaches.size() - 1));
+        }
         return &EventCaches[(*EventCachesMap)[Device]];
       } else {
-        return WithProfiling
-                   ? &EventCaches[CounterBasedRegularProfilingCacheType]
-                   : &EventCaches[CounterBasedRegularCacheType];
+        return WithProfiling ? &EventCaches[2] : &EventCaches[3];
       }
     }
   }
 };
 
-// Helper function to release the context, a caller must lock the
-// platform-level mutex guarding the container with contexts because the
-// context can be removed from the list of tracked contexts.
+// Helper function to release the context, a caller must lock the platform-level
+// mutex guarding the container with contexts because the context can be removed
+// from the list of tracked contexts.
 ur_result_t ContextReleaseHelper(ur_context_handle_t Context);
diff --git a/source/adapters/level_zero/event.cpp b/source/adapters/level_zero/event.cpp
@@ -835,6 +835,7 @@ urEventRelease(ur_event_handle_t Event ///< [in] handle of the event object
 ) {
   Event->RefCountExternal--;
   UR_CALL(urEventReleaseInternal(Event));
+
   return UR_RESULT_SUCCESS;
 }
 
@@ -1256,8 +1257,7 @@ ur_result_t EventCreate(ur_context_handle_t Context, ur_queue_handle_t Queue,
   }
 
   if (auto CachedEvent = Context->getEventFromContextCache(
-          HostVisible, ProfilingEnabled, Device, CounterBasedEventEnabled,
-          UsingImmediateCommandlists)) {
+          HostVisible, ProfilingEnabled, Device, CounterBasedEventEnabled)) {
     *RetEvent = CachedEvent;
     return UR_RESULT_SUCCESS;
   }
diff --git a/source/adapters/level_zero/queue.cpp b/source/adapters/level_zero/queue.cpp
@@ -1187,7 +1187,7 @@ ur_queue_handle_t_::ur_queue_handle_t_(
     return std::atoi(UrRet) != 0;
   }();
   this->CounterBasedEventsEnabled =
-      isInOrderQueue() && Device->useDriverInOrderLists() &&
+      UsingImmCmdLists && isInOrderQueue() && Device->useDriverInOrderLists() &&
       useDriverCounterBasedEvents &&
       Device->Platform->ZeDriverEventPoolCountingEventsExtensionFound;
 }

Original file line number	Diff line number	Diff line change
`@@ -835,6 +835,7 @@ urEventRelease(ur_event_handle_t Event ///< [in] handle of the event object`
`835`	`835`	`) {`
`836`	`836`	`Event->RefCountExternal--;`
`837`	`837`	`UR_CALL(urEventReleaseInternal(Event));`
	`838`	`+`
`838`	`839`	`return UR_RESULT_SUCCESS;`
`839`	`840`	`}`
`840`	`841`
`@@ -1256,8 +1257,7 @@ ur_result_t EventCreate(ur_context_handle_t Context, ur_queue_handle_t Queue,`
`1256`	`1257`	`}`
`1257`	`1258`
`1258`	`1259`	`if (auto CachedEvent = Context->getEventFromContextCache(`
`1259`		`- HostVisible, ProfilingEnabled, Device, CounterBasedEventEnabled,`
`1260`		`- UsingImmediateCommandlists)) {`
	`1260`	`+ HostVisible, ProfilingEnabled, Device, CounterBasedEventEnabled)) {`
`1261`	`1261`	`*RetEvent = CachedEvent;`
`1262`	`1262`	`return UR_RESULT_SUCCESS;`
`1263`	`1263`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1187,7 +1187,7 @@ ur_queue_handle_t_::ur_queue_handle_t_(`
`1187`	`1187`	`return std::atoi(UrRet) != 0;`
`1188`	`1188`	`}();`
`1189`	`1189`	`this->CounterBasedEventsEnabled =`
`1190`		`- isInOrderQueue() && Device->useDriverInOrderLists() &&`
	`1190`	`+ UsingImmCmdLists && isInOrderQueue() && Device->useDriverInOrderLists() &&`
`1191`	`1191`	`useDriverCounterBasedEvents &&`
`1192`	`1192`	`Device->Platform->ZeDriverEventPoolCountingEventsExtensionFound;`
`1193`	`1193`	`}`