[L0 v2] event improvements

- Implement native handle API for events
- Always allocate events as multi-device when using provider_normal,
  as all events can be used on multiple devices

Author: igchor

source/adapters/level_zero/v2/api.cpp

@@ -181,21 +181,6 @@ ur_result_t urKernelGetSuggestedLocalWorkSize(ur_kernel_handle_t hKernel,
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t urEventGetNativeHandle(ur_event_handle_t hEvent,
-                                   ur_native_handle_t *phNativeEvent) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t
-urEventCreateWithNativeHandle(ur_native_handle_t hNativeEvent,
-                              ur_context_handle_t hContext,
-                              const ur_event_native_properties_t *pProperties,
-                              ur_event_handle_t *phEvent) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t urEventSetCallback(ur_event_handle_t hEvent,
                                ur_execution_info_t execStatus,
                                ur_event_callback_t pfnNotify, void *pUserData) {

source/adapters/level_zero/v2/context.cpp

@@ -11,6 +11,7 @@
 #include "../device.hpp"
 
 #include "context.hpp"
+#include "event_provider_counter.hpp"
 #include "event_provider_normal.hpp"
 
 static std::vector<ur_device_handle_t>
@@ -48,14 +49,22 @@ ur_context_handle_t_::ur_context_handle_t_(ze_context_handle_t hContext,
                                            const ur_device_handle_t *phDevices,
                                            bool ownZeContext)
     : commandListCache(hContext),
-      eventPoolCache(phDevices[0]->Platform->getNumDevices(),
+      eventPoolCache(this, phDevices[0]->Platform->getNumDevices(),
                      [context = this, platform = phDevices[0]->Platform](
-                         DeviceId deviceId, v2::event_flags_t flags) {
-                       auto device = platform->getDeviceById(deviceId);
+                         DeviceId deviceId, v2::event_flags_t flags)
+                         -> std::unique_ptr<v2::event_provider> {
+                       assert((flags & v2::EVENT_FLAGS_COUNTER) != 0);
+
+                       std::ignore = deviceId;
+                       std::ignore = platform;
+
                        // TODO: just use per-context id?
                        return std::make_unique<v2::provider_normal>(
-                           context, device, v2::QUEUE_IMMEDIATE, flags);
+                           context, v2::QUEUE_IMMEDIATE, flags);
                      }),
+      nativeEventsPool(this, std::make_unique<v2::provider_normal>(
+                                 this, v2::QUEUE_IMMEDIATE,
+                                 v2::EVENT_FLAGS_PROFILING_ENABLED)),
       hContext(hContext, ownZeContext),
       hDevices(phDevices, phDevices + numDevices),
       p2pAccessDevices(populateP2PDevices(

source/adapters/level_zero/v2/context.hpp

@@ -38,6 +38,10 @@ struct ur_context_handle_t_ : _ur_object {
   v2::command_list_cache_t commandListCache;
   v2::event_pool_cache eventPoolCache;
 
+  // pool used for urEventCreateWithNativeHandle when native handle is NULL
+  // (uses non-counter based events to allow for signaling from host)
+  v2::event_pool nativeEventsPool;
+
 private:
   const v2::raii::ze_context_handle_t hContext;
   const std::vector<ur_device_handle_t> hDevices;