[L0 v2] Use ze_handle_wrapper to hold ze context

This was the last place where we stored ze handle
directly. Now, we always use ze_handle_wrapper for
managing ownership which makes the code more
robust.

Author: igchor

source/adapters/level_zero/v2/common.hpp

@@ -54,6 +54,8 @@ struct ze_handle_wrapper {
     try {
       reset();
     } catch (...) {
+      // TODO: add appropriate logging or pass the error
+      // to the caller (make the dtor noexcept(false) or use tls?)
     }
   }
 
@@ -158,6 +160,9 @@ using ze_event_handle_t =
 using ze_event_pool_handle_t =
     ze_handle_wrapper<::ze_event_pool_handle_t, zeEventPoolDestroy>;
 
+using ze_context_handle_t =
+    ze_handle_wrapper<::ze_context_handle_t, zeContextDestroy>;
+
 using ur_queue_shared_handle_t =
     ur_shared_handle<ur_queue_handle_t, urQueueRetain, urQueueRelease>;
 

source/adapters/level_zero/v2/context.cpp

@@ -17,8 +17,8 @@ ur_context_handle_t_::ur_context_handle_t_(ze_context_handle_t hContext,
                                            uint32_t numDevices,
                                            const ur_device_handle_t *phDevices,
                                            bool ownZeContext)
-    : hContext(hContext), hDevices(phDevices, phDevices + numDevices),
-      commandListCache(hContext),
+    : hContext(hContext, ownZeContext),
+      hDevices(phDevices, phDevices + numDevices), commandListCache(hContext),
       eventPoolCache(phDevices[0]->Platform->getNumDevices(),
                      [context = this,
                       platform = phDevices[0]->Platform](DeviceId deviceId) {
@@ -27,19 +27,7 @@ ur_context_handle_t_::ur_context_handle_t_(ze_context_handle_t hContext,
                        return std::make_unique<v2::provider_normal>(
                            context, device, v2::EVENT_COUNTER,
                            v2::QUEUE_IMMEDIATE);
-                     }) {
-  std::ignore = ownZeContext;
-}
-
-ur_context_handle_t_::~ur_context_handle_t_() noexcept(false) {
-  // ur_context_handle_t_ is only created/destroyed through urContextCreate
-  // and urContextRelease so it's safe to throw here
-  ZE2UR_CALL_THROWS(zeContextDestroy, (hContext));
-}
-
-ze_context_handle_t ur_context_handle_t_::getZeHandle() const {
-  return hContext;
-}
+                     }) {}
 
 ur_result_t ur_context_handle_t_::retain() {
   RefCount.increment();

source/adapters/level_zero/v2/context.hpp

@@ -13,25 +13,25 @@
 #include <ur_api.h>
 
 #include "command_list_cache.hpp"
+#include "common.hpp"
 #include "event_pool_cache.hpp"
 
 struct ur_context_handle_t_ : _ur_object {
   ur_context_handle_t_(ze_context_handle_t hContext, uint32_t numDevices,
                        const ur_device_handle_t *phDevices, bool ownZeContext);
-  ~ur_context_handle_t_() noexcept(false);
 
   ur_result_t retain();
   ur_result_t release();
 
-  ze_context_handle_t getZeHandle() const;
+  inline ze_context_handle_t getZeHandle() const { return hContext.get(); }
   ur_platform_handle_t getPlatform() const;
   const std::vector<ur_device_handle_t> &getDevices() const;
 
   // Checks if Device is covered by this context.
   // For that the Device or its root devices need to be in the context.
   bool isValidDevice(ur_device_handle_t Device) const;
 
-  const ze_context_handle_t hContext;
+  const v2::raii::ze_context_handle_t hContext;
   const std::vector<ur_device_handle_t> hDevices;
   v2::command_list_cache_t commandListCache;
   v2::event_pool_cache eventPoolCache;

source/adapters/level_zero/v2/event_provider_counter.cpp

@@ -27,9 +27,9 @@ provider_counter::provider_counter(ur_platform_handle_t platform,
   ZE2UR_CALL_THROWS(zeDriverGetExtensionFunctionAddress,
                     (platform->ZeDriver, "zexCounterBasedEventCreate",
                      (void **)&this->eventCreateFunc));
-  ZE2UR_CALL_THROWS(
-      zelLoaderTranslateHandle,
-      (ZEL_HANDLE_CONTEXT, context->hContext, (void **)&translatedContext));
+  ZE2UR_CALL_THROWS(zelLoaderTranslateHandle,
+                    (ZEL_HANDLE_CONTEXT, context->getZeHandle(),
+                     (void **)&translatedContext));
   ZE2UR_CALL_THROWS(
       zelLoaderTranslateHandle,
       (ZEL_HANDLE_DEVICE, device->ZeDevice, (void **)&translatedDevice));

source/adapters/level_zero/v2/event_provider_normal.cpp

@@ -43,7 +43,7 @@ provider_pool::provider_pool(ur_context_handle_t context,
   }
 
   ZE2UR_CALL_THROWS(zeEventPoolCreate,
-                    (context->hContext, &desc, 1,
+                    (context->getZeHandle(), &desc, 1,
                      const_cast<ze_device_handle_t *>(&device->ZeDevice),
                      pool.ptr()));
 

test/adapters/level_zero/v2/command_list_cache_test.cpp

@@ -23,7 +23,7 @@ struct CommandListCacheTest : public uur::urContextTest {};
 UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(CommandListCacheTest);
 
 TEST_P(CommandListCacheTest, CanStoreAndRetriveImmediateAndRegularCmdLists) {
-    v2::command_list_cache_t cache(context->hContext);
+    v2::command_list_cache_t cache(context->getZeHandle());
 
     bool IsInOrder = false;
     uint32_t Ordinal = 0;
@@ -75,7 +75,7 @@ TEST_P(CommandListCacheTest, CanStoreAndRetriveImmediateAndRegularCmdLists) {
 }
 
 TEST_P(CommandListCacheTest, ImmediateCommandListsHaveProperAttributes) {
-    v2::command_list_cache_t cache(context->hContext);
+    v2::command_list_cache_t cache(context->getZeHandle());
 
     uint32_t numQueueGroups = 0;
     ASSERT_EQ(zeDeviceGetCommandQueueGroupProperties(device->ZeDevice,