Merge pull request #2408 from oneapi-src/v0.10.14rc

Candidate for the v0.10.14 release tag

Author: pbalcer

CMakeLists.txt

@@ -4,7 +4,7 @@
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 cmake_minimum_required(VERSION 3.20.0 FATAL_ERROR)
-project(unified-runtime VERSION 0.10.13)
+project(unified-runtime VERSION 0.10.14)
 
 # Check if unified runtime is built as a standalone project.
 if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR OR UR_STANDALONE_BUILD)

source/adapters/level_zero/context.cpp

@@ -561,18 +561,26 @@ ur_event_handle_t ur_context_handle_t_::getEventFromContextCache(
     bool HostVisible, bool WithProfiling, ur_device_handle_t Device,
     bool CounterBasedEventEnabled) {
   std::scoped_lock<ur_mutex> Lock(EventCacheMutex);
-  auto Cache = getEventCache(HostVisible, WithProfiling, Device);
-  if (Cache->empty())
+  auto Cache = getEventCache(HostVisible, WithProfiling, Device,
+                             CounterBasedEventEnabled);
+  if (Cache->empty()) {
+    logger::info("Cache empty (Host Visible: {}, Profiling: {}, Counter: {}, "
+                 "Device: {})",
+                 HostVisible, WithProfiling, CounterBasedEventEnabled, Device);
     return nullptr;
+  }
 
   auto It = Cache->begin();
   ur_event_handle_t Event = *It;
-  if (Event->CounterBasedEventsEnabled != CounterBasedEventEnabled) {
-    return nullptr;
-  }
   Cache->erase(It);
   // We have to reset event before using it.
   Event->reset();
+
+  logger::info("Using {} event (Host Visible: {}, Profiling: {}, Counter: {}, "
+               "Device: {}) from cache {}",
+               Event, Event->HostVisibleEvent, Event->isProfilingEnabled(),
+               Event->CounterBasedEventsEnabled, Device, Cache);
+
   return Event;
 }
 
@@ -584,8 +592,13 @@ void ur_context_handle_t_::addEventToContextCache(ur_event_handle_t Event) {
     Device = Legacy(Event->UrQueue)->Device;
   }
 
-  auto Cache = getEventCache(Event->isHostVisible(),
-                             Event->isProfilingEnabled(), Device);
+  auto Cache =
+      getEventCache(Event->isHostVisible(), Event->isProfilingEnabled(), Device,
+                    Event->CounterBasedEventsEnabled);
+  logger::info("Inserting {} event (Host Visible: {}, Profiling: {}, Counter: "
+               "{}, Device: {}) into cache {}",
+               Event, Event->HostVisibleEvent, Event->isProfilingEnabled(),
+               Event->CounterBasedEventsEnabled, Device, Cache);
   Cache->emplace_back(Event);
 }
 

source/adapters/level_zero/context.hpp

@@ -168,15 +168,6 @@ struct ur_context_handle_t_ : _ur_object {
   // holding the current pool usage counts.
   ur_mutex ZeEventPoolCacheMutex;
 
-  // Mutex to control operations on event caches.
-  ur_mutex EventCacheMutex;
-
-  // Caches for events.
-  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.
   ur_result_t initialize();
 
@@ -306,36 +297,45 @@ struct ur_context_handle_t_ : _ur_object {
   bool isValidDevice(ur_device_handle_t Device) const;
 
 private:
+  enum EventFlags {
+    EVENT_FLAG_HOST_VISIBLE = UR_BIT(0),
+    EVENT_FLAG_WITH_PROFILING = UR_BIT(1),
+    EVENT_FLAG_COUNTER = UR_BIT(2),
+    EVENT_FLAG_DEVICE = UR_BIT(3), // if set, subsequent bits are device id
+    MAX_EVENT_FLAG_BITS =
+        4, // this is used as an offset for embedding device id
+  };
+
+  // Mutex to control operations on event caches.
+  ur_mutex EventCacheMutex;
+
+  // Caches for events.
+  using EventCache = std::list<ur_event_handle_t>;
+  std::vector<EventCache> EventCaches;
+
   // Get the cache of events for a provided scope and profiling mode.
-  auto getEventCache(bool HostVisible, bool WithProfiling,
-                     ur_device_handle_t Device) {
+  EventCache *getEventCache(bool HostVisible, bool WithProfiling,
+                            ur_device_handle_t Device, bool Counter) {
+
+    size_t index = 0;
     if (HostVisible) {
-      if (Device) {
-        auto EventCachesMap =
-            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[0] : &EventCaches[1];
-      }
-    } else {
-      if (Device) {
-        auto EventCachesMap =
-            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[2] : &EventCaches[3];
-      }
+      index |= EVENT_FLAG_HOST_VISIBLE;
+    }
+    if (WithProfiling) {
+      index |= EVENT_FLAG_WITH_PROFILING;
     }
+    if (Counter) {
+      index |= EVENT_FLAG_COUNTER;
+    }
+    if (Device) {
+      index |= EVENT_FLAG_DEVICE | (*Device->Id << MAX_EVENT_FLAG_BITS);
+    }
+
+    if (index >= EventCaches.size()) {
+      EventCaches.resize(index + 1);
+    }
+
+    return &EventCaches[index];
   }
 };