[L0 v2] Rename ur_event to ur_event_handle_t and fix compilation

Author: igchor

source/adapters/level_zero/CMakeLists.txt

@@ -207,11 +207,11 @@ if(UR_BUILD_ADAPTER_L0_V2)
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_immediate_in_order.cpp
     )
 
-    # api.cpp contains NOT_SUPPORTED functions-only
-    set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/v2/api.cpp
-        PROPERTIES APPEND_STRING PROPERTY COMPILE_FLAGS "-Wno-unused-parameter")
-
     if(NOT WIN32)
+        # api.cpp contains NOT_SUPPORTED functions-only
+        set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/v2/api.cpp
+            PROPERTIES APPEND_STRING PROPERTY COMPILE_FLAGS "-Wno-unused-parameter")
+
         target_sources(ur_adapter_level_zero_v2
             PRIVATE
                 ${CMAKE_CURRENT_SOURCE_DIR}/adapter_lib_init_linux.cpp

source/adapters/level_zero/v2/api.cpp

@@ -538,16 +538,6 @@ ur_result_t UR_APICALL urEventWait(uint32_t numEvents,
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t UR_APICALL urEventRetain(ur_event_handle_t hEvent) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urEventRelease(ur_event_handle_t hEvent) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t UR_APICALL urEventGetNativeHandle(
     ur_event_handle_t hEvent, ur_native_handle_t *phNativeEvent) {
   logger::error("{} function not implemented!", __FUNCTION__);

source/adapters/level_zero/v2/event.cpp

@@ -7,22 +7,49 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+
+#include <ze_api.h>
+
 #include "event.hpp"
+#include "event_pool.hpp"
 #include "event_provider.hpp"
-#include "ze_api.h"
 
-namespace v2 {
-void ur_event::reset() {
+ur_event_handle_t_::ur_event_handle_t_(v2::event_allocation eventAllocation,
+                                       v2::event_pool *pool)
+    : type(eventAllocation.type), zeEvent(std::move(eventAllocation.borrow)),
+      pool(pool) {}
+
+void ur_event_handle_t_::reset() {
   // consider make an abstraction for regular/counter based
   // events if there's more of this type of conditions
-  if (type == event_type::EVENT_REGULAR) {
+  if (type == v2::event_type::EVENT_REGULAR) {
     zeEventHostReset(zeEvent.get());
   }
 }
 
-ze_event_handle_t ur_event::getZeEvent() { return zeEvent.get(); }
+ze_event_handle_t ur_event_handle_t_::getZeEvent() const {
+  return zeEvent.get();
+}
+
+ur_result_t ur_event_handle_t_::retain() {
+  RefCount.increment();
+  return UR_RESULT_SUCCESS;
+}
+
+ur_result_t ur_event_handle_t_::release() {
+  if (!RefCount.decrementAndTest())
+    return UR_RESULT_SUCCESS;
+
+  pool->free(this);
+  RefCount.increment();
+
+  return UR_RESULT_SUCCESS;
+}
 
-ur_event::ur_event(event_allocation eventAllocation)
-    : type(eventAllocation.type), zeEvent(std::move(eventAllocation.borrow)) {}
+UR_APIEXPORT ur_result_t UR_APICALL urEventRetain(ur_event_handle_t hEvent) {
+  return hEvent->retain();
+}
 
-} // namespace v2
+UR_APIEXPORT ur_result_t UR_APICALL urEventRelease(ur_event_handle_t hEvent) {
+  return hEvent->release();
+}

source/adapters/level_zero/v2/event.hpp

@@ -15,20 +15,29 @@
 #include <ur_api.h>
 #include <ze_api.h>
 
+#include "common.hpp"
 #include "event_provider.hpp"
 
 namespace v2 {
+class event_pool;
+}
 
-class ur_event {
+struct ur_event_handle_t_;
+using ur_event_handle_t = ur_event_handle_t_ *;
+
+struct ur_event_handle_t_ : _ur_object {
 public:
-  ur_event(event_allocation eventAllocation);
+  ur_event_handle_t_(v2::event_allocation eventAllocation,
+                     v2::event_pool *pool);
 
   void reset();
-  ze_event_handle_t getZeEvent();
+  ze_event_handle_t getZeEvent() const;
+
+  ur_result_t retain();
+  ur_result_t release();
 
 private:
-  event_type type;
-  event_borrowed zeEvent;
+  v2::event_type type;
+  v2::raii::cache_borrowed_event zeEvent;
+  v2::event_pool *pool;
 };
-
-} // namespace v2

source/adapters/level_zero/v2/event_pool.cpp

@@ -14,12 +14,12 @@ namespace v2 {
 
 static constexpr size_t EVENTS_BURST = 64;
 
-ur_event *event_pool::allocate() {
+ur_event_handle_t_ *event_pool::allocate() {
   if (freelist.empty()) {
     auto start = events.size();
     auto end = start + EVENTS_BURST;
     for (; start < end; ++start) {
-      events.emplace_back(provider->allocate());
+      events.emplace_back(provider->allocate(), this);
       freelist.push_back(&events.at(start));
     }
   }
@@ -30,9 +30,11 @@ ur_event *event_pool::allocate() {
   return event;
 }
 
-void event_pool::free(ur_event *event) {
+void event_pool::free(ur_event_handle_t_ *event) {
   event->reset();
   freelist.push_back(event);
 }
 
+event_provider *event_pool::getProvider() { return provider.get(); }
+
 } // namespace v2

source/adapters/level_zero/v2/event_pool.hpp

@@ -39,14 +39,16 @@ class event_pool {
 
   DeviceId Id() { return provider->device()->Id; };
 
-  ur_event *allocate();
-  void free(ur_event *event);
+  ur_event_handle_t_ *allocate();
+  void free(ur_event_handle_t_ *event);
+
+  event_provider *getProvider();
 
 private:
   std::unique_ptr<event_provider> provider;
 
-  std::deque<ur_event> events;
-  std::vector<ur_event *> freelist;
+  std::deque<ur_event_handle_t_> events;
+  std::vector<ur_event_handle_t_ *> freelist;
 };
 
 } // namespace v2

source/adapters/level_zero/v2/event_pool_cache.cpp

@@ -21,7 +21,7 @@ event_pool_cache::event_pool_cache(size_t max_devices,
 
 event_pool_cache::~event_pool_cache() {}
 
-event_pool_borrowed event_pool_cache::borrow(DeviceId id) {
+raii::cache_borrowed_event_pool event_pool_cache::borrow(DeviceId id) {
   std::unique_lock<ur_mutex> Lock(mutex);
 
   if (id >= pools.size()) {
@@ -36,7 +36,7 @@ event_pool_borrowed event_pool_cache::borrow(DeviceId id) {
   auto pool = vec.back().release();
   vec.pop_back();
 
-  return event_pool_borrowed(pool, [this](event_pool *pool) {
+  return raii::cache_borrowed_event_pool(pool, [this](event_pool *pool) {
     std::unique_lock<ur_mutex> Lock(mutex);
     pools[pool->Id()].emplace_back(pool);
   });

source/adapters/level_zero/v2/event_pool_cache.hpp

@@ -25,8 +25,10 @@
 
 namespace v2 {
 
-using event_pool_borrowed =
+namespace raii {
+using cache_borrowed_event_pool =
     std::unique_ptr<event_pool, std::function<void(event_pool *)>>;
+} // namespace raii
 
 class event_pool_cache {
 public:
@@ -36,7 +38,7 @@ class event_pool_cache {
   event_pool_cache(size_t max_devices, ProviderCreateFunc);
   ~event_pool_cache();
 
-  event_pool_borrowed borrow(DeviceId);
+  raii::cache_borrowed_event_pool borrow(DeviceId);
 
 private:
   ur_mutex mutex;

source/adapters/level_zero/v2/event_provider.hpp

@@ -23,12 +23,17 @@ namespace v2 {
 
 enum event_type { EVENT_REGULAR, EVENT_COUNTER };
 
-using event_borrowed =
-    std::unique_ptr<_ze_event_handle_t, std::function<void(ze_event_handle_t)>>;
+class event_provider;
+
+namespace raii {
+using cache_borrowed_event =
+    std::unique_ptr<_ze_event_handle_t,
+                    std::function<void(::ze_event_handle_t)>>;
+} // namespace raii
 
 struct event_allocation {
   event_type type;
-  event_borrowed borrow;
+  raii::cache_borrowed_event borrow;
 };
 
 class event_provider {

source/adapters/level_zero/v2/event_provider_counter.cpp

@@ -7,14 +7,16 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+#include <ur_api.h>
+#include <ze_api.h>
+
+#include "context.hpp"
+#include "event_provider.hpp"
 #include "event_provider_counter.hpp"
-#include "../context.hpp"
+#include "loader/ze_loader.h"
+
 #include "../device.hpp"
 #include "../platform.hpp"
-#include "event_provider.hpp"
-#include "loader/ze_loader.h"
-#include "ur_api.h"
-#include "ze_api.h"
 
 namespace v2 {
 
@@ -27,7 +29,7 @@ provider_counter::provider_counter(ur_platform_handle_t platform,
                      (void **)&this->eventCreateFunc));
   ZE2UR_CALL_THROWS(
       zelLoaderTranslateHandle,
-      (ZEL_HANDLE_CONTEXT, context->ZeContext, (void **)&translatedContext));
+      (ZEL_HANDLE_CONTEXT, context->hContext, (void **)&translatedContext));
   ZE2UR_CALL_THROWS(
       zelLoaderTranslateHandle,
       (ZEL_HANDLE_DEVICE, device->ZeDevice, (void **)&translatedDevice));
@@ -52,9 +54,10 @@ event_allocation provider_counter::allocate() {
   freelist.pop_back();
 
   return {event_type::EVENT_COUNTER,
-          event_borrowed(event.release(), [this](ze_event_handle_t handle) {
-            freelist.push_back(handle);
-          })};
+          raii::cache_borrowed_event(event.release(),
+                                     [this](ze_event_handle_t handle) {
+                                       freelist.push_back(handle);
+                                     })};
 }
 
 ur_device_handle_t provider_counter::device() { return urDevice; }