add fallback to provider_normal

Signed-off-by: Mateusz P. Nowak <[email protected]>

Author: mateuszpn

unified-runtime/source/adapters/level_zero/v2/context.cpp

@@ -86,20 +86,20 @@ ur_context_handle_t_::ur_context_handle_t_(ze_context_handle_t hContext,
             auto device = platform->getDeviceById(deviceId);
 
             // TODO: just use per-context id?
-            return std::make_unique<v2::provider_counter>(
-                platform, context, v2::QUEUE_IMMEDIATE, device, flags);
+            return v2::createProvider(platform, context, v2::QUEUE_IMMEDIATE,
+                                      device, flags);
+          }),
+      eventPoolCacheRegular(
+          this, phDevices[0]->Platform->getNumDevices(),
+          [context = this, platform = phDevices[0]->Platform](
+              DeviceId deviceId,
+              v2::event_flags_t flags) -> std::unique_ptr<v2::event_provider> {
+            auto device = platform->getDeviceById(deviceId);
+
+            // TODO: just use per-context id?
+            return v2::createProvider(platform, context, v2::QUEUE_REGULAR,
+                                      device, flags);
           }),
-      eventPoolCacheRegular(this, phDevices[0]->Platform->getNumDevices(),
-                            [context = this, platform = phDevices[0]->Platform](
-                                DeviceId deviceId, v2::event_flags_t flags)
-                                -> std::unique_ptr<v2::event_provider> {
-                              std::ignore = deviceId;
-                              std::ignore = platform;
-
-                              // TODO: just use per-context id?
-                              return std::make_unique<v2::provider_normal>(
-                                  context, v2::QUEUE_REGULAR, flags);
-                            }),
       nativeEventsPool(this, std::make_unique<v2::provider_normal>(
                                  this, v2::QUEUE_IMMEDIATE,
                                  v2::EVENT_FLAGS_PROFILING_ENABLED)),

unified-runtime/source/adapters/level_zero/v2/event_provider_counter.cpp

@@ -13,6 +13,7 @@
 #include "context.hpp"
 #include "event_provider.hpp"
 #include "event_provider_counter.hpp"
+#include "event_provider_normal.hpp"
 #include "loader/ze_loader.h"
 
 #include "../device.hpp"
@@ -28,9 +29,15 @@ provider_counter::provider_counter(ur_platform_handle_t platform,
     : queueType(queueType), flags(flags) {
   assert(flags & EVENT_FLAGS_COUNTER);
 
-  ZE2UR_CALL_THROWS(zeDriverGetExtensionFunctionAddress,
-                    (platform->ZeDriver, "zexCounterBasedEventCreate2",
-                     (void **)&this->eventCreateFunc));
+  // Try to get the counter-based event extension function
+  auto result =
+      ZE_CALL_NOCHECK(zeDriverGetExtensionFunctionAddress,
+                      (platform->ZeDriver, "zexCounterBasedEventCreate2",
+                       (void **)&this->eventCreateFunc));
+  if (result != ZE_RESULT_SUCCESS) {
+    throw ur_result_t(ze2urResult(result));
+  }
+
   ZE2UR_CALL_THROWS(zelLoaderTranslateHandle,
                     (ZEL_HANDLE_CONTEXT, context->getZeHandle(),
                      (void **)&translatedContext));
@@ -88,4 +95,21 @@ raii::cache_borrowed_event provider_counter::allocate() {
 
 event_flags_t provider_counter::eventFlags() const { return flags; }
 
+std::unique_ptr<event_provider> createProvider(ur_platform_handle_t platform,
+                                               ur_context_handle_t context,
+                                               queue_type queueType,
+                                               ur_device_handle_t device,
+                                               event_flags_t flags) {
+  // Try to create a counter-based event provider first
+  try {
+    return std::make_unique<provider_counter>(platform, context, queueType,
+                                              device, flags);
+  } catch (...) {
+    // If counter-based events are not supported, fall back to normal events
+    // Remove the counter flag as the normal provider doesn't support it
+    event_flags_t normalFlags = flags & ~EVENT_FLAGS_COUNTER;
+    return std::make_unique<provider_normal>(context, queueType, normalFlags);
+  }
+}
+
 } // namespace v2

unified-runtime/source/adapters/level_zero/v2/event_provider_counter.hpp

@@ -54,4 +54,12 @@ class provider_counter : public event_provider {
   std::vector<raii::ze_event_handle_t> freelist;
 };
 
+// Factory function that creates a counter-based provider with fallback to
+// normal provider
+std::unique_ptr<event_provider> createProvider(ur_platform_handle_t platform,
+                                               ur_context_handle_t context,
+                                               queue_type queueType,
+                                               ur_device_handle_t device,
+                                               event_flags_t flags);
+
 } // namespace v2