[L0] avoid using pointers into event cache related vectors

Author: pbalcer

source/adapters/level_zero/context.hpp

@@ -142,8 +142,7 @@ struct ur_context_handle_t_ : _ur_object {
   //
   // Cache of event pools to which host-visible events are added to.
   std::vector<std::list<ze_event_pool_handle_t>> ZeEventPoolCache{4};
-  std::vector<std::unordered_map<ze_device_handle_t,
-                                 std::list<ze_event_pool_handle_t> *>>
+  std::vector<std::unordered_map<ze_device_handle_t, size_t>>
       ZeEventPoolCacheDeviceMap{4};
 
   // This map will be used to determine if a pool is full or not
@@ -165,9 +164,9 @@ struct ur_context_handle_t_ : _ur_object {
   ur_mutex EventCacheMutex;
 
   // Caches for events.
-  std::vector<std::list<ur_event_handle_t>> EventCaches{4};
-  std::vector<
-      std::unordered_map<ur_device_handle_t, std::list<ur_event_handle_t> *>>
+  using EventCache = std::vector<std::list<ur_event_handle_t>>;
+  EventCache EventCaches{4};
+  std::vector<std::unordered_map<ur_device_handle_t, size_t>>
       EventCachesDeviceMap{4};
 
   // Initialize the PI context.
@@ -205,18 +204,20 @@ struct ur_context_handle_t_ : _ur_object {
   // Add ur_event_handle_t to cache.
   void addEventToContextCache(ur_event_handle_t);
 
-  auto getZeEventPoolCache(bool HostVisible, bool WithProfiling,
-                           ze_device_handle_t ZeDevice) {
+  std::list<ze_event_pool_handle_t> *
+  getZeEventPoolCache(bool HostVisible, bool WithProfiling,
+                      ze_device_handle_t ZeDevice) {
     if (HostVisible) {
       if (ZeDevice) {
         auto ZeEventPoolCacheMap = WithProfiling
                                        ? &ZeEventPoolCacheDeviceMap[0]
                                        : &ZeEventPoolCacheDeviceMap[1];
         if (ZeEventPoolCacheMap->find(ZeDevice) == ZeEventPoolCacheMap->end()) {
           ZeEventPoolCache.emplace_back();
-          (*ZeEventPoolCacheMap)[ZeDevice] = &ZeEventPoolCache.back();
+          ZeEventPoolCacheMap->insert(
+              std::make_pair(ZeDevice, ZeEventPoolCache.size() - 1));
         }
-        return (*ZeEventPoolCacheMap)[ZeDevice];
+        return &ZeEventPoolCache[(*ZeEventPoolCacheMap)[ZeDevice]];
       } else {
         return WithProfiling ? &ZeEventPoolCache[0] : &ZeEventPoolCache[1];
       }
@@ -227,9 +228,10 @@ struct ur_context_handle_t_ : _ur_object {
                                        : &ZeEventPoolCacheDeviceMap[3];
         if (ZeEventPoolCacheMap->find(ZeDevice) == ZeEventPoolCacheMap->end()) {
           ZeEventPoolCache.emplace_back();
-          (*ZeEventPoolCacheMap)[ZeDevice] = &ZeEventPoolCache.back();
+          ZeEventPoolCacheMap->insert(
+              std::make_pair(ZeDevice, ZeEventPoolCache.size() - 1));
         }
-        return (*ZeEventPoolCacheMap)[ZeDevice];
+        return &ZeEventPoolCache[(*ZeEventPoolCacheMap)[ZeDevice]];
       } else {
         return WithProfiling ? &ZeEventPoolCache[2] : &ZeEventPoolCache[3];
       }
@@ -280,9 +282,10 @@ struct ur_context_handle_t_ : _ur_object {
             WithProfiling ? &EventCachesDeviceMap[0] : &EventCachesDeviceMap[1];
         if (EventCachesMap->find(Device) == EventCachesMap->end()) {
           EventCaches.emplace_back();
-          (*EventCachesMap)[Device] = &EventCaches.back();
+          EventCachesMap->insert(
+              std::make_pair(Device, EventCaches.size() - 1));
         }
-        return (*EventCachesMap)[Device];
+        return &EventCaches[(*EventCachesMap)[Device]];
       } else {
         return WithProfiling ? &EventCaches[0] : &EventCaches[1];
       }
@@ -292,9 +295,10 @@ struct ur_context_handle_t_ : _ur_object {
             WithProfiling ? &EventCachesDeviceMap[2] : &EventCachesDeviceMap[3];
         if (EventCachesMap->find(Device) == EventCachesMap->end()) {
           EventCaches.emplace_back();
-          (*EventCachesMap)[Device] = &EventCaches.back();
+          EventCachesMap->insert(
+              std::make_pair(Device, EventCaches.size() - 1));
         }
-        return (*EventCachesMap)[Device];
+        return &EventCaches[(*EventCachesMap)[Device]];
       } else {
         return WithProfiling ? &EventCaches[2] : &EventCaches[3];
       }

source/adapters/level_zero/queue.cpp

@@ -1273,9 +1273,9 @@ ur_result_t ur_queue_handle_t_::addEventToQueueCache(ur_event_handle_t Event) {
                                                  : &EventCachesDeviceMap[1];
     if (EventCachesMap->find(Device) == EventCachesMap->end()) {
       EventCaches.emplace_back();
-      (*EventCachesMap)[Device] = &EventCaches.back();
+      EventCachesMap->insert(std::make_pair(Device, EventCaches.size() - 1));
     }
-    (*EventCachesMap)[Device]->emplace_back(Event);
+    EventCaches[EventCachesMap->at(Device)].emplace_back(Event);
   } else {
     auto Cache = Event->isHostVisible() ? &EventCaches[0] : &EventCaches[1];
     Cache->emplace_back(Event);
@@ -1301,9 +1301,11 @@ ur_result_t urQueueReleaseInternal(ur_queue_handle_t Queue) {
   if (!UrQueue->RefCount.decrementAndTest())
     return UR_RESULT_SUCCESS;
 
-  for (auto &Cache : UrQueue->EventCaches)
+  for (auto &Cache : UrQueue->EventCaches) {
     for (auto &Event : Cache)
       UR_CALL(urEventReleaseInternal(Event));
+    Cache.clear();
+  }
 
   if (UrQueue->OwnZeCommandQueue) {
     for (auto &QueueMap :
@@ -1462,8 +1464,8 @@ ur_event_handle_t ur_queue_handle_t_::getEventFromQueueCache(bool IsMultiDevice,
 
   if (!IsMultiDevice) {
     auto Device = this->Device;
-    Cache = HostVisible ? EventCachesDeviceMap[0][Device]
-                        : EventCachesDeviceMap[1][Device];
+    Cache = HostVisible ? &EventCaches[EventCachesDeviceMap[0][Device]]
+                        : &EventCaches[EventCachesDeviceMap[1][Device]];
     if (!Cache) {
       return nullptr;
     }

source/adapters/level_zero/queue.hpp

@@ -343,8 +343,7 @@ struct ur_queue_handle_t_ : _ur_object {
   // inside all command lists in the queue as described in the 2-event model.
   // Leftover events in the cache are relased at the queue destruction.
   std::vector<std::list<ur_event_handle_t>> EventCaches{2};
-  std::vector<
-      std::unordered_map<ur_device_handle_t, std::list<ur_event_handle_t> *>>
+  std::vector<std::unordered_map<ur_device_handle_t, size_t>>
       EventCachesDeviceMap{2};
 
   // adjust the queue's batch size, knowing that the current command list