rebase

Signed-off-by: Sergey V Maslov <sergey.v.maslov@intel.com>

Author: smaslov-intel

sycl/include/CL/sycl/backend.hpp

@@ -66,8 +66,8 @@ using backend_return_t =
     typename backend_traits<Backend>::template return_type<SyclType>;
 
 template <backend BackendName, class SyclObjectT>
-auto get_native(const SyclObjectT &Obj) ->
-    typename interop<BackendName, SyclObjectT>::type {
+auto get_native(const SyclObjectT &Obj)
+    -> backend_return_t<BackendName, SyclObjectT> {
   // TODO use SYCL 2020 exception when implemented
   if (Obj.get_backend() != BackendName)
     throw runtime_error("Backends mismatch", PI_INVALID_OPERATION);
@@ -146,17 +146,18 @@ make_context(
 }
 
 template <backend Backend>
+__SYCL_DEPRECATED("Use SYCL-2020 sycl::make_queue free function")
 typename std::enable_if<
     detail::InteropFeatureSupportMap<Backend>::MakeQueue == true, queue>::type
-make_queue(const typename backend_traits<Backend>::template input_type<queue>
-               &BackendObject,
-           const context &TargetContext, bool KeepOwnership,
-           const async_handler Handler = {}) {
+    make_queue(
+        const typename backend_traits<Backend>::template input_type<queue>
+            &BackendObject,
+        const context &TargetContext, bool KeepOwnership,
+        const async_handler Handler = {}) {
   return detail::make_queue(detail::pi::cast<pi_native_handle>(BackendObject),
                             TargetContext, KeepOwnership, Handler, Backend);
 }
 
-// TODO: remove this version (without ownership) when allowed to break ABI.
 template <backend Backend>
 typename std::enable_if<
     detail::InteropFeatureSupportMap<Backend>::MakeQueue == true, queue>::type
@@ -178,11 +179,13 @@ make_event(const typename backend_traits<Backend>::template input_type<event>
 }
 
 template <backend Backend>
+__SYCL_DEPRECATED("Use SYCL-2020 sycl::make_event free function")
 typename std::enable_if<
     detail::InteropFeatureSupportMap<Backend>::MakeEvent == true, event>::type
-make_event(const typename backend_traits<Backend>::template input_type<event>
-               &BackendObject,
-           const context &TargetContext, bool KeepOwnership) {
+    make_event(
+        const typename backend_traits<Backend>::template input_type<event>
+            &BackendObject,
+        const context &TargetContext, bool KeepOwnership) {
   return detail::make_event(detail::pi::cast<pi_native_handle>(BackendObject),
                             TargetContext, KeepOwnership, Backend);
 }

sycl/include/CL/sycl/backend/level_zero.hpp

@@ -13,4 +13,246 @@
 __SYCL_WARNING("CL/sycl/backend/level_zero.hpp usage is deprecated, include "
                "sycl/ext/oneapi/backend/level_zero.hpp instead")
 
+<<<<<<< HEAD
 #include <sycl/ext/oneapi/backend/level_zero.hpp>
+=======
+template <> struct interop<backend::level_zero, platform> {
+  using type = ze_driver_handle_t;
+};
+
+template <> struct interop<backend::level_zero, device> {
+  using type = ze_device_handle_t;
+};
+
+template <> struct interop<backend::level_zero, context> {
+  using type = ze_context_handle_t;
+};
+
+template <> struct interop<backend::level_zero, queue> {
+  using type = ze_command_queue_handle_t;
+};
+
+template <> struct interop<backend::level_zero, event> {
+  using type = ze_event_handle_t;
+};
+
+template <> struct interop<backend::level_zero, program> {
+  using type = ze_module_handle_t;
+};
+
+template <typename DataT, int Dimensions, access::mode AccessMode>
+struct interop<backend::level_zero, accessor<DataT, Dimensions, AccessMode,
+                                             access::target::global_buffer,
+                                             access::placeholder::false_t>> {
+  using type = char *;
+};
+
+template <typename DataT, int Dimensions, access::mode AccessMode>
+struct interop<backend::level_zero, accessor<DataT, Dimensions, AccessMode,
+                                             access::target::constant_buffer,
+                                             access::placeholder::false_t>> {
+  using type = char *;
+};
+
+template <typename DataT, int Dimensions, access::mode AccessMode>
+struct interop<backend::level_zero,
+               accessor<DataT, Dimensions, AccessMode, access::target::image,
+                        access::placeholder::false_t>> {
+  using type = ze_image_handle_t;
+};
+
+namespace level_zero {
+// Since Level-Zero is not doing any reference counting itself, we have to
+// be explicit about the ownership of the native handles used in the
+// interop functions below.
+//
+enum class ownership { transfer, keep };
+} // namespace level_zero
+
+namespace detail {
+
+template <> struct BackendInput<backend::level_zero, context> {
+  using type = struct {
+    interop<backend::level_zero, context>::type NativeHandle;
+    std::vector<device> DeviceList;
+    level_zero::ownership Ownership;
+  };
+};
+
+template <> struct BackendInput<backend::level_zero, queue> {
+  using type = struct {
+    interop<backend::level_zero, queue>::type NativeHandle;
+    level_zero::ownership Ownership;
+  };
+};
+
+template <> struct BackendInput<backend::level_zero, event> {
+  using type = struct {
+    interop<backend::level_zero, event>::type NativeHandle;
+    level_zero::ownership Ownership;
+  };
+};
+
+template <bundle_state State>
+struct BackendInput<backend::level_zero, kernel_bundle<State>> {
+  using type = ze_module_handle_t;
+};
+
+template <bundle_state State>
+struct BackendReturn<backend::level_zero, kernel_bundle<State>> {
+  using type = std::vector<ze_module_handle_t>;
+};
+
+template <> struct BackendReturn<backend::level_zero, kernel> {
+  using type = ze_kernel_handle_t;
+};
+
+template <> struct InteropFeatureSupportMap<backend::level_zero> {
+  static constexpr bool MakePlatform = true;
+  static constexpr bool MakeDevice = true;
+  static constexpr bool MakeContext = true;
+  static constexpr bool MakeQueue = true;
+  static constexpr bool MakeEvent = true;
+  static constexpr bool MakeKernelBundle = true;
+  static constexpr bool MakeBuffer = false;
+  static constexpr bool MakeKernel = false;
+};
+} // namespace detail
+
+namespace 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);
+__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 program make_program(const context &Context,
+                                   pi_native_handle NativeHandle);
+__SYCL_EXPORT queue make_queue(const context &Context,
+                               pi_native_handle InteropHandle,
+                               bool keep_ownership = false);
+__SYCL_EXPORT event make_event(const context &Context,
+                               pi_native_handle InteropHandle,
+                               bool keep_ownership = false);
+
+// Construction of SYCL platform.
+template <typename T, typename detail::enable_if_t<
+                          std::is_same<T, platform>::value> * = nullptr>
+__SYCL_DEPRECATED("Use SYCL-2020 sycl::make_platform free function")
+T make(typename interop<backend::level_zero, T>::type Interop) {
+  return make_platform(reinterpret_cast<pi_native_handle>(Interop));
+}
+
+// Construction of SYCL device.
+template <typename T, typename detail::enable_if_t<
+                          std::is_same<T, device>::value> * = nullptr>
+__SYCL_DEPRECATED("Use SYCL-2020 sycl::make_device free function")
+T make(const platform &Platform,
+       typename interop<backend::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, typename std::enable_if<
+                          std::is_same<T, context>::value>::type * = nullptr>
+__SYCL_DEPRECATED("Use SYCL-2020 sycl::make_context free function")
+T make(const std::vector<device> &DeviceList,
+       typename interop<backend::level_zero, T>::type Interop,
+       ownership Ownership = ownership::transfer) {
+  return make_context(DeviceList, detail::pi::cast<pi_native_handle>(Interop),
+                      Ownership == ownership::keep);
+}
+
+// Construction of SYCL program.
+template <typename T, typename detail::enable_if_t<
+                          std::is_same<T, program>::value> * = nullptr>
+__SYCL_DEPRECATED("Use SYCL-2020 sycl::make_kernel_bundle free function")
+T make(const context &Context,
+       typename interop<backend::level_zero, T>::type Interop) {
+  return make_program(Context, reinterpret_cast<pi_native_handle>(Interop));
+}
+
+// Construction of SYCL queue.
+template <typename T, typename detail::enable_if_t<
+                          std::is_same<T, queue>::value> * = nullptr>
+__SYCL_DEPRECATED("Use SYCL-2020 sycl::make_queue free function")
+T make(const context &Context,
+       typename interop<backend::level_zero, T>::type Interop,
+       ownership Ownership = ownership::transfer) {
+  return make_queue(Context, reinterpret_cast<pi_native_handle>(Interop),
+                    Ownership == ownership::keep);
+}
+
+// Construction of SYCL event.
+template <typename T, typename detail::enable_if_t<
+                          std::is_same<T, event>::value> * = nullptr>
+__SYCL_DEPRECATED("Use SYCL-2020 sycl::make_event free function")
+T make(const context &Context,
+       typename interop<backend::level_zero, T>::type Interop,
+       ownership Ownership = ownership::transfer) {
+  return make_event(Context, reinterpret_cast<pi_native_handle>(Interop),
+                    Ownership == ownership::keep);
+}
+} // namespace level_zero
+
+// Specialization of sycl::make_context for Level-Zero backend.
+template <>
+context make_context<backend::level_zero>(
+    const backend_input_t<backend::level_zero, context> &BackendObject,
+    const async_handler &Handler) {
+  return level_zero::make_context(
+      BackendObject.DeviceList,
+      detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
+      BackendObject.Ownership == level_zero::ownership::keep);
+}
+
+// Specialization of sycl::make_queue for Level-Zero backend.
+template <>
+queue make_queue<backend::level_zero>(
+    const backend_input_t<backend::level_zero, queue> &BackendObject,
+    const context &TargetContext, const async_handler Handler) {
+  return level_zero::make_queue(
+      TargetContext,
+      detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
+      BackendObject.Ownership == level_zero::ownership::keep);
+}
+
+// Specialization of sycl::make_event for Level-Zero backend.
+template <>
+event make_event<backend::level_zero>(
+    const backend_input_t<backend::level_zero, event> &BackendObject,
+    const context &TargetContext) {
+  return level_zero::make_event(
+      TargetContext,
+      detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
+      BackendObject.Ownership == level_zero::ownership::keep);
+}
+
+// TODO: remove this specialization when generic is changed to call
+// .GetNative() instead of .get_native() member of kernel_bundle.
+template <>
+auto get_native<backend::level_zero>(
+    const kernel_bundle<bundle_state::executable> &Obj)
+    -> backend_return_t<backend::level_zero,
+                        kernel_bundle<bundle_state::executable>> {
+  // TODO use SYCL 2020 exception when implemented
+  if (Obj.get_backend() != backend::level_zero)
+    throw runtime_error("Backends mismatch", PI_INVALID_OPERATION);
+
+  return Obj.template getNative<backend::level_zero>();
+}
+
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)
+>>>>>>> 6c9a8addf701 ([SYCL] Make Level-Zero interop API SYCL-2020 compliant for queue, event, and kernel_bundle(was program).)

sycl/include/CL/sycl/backend/opencl.hpp

@@ -75,6 +75,7 @@ struct BackendInput<backend::opencl, kernel_bundle<State>> {
 
 template <bundle_state State>
 struct BackendReturn<backend::opencl, kernel_bundle<State>> {
+  // TODO: Per SYCL-2020 this should be std::vector<cl_program>
   using type = cl_program;
 };
 

sycl/include/CL/sycl/event.hpp

@@ -129,10 +129,12 @@ class __SYCL_EXPORT event {
   ///
   /// \return a native handle, the type of which defined by the backend.
   template <backend BackendName>
+  __SYCL_DEPRECATED("Use SYCL-2020 sycl::get_native free function")
   auto get_native() const -> typename interop<BackendName, event>::type {
     return reinterpret_cast<typename interop<BackendName, event>::type>(
         getNative());
   }
+
 private:
   event(std::shared_ptr<detail::event_impl> EventImpl);
 

sycl/include/CL/sycl/kernel_bundle.hpp

@@ -25,6 +25,8 @@ __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 // Forward declaration
 template <backend Backend> class backend_traits;
+template <backend Backend, class SyclT>
+auto get_native(const SyclT &Obj) -> backend_return_t<Backend, SyclT>;
 
 namespace detail {
 class kernel_id_impl;
@@ -176,8 +178,8 @@ class __SYCL_EXPORT kernel_bundle_plain {
   void set_specialization_constant_impl(const char *SpecName, void *Value,
                                         size_t Size) noexcept;
 
-  void get_specialization_constant_impl(const char *SpecName, void *Value) const
-      noexcept;
+  void get_specialization_constant_impl(const char *SpecName,
+                                        void *Value) const noexcept;
 
   bool is_specialization_constant_set(const char *SpecName) const noexcept;
 
@@ -308,9 +310,9 @@ class kernel_bundle : public detail::kernel_bundle_plain {
   }
 
   template <backend Backend>
+  __SYCL_DEPRECATED("Use SYCL-2020 sycl::get_native free function")
   std::vector<typename backend_traits<Backend>::template return_type<
-      kernel_bundle<State>>>
-  get_native() {
+      kernel_bundle<State>>> get_native() {
     std::vector<typename backend_traits<Backend>::template return_type<
         kernel_bundle<State>>>
         ReturnValue;
@@ -335,6 +337,25 @@ class kernel_bundle : public detail::kernel_bundle_plain {
 
   template <class T>
   friend T detail::createSyclObjFromImpl(decltype(T::impl) ImplObj);
+
+  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 {
+    // NOTE: implementation assumes that the return type is a
+    // derivative of std::vector.
+    backend_return_t<Backend, kernel_bundle<State>> ReturnValue;
+    ReturnValue.reserve(std::distance(begin(), end()));
+
+    for (const device_image<State> &DevImg : *this) {
+      ReturnValue.push_back(
+          detail::pi::cast<typename decltype(ReturnValue)::value_type>(
+              DevImg.getNative()));
+    }
+
+    return ReturnValue;
+  }
 };
 
 /////////////////////////
@@ -604,7 +625,7 @@ __SYCL_EXPORT std::vector<sycl::device> find_device_intersection(
 __SYCL_EXPORT std::shared_ptr<detail::kernel_bundle_impl>
 link_impl(const std::vector<kernel_bundle<bundle_state::object>> &ObjectBundles,
           const std::vector<device> &Devs, const property_list &PropList);
-}
+} // namespace detail
 
 /// \returns a new kernel_bundle which contains the device images from the
 /// ObjectBundles that are translated into one or more new device images of

sycl/include/CL/sycl/program.hpp

@@ -365,6 +365,7 @@ class __SYCL_EXPORT __SYCL2020_DEPRECATED(
   ///
   /// \return a native handle, the type of which defined by the backend.
   template <backend BackendName>
+  __SYCL_DEPRECATED("Use SYCL-2020 sycl::get_native free function")
   auto get_native() const -> typename interop<BackendName, program>::type {
     return reinterpret_cast<typename interop<BackendName, program>::type>(
         getNative());