Testing refactor ext function cache

sycl/include/sycl/detail/pi.def

@@ -103,6 +103,8 @@ _PI_API(piSamplerCreate)
 _PI_API(piSamplerGetInfo)
 _PI_API(piSamplerRetain)
 _PI_API(piSamplerRelease)
+_PI_API(piextSamplerGetNativeHandle)
+_PI_API(piextSamplerCreateWithNativeHandle)
 // Queue commands
 _PI_API(piEnqueueKernelLaunch)
 _PI_API(piEnqueueEventsWait)

sycl/include/sycl/detail/pi.h

@@ -1743,6 +1743,13 @@ __SYCL_EXPORT pi_result piSamplerRetain(pi_sampler sampler);
 
 __SYCL_EXPORT pi_result piSamplerRelease(pi_sampler sampler);
 
+__SYCL_EXPORT pi_result piextSamplerCreateWithNativeHandle(
+    pi_native_handle nativeHandle, pi_context context,
+    const bool ownNativeHandle, pi_sampler *sampler);
+
+__SYCL_EXPORT pi_result
+piextSamplerGetNativeHandle(pi_sampler sampler, pi_native_handle *nativeHandle);
+
 //
 // Queue Commands
 //

sycl/plugins/cuda/pi_cuda.cpp

@@ -637,6 +637,19 @@ pi_result piSamplerRelease(pi_sampler Sampler) {
   return pi2ur::piSamplerRelease(Sampler);
 }
 
+pi_result piextSamplerGetNativeHandle(pi_sampler sampler,
+                                      pi_native_handle *nativeHandle) {
+  return pi2ur::piextSamplerGetNativeHandle(sampler, nativeHandle);
+}
+
+pi_result piextSamplerCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                             pi_context context,
+                                             const bool ownNativeHandle,
+                                             pi_sampler *sampler) {
+  return pi2ur::piextSamplerCreateWithNativeHandle(nativeHandle, context,
+                                                   ownNativeHandle, sampler);
+}
+
 pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList,
                               const pi_event *EventWaitList,
                               pi_event *OutEvent) {

sycl/plugins/hip/pi_hip.cpp

@@ -640,6 +640,19 @@ pi_result piSamplerRelease(pi_sampler Sampler) {
   return pi2ur::piSamplerRelease(Sampler);
 }
 
+pi_result piextSamplerGetNativeHandle(pi_sampler sampler,
+                                      pi_native_handle *nativeHandle) {
+  return pi2ur::piextSamplerGetNativeHandle(sampler, nativeHandle);
+}
+
+pi_result piextSamplerCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                             pi_context context,
+                                             const bool ownNativeHandle,
+                                             pi_sampler *sampler) {
+  return pi2ur::piextSamplerCreateWithNativeHandle(nativeHandle, context,
+                                                   ownNativeHandle, sampler);
+}
+
 pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList,
                               const pi_event *EventWaitList,
                               pi_event *OutEvent) {

sycl/plugins/level_zero/pi_level_zero.cpp

@@ -659,6 +659,19 @@ pi_result piSamplerRelease(pi_sampler Sampler) {
   return pi2ur::piSamplerRelease(Sampler);
 }
 
+pi_result piextSamplerGetNativeHandle(pi_sampler sampler,
+                                      pi_native_handle *nativeHandle) {
+  return pi2ur::piextSamplerGetNativeHandle(sampler, nativeHandle);
+}
+
+pi_result piextSamplerCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                             pi_context context,
+                                             const bool ownNativeHandle,
+                                             pi_sampler *sampler) {
+  return pi2ur::piextSamplerCreateWithNativeHandle(nativeHandle, context,
+                                                   ownNativeHandle, sampler);
+}
+
 //
 // Queue Commands
 //

sycl/plugins/native_cpu/pi_native_cpu.cpp

@@ -654,6 +654,19 @@ pi_result piSamplerRelease(pi_sampler Sampler) {
   return pi2ur::piSamplerRelease(Sampler);
 }
 
+pi_result piextSamplerGetNativeHandle(pi_sampler sampler,
+                                      pi_native_handle *nativeHandle) {
+  return pi2ur::piextSamplerGetNativeHandle(sampler, nativeHandle);
+}
+
+pi_result piextSamplerCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                             pi_context context,
+                                             const bool ownNativeHandle,
+                                             pi_sampler *sampler) {
+  return pi2ur::piextSamplerCreateWithNativeHandle(nativeHandle, context,
+                                                   ownNativeHandle, sampler);
+}
+
 //
 // Queue Commands
 //

sycl/plugins/opencl/pi_opencl.cpp

@@ -616,6 +616,19 @@ pi_result piSamplerRelease(pi_sampler Sampler) {
   return pi2ur::piSamplerRelease(Sampler);
 }
 
+pi_result piextSamplerGetNativeHandle(pi_sampler sampler,
+                                      pi_native_handle *nativeHandle) {
+  return pi2ur::piextSamplerGetNativeHandle(sampler, nativeHandle);
+}
+
+pi_result piextSamplerCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                             pi_context context,
+                                             const bool ownNativeHandle,
+                                             pi_sampler *sampler) {
+  return pi2ur::piextSamplerCreateWithNativeHandle(nativeHandle, context,
+                                                   ownNativeHandle, sampler);
+}
+
 pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList,
                               const pi_event *EventWaitList,
                               pi_event *OutEvent) {

sycl/plugins/unified_runtime/CMakeLists.txt

@@ -56,16 +56,14 @@ endif()
 if(SYCL_PI_UR_USE_FETCH_CONTENT)
   include(FetchContent)
 
-  set(UNIFIED_RUNTIME_REPO "https://github.com/oneapi-src/unified-runtime.git")
-  # commit 69ac6c7fecac1028024ec1889d3e2cc02565c9e7
-  # Merge: f11823e1 b3469f1e
-  # Author: Kenneth Benzie (Benie) <k.benzie@codeplay.com>
-  # Date:   Thu Feb 15 15:28:12 2024 +0100
-  #
-  #    Merge pull request #1344 from aarongreig/aaron/correctlyMapBufferLocation
-  #
-  #    Correct mapping of BUFFER_ALLOC_LOCATION_PROPERITES in CL adapter.
-  set(UNIFIED_RUNTIME_TAG 69ac6c7fecac1028024ec1889d3e2cc02565c9e7)
+  set(UNIFIED_RUNTIME_REPO "https://github.com/omarahmed1111/unified-runtime.git")
+  # commit 47af3ee296ae0517213114332ffd3ac54a456b16
+  # Merge: bd76c510 f2ca7a91
+  # Author: Omar Ahmed <30423288+omarahmed1111@users.noreply.github.com>
+  # Date:   Thu Nov 30 16:11:56 2023 +0000
+  # - Merge pull request #1072 from omarahmed1111/merge-some-main-changes-into-adapters-third-patch
+  # - Merge main into adapters branch
+  set(UNIFIED_RUNTIME_TAG 9bfbf6e654ed3813926e041f9470689b46569907)
 
   if(SYCL_PI_UR_OVERRIDE_FETCH_CONTENT_REPO)
     set(UNIFIED_RUNTIME_REPO "${SYCL_PI_UR_OVERRIDE_FETCH_CONTENT_REPO}")

sycl/plugins/unified_runtime/pi2ur.hpp

@@ -4412,6 +4412,38 @@ inline pi_result piSamplerRelease(pi_sampler Sampler) {
   return PI_SUCCESS;
 }
 
+pi_result piextSamplerGetNativeHandle(pi_sampler sampler,
+                                      pi_native_handle *nativeHandle) {
+  auto UrSampler = reinterpret_cast<ur_sampler_handle_t>(sampler);
+
+  ur_native_handle_t UrNativeHandle{};
+  HANDLE_ERRORS(urSamplerGetNativeHandle(UrSampler, &UrNativeHandle));
+
+  *nativeHandle = reinterpret_cast<pi_native_handle>(UrNativeHandle);
+
+  return PI_SUCCESS;
+}
+
+pi_result piextSamplerCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                             pi_context context,
+                                             bool ownNativeHandle,
+                                             pi_sampler *sampler) {
+  ur_native_handle_t UrNativeSampler =
+      reinterpret_cast<ur_native_handle_t>(nativeHandle);
+
+  ur_context_handle_t UrContext =
+      reinterpret_cast<ur_context_handle_t>(context);
+
+  ur_sampler_handle_t *URSampler =
+      reinterpret_cast<ur_sampler_handle_t *>(sampler);
+  ur_sampler_native_properties_t Properties{};
+  Properties.isNativeHandleOwned = ownNativeHandle;
+  HANDLE_ERRORS(urSamplerCreateWithNativeHandle(UrNativeSampler, UrContext,
+                                                &Properties, URSampler));
+
+  return PI_SUCCESS;
+}
+
 // Sampler
 ///////////////////////////////////////////////////////////////////////////////
 

sycl/plugins/unified_runtime/pi_unified_runtime.cpp

@@ -910,6 +910,18 @@ __SYCL_EXPORT pi_result piSamplerRetain(pi_sampler Sampler) {
 __SYCL_EXPORT pi_result piSamplerRelease(pi_sampler Sampler) {
   return pi2ur::piSamplerRelease(Sampler);
 }
+/* clang-format off */
+__SYCL_EXPORT pi_result piextSamplerGetNativeHandle(
+    pi_sampler sampler, pi_native_handle *nativeHandle) {
+  return pi2ur::piextSamplerGetNativeHandle(sampler, nativeHandle);
+}
+/* clang-format on */
+__SYCL_EXPORT pi_result piextSamplerCreateWithNativeHandle(
+    pi_native_handle nativeHandle, pi_context context,
+    const bool ownNativeHandle, pi_sampler *sampler) {
+  return pi2ur::piextSamplerCreateWithNativeHandle(nativeHandle, context,
+                                                   ownNativeHandle, sampler);
+}
 
 __SYCL_EXPORT pi_result piMemImageGetInfo(pi_mem Image, pi_image_info ParamName,
                                           size_t ParamValueSize,
@@ -1484,6 +1496,8 @@ __SYCL_EXPORT pi_result piPluginInit(pi_plugin *PluginInit) {
   _PI_API(piSamplerGetInfo)
   _PI_API(piSamplerRetain)
   _PI_API(piSamplerRelease)
+  _PI_API(piextSamplerCreateWithNativeHandle)
+  _PI_API(piextSamplerGetNativeHandle)
 
   // Peer to Peer
   _PI_API(piextEnablePeerAccess)

sycl/source/CMakeLists.txt

@@ -129,6 +129,9 @@ function(add_sycl_rt_library LIB_NAME LIB_OBJ_NAME)
   target_link_libraries(${LIB_OBJ_NAME}
     PRIVATE OpenCL-Headers
   )
+  target_link_libraries(${LIB_NAME}
+    PRIVATE OpenCL::OpenCL
+  )
 
   if(SYCL_ENABLE_KERNEL_FUSION)
     target_link_libraries(${LIB_NAME} PRIVATE sycl-fusion)

sycl/source/backend.cpp

@@ -94,6 +94,11 @@ __SYCL_EXPORT device make_device(pi_native_handle NativeHandle,
 __SYCL_EXPORT context make_context(pi_native_handle NativeHandle,
                                    const async_handler &Handler,
                                    backend Backend) {
+  if (Backend == backend::opencl) {
+    sycl::context Context(detail::pi::cast<cl_context>(NativeHandle), Handler);
+    return Context;
+  }
+
   const auto &Plugin = getPlugin(Backend);
 
   pi::PiContext PiContext = nullptr;
@@ -127,7 +132,11 @@ __SYCL_EXPORT queue make_queue(pi_native_handle NativeHandle,
         make_error_code(errc::invalid),
         "Queue create using make_queue cannot have compute_index property.");
   }
-
+  if (Backend == backend::opencl) {
+    sycl::queue Queue(detail::pi::cast<cl_command_queue>(NativeHandle), Context,
+                      Handler);
+    return Queue;
+  }
   // Create PI queue first.
   pi::PiQueue PiQueue = nullptr;
   Plugin->call<PiApiKind::piextQueueCreateWithNativeHandle>(
@@ -276,6 +285,19 @@ kernel make_kernel(const context &TargetContext,
         *KernelBundle.begin();
     const auto &DeviceImageImpl = getSyclObjImpl(DeviceImage);
     PiProgram = DeviceImageImpl->get_program_ref();
+  } else if (Backend == backend::opencl) {
+    cl_kernel CLKernel = detail::pi::cast<cl_kernel>(NativeHandle);
+    cl_program CLProgram;
+    size_t Ret = clGetKernelInfo(CLKernel, CL_KERNEL_PROGRAM, sizeof(CLProgram),
+                                 &CLProgram, nullptr);
+    if (Ret != CL_SUCCESS) {
+      throw runtime_error(
+          "Failed to retrieve program associated with the kernel",
+          PI_ERROR_INVALID_KERNEL);
+    }
+    Plugin->call<detail::PiApiKind::piextProgramCreateWithNativeHandle>(
+        detail::pi::cast<pi_native_handle>(CLProgram),
+        ContextImpl->getHandleRef(), false, &PiProgram);
   }
 
   // Create PI kernel first.

sycl/source/context.cpp

@@ -83,11 +83,35 @@ context::context(const std::vector<device> &DeviceList,
                                                     PropList);
   }
 }
+
 context::context(cl_context ClContext, async_handler AsyncHandler) {
   const auto &Plugin = sycl::detail::pi::getPlugin<backend::opencl>();
-  impl = std::make_shared<detail::context_impl>(
-      detail::pi::cast<sycl::detail::pi::PiContext>(ClContext), AsyncHandler,
-      Plugin);
+  uint32_t DeviceCount = 0;
+  size_t Ret = clGetContextInfo(ClContext, CL_CONTEXT_NUM_DEVICES,
+                                sizeof(DeviceCount), &DeviceCount, nullptr);
+  if (Ret != CL_SUCCESS) {
+    throw runtime_error(
+        "Failed to retrieve device count associated with the context",
+        PI_ERROR_INVALID_CONTEXT);
+  }
+  std::vector<cl_device_id> CLDevices(DeviceCount);
+  Ret = clGetContextInfo(ClContext, CL_CONTEXT_DEVICES, sizeof(CLDevices),
+                         CLDevices.data(), nullptr);
+  if (Ret != CL_SUCCESS) {
+    throw runtime_error(
+        "Failed to retrieve devices associated with the context",
+        PI_ERROR_INVALID_CONTEXT);
+  }
+  std::vector<sycl::detail::pi::PiDevice> Devices(DeviceCount);
+  for (uint32_t i = 0; i < DeviceCount; i++) {
+    Plugin->call<detail::PiApiKind::piextDeviceCreateWithNativeHandle>(
+        detail::pi::cast<pi_native_handle>(CLDevices[i]), nullptr, &Devices[i]);
+  }
+  sycl::detail::pi::PiContext Context;
+  Plugin->call<detail::PiApiKind::piextContextCreateWithNativeHandle>(
+      detail::pi::cast<pi_native_handle>(ClContext), DeviceCount,
+      Devices.data(), false, &Context);
+  impl = std::make_shared<detail::context_impl>(Context, AsyncHandler, Plugin);
 }
 
 template <typename Param>
@@ -122,7 +146,9 @@ context::get_info() const {
 
 #undef __SYCL_PARAM_TRAITS_SPEC
 
-cl_context context::get() const { return impl->get(); }
+cl_context context::get() const {
+  return detail::pi::cast<cl_context>(impl->getNative());
+}
 
 bool context::is_host() const {
   bool IsHost = impl->is_host();

sycl/source/detail/buffer_impl.cpp

@@ -54,7 +54,10 @@ void buffer_impl::addInteropObject(
       const PluginPtr &Plugin = getPlugin();
       Plugin->call<PiApiKind::piMemRetain>(
           pi::cast<sycl::detail::pi::PiMem>(MInteropMemObject));
-      Handles.push_back(pi::cast<pi_native_handle>(MInteropMemObject));
+      pi_native_handle Handle;
+      Plugin->call<PiApiKind::piextMemGetNativeHandle>(MInteropMemObject,
+                                                       nullptr, &Handle);
+      Handles.push_back(Handle);
     }
   }
 }

sycl/source/detail/context_impl.cpp

@@ -126,9 +126,12 @@ cl_context context_impl::get() const {
         "This instance of context doesn't support OpenCL interoperability.",
         PI_ERROR_INVALID_CONTEXT);
   }
-  // TODO catch an exception and put it to list of asynchronous exceptions
   getPlugin()->call<PiApiKind::piContextRetain>(MContext);
-  return pi::cast<cl_context>(MContext);
+  // TODO catch an exception and put it to list of asynchronous exceptions
+  pi_native_handle NativeContext;
+  getPlugin()->call<PiApiKind::piextContextGetNativeHandle>(MContext,
+                                                            &NativeContext);
+  return pi::cast<cl_context>(NativeContext);
 }
 
 bool context_impl::is_host() const { return MHostContext; }

sycl/source/detail/kernel_impl.cpp

@@ -44,16 +44,6 @@ kernel_impl::kernel_impl(sycl::detail::pi::PiKernel Kernel,
       MCreatedFromSource(IsCreatedFromSource),
       MKernelBundleImpl(std::move(KernelBundleImpl)),
       MKernelArgMaskPtr{ArgMask} {
-
-  sycl::detail::pi::PiContext Context = nullptr;
-  // Using the plugin from the passed ContextImpl
-  getPlugin()->call<PiApiKind::piKernelGetInfo>(
-      MKernel, PI_KERNEL_INFO_CONTEXT, sizeof(Context), &Context, nullptr);
-  if (ContextImpl->getHandleRef() != Context)
-    throw sycl::invalid_parameter_error(
-        "Input context must be the same as the context of cl_kernel",
-        PI_ERROR_INVALID_CONTEXT);
-
   MIsInterop = MProgramImpl->isInterop();
 }
 

sycl/source/detail/kernel_impl.hpp

@@ -106,7 +106,11 @@ class kernel_impl {
           PI_ERROR_INVALID_KERNEL);
     }
     getPlugin()->call<PiApiKind::piKernelRetain>(MKernel);
-    return pi::cast<cl_kernel>(MKernel);
+    // TODO catch an exception and put it to list of asynchronous exceptions
+    pi_native_handle NativeKernel;
+    getPlugin()->call<PiApiKind::piextKernelGetNativeHandle>(MKernel,
+                                                             &NativeKernel);
+    return pi::cast<cl_kernel>(NativeKernel);
   }
 
   /// Check if the associated SYCL context is a SYCL host context.