[SYCL] Make Level-Zero interop API SYCL 2020 compliant for platform, device and context (#4479)

Signed-off-by: Sergey V Maslov <[email protected]>

Author: smaslov-intel

sycl/include/CL/sycl/backend.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <CL/sycl/accessor.hpp>
+#include <CL/sycl/backend.hpp>
 #include <CL/sycl/backend_types.hpp>
 #include <CL/sycl/buffer.hpp>
 #include <CL/sycl/context.hpp>

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

@@ -60,15 +60,32 @@ struct interop<backend::level_zero,
   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 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 = false;
-  static constexpr bool MakeContext = false;
+  static constexpr bool MakeDevice = true;
+  static constexpr bool MakeContext = true;
   static constexpr bool MakeQueue = false;
   static constexpr bool MakeEvent = true;
   static constexpr bool MakeBuffer = false;
@@ -78,15 +95,9 @@ template <> struct InteropFeatureSupportMap<backend::level_zero> {
 } // namespace detail
 
 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 };
-
 // 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);
@@ -105,13 +116,15 @@ __SYCL_EXPORT event make_event(const context &Context,
 // 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));
@@ -128,6 +141,7 @@ T make(const platform &Platform,
 ///
 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) {
@@ -162,7 +176,18 @@ T make(const context &Context,
   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);
+}
+
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/context.hpp

@@ -216,6 +216,7 @@ class __SYCL_EXPORT context {
   ///
   /// \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, context>::type {
     return reinterpret_cast<typename interop<BackendName, context>::type>(
         getNative());

sycl/include/CL/sycl/device.hpp

@@ -184,6 +184,7 @@ class __SYCL_EXPORT device {
   ///
   /// \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, device>::type {
     return (typename interop<BackendName, device>::type)getNative();
   }

sycl/include/CL/sycl/platform.hpp

@@ -116,6 +116,7 @@ class __SYCL_EXPORT platform {
   ///
   /// \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, platform>::type {
     return reinterpret_cast<typename interop<BackendName, platform>::type>(
         getNative());

sycl/test/basic_tests/interop-level-zero-2020.cpp

@@ -0,0 +1,109 @@
+// RUN: %clangxx %fsycl-host-only -fsyntax-only -Xclang -verify -Xclang -verify-ignore-unexpected=note %s -o %t.out
+
+// Test for SYCL-2020 Level Zero interop API
+
+#include <sycl/sycl.hpp>
+// clang-format off
+#include <level_zero/ze_api.h>
+#include <CL/sycl/backend/level_zero.hpp>
+// clang-format on
+
+using namespace sycl;
+
+//
+// 4.5.1 SYCL application interoperability may be provided for
+// platform,
+// device,
+// context,
+// TODO:
+// buffer,
+// device_image,
+// event,
+// kernel,
+// kernel_bundle,
+// queue,
+// sampled_image,
+// unsampled_image.
+
+int main() {
+
+  // Create SYCL objects
+  device Device;
+  platform Platform = Device.get_info<info::device::platform>();
+  context Context(Device);
+
+  // 4.5.1.1 For each SYCL runtime class T which supports SYCL application
+  // interoperability with the SYCL backend, a specialization of return_type
+  // must be defined as the type of SYCL application interoperability native
+  // backend object associated with T for the SYCL backend, specified in the
+  // SYCL backend specification.
+  //
+  // return_type is used when retrieving the backend specific native object from
+  // a SYCL object. See the relevant backend specification for details.
+
+  backend_traits<backend::level_zero>::return_type<platform> ZeDriver;
+  backend_traits<backend::level_zero>::return_type<device> ZeDevice;
+  backend_traits<backend::level_zero>::return_type<context> ZeContext;
+
+  // 4.5.1.2 For each SYCL runtime class T which supports SYCL application
+  // interoperability, a specialization of get_native must be defined, which
+  // takes an instance of T and returns a SYCL application interoperability
+  // native backend object associated with syclObject which can be used for SYCL
+  // application interoperability. The lifetime of the object returned are
+  // backend-defined and specified in the backend specification.
+
+  ZeDriver = get_native<backend::level_zero>(Platform);
+  ZeDevice = get_native<backend::level_zero>(Device);
+  ZeContext = get_native<backend::level_zero>(Context);
+
+  // Check deprecated
+  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL-2020 sycl::get_native free function}}
+  // expected-warning@+1 {{'get_native<sycl::backend::level_zero>' is deprecated: Use SYCL-2020 sycl::get_native free function}}
+  ZeDriver = Platform.get_native<backend::level_zero>();
+  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL-2020 sycl::get_native free function}}
+  // expected-warning@+1 {{'get_native<sycl::backend::level_zero>' is deprecated: Use SYCL-2020 sycl::get_native free function}}
+  ZeDevice = Device.get_native<backend::level_zero>();
+  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL-2020 sycl::get_native free function}}
+  // expected-warning@+1 {{'get_native<sycl::backend::level_zero>' is deprecated: Use SYCL-2020 sycl::get_native free function}}
+  ZeContext = Context.get_native<backend::level_zero>();
+
+  // 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
+  // object associated with T for the SYCL backend, specified in the SYCL
+  // backend specification. input_type is used when constructing SYCL objects
+  // from backend specific native objects. See the relevant backend
+  // specification for details.
+
+  // 4.5.1.3 For each SYCL runtime class T which supports SYCL application
+  // interoperability, a specialization of the appropriate template function
+  // make_{sycl_class} where {sycl_class} is the class name of T, must be
+  // defined, which takes a SYCL application interoperability native backend
+  // object and constructs and returns an instance of T. The availability and
+  // behavior of these template functions is defined by the SYCL backend
+  // specification document.
+
+  backend_input_t<backend::level_zero, platform> InteropPlatformInput{ZeDriver};
+  platform InteropPlatform =
+      make_platform<backend::level_zero>(InteropPlatformInput);
+
+  backend_input_t<backend::level_zero, device> InteropDeviceInput{ZeDevice};
+  device InteropDevice = make_device<backend::level_zero>(InteropDeviceInput);
+
+  backend_input_t<backend::level_zero, context> InteropContextInput{
+      ZeContext, std::vector<device>(1, InteropDevice),
+      level_zero::ownership::keep};
+  context InteropContext =
+      make_context<backend::level_zero>(InteropContextInput);
+
+  // Check deprecated
+  // expected-warning@+1 {{'make<sycl::platform, nullptr>' is deprecated: Use SYCL-2020 sycl::make_platform free function}}
+  auto P = level_zero::make<platform>(ZeDriver);
+  // expected-warning@+1 {{'make<sycl::device, nullptr>' is deprecated: Use SYCL-2020 sycl::make_device free function}}
+  auto D = level_zero::make<device>(P, ZeDevice);
+  // expected-warning@+1 {{'make<sycl::context, nullptr>' is deprecated: Use SYCL-2020 sycl::make_context free function}}
+  auto C = level_zero::make<context>(std::vector<device>(1, D), ZeContext,
+                                     level_zero::ownership::keep);
+
+  return 0;
+}