Use new UR handles for opencl instead of casting mechanism

sycl/cmake/modules/UnifiedRuntimeTag.cmake

@@ -1,7 +1,2 @@
-# commit e2df8acd37c3c159364cfdf9dfdc1be35b71779e
-# Merge: 992ff37f 3a31ffee
-# Author: Kenneth Benzie (Benie) <k.benzie@codeplay.com>
-# Date:   Fri Jan 31 10:15:03 2025 +0000
-#     Merge pull request #2575 from DBDuncan/duncan/extend-copies
-#     [CUDA][Bindless] Add support for device to device pitched copies and host to host copies
-set(UNIFIED_RUNTIME_TAG e2df8acd37c3c159364cfdf9dfdc1be35b71779e)
+set(UNIFIED_RUNTIME_REPO "https://github.com/omarahmed1111/unified-runtime.git")
+set(UNIFIED_RUNTIME_TAG da306bae38372600c14fb2b1fed406de36cba474)

sycl/include/sycl/backend.hpp

@@ -328,7 +328,7 @@ make_context(
     const async_handler &Handler = {}) {
   return detail::make_context(
       detail::ur::cast<ur_native_handle_t>(BackendObject), Handler, Backend,
-      false /* KeepOwnership */);
+      true /* KeepOwnership */);
 }
 
 template <backend Backend>
@@ -337,8 +337,9 @@ std::enable_if_t<detail::InteropFeatureSupportMap<Backend>::MakeQueue == true,
 make_queue(const typename backend_traits<Backend>::template input_type<queue>
                &BackendObject,
            const context &TargetContext, const async_handler Handler = {}) {
-  auto KeepOwnership =
-      Backend == backend::ext_oneapi_cuda || Backend == backend::ext_oneapi_hip;
+  auto KeepOwnership = Backend == backend::ext_oneapi_cuda ||
+                       Backend == backend::ext_oneapi_hip ||
+                       Backend == backend::opencl;
   if constexpr (Backend == backend::ext_oneapi_level_zero) {
     return detail::make_queue(
         detail::ur::cast<ur_native_handle_t>(
@@ -429,7 +430,7 @@ make_kernel_bundle(const typename backend_traits<Backend>::template input_type<
   std::shared_ptr<detail::kernel_bundle_impl> KBImpl =
       detail::make_kernel_bundle(
           detail::ur::cast<ur_native_handle_t>(BackendObject), TargetContext,
-          false, State, Backend);
+          true /* KeepOwnership */, State, Backend);
   return detail::createSyclObjFromImpl<kernel_bundle<State>>(KBImpl);
 }
 } // namespace _V1

sycl/source/backend.cpp

@@ -161,7 +161,7 @@ __SYCL_EXPORT queue make_queue(ur_native_handle_t NativeHandle,
 
 __SYCL_EXPORT event make_event(ur_native_handle_t NativeHandle,
                                const context &Context, backend Backend) {
-  return make_event(NativeHandle, Context, false, Backend);
+  return make_event(NativeHandle, Context, true /* KeepOwnership */, Backend);
 }
 
 __SYCL_EXPORT event make_event(ur_native_handle_t NativeHandle,
@@ -179,9 +179,6 @@ __SYCL_EXPORT event make_event(ur_native_handle_t NativeHandle,
       NativeHandle, ContextImpl->getHandleRef(), &Properties, &UrEvent);
   event Event = detail::createSyclObjFromImpl<event>(
       std::make_shared<event_impl>(UrEvent, Context));
-
-  if (Backend == backend::opencl)
-    Adapter->call<UrApiKind::urEventRetain>(UrEvent);
   return Event;
 }
 
@@ -204,9 +201,6 @@ make_kernel_bundle(ur_native_handle_t NativeHandle,
         sycl::make_error_code(sycl::errc::invalid),
         "urProgramCreateWithNativeHandle resulted in a null program handle.");
 
-  if (ContextImpl->getBackend() == backend::opencl)
-    Adapter->call<UrApiKind::urProgramRetain>(UrProgram);
-
   std::vector<ur_device_handle_t> ProgramDevices;
   uint32_t NumDevices = 0;
 
@@ -310,7 +304,8 @@ std::shared_ptr<detail::kernel_bundle_impl>
 make_kernel_bundle(ur_native_handle_t NativeHandle,
                    const context &TargetContext, bundle_state State,
                    backend Backend) {
-  return make_kernel_bundle(NativeHandle, TargetContext, false, State, Backend);
+  return make_kernel_bundle(NativeHandle, TargetContext,
+                            true /* KeepOwnership*/, State, Backend);
 }
 
 kernel make_kernel(const context &TargetContext,
@@ -351,9 +346,6 @@ kernel make_kernel(const context &TargetContext,
       NativeHandle, ContextImpl->getHandleRef(), UrProgram, &Properties,
       &UrKernel);
 
-  if (Backend == backend::opencl)
-    Adapter->call<UrApiKind::urKernelRetain>(UrKernel);
-
   // Construct the SYCL queue from UR queue.
   return detail::createSyclObjFromImpl<kernel>(
       std::make_shared<kernel_impl>(UrKernel, ContextImpl, KernelBundleImpl));
@@ -364,7 +356,7 @@ kernel make_kernel(ur_native_handle_t NativeHandle,
   return make_kernel(
       TargetContext,
       get_empty_interop_kernel_bundle<bundle_state::executable>(TargetContext),
-      NativeHandle, false, Backend);
+      NativeHandle, true /* KeepOwnership */, Backend);
 }
 
 } // namespace detail

sycl/source/detail/buffer_impl.cpp

@@ -49,15 +49,12 @@ void buffer_impl::destructorNotification(void *UserObj) {
 void buffer_impl::addInteropObject(
     std::vector<ur_native_handle_t> &Handles) const {
   if (MOpenCLInterop) {
-    if (std::find(Handles.begin(), Handles.end(),
-                  ur::cast<ur_native_handle_t>(MInteropMemObject)) ==
+    const AdapterPtr &Adapter = getAdapter();
+    ur_native_handle_t NativeHandle = 0;
+    Adapter->call<UrApiKind::urMemGetNativeHandle>(MInteropMemObject, nullptr,
+                                                   &NativeHandle);
+    if (std::find(Handles.begin(), Handles.end(), NativeHandle) ==
         Handles.end()) {
-      const AdapterPtr &Adapter = getAdapter();
-      Adapter->call<UrApiKind::urMemRetain>(
-          ur::cast<ur_mem_handle_t>(MInteropMemObject));
-      ur_native_handle_t NativeHandle = 0;
-      Adapter->call<UrApiKind::urMemGetNativeHandle>(MInteropMemObject, nullptr,
-                                                     &NativeHandle);
       Handles.push_back(NativeHandle);
     }
   }
@@ -86,10 +83,6 @@ buffer_impl::getNativeVector(backend BackendName) const {
 
     auto Adapter = Platform->getAdapter();
 
-    if (Platform->getBackend() == backend::opencl) {
-      Adapter->call<UrApiKind::urMemRetain>(NativeMem);
-    }
-
     ur_native_handle_t Handle = 0;
     // When doing buffer interop we don't know what device the memory should be
     // resident on, so pass nullptr for Device param. Buffer interop may not be

sycl/source/detail/context_impl.cpp

@@ -104,21 +104,11 @@ context_impl::context_impl(ur_context_handle_t UrContext,
     }
     MPlatform = Platform;
   }
-  // TODO catch an exception and put it to list of asynchronous exceptions
-  // getAdapter() will be the same as the Adapter passed. This should be taken
-  // care of when creating device object.
-  //
-  // TODO: Move this backend-specific retain of the context to SYCL-2020 style
-  //       make_context<backend::opencl> interop, when that is created.
-  if (getBackend() == sycl::backend::opencl) {
-    getAdapter()->call<UrApiKind::urContextRetain>(MContext);
-  }
   MKernelProgramCache.setContextPtr(this);
 }
 
 cl_context context_impl::get() const {
   // TODO catch an exception and put it to list of asynchronous exceptions
-  getAdapter()->call<UrApiKind::urContextRetain>(MContext);
   ur_native_handle_t nativeHandle = 0;
   getAdapter()->call<UrApiKind::urContextGetNativeHandle>(MContext,
                                                           &nativeHandle);
@@ -303,8 +293,6 @@ context_impl::findMatchingDeviceImpl(ur_device_handle_t &DeviceUR) const {
 
 ur_native_handle_t context_impl::getNative() const {
   const auto &Adapter = getAdapter();
-  if (getBackend() == backend::opencl)
-    Adapter->call<UrApiKind::urContextRetain>(getHandleRef());
   ur_native_handle_t Handle;
   Adapter->call<UrApiKind::urContextGetNativeHandle>(getHandleRef(), &Handle);
   return Handle;

sycl/source/detail/device_image_impl.hpp

@@ -299,9 +299,6 @@ class device_image_impl {
     assert(MProgram);
     const auto &ContextImplPtr = detail::getSyclObjImpl(MContext);
     const AdapterPtr &Adapter = ContextImplPtr->getAdapter();
-
-    if (ContextImplPtr->getBackend() == backend::opencl)
-      Adapter->call<UrApiKind::urProgramRetain>(MProgram);
     ur_native_handle_t NativeProgram = 0;
     Adapter->call<UrApiKind::urProgramGetNativeHandle>(MProgram,
                                                        &NativeProgram);

sycl/source/detail/device_impl.cpp

@@ -98,7 +98,6 @@ bool device_impl::is_affinity_supported(
 
 cl_device_id device_impl::get() const {
   // TODO catch an exception and put it to list of asynchronous exceptions
-  getAdapter()->call<UrApiKind::urDeviceRetain>(MDevice);
   return ur::cast<cl_device_id>(getNative());
 }
 
@@ -345,8 +344,6 @@ std::vector<device> device_impl::create_sub_devices() const {
 
 ur_native_handle_t device_impl::getNative() const {
   auto Adapter = getAdapter();
-  if (getBackend() == backend::opencl)
-    Adapter->call<UrApiKind::urDeviceRetain>(getHandleRef());
   ur_native_handle_t Handle;
   Adapter->call<UrApiKind::urDeviceGetNativeHandle>(getHandleRef(), &Handle);
   return Handle;

sycl/source/detail/event_impl.cpp

@@ -500,8 +500,6 @@ ur_native_handle_t event_impl::getNative() {
     this->setHandle(UREvent);
     Handle = UREvent;
   }
-  if (MContext->getBackend() == backend::opencl)
-    Adapter->call<UrApiKind::urEventRetain>(Handle);
   ur_native_handle_t OutHandle;
   Adapter->call<UrApiKind::urEventGetNativeHandle>(Handle, &OutHandle);
   return OutHandle;

sycl/source/detail/kernel_impl.cpp

@@ -24,14 +24,6 @@ kernel_impl::kernel_impl(ur_kernel_handle_t Kernel, ContextImplPtr Context,
                                                                       Context)),
       MCreatedFromSource(true), MKernelBundleImpl(std::move(KernelBundleImpl)),
       MIsInterop(true), MKernelArgMaskPtr{ArgMask} {
-  ur_context_handle_t UrContext = nullptr;
-  // Using the adapter from the passed ContextImpl
-  getAdapter()->call<UrApiKind::urKernelGetInfo>(
-      MKernel, UR_KERNEL_INFO_CONTEXT, sizeof(UrContext), &UrContext, nullptr);
-  if (Context->getHandleRef() != UrContext)
-    throw sycl::exception(
-        make_error_code(errc::invalid),
-        "Input context must be the same as the context of cl_kernel");
 
   // Enable USM indirect access for interoperability kernels.
   // Some UR Adapters (like OpenCL) require this call to enable USM

sycl/source/detail/kernel_impl.hpp

@@ -75,7 +75,6 @@ class kernel_impl {
   ///
   /// \return a valid cl_kernel instance
   cl_kernel get() const {
-    getAdapter()->call<UrApiKind::urKernelRetain>(MKernel);
     ur_native_handle_t nativeHandle = 0;
     getAdapter()->call<UrApiKind::urKernelGetNativeHandle>(MKernel,
                                                            &nativeHandle);
@@ -179,9 +178,6 @@ class kernel_impl {
   ur_native_handle_t getNative() const {
     const AdapterPtr &Adapter = MContext->getAdapter();
 
-    if (MContext->getBackend() == backend::opencl)
-      Adapter->call<UrApiKind::urKernelRetain>(MKernel);
-
     ur_native_handle_t NativeKernel = 0;
     Adapter->call<UrApiKind::urKernelGetNativeHandle>(MKernel, &NativeKernel);
 

sycl/source/detail/queue_impl.cpp

@@ -731,8 +731,6 @@ void queue_impl::destructorNotification() {
 
 ur_native_handle_t queue_impl::getNative(int32_t &NativeHandleDesc) const {
   const AdapterPtr &Adapter = getAdapter();
-  if (getContextImplPtr()->getBackend() == backend::opencl)
-    Adapter->call<UrApiKind::urQueueRetain>(MQueues[0]);
   ur_native_handle_t Handle{};
   ur_queue_native_desc_t UrNativeDesc{UR_STRUCTURE_TYPE_QUEUE_NATIVE_DESC,
                                       nullptr, nullptr};

sycl/source/detail/queue_impl.hpp

@@ -273,7 +273,6 @@ class queue_impl {
   /// \return an OpenCL interoperability queue handle.
 
   cl_command_queue get() {
-    getAdapter()->call<UrApiKind::urQueueRetain>(MQueues[0]);
     ur_native_handle_t nativeHandle = 0;
     getAdapter()->call<UrApiKind::urQueueGetNativeHandle>(MQueues[0], nullptr,
                                                           &nativeHandle);

sycl/source/detail/sycl_mem_obj_t.cpp

@@ -56,9 +56,6 @@ SYCLMemObjT::SYCLMemObjT(ur_native_handle_t MemObject,
     throw sycl::exception(
         make_error_code(errc::invalid),
         "Input context must be the same as the context of cl_mem");
-
-  if (MInteropContext->getBackend() == backend::opencl)
-    Adapter->call<UrApiKind::urMemRetain>(MInteropMemObject);
 }
 
 ur_mem_type_t getImageType(int Dimensions) {
@@ -111,9 +108,6 @@ SYCLMemObjT::SYCLMemObjT(ur_native_handle_t MemObject,
     throw sycl::exception(
         make_error_code(errc::invalid),
         "Input context must be the same as the context of cl_mem");
-
-  if (MInteropContext->getBackend() == backend::opencl)
-    Adapter->call<UrApiKind::urMemRetain>(MInteropMemObject);
 }
 
 void SYCLMemObjT::releaseMem(ContextImplPtr Context, void *MemAllocation) {

sycl/source/device.cpp

@@ -43,7 +43,6 @@ device::device(cl_device_id DeviceId) {
   auto Platform =
       detail::platform_impl::getPlatformFromUrDevice(Device, Adapter);
   impl = Platform->getOrMakeDeviceImpl(Device, Platform);
-  Adapter->call<detail::UrApiKind::urDeviceRetain>(impl->getHandleRef());
 }
 
 device::device(const device_selector &deviceSelector) {

sycl/source/event.cpp

@@ -24,14 +24,13 @@ inline namespace _V1 {
 
 event::event() : impl(std::make_shared<detail::event_impl>(std::nullopt)) {}
 
-event::event(cl_event ClEvent, const context &SyclContext)
-    : impl(std::make_shared<detail::event_impl>(
-          detail::ur::cast<ur_event_handle_t>(ClEvent), SyclContext)) {
-  // This is a special interop constructor for OpenCL, so the event must be
-  // retained.
-  // TODO(pi2ur): Don't just cast from cl_event above
-  impl->getAdapter()->call<detail::UrApiKind::urEventRetain>(
-      detail::ur::cast<ur_event_handle_t>(ClEvent));
+event::event(cl_event ClEvent, const context &SyclContext) {
+  ur_event_handle_t hEvent = nullptr;
+  impl->getAdapter()->call<detail::UrApiKind::urEventCreateWithNativeHandle>(
+      detail::ur::cast<ur_native_handle_t>(ClEvent),
+      detail::getSyclObjImpl(SyclContext)->getHandleRef(), nullptr, &hEvent);
+
+  impl = std::make_shared<detail::event_impl>(hEvent, SyclContext);
 }
 
 bool event::operator==(const event &rhs) const { return rhs.impl == impl; }

sycl/source/kernel.cpp

@@ -16,22 +16,22 @@
 namespace sycl {
 inline namespace _V1 {
 
-// TODO(pi2ur): Don't cast straight from cl_kernel below
 kernel::kernel(cl_kernel ClKernel, const context &SyclContext) {
   auto Adapter = sycl::detail::ur::getAdapter<backend::opencl>();
   ur_kernel_handle_t hKernel = nullptr;
   ur_native_handle_t nativeHandle =
       reinterpret_cast<ur_native_handle_t>(ClKernel);
-  Adapter->call<detail::UrApiKind::urKernelCreateWithNativeHandle>(
-      nativeHandle, detail::getSyclObjImpl(SyclContext)->getHandleRef(),
-      nullptr, nullptr, &hKernel);
+  ur_result_t Res =
+      Adapter->call_nocheck<detail::UrApiKind::urKernelCreateWithNativeHandle>(
+          nativeHandle, detail::getSyclObjImpl(SyclContext)->getHandleRef(),
+          nullptr, nullptr, &hKernel);
+  if (Res == UR_RESULT_ERROR_INVALID_CONTEXT) {
+    throw sycl::exception(
+        make_error_code(errc::invalid),
+        "Input context must be the same as the context of cl_kernel");
+  }
   impl = std::make_shared<detail::kernel_impl>(
       hKernel, detail::getSyclObjImpl(SyclContext), nullptr, nullptr);
-  // This is a special interop constructor for OpenCL, so the kernel must be
-  // retained.
-  if (get_backend() == backend::opencl) {
-    impl->getAdapter()->call<detail::UrApiKind::urKernelRetain>(hKernel);
-  }
 }
 
 cl_kernel kernel::get() const { return impl->get(); }

sycl/source/queue.cpp

@@ -94,10 +94,21 @@ queue::queue(const context &SyclContext, const device &SyclDevice,
 queue::queue(cl_command_queue clQueue, const context &SyclContext,
              const async_handler &AsyncHandler) {
   const property_list PropList{};
-  impl = std::make_shared<detail::queue_impl>(
-      // TODO(pi2ur): Don't cast straight from cl_command_queue
-      reinterpret_cast<ur_queue_handle_t>(clQueue),
-      detail::getSyclObjImpl(SyclContext), AsyncHandler, PropList);
+  ur_queue_handle_t hQueue;
+  auto Context = detail::getSyclObjImpl(SyclContext);
+  auto Adapter = sycl::detail::ur::getAdapter<backend::opencl>();
+
+  ur_queue_native_properties_t Properties = {
+      /*.stype = */ UR_STRUCTURE_TYPE_QUEUE_PROPERTIES,
+      /*.pNext = */ nullptr,
+      /*.isNativeHandleOwned = */ false,
+  };
+  Adapter->call<detail::UrApiKind::urQueueCreateWithNativeHandle>(
+      detail::ur::cast<ur_native_handle_t>(clQueue), Context->getHandleRef(),
+      nullptr, &Properties, &hQueue);
+
+  impl = std::make_shared<detail::queue_impl>(hQueue, Context, AsyncHandler,
+                                              PropList);
 }
 
 cl_command_queue queue::get() const { return impl->get(); }

sycl/test-e2e/Adapters/interop-opencl-make-kernel-bundle.cpp

@@ -33,28 +33,22 @@ int main() {
       clCreateProgramWithSource(native_context, 1, &source, nullptr, nullptr);
   std::cerr << "Build native program." << std::endl;
   clBuildProgram(p, 0, nullptr, nullptr, nullptr, nullptr);
-  std::cerr << "Release native context." << std::endl;
-  clReleaseContext(native_context);
 
   std::cerr << "Make kernel bundle." << std::endl;
   auto bundle = make_kernel_bundle<backend::opencl, bundle_state::executable>(
       p, q.get_context());
-  std::cerr << "Release native program." << std::endl;
-  // cl_program must have been retained by the above call.
-  clReleaseProgram(p);
 
   std::cerr << "Get native program." << std::endl;
   std::vector<cl_program> device_image =
       get_native<backend::opencl, bundle_state::executable>(bundle);
   assert(device_image.size() == 1);
   std::cerr << "Create native kernel." << std::endl;
   cl_kernel k = clCreateKernel(device_image.front(), "do_nothing", nullptr);
-  // get_native must have retained cl_program as well.
-  clReleaseProgram(device_image.front());
 
   std::cerr << "Make kernel." << std::endl;
   make_kernel<backend::opencl>(k, q.get_context());
-  std::cerr << "Release native kernel." << std::endl;
+
+  clReleaseProgram(p);
   clReleaseKernel(k);
 
   return 0;