[SYCL] Add Level-Zero interop with specification of ownership

Signed-off-by: Sergey V Maslov <[email protected]>

Author: smaslov-intel

sycl/include/CL/sycl/backend/level_zero.hpp

@@ -51,12 +51,20 @@ struct interop<backend::level_zero, accessor<DataT, Dimensions, AccessMode,
 
 namespace level_zero {
 
-// Implementation of various "make" functions resides in libsycl.so
+// Since Level-Zero is not doing any reference counting itself, we have to
+// be explicit about the ownership of the native handles used in the
+// interop functions below.
+//
+enum ownership { transfer, keep };
+
+// Implementation of various "make" functions resides in libsycl.so and thus
+// their interface needs to be backend agnostic.
 __SYCL_EXPORT platform make_platform(pi_native_handle NativeHandle);
 __SYCL_EXPORT device make_device(const platform &Platform,
                                  pi_native_handle NativeHandle);
 __SYCL_EXPORT context make_context(const vector_class<device> &DeviceList,
-                                   pi_native_handle NativeHandle);
+                                   pi_native_handle NativeHandle,
+                                   bool keep_ownership = false);
 __SYCL_EXPORT program make_program(const context &Context,
                                    pi_native_handle NativeHandle);
 __SYCL_EXPORT queue make_queue(const context &Context,
@@ -82,11 +90,17 @@ T make(const platform &Platform,
 ///        created SYCL context. Provided devices and native context handle must
 ///        be associated with the same platform.
 /// \param Interop is a Level Zero native context handle.
+/// \param Ownership (optional) specifies who will assume ownership of the
+///        native context handle. Default is that SYCL RT does, so it destroys
+///        the native handle when the created SYCL object goes out of life.
+///
 template <typename T, typename std::enable_if<
                           std::is_same<T, context>::value>::type * = nullptr>
 T make(const vector_class<device> &DeviceList,
-       typename interop<backend::level_zero, T>::type Interop) {
-  return make_context(DeviceList, detail::pi::cast<pi_native_handle>(Interop));
+       typename interop<backend::level_zero, T>::type Interop,
+       ownership Ownership = ownership::transfer) {
+  return make_context(DeviceList, detail::pi::cast<pi_native_handle>(Interop),
+                      Ownership == ownership::keep);
 }
 
 // Construction of SYCL program.

sycl/include/CL/sycl/detail/pi.h

@@ -983,6 +983,8 @@ piextContextGetNativeHandle(pi_context context, pi_native_handle *nativeHandle);
 /// \param devices is the list of devices in the context. Parameter is ignored
 ///        if devices can be queried from the context native handle for a
 ///        backend.
+/// \param ownNativeHandle tells if SYCL RT should assume the ownership of
+///        the native handle, if it can.
 /// \param context is the PI context created from the native handle.
 /// \return PI_SUCCESS if successfully created pi_context from the handle.
 ///         PI_OUT_OF_HOST_MEMORY if can't allocate memory for the pi_context
@@ -991,7 +993,7 @@ piextContextGetNativeHandle(pi_context context, pi_native_handle *nativeHandle);
 ///         native handle. PI_UNKNOWN_ERROR in case of another error.
 __SYCL_EXPORT pi_result piextContextCreateWithNativeHandle(
     pi_native_handle nativeHandle, pi_uint32 numDevices,
-    const pi_device *devices, pi_context *context);
+    const pi_device *devices, bool ownNativeHandle, pi_context *context);
 
 //
 // Queue

sycl/plugins/cuda/pi_cuda.cpp

@@ -1698,6 +1698,7 @@ pi_result cuda_piextContextGetNativeHandle(pi_context context,
 pi_result cuda_piextContextCreateWithNativeHandle(pi_native_handle nativeHandle,
                                                   pi_uint32 num_devices,
                                                   const pi_device *devices,
+                                                  bool ownNativeHandle,
                                                   pi_context *context) {
   cl::sycl::detail::pi::die(
       "Creation of PI context from native handle not implemented");

sycl/plugins/level_zero/pi_level_zero.cpp

@@ -1954,7 +1954,7 @@ pi_result piContextCreate(const pi_context_properties *Properties,
   ZE_CALL(zeContextCreate((*Devices)->Platform->ZeDriver, &ContextDesc,
                           &ZeContext));
   try {
-    *RetContext = new _pi_context(ZeContext, NumDevices, Devices);
+    *RetContext = new _pi_context(ZeContext, NumDevices, Devices, true);
     (*RetContext)->initialize();
   } catch (const std::bad_alloc &) {
     return PI_OUT_OF_HOST_MEMORY;
@@ -2013,6 +2013,7 @@ pi_result piextContextGetNativeHandle(pi_context Context,
 pi_result piextContextCreateWithNativeHandle(pi_native_handle NativeHandle,
                                              pi_uint32 NumDevices,
                                              const pi_device *Devices,
+                                             bool OwnNativeHandle,
                                              pi_context *RetContext) {
   PI_ASSERT(NativeHandle, PI_INVALID_VALUE);
   PI_ASSERT(Devices, PI_INVALID_DEVICE);
@@ -2021,7 +2022,7 @@ pi_result piextContextCreateWithNativeHandle(pi_native_handle NativeHandle,
 
   try {
     *RetContext = new _pi_context(pi_cast<ze_context_handle_t>(NativeHandle),
-                                  NumDevices, Devices);
+                                  NumDevices, Devices, OwnNativeHandle);
     (*RetContext)->initialize();
   } catch (const std::bad_alloc &) {
     return PI_OUT_OF_HOST_MEMORY;
@@ -2059,7 +2060,9 @@ pi_result piContextRelease(pi_context Context) {
     // and therefore it must be valid at that point.
     // Technically it should be placed to the destructor of pi_context
     // but this makes API error handling more complex.
-    ZE_CALL(zeContextDestroy(ZeContext));
+    if (Context->OwnZeContext) {
+      ZE_CALL(zeContextDestroy(ZeContext));
+    }
 
     return Result;
   }

sycl/plugins/level_zero/pi_level_zero.hpp

@@ -171,8 +171,9 @@ struct _pi_device : _pi_object {
 
 struct _pi_context : _pi_object {
   _pi_context(ze_context_handle_t ZeContext, pi_uint32 NumDevices,
-              const pi_device *Devs)
-      : ZeContext{ZeContext}, Devices{Devs, Devs + NumDevices},
+              const pi_device *Devs, bool OwnZeContext)
+      : ZeContext{ZeContext},
+        OwnZeContext{OwnZeContext}, Devices{Devs, Devs + NumDevices},
         ZeCommandListInit{nullptr}, ZeEventPool{nullptr},
         NumEventsAvailableInEventPool{}, NumEventsLiveInEventPool{} {
     // Create USM allocator context for each pair (device, context).
@@ -201,6 +202,10 @@ struct _pi_context : _pi_object {
   // resources that may be used by multiple devices.
   ze_context_handle_t ZeContext;
 
+  // Indicates if we own the ZeContext or it came from interop that
+  // asked to not transfer the ownership to SYCL RT.
+  bool OwnZeContext;
+
   // Keep the PI devices this PI context was created for.
   std::vector<pi_device> Devices;
 

sycl/plugins/opencl/pi_opencl.cpp

@@ -536,10 +536,12 @@ pi_result piContextCreate(const pi_context_properties *properties,
 pi_result piextContextCreateWithNativeHandle(pi_native_handle nativeHandle,
                                              pi_uint32 num_devices,
                                              const pi_device *devices,
+                                             bool ownNativeHandle,
                                              pi_context *piContext) {
   (void)num_devices;
   (void)devices;
   assert(piContext != nullptr);
+  assert(ownNativeHandle == false);
   *piContext = reinterpret_cast<pi_context>(nativeHandle);
   return PI_SUCCESS;
 }

sycl/source/backend/level_zero.cpp

@@ -48,7 +48,8 @@ __SYCL_EXPORT device make_device(const platform &Platform,
 //----------------------------------------------------------------------------
 // Implementation of level_zero::make<context>
 __SYCL_EXPORT context make_context(const vector_class<device> &DeviceList,
-                                   pi_native_handle NativeHandle) {
+                                   pi_native_handle NativeHandle,
+                                   bool KeepOwnership) {
   const auto &Plugin = pi::getPlugin<backend::level_zero>();
   // Create PI context first.
   pi_context PiContext;
@@ -57,7 +58,8 @@ __SYCL_EXPORT context make_context(const vector_class<device> &DeviceList,
     DeviceHandles.push_back(detail::getSyclObjImpl(Dev)->getHandleRef());
   }
   Plugin.call<PiApiKind::piextContextCreateWithNativeHandle>(
-      NativeHandle, DeviceHandles.size(), DeviceHandles.data(), &PiContext);
+      NativeHandle, DeviceHandles.size(), DeviceHandles.data(), !KeepOwnership,
+      &PiContext);
   // Construct the SYCL context from PI context.
   return detail::createSyclObjFromImpl<context>(
       std::make_shared<context_impl>(PiContext, async_handler{}, Plugin));

sycl/source/backend/opencl.cpp

@@ -51,7 +51,7 @@ __SYCL_EXPORT context make_context(pi_native_handle NativeHandle) {
   // Create PI context first.
   pi::PiContext PiContext;
   Plugin.call<PiApiKind::piextContextCreateWithNativeHandle>(
-      NativeHandle, 0, nullptr, &PiContext);
+      NativeHandle, 0, nullptr, false, &PiContext);
   // Construct the SYCL context from PI context.
   return detail::createSyclObjFromImpl<context>(
       std::make_shared<context_impl>(PiContext, async_handler{}, Plugin));

sycl/source/detail/context_impl.cpp

@@ -56,7 +56,8 @@ context_impl::context_impl(const vector_class<cl::sycl::device> Devices,
     getPlugin().call<PiApiKind::piContextCreate>(
         Props, DeviceIds.size(), DeviceIds.data(), nullptr, nullptr, &MContext);
 #else
-    cl::sycl::detail::pi::die("CUDA support was not enabled at compilation time");
+    cl::sycl::detail::pi::die(
+        "CUDA support was not enabled at compilation time");
 #endif
   } else {
     getPlugin().call<PiApiKind::piContextCreate>(nullptr, DeviceIds.size(),
@@ -96,7 +97,12 @@ context_impl::context_impl(RT::PiContext PiContext, async_handler AsyncHandler,
   // TODO catch an exception and put it to list of asynchronous exceptions
   // getPlugin() will be the same as the Plugin passed. This should be taken
   // care of when creating device object.
-  getPlugin().call<PiApiKind::piContextRetain>(MContext);
+  //
+  // TODO: Move this backend-specific retain of the context to SYCL-2020 style
+  //       make_context<backend::opencl> interop, when that is created.
+  if (getPlugin().getBackend() == cl::sycl::backend::opencl) {
+    getPlugin().call<PiApiKind::piContextRetain>(MContext);
+  }
   MKernelProgramCache.setContextPtr(this);
 }
 
@@ -153,8 +159,8 @@ KernelProgramCache &context_impl::getKernelProgramCache() const {
   return MKernelProgramCache;
 }
 
-bool
-context_impl::hasDevice(shared_ptr_class<detail::device_impl> Device) const {
+bool context_impl::hasDevice(
+    shared_ptr_class<detail::device_impl> Device) const {
   for (auto D : MDevices)
     if (getSyclObjImpl(D) == Device)
       return true;