[SYCL] Remove deprecated interop interfaces

sycl/include/sycl/backend.hpp

@@ -269,7 +269,8 @@ __SYCL_EXPORT device make_device(pi_native_handle NativeHandle,
                                  backend Backend);
 __SYCL_EXPORT context make_context(pi_native_handle NativeHandle,
                                    const async_handler &Handler,
-                                   backend Backend);
+                                   backend Backend, bool KeepOwnership,
+                                   const std::vector<device> &DeviceList = {});
 __SYCL_EXPORT queue make_queue(pi_native_handle NativeHandle,
                                int32_t nativeHandleDesc,
                                const context &TargetContext,
@@ -334,7 +335,7 @@ make_context(
         &BackendObject,
     const async_handler &Handler = {}) {
   return detail::make_context(detail::pi::cast<pi_native_handle>(BackendObject),
-                              Handler, Backend);
+                              Handler, Backend, false /* KeepOwnership */);
 }
 
 template <backend Backend>

sycl/include/sycl/backend/opencl.hpp

@@ -24,54 +24,10 @@
 namespace sycl {
 inline namespace _V1 {
 namespace opencl {
-// Implementation of various "make" functions resides in SYCL RT because
-// creating SYCL objects requires knowing details not accessible here.
-// Note that they take opaque pi_native_handle that real OpenCL handles
-// are casted to.
-//
-__SYCL_EXPORT platform make_platform(pi_native_handle NativeHandle);
-__SYCL_EXPORT device make_device(pi_native_handle NativeHandle);
-__SYCL_EXPORT context make_context(pi_native_handle NativeHandle);
-__SYCL_EXPORT queue make_queue(const context &Context,
-                               pi_native_handle InteropHandle);
-
 __SYCL_EXPORT bool has_extension(const sycl::platform &SyclPlatform,
                                  const std::string &Extension);
 __SYCL_EXPORT bool has_extension(const sycl::device &SyclDevice,
                                  const std::string &Extension);
-
-// Construction of SYCL platform.
-template <typename T,
-          typename std::enable_if_t<std::is_same_v<T, platform>> * = nullptr>
-__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_platform free function")
-T make(typename detail::interop<backend::opencl, T>::type Interop) {
-  return make_platform(detail::pi::cast<pi_native_handle>(Interop));
-}
-
-// Construction of SYCL device.
-template <typename T,
-          typename std::enable_if_t<std::is_same_v<T, device>> * = nullptr>
-__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_device free function")
-T make(typename detail::interop<backend::opencl, T>::type Interop) {
-  return make_device(detail::pi::cast<pi_native_handle>(Interop));
-}
-
-// Construction of SYCL context.
-template <typename T,
-          typename std::enable_if_t<std::is_same_v<T, context>> * = nullptr>
-__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_context free function")
-T make(typename detail::interop<backend::opencl, T>::type Interop) {
-  return make_context(detail::pi::cast<pi_native_handle>(Interop));
-}
-
-// Construction of SYCL queue.
-template <typename T,
-          typename std::enable_if_t<std::is_same_v<T, queue>> * = nullptr>
-__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_queue free function")
-T make(const context &Context,
-       typename detail::interop<backend::opencl, T>::type Interop) {
-  return make_queue(Context, detail::pi::cast<pi_native_handle>(Interop));
-}
 } // namespace opencl
 } // namespace _V1
 } // namespace sycl

sycl/include/sycl/ext/oneapi/backend/level_zero.hpp

@@ -41,88 +41,27 @@
 
 namespace sycl {
 inline namespace _V1 {
-namespace ext::oneapi::level_zero {
-// Implementation of various "make" functions resides in libsycl.so and thus
-// their interface needs to be backend agnostic.
-// TODO: remove/merge with similar functions in sycl::detail
-__SYCL_EXPORT platform make_platform(pi_native_handle NativeHandle);
+namespace ext::oneapi::level_zero::detail {
 __SYCL_EXPORT device make_device(const platform &Platform,
                                  pi_native_handle NativeHandle);
-__SYCL_EXPORT context make_context(const std::vector<device> &DeviceList,
-                                   pi_native_handle NativeHandle,
-                                   bool keep_ownership = false);
-__SYCL_EXPORT queue make_queue(const context &Context, const device &Device,
-                               pi_native_handle InteropHandle,
-                               bool IsImmCmdList, bool keep_ownership,
-                               const property_list &Properties);
-__SYCL_EXPORT event make_event(const context &Context,
-                               pi_native_handle InteropHandle,
-                               bool keep_ownership = false);
-
-// Construction of SYCL platform.
-template <typename T,
-          typename std::enable_if_t<std::is_same_v<T, platform>> * = nullptr>
-__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_platform free function")
-T make(typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
-           Interop) {
-  return make_platform(reinterpret_cast<pi_native_handle>(Interop));
-}
-
-// Construction of SYCL device.
-template <typename T,
-          typename std::enable_if_t<std::is_same_v<T, device>> * = nullptr>
-__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_device free function")
-T make(const platform &Platform,
-       typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
-           Interop) {
-  return make_device(Platform, reinterpret_cast<pi_native_handle>(Interop));
-}
-
-/// Construction of SYCL context.
-/// \param DeviceList is a vector of devices which must be encapsulated by
-///        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, std::enable_if_t<std::is_same_v<T, context>> * = nullptr>
-__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_context free function")
-T make(const std::vector<device> &DeviceList,
-       typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
-           Interop,
-       ownership Ownership = ownership::transfer) {
-  return make_context(DeviceList,
-                      sycl::detail::pi::cast<pi_native_handle>(Interop),
-                      Ownership == ownership::keep);
-}
-
-// Construction of SYCL event.
-template <typename T,
-          typename std::enable_if_t<std::is_same_v<T, event>> * = nullptr>
-__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_event free function")
-T make(const context &Context,
-       typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
-           Interop,
-       ownership Ownership = ownership::transfer) {
-  return make_event(Context, reinterpret_cast<pi_native_handle>(Interop),
-                    Ownership == ownership::keep);
-}
-
-} // namespace ext::oneapi::level_zero
+} // namespace ext::oneapi::level_zero::detail
 
 // Specialization of sycl::make_context for Level-Zero backend.
 template <>
 inline context make_context<backend::ext_oneapi_level_zero>(
     const backend_input_t<backend::ext_oneapi_level_zero, context>
         &BackendObject,
     const async_handler &Handler) {
-  (void)Handler;
-  return ext::oneapi::level_zero::make_context(
-      BackendObject.DeviceList,
-      detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
-      BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep);
+
+  const std::vector<device> &DeviceList = BackendObject.DeviceList;
+  pi_native_handle NativeHandle =
+      detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle);
+  bool KeepOwnership =
+      BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep;
+
+  return sycl::detail::make_context(NativeHandle, Handler,
+                                    backend::ext_oneapi_level_zero,
+                                    KeepOwnership, DeviceList);
 }
 
 namespace detail {
@@ -191,7 +130,6 @@ template <>
 inline queue make_queue<backend::ext_oneapi_level_zero>(
     const backend_input_t<backend::ext_oneapi_level_zero, queue> &BackendObject,
     const context &TargetContext, const async_handler Handler) {
-  (void)Handler;
   const device Device = device{BackendObject.Device};
   bool IsImmCmdList = std::holds_alternative<ze_command_list_handle_t>(
       BackendObject.NativeHandle);
@@ -202,10 +140,11 @@ inline queue make_queue<backend::ext_oneapi_level_zero>(
                                 : reinterpret_cast<pi_native_handle>(
                                       *(std::get_if<ze_command_queue_handle_t>(
                                           &BackendObject.NativeHandle)));
-  return ext::oneapi::level_zero::make_queue(
-      TargetContext, Device, Handle, IsImmCmdList,
+
+  return sycl::detail::make_queue(
+      Handle, IsImmCmdList, TargetContext, &Device,
       BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep,
-      BackendObject.Properties);
+      BackendObject.Properties, Handler, backend::ext_oneapi_level_zero);
 }
 
 // Specialization of sycl::get_native for Level-Zero backend.
@@ -227,10 +166,11 @@ template <>
 inline event make_event<backend::ext_oneapi_level_zero>(
     const backend_input_t<backend::ext_oneapi_level_zero, event> &BackendObject,
     const context &TargetContext) {
-  return ext::oneapi::level_zero::make_event(
-      TargetContext,
+  return sycl::detail::make_event(
       detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
-      BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep);
+      TargetContext,
+      BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep,
+      backend::ext_oneapi_level_zero);
 }
 
 // Specialization of sycl::make_kernel_bundle for Level-Zero backend.

sycl/source/backend.cpp

@@ -93,15 +93,21 @@ __SYCL_EXPORT device make_device(pi_native_handle NativeHandle,
 
 __SYCL_EXPORT context make_context(pi_native_handle NativeHandle,
                                    const async_handler &Handler,
-                                   backend Backend) {
+                                   backend Backend, bool KeepOwnership,
+                                   const std::vector<device> &DeviceList) {
   const auto &Plugin = getPlugin(Backend);
 
   pi::PiContext PiContext = nullptr;
+  std::vector<pi_device> DeviceHandles;
+  for (auto Dev : DeviceList) {
+    DeviceHandles.push_back(detail::getSyclObjImpl(Dev)->getHandleRef());
+  }
   Plugin->call<PiApiKind::piextContextCreateWithNativeHandle>(
-      NativeHandle, 0, nullptr, false, &PiContext);
+      NativeHandle, DeviceHandles.size(), DeviceHandles.data(), false,
+      &PiContext);
   // Construct the SYCL context from PI context.
-  return detail::createSyclObjFromImpl<context>(
-      std::make_shared<context_impl>(PiContext, Handler, Plugin));
+  return detail::createSyclObjFromImpl<context>(std::make_shared<context_impl>(
+      PiContext, Handler, Plugin, DeviceList, !KeepOwnership));
 }
 
 __SYCL_EXPORT queue make_queue(pi_native_handle NativeHandle,

sycl/source/backend/level_zero.cpp

@@ -15,17 +15,9 @@
 
 namespace sycl {
 inline namespace _V1 {
-namespace ext::oneapi::level_zero {
-using namespace detail;
+namespace ext::oneapi::level_zero::detail {
+using namespace sycl::detail;
 
-//----------------------------------------------------------------------------
-// Implementation of level_zero::make<platform>
-__SYCL_EXPORT platform make_platform(pi_native_handle NativeHandle) {
-  return detail::make_platform(NativeHandle, backend::ext_oneapi_level_zero);
-}
-
-//----------------------------------------------------------------------------
-// Implementation of level_zero::make<device>
 __SYCL_EXPORT device make_device(const platform &Platform,
                                  pi_native_handle NativeHandle) {
   const auto &Plugin = pi::getPlugin<backend::ext_oneapi_level_zero>();
@@ -39,48 +31,6 @@ __SYCL_EXPORT device make_device(const platform &Platform,
       PlatformImpl->getOrMakeDeviceImpl(PiDevice, PlatformImpl));
 }
 
-//----------------------------------------------------------------------------
-// Implementation of level_zero::make<context>
-__SYCL_EXPORT context make_context(const std::vector<device> &DeviceList,
-                                   pi_native_handle NativeHandle,
-                                   bool KeepOwnership) {
-  const auto &Plugin = pi::getPlugin<backend::ext_oneapi_level_zero>();
-  // Create PI context first.
-  pi_context PiContext;
-  std::vector<pi_device> DeviceHandles;
-  for (auto Dev : DeviceList) {
-    DeviceHandles.push_back(detail::getSyclObjImpl(Dev)->getHandleRef());
-  }
-  Plugin->call<PiApiKind::piextContextCreateWithNativeHandle>(
-      NativeHandle, DeviceHandles.size(), DeviceHandles.data(), !KeepOwnership,
-      &PiContext);
-  // Construct the SYCL context from PI context.
-  return detail::createSyclObjFromImpl<context>(
-      std::make_shared<context_impl>(PiContext, detail::defaultAsyncHandler,
-                                     Plugin, DeviceList, !KeepOwnership));
-}
-
-//----------------------------------------------------------------------------
-// Implementation of level_zero::make<queue>
-__SYCL_EXPORT queue make_queue(const context &Context, const device &Device,
-                               pi_native_handle NativeHandle, bool IsImmCmdList,
-                               bool KeepOwnership,
-                               const property_list &Properties) {
-  const auto &ContextImpl = getSyclObjImpl(Context);
-  return detail::make_queue(
-      NativeHandle, IsImmCmdList, Context, &Device, KeepOwnership, Properties,
-      ContextImpl->get_async_handler(), backend::ext_oneapi_level_zero);
-}
-
-//----------------------------------------------------------------------------
-// Implementation of level_zero::make<event>
-__SYCL_EXPORT event make_event(const context &Context,
-                               pi_native_handle NativeHandle,
-                               bool KeepOwnership) {
-  return detail::make_event(NativeHandle, Context, KeepOwnership,
-                            backend::ext_oneapi_level_zero);
-}
-
-} // namespace ext::oneapi::level_zero
+} // namespace ext::oneapi::level_zero::detail
 } // namespace _V1
 } // namespace sycl

sycl/source/backend/opencl.cpp

@@ -21,34 +21,6 @@ inline namespace _V1 {
 namespace opencl {
 using namespace detail;
 
-//----------------------------------------------------------------------------
-// Implementation of opencl::make<platform>
-__SYCL_EXPORT platform make_platform(pi_native_handle NativeHandle) {
-  return detail::make_platform(NativeHandle, backend::opencl);
-}
-
-//----------------------------------------------------------------------------
-// Implementation of opencl::make<device>
-__SYCL_EXPORT device make_device(pi_native_handle NativeHandle) {
-  return detail::make_device(NativeHandle, backend::opencl);
-}
-
-//----------------------------------------------------------------------------
-// Implementation of opencl::make<context>
-__SYCL_EXPORT context make_context(pi_native_handle NativeHandle) {
-  return detail::make_context(NativeHandle, detail::defaultAsyncHandler,
-                              backend::opencl);
-}
-
-//----------------------------------------------------------------------------
-// Implementation of opencl::make<queue>
-__SYCL_EXPORT queue make_queue(const context &Context,
-                               pi_native_handle NativeHandle) {
-  const auto &ContextImpl = getSyclObjImpl(Context);
-  return detail::make_queue(NativeHandle, 0, Context, nullptr, false, {},
-                            ContextImpl->get_async_handler(), backend::opencl);
-}
-
 //----------------------------------------------------------------------------
 // Free functions to query OpenCL backend extensions
 __SYCL_EXPORT bool has_extension(const sycl::platform &SyclPlatform,

sycl/test-e2e/Plugin/interop-level-zero-keep-ownership.cpp

@@ -30,8 +30,9 @@ int main() {
   { // Scope in which SYCL interop context object is live
     std::vector<device> Devices{};
     Devices.push_back(Device);
-    auto Context = level_zero::make<context>(Devices, ZeContext,
-                                             level_zero::ownership::keep);
+    auto Context = make_context<backend::ext_oneapi_level_zero>(
+        backend_input_t<backend::ext_oneapi_level_zero, context>{
+            ZeContext, Devices, ext::oneapi::level_zero::ownership::keep});
 
     // Create L0 event pool
     ze_event_pool_handle_t ZeEventPool;
@@ -52,8 +53,10 @@ int main() {
 
     { // Scope in which SYCL interop event is alive
       int i = 0;
-      event Event = level_zero::make<event>(Context, ZeEvent,
-                                            level_zero::ownership::keep);
+      event Event = make_event<backend::ext_oneapi_level_zero>(
+          backend_input_t<backend::ext_oneapi_level_zero, event>{
+              ZeEvent, ext::oneapi::level_zero::ownership::keep},
+          Context);
 
       info::event_command_status status;
       do {

sycl/test-e2e/Plugin/interop-opencl.cpp

@@ -47,10 +47,11 @@ int main() {
   assert(ocl_buffers.size() == 1);
 
   // Re-create SYCL objects from native OpenCL handles
-  auto PlatformInterop = opencl::make<platform>(ocl_platform);
-  auto DeviceInterop = opencl::make<device>(ocl_device);
-  auto ContextInterop = opencl::make<context>(ocl_context);
-  auto QueueInterop = opencl::make<queue>(ContextInterop, ocl_queue);
+  auto PlatformInterop = sycl::make_platform<backend::opencl>(ocl_platform);
+  auto DeviceInterop = sycl::make_device<backend::opencl>(ocl_device);
+  auto ContextInterop = sycl::make_context<backend::opencl>(ocl_context);
+  auto QueueInterop =
+      sycl::make_queue<backend::opencl>(ocl_queue, ContextInterop);
   auto BufferInterop =
       sycl::make_buffer<backend::opencl, int>(ocl_buffers[0], ContextInterop);