Revert "[SYCL] Drop get_native class functions (intel#6483)"

This reverts commit 282e774.

Author: hjabird

sycl/include/sycl/backend.hpp

@@ -125,19 +125,7 @@ auto get_native(const SyclObjectT &Obj)
     throw sycl::runtime_error(errc::backend_mismatch, "Backends mismatch",
                               PI_ERROR_INVALID_OPERATION);
   }
-  return reinterpret_cast<backend_return_t<BackendName, SyclObjectT>>(
-      Obj.getNative());
-}
-
-template <backend BackendName, bundle_state State>
-auto get_native(const kernel_bundle<State> &Obj)
-    -> backend_return_t<BackendName, kernel_bundle<State>> {
-  // TODO use SYCL 2020 exception when implemented
-  if (Obj.get_backend() != BackendName) {
-    throw sycl::runtime_error(errc::backend_mismatch, "Backends mismatch",
-                              PI_ERROR_INVALID_OPERATION);
-  }
-  return Obj.template getNative<BackendName>();
+  return Obj.template get_native<BackendName>();
 }
 
 template <backend BackendName, typename DataT, int Dimensions,

sycl/include/sycl/context.hpp

@@ -217,6 +217,15 @@ class __SYCL_EXPORT context {
   /// \return a vector of valid SYCL device instances.
   std::vector<device> get_devices() const;
 
+  /// Gets the native handle of the SYCL context.
+  ///
+  /// \return a native handle, the type of which defined by the backend.
+  template <backend Backend>
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
+  backend_return_t<Backend, context> get_native() const {
+    return reinterpret_cast<backend_return_t<Backend, context>>(getNative());
+  }
+
 private:
   /// Constructs a SYCL context object from a valid context_impl instance.
   context(std::shared_ptr<detail::context_impl> Impl);

sycl/include/sycl/device.hpp

@@ -25,9 +25,6 @@ namespace sycl {
 __SYCL_INLINE_VER_NAMESPACE(_V1) {
 // Forward declarations
 class device_selector;
-template <backend BackendName, class SyclObjectT>
-auto get_native(const SyclObjectT &Obj)
-    -> backend_return_t<BackendName, SyclObjectT>;
 namespace detail {
 class device_impl;
 auto getDeviceComparisonLambda();
@@ -205,6 +202,19 @@ class __SYCL_EXPORT device {
   /// \return the backend associated with this device.
   backend get_backend() const noexcept;
 
+  /// Gets the native handle of the SYCL device.
+  ///
+  /// \return a native handle, the type of which defined by the backend.
+  template <backend Backend>
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
+  backend_return_t<Backend, device> get_native() const {
+    // In CUDA CUdevice isn't an opaque pointer, unlike a lot of the others,
+    // but instead a 32-bit int (on all relevant systems). Different
+    // backends use the same function for this purpose so static_cast is
+    // needed in some cases but not others, so a C-style cast was chosen.
+    return (backend_return_t<Backend, device>)getNative();
+  }
+
   /// Indicates if the SYCL device has the given feature.
   ///
   /// \param Aspect is one of the values in Table 4.20 of the SYCL 2020
@@ -231,10 +241,6 @@ class __SYCL_EXPORT device {
   friend T detail::createSyclObjFromImpl(decltype(T::impl) ImplObj);
 
   friend auto detail::getDeviceComparisonLambda();
-
-  template <backend BackendName, class SyclObjectT>
-  friend auto get_native(const SyclObjectT &Obj)
-      -> backend_return_t<BackendName, SyclObjectT>;
 };
 
 } // __SYCL_INLINE_VER_NAMESPACE(_V1)

sycl/include/sycl/event.hpp

@@ -22,11 +22,6 @@ namespace sycl {
 __SYCL_INLINE_VER_NAMESPACE(_V1) {
 // Forward declaration
 class context;
-
-template <backend BackendName, class SyclObjectT>
-auto get_native(const SyclObjectT &Obj)
-    -> backend_return_t<BackendName, SyclObjectT>;
-
 namespace detail {
 class event_impl;
 }
@@ -127,6 +122,15 @@ class __SYCL_EXPORT event {
   /// \return the backend associated with this platform
   backend get_backend() const noexcept;
 
+  /// Gets the native handle of the SYCL event.
+  ///
+  /// \return a native handle, the type of which defined by the backend.
+  template <backend Backend>
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
+  backend_return_t<Backend, event> get_native() const {
+    return reinterpret_cast<backend_return_t<Backend, event>>(getNative());
+  }
+
 private:
   event(std::shared_ptr<detail::event_impl> EventImpl);
 

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

@@ -221,6 +221,21 @@ make_buffer(
       !(BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep));
 }
 
+// TODO: remove this specialization when generic is changed to call
+// .GetNative() instead of .get_native() member of kernel_bundle.
+template <>
+inline auto get_native<backend::ext_oneapi_level_zero>(
+    const kernel_bundle<bundle_state::executable> &Obj)
+    -> backend_return_t<backend::ext_oneapi_level_zero,
+                        kernel_bundle<bundle_state::executable>> {
+  // TODO use SYCL 2020 exception when implemented
+  if (Obj.get_backend() != backend::ext_oneapi_level_zero)
+    throw runtime_error(errc::backend_mismatch, "Backends mismatch",
+                        PI_ERROR_INVALID_OPERATION);
+
+  return Obj.template getNative<backend::ext_oneapi_level_zero>();
+}
+
 namespace __SYCL2020_DEPRECATED("use 'ext::oneapi::level_zero' instead")
     level_zero {
 using namespace ext::oneapi::level_zero;

sycl/include/sycl/ext/oneapi/experimental/backend/cuda.hpp

@@ -10,7 +10,6 @@
 
 #include <sycl/backend.hpp>
 #include <sycl/context.hpp>
-#include <sycl/ext/oneapi/experimental/backend/backend_traits_cuda.hpp>
 
 #include <vector>
 
@@ -53,6 +52,13 @@ inline auto get_native<backend::ext_oneapi_cuda, context>(const context &C)
   return ret;
 }
 
+// Specialisation of non-free context get_native
+template <>
+inline backend_return_t<backend::ext_oneapi_cuda, context>
+context::get_native<backend::ext_oneapi_cuda>() const {
+  return sycl::get_native<backend::ext_oneapi_cuda, context>(*this);
+}
+
 // Specialisation of interop_handles get_native_context
 template <>
 inline backend_return_t<backend::ext_oneapi_cuda, context>
@@ -73,20 +79,6 @@ inline device make_device<backend::ext_oneapi_cuda>(
   return ext::oneapi::cuda::make_device(NativeHandle);
 }
 
-template <>
-backend_return_t<backend::ext_oneapi_cuda, device>
-get_native<backend::ext_oneapi_cuda, device>(const device &Obj) {
-  // TODO use SYCL 2020 exception when implemented
-  if (Obj.get_backend() != backend::ext_oneapi_cuda) {
-    throw sycl::runtime_error(errc::backend_mismatch, "Backends mismatch",
-                              PI_ERROR_INVALID_OPERATION);
-  }
-  // CUDA uses a 32-bit int instead of an opaque pointer like other backends,
-  // so we need a specialization with static_cast instead of reinterpret_cast.
-  return static_cast<backend_return_t<backend::ext_oneapi_cuda, device>>(
-      Obj.getNative());
-}
-
 // CUDA event specialization
 template <>
 inline event make_event<backend::ext_oneapi_cuda>(

sycl/include/sycl/kernel.hpp

@@ -28,9 +28,6 @@ class program;
 class context;
 template <backend Backend> class backend_traits;
 template <bundle_state State> class kernel_bundle;
-template <backend BackendName, class SyclObjectT>
-auto get_native(const SyclObjectT &Obj)
-    -> backend_return_t<BackendName, SyclObjectT>;
 
 namespace detail {
 class kernel_impl;
@@ -166,6 +163,12 @@ class __SYCL_EXPORT kernel {
       Param>::with_input_return_type
   get_info(const device &Device, const range<3> &WGSize) const;
 
+  template <backend Backend>
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
+  backend_return_t<Backend, kernel> get_native() const {
+    return detail::pi::cast<backend_return_t<Backend, kernel>>(getNative());
+  }
+
 private:
   /// Constructs a SYCL kernel object from a valid kernel_impl instance.
   kernel(std::shared_ptr<detail::kernel_impl> Impl);
@@ -181,9 +184,6 @@ class __SYCL_EXPORT kernel {
   friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);
   template <class T>
   friend T detail::createSyclObjFromImpl(decltype(T::impl) ImplObj);
-  template <backend BackendName, class SyclObjectT>
-  friend auto get_native(const SyclObjectT &Obj)
-      -> backend_return_t<BackendName, SyclObjectT>;
 };
 } // __SYCL_INLINE_VER_NAMESPACE(_V1)
 } // namespace sycl

sycl/include/sycl/kernel_bundle.hpp

@@ -26,9 +26,8 @@ namespace sycl {
 __SYCL_INLINE_VER_NAMESPACE(_V1) {
 // Forward declaration
 template <backend Backend> class backend_traits;
-template <backend Backend, bundle_state State>
-auto get_native(const kernel_bundle<State> &Obj)
-    -> backend_return_t<Backend, kernel_bundle<State>>;
+template <backend Backend, class SyclT>
+auto get_native(const SyclT &Obj) -> backend_return_t<Backend, SyclT>;
 
 namespace detail {
 class kernel_id_impl;
@@ -311,6 +310,12 @@ class kernel_bundle : public detail::kernel_bundle_plain {
     return reinterpret_cast<device_image_iterator>(kernel_bundle_plain::end());
   }
 
+  template <backend Backend>
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
+  backend_return_t<Backend, kernel_bundle<State>> get_native() const {
+    return getNative<Backend>();
+  }
+
 private:
   kernel_bundle(detail::KernelBundleImplPtr Impl)
       : kernel_bundle_plain(std::move(Impl)) {}
@@ -321,9 +326,8 @@ class kernel_bundle : public detail::kernel_bundle_plain {
   template <class T>
   friend T detail::createSyclObjFromImpl(decltype(T::impl) ImplObj);
 
-  template <backend Backend, bundle_state StateB>
-  friend auto get_native(const kernel_bundle<StateB> &Obj)
-      -> backend_return_t<Backend, kernel_bundle<StateB>>;
+  template <backend Backend, class SyclT>
+  friend auto get_native(const SyclT &Obj) -> backend_return_t<Backend, SyclT>;
 
   template <backend Backend>
   backend_return_t<Backend, kernel_bundle<State>> getNative() const {

sycl/include/sycl/platform.hpp

@@ -26,9 +26,6 @@ __SYCL_INLINE_VER_NAMESPACE(_V1) {
 // Forward declaration
 class device_selector;
 class device;
-template <backend BackendName, class SyclObjectT>
-auto get_native(const SyclObjectT &Obj)
-    -> backend_return_t<BackendName, SyclObjectT>;
 namespace detail {
 class platform_impl;
 }
@@ -138,6 +135,15 @@ class __SYCL_EXPORT platform {
   /// \return the backend associated with this platform
   backend get_backend() const noexcept;
 
+  /// Gets the native handle of the SYCL platform.
+  ///
+  /// \return a native handle, the type of which defined by the backend.
+  template <backend Backend>
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
+  backend_return_t<Backend, platform> get_native() const {
+    return reinterpret_cast<backend_return_t<Backend, platform>>(getNative());
+  }
+
   /// Indicates if all of the SYCL devices on this platform have the
   /// given feature.
   ///
@@ -166,9 +172,6 @@ class __SYCL_EXPORT platform {
   template <class Obj>
   friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);
 
-  template <backend BackendName, class SyclObjectT>
-  friend auto get_native(const SyclObjectT &Obj)
-      -> backend_return_t<BackendName, SyclObjectT>;
 }; // class platform
 } // __SYCL_INLINE_VER_NAMESPACE(_V1)
 } // namespace sycl

sycl/include/sycl/program.hpp

@@ -28,10 +28,6 @@ __SYCL_INLINE_VER_NAMESPACE(_V1) {
 // Forward declarations
 class context;
 class device;
-template <backend BackendName, class SyclObjectT>
-auto get_native(const SyclObjectT &Obj)
-    -> backend_return_t<BackendName, SyclObjectT>;
-
 namespace detail {
 class program_impl;
 }
@@ -369,6 +365,15 @@ class __SYCL_EXPORT __SYCL2020_DEPRECATED(
   /// \return the backend associated with this program.
   backend get_backend() const noexcept;
 
+  /// Gets the native handle of the SYCL platform.
+  ///
+  /// \return a native handle, the type of which defined by the backend.
+  template <backend Backend>
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
+  backend_return_t<Backend, program> get_native() const {
+    return reinterpret_cast<backend_return_t<Backend, program>>(getNative());
+  }
+
 private:
   pi_native_handle getNative() const;
   program(std::shared_ptr<detail::program_impl> impl);
@@ -414,9 +419,6 @@ class __SYCL_EXPORT __SYCL2020_DEPRECATED(
   friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);
   template <class T>
   friend T detail::createSyclObjFromImpl(decltype(T::impl) ImplObj);
-  template <backend BackendName, class SyclObjectT>
-  friend auto get_native(const SyclObjectT &Obj)
-      -> backend_return_t<BackendName, SyclObjectT>;
 };
 } // __SYCL_INLINE_VER_NAMESPACE(_V1)
 } // namespace sycl

sycl/include/sycl/queue.hpp

@@ -59,13 +59,8 @@ class context;
 class device;
 class queue;
 
-template <backend BackendName, class SyclObjectT>
-auto get_native(const SyclObjectT &Obj)
-    -> backend_return_t<BackendName, SyclObjectT>;
-
 namespace detail {
 class queue_impl;
-
 #if __SYCL_USE_FALLBACK_ASSERT
 static event submitAssertCapture(queue &, event &, queue *,
                                  const detail::code_location &);
@@ -1069,6 +1064,15 @@ class __SYCL_EXPORT queue {
   /// \return the backend associated with this queue.
   backend get_backend() const noexcept;
 
+  /// Gets the native handle of the SYCL queue.
+  ///
+  /// \return a native handle, the type of which defined by the backend.
+  template <backend Backend>
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
+  backend_return_t<Backend, queue> get_native() const {
+    return reinterpret_cast<backend_return_t<Backend, queue>>(getNative());
+  }
+
 private:
   pi_native_handle getNative() const;
 
@@ -1080,10 +1084,6 @@ class __SYCL_EXPORT queue {
   template <class T>
   friend T detail::createSyclObjFromImpl(decltype(T::impl) ImplObj);
 
-  template <backend BackendName, class SyclObjectT>
-  friend auto get_native(const SyclObjectT &Obj)
-      -> backend_return_t<BackendName, SyclObjectT>;
-
 #if __SYCL_USE_FALLBACK_ASSERT
   friend event detail::submitAssertCapture(queue &, event &, queue *,
                                            const detail::code_location &);

sycl/test/basic_tests/interop-cuda-experimental.cpp

@@ -57,6 +57,20 @@ int main() {
   cu_event = get_native<backend::ext_oneapi_cuda>(Event);
   cu_queue = get_native<backend::ext_oneapi_cuda>(Queue);
 
+  // Check deprecated
+  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  // expected-warning@+1 {{'get_native<sycl::backend::ext_oneapi_cuda>' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  cu_device = Device.get_native<backend::ext_oneapi_cuda>();
+  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  // expected-warning@+1 {{'get_native<sycl::backend::ext_oneapi_cuda>' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  cu_context = Context.get_native<backend::ext_oneapi_cuda>();
+  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  // expected-warning@+1 {{'get_native<sycl::backend::ext_oneapi_cuda>' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  cu_event = Event.get_native<backend::ext_oneapi_cuda>();
+  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  // expected-warning@+1 {{'get_native<sycl::backend::ext_oneapi_cuda>' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  cu_queue = Queue.get_native<backend::ext_oneapi_cuda>();
+
   // 4.5.1.1 For each SYCL runtime class T which supports SYCL application
   // interoperability with the SYCL backend, a specialization of input_type must
   // be defined as the type of SYCL application interoperability native backend