[SYCL][PI] PI objects created with native handles takes ownership

PI objects created with the associated piextCreate*WithNativeHandle
function takes ownership of the native handle passed to it. For OpenCL
this means that the native OpenCL object is not retained, so the PI
object effectively owns the reference of the caller.
The OpenCL interoperability have been changed to retain the native
OpenCL handle as the implementation no longer does it. This is required
by the SYCL 1.2.1 specification (Rev6, section 4.3.1.)

Signed-off-by: Steffen Larsen <[email protected]>

Author: Steffen Larsen

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

@@ -788,9 +788,7 @@ pi_result piextDeviceGetNativeHandle(pi_device device,
                                      pi_native_handle *nativeHandle);
 
 /// Creates PI device object from a native handle.
-/// NOTE: If the created PI object shares reference count with the native object
-///       the reference count is increased by one. Otherwise the newly created
-///       PI object has a reference count of 1.
+/// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param nativeHandle is the native handle to create PI device from.
 /// \param device is the PI device created from the native handle.
@@ -848,9 +846,7 @@ pi_result piextContextGetNativeHandle(pi_context context,
                                       pi_native_handle *nativeHandle);
 
 /// Creates PI context object from a native handle.
-/// NOTE: If the created PI object shares reference count with the native object
-///       the reference count is increased by one. Otherwise the newly created
-///       PI object has a reference count of 1.
+/// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param nativeHandle is the native handle to create PI context from.
 /// \param context is the PI context created from the native handle.
@@ -881,9 +877,7 @@ pi_result piextQueueGetNativeHandle(pi_queue queue,
                                     pi_native_handle *nativeHandle);
 
 /// Creates PI queue object from a native handle.
-/// NOTE: If the created PI object shares reference count with the native object
-///       the reference count is increased by one. Otherwise the newly created
-///       PI object has a reference count of 1.
+/// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param nativeHandle is the native handle to create PI queue from.
 /// \param queue is the PI queue created from the native handle.
@@ -925,9 +919,7 @@ pi_result piMemBufferPartition(pi_mem buffer, pi_mem_flags flags,
 pi_result piextMemGetNativeHandle(pi_mem mem, pi_native_handle *nativeHandle);
 
 /// Creates PI mem object from a native handle.
-/// NOTE: If the created PI object shares reference count with the native object
-///       the reference count is increased by one. Otherwise the newly created
-///       PI object has a reference count of 1.
+/// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param nativeHandle is the native handle to create PI mem from.
 /// \param mem is the PI mem created from the native handle.
@@ -1004,9 +996,7 @@ pi_result piextProgramGetNativeHandle(pi_program program,
                                       pi_native_handle *nativeHandle);
 
 /// Creates PI program object from a native handle.
-/// NOTE: If the created PI object shares reference count with the native object
-///       the reference count is increased by one. Otherwise the newly created
-///       PI object has a reference count of 1.
+/// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param nativeHandle is the native handle to create PI program from.
 /// \param program is the PI program created from the native handle.
@@ -1112,9 +1102,7 @@ pi_result piextEventGetNativeHandle(pi_event event,
                                     pi_native_handle *nativeHandle);
 
 /// Creates PI event object from a native handle.
-/// NOTE: If the created PI object shares reference count with the native object
-///       the reference count is increased by one. Otherwise the newly created
-///       PI object has a reference count of 1.
+/// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param nativeHandle is the native handle to create PI event from.
 /// \param event is the PI event created from the native handle.

sycl/plugins/cuda/pi_cuda.cpp

@@ -1366,12 +1366,7 @@ pi_result cuda_piextDeviceGetNativeHandle(pi_device device,
 
 /// Created a PI device object from a CUDA device handle.
 /// TODO: Implement this.
-/// NOTE: Approaches for native object lifetime:
-///        1. Make the created PI object the owner of the native object,
-///           deleting it upon its own destruction.
-///        2. Make a special-case where the PI object does not destroy the
-///           native object.
-///       Both options may make lifetime tracking difficult for the user.
+/// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param[in] nativeHandle The native handle to create PI device object from.
 /// \param[out] device Set to the PI device object created from native handle.
@@ -1533,12 +1528,7 @@ pi_result cuda_piextContextGetNativeHandle(pi_context context,
 
 /// Created a PI context object from a CUDA context handle.
 /// TODO: Implement this.
-/// NOTE: Approaches for native object lifetime:
-///        1. Make the created PI object the owner of the native object,
-///           deleting it upon its own destruction.
-///        2. Make a special-case where the PI object does not destroy the
-///           native object.
-///       Both options may make lifetime tracking difficult for the user.
+/// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param[in] nativeHandle The native handle to create PI context object from.
 /// \param[out] context Set to the PI context object created from native handle.
@@ -1747,12 +1737,7 @@ pi_result cuda_piextMemGetNativeHandle(pi_mem mem,
 
 /// Created a PI mem object from a CUDA mem handle.
 /// TODO: Implement this.
-/// NOTE: Approaches for native object lifetime:
-///        1. Make the created PI object the owner of the native object,
-///           deleting it upon its own destruction.
-///        2. Make a special-case where the PI object does not destroy the
-///           native object.
-///       Both options may make lifetime tracking difficult for the user.
+/// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param[in] nativeHandle The native handle to create PI mem object from.
 /// \param[out] mem Set to the PI mem object created from native handle.
@@ -1914,12 +1899,7 @@ pi_result cuda_piextQueueGetNativeHandle(pi_queue queue,
 
 /// Created a PI queue object from a CUDA queue handle.
 /// TODO: Implement this.
-/// NOTE: Approaches for native object lifetime:
-///        1. Make the created PI object the owner of the native object,
-///           deleting it upon its own destruction.
-///        2. Make a special-case where the PI object does not destroy the
-///           native object.
-///       Both options may make lifetime tracking difficult for the user.
+/// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param[in] nativeHandle The native handle to create PI queue object from.
 /// \param[out] queue Set to the PI queue object created from native handle.
@@ -2533,12 +2513,7 @@ pi_result cuda_piextProgramGetNativeHandle(pi_program program,
 
 /// Created a PI program object from a CUDA program handle.
 /// TODO: Implement this.
-/// NOTE: Approaches for native object lifetime:
-///        1. Make the created PI object the owner of the native object,
-///           deleting it upon its own destruction.
-///        2. Make a special-case where the PI object does not destroy the
-///           native object.
-///       Both options may make lifetime tracking difficult for the user.
+/// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param[in] nativeHandle The native handle to create PI program object from.
 /// \param[out] program Set to the PI program object created from native handle.
@@ -2923,12 +2898,7 @@ pi_result cuda_piextEventGetNativeHandle(pi_event event,
 
 /// Created a PI event object from a CUDA event handle.
 /// TODO: Implement this.
-/// NOTE: Approaches for native object lifetime:
-///        1. Make the created PI object the owner of the native object,
-///           deleting it upon its own destruction.
-///        2. Make a special-case where the PI object does not destroy the
-///           native object.
-///       Both options may make lifetime tracking difficult for the user.
+/// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param[in] nativeHandle The native handle to create PI event object from.
 /// \param[out] event Set to the PI event object created from native handle.

sycl/plugins/opencl/pi_opencl.cpp

@@ -273,7 +273,6 @@ pi_result OCL(piextDeviceCreateWithNativeHandle)(pi_native_handle nativeHandle,
                                                  pi_device *piDevice) {
   assert(piDevice != nullptr);
   *piDevice = reinterpret_cast<pi_device>(nativeHandle);
-  clRetainDevice(cast<cl_device_id>(*piDevice));
   return PI_SUCCESS;
 }
 
@@ -321,7 +320,6 @@ pi_result OCL(piextQueueCreateWithNativeHandle)(pi_native_handle nativeHandle,
                                                 pi_queue *piQueue) {
   assert(piQueue != nullptr);
   *piQueue = reinterpret_cast<pi_queue>(nativeHandle);
-  clRetainCommandQueue(cast<cl_command_queue>(*piQueue));
   return PI_SUCCESS;
 }
 
@@ -407,7 +405,6 @@ pi_result OCL(piextProgramCreateWithNativeHandle)(pi_native_handle nativeHandle,
                                                   pi_program *piProgram) {
   assert(piProgram != nullptr);
   *piProgram = reinterpret_cast<pi_program>(nativeHandle);
-  clRetainProgram(cast<cl_program>(*piProgram));
   return PI_SUCCESS;
 }
 
@@ -506,7 +503,6 @@ pi_result OCL(piextContextCreateWithNativeHandle)(pi_native_handle nativeHandle,
                                                   pi_context *piContext) {
   assert(piContext != nullptr);
   *piContext = reinterpret_cast<pi_context>(nativeHandle);
-  clRetainContext(cast<cl_context>(*piContext));
   return PI_SUCCESS;
 }
 
@@ -550,7 +546,6 @@ pi_result OCL(piextMemCreateWithNativeHandle)(pi_native_handle nativeHandle,
                                               pi_mem *piMem) {
   assert(piMem != nullptr);
   *piMem = reinterpret_cast<pi_mem>(nativeHandle);
-  clRetainMemObject(cast<cl_mem>(*piMem));
   return PI_SUCCESS;
 }
 
@@ -619,7 +614,6 @@ pi_result OCL(piextEventCreateWithNativeHandle)(pi_native_handle nativeHandle,
                                                 pi_event *piEvent) {
   assert(piEvent != nullptr);
   *piEvent = reinterpret_cast<pi_event>(nativeHandle);
-  clRetainEvent(cast<cl_event>(*piEvent));
   return PI_SUCCESS;
 }
 

sycl/source/device.cpp

@@ -30,7 +30,11 @@ device::device() : impl(std::make_shared<detail::device_impl>()) {}
 
 device::device(cl_device_id deviceId)
     : impl(std::make_shared<detail::device_impl>(
-          detail::pi::cast<pi_native_handle>(deviceId), *RT::GlobalPlugin)) {}
+          detail::pi::cast<pi_native_handle>(deviceId), *RT::GlobalPlugin)) {
+  // The implementation constructor takes ownership of the native handle so we
+  // must retain it in order to adhere to SYCL 1.2.1 spec (Rev6, section 4.3.1.)
+  clRetainDevice(deviceId);
+}
 
 device::device(const device_selector &deviceSelector) {
   *this = deviceSelector.select_device();

sycl/source/program.cpp

@@ -30,7 +30,11 @@ program::program(vector_class<program> programList, string_class linkOptions) {
 program::program(const context &context, cl_program clProgram)
     : impl(std::make_shared<detail::program_impl>(
           detail::getSyclObjImpl(context),
-          detail::pi::cast<pi_native_handle>(clProgram))) {}
+          detail::pi::cast<pi_native_handle>(clProgram))) {
+  // The implementation constructor takes ownership of the native handle so we
+  // must retain it in order to adhere to SYCL 1.2.1 spec (Rev6, section 4.3.1.)
+  clRetainProgram(clProgram);
+}
 program::program(std::shared_ptr<detail::program_impl> impl) : impl(impl) {}
 
 cl_program program::get() const { return impl->get(); }