Merge remote-tracking branch 'upstream/sycl' into private/dvodopya/update-oneapi-and-intel-extensions

Author: dm-vodopyanov

sycl/include/CL/sycl/aliases.hpp

@@ -68,7 +68,6 @@ using half __SYCL2020_DEPRECATED("use 'sycl::half' instead") =
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
-using byte __SYCL2020_DEPRECATED("use std::byte instead") = std::uint8_t;
 using schar = signed char;
 using uchar = unsigned char;
 using ushort = unsigned short;

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/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/detail/image_impl.hpp

@@ -21,7 +21,6 @@
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
-
 // forward declarations
 enum class image_channel_order : unsigned int;
 enum class image_channel_type : unsigned int;
@@ -36,7 +35,7 @@ class handler;
 namespace detail {
 
 // utility functions and typedefs for image_impl
-using image_allocator = aligned_allocator<byte>;
+using image_allocator = aligned_allocator<unsigned char>;
 
 // utility function: Returns the Number of Channels for a given Order.
 __SYCL_EXPORT uint8_t getImageNumberChannels(image_channel_order Order);

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/image.hpp

@@ -59,9 +59,7 @@ enum class image_channel_type : unsigned int {
   fp32 = 14
 };
 
-using byte = unsigned char;
-
-using image_allocator = detail::aligned_allocator<byte>;
+using image_allocator = detail::aligned_allocator<unsigned char>;
 
 /// Defines a shared image data.
 ///

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/include/CL/sycl/sycl_span.hpp

@@ -138,9 +138,6 @@ template<class Container>
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 
-// byte is unsigned char at sycl/image.hpp:58
-using byte = unsigned char;
-
 // asserts suppressed for device compatibility.
 // TODO: enable
 #if defined(__SYCL_DEVICE_ONLY__)
@@ -384,16 +381,17 @@ template <typename _Tp, size_t _Extent> class _SYCL_SPAN_TEMPLATE_VIS span {
     return rev_iterator(begin());
   }
 
-  _SYCL_SPAN_INLINE_VISIBILITY span<const byte, _Extent * sizeof(element_type)>
+  _SYCL_SPAN_INLINE_VISIBILITY
+  span<const std::byte, _Extent * sizeof(element_type)>
   __as_bytes() const noexcept {
-    return span<const byte, _Extent * sizeof(element_type)>{
-        reinterpret_cast<const byte *>(data()), size_bytes()};
+    return span<const std::byte, _Extent * sizeof(element_type)>{
+        reinterpret_cast<const std::byte *>(data()), size_bytes()};
   }
 
-  _SYCL_SPAN_INLINE_VISIBILITY span<byte, _Extent * sizeof(element_type)>
+  _SYCL_SPAN_INLINE_VISIBILITY span<std::byte, _Extent * sizeof(element_type)>
   __as_writable_bytes() const noexcept {
-    return span<byte, _Extent * sizeof(element_type)>{
-        reinterpret_cast<byte *>(data()), size_bytes()};
+    return span<std::byte, _Extent * sizeof(element_type)>{
+        reinterpret_cast<std::byte *>(data()), size_bytes()};
   }
 
 private:
@@ -577,14 +575,14 @@ class _SYCL_SPAN_TEMPLATE_VIS span<_Tp, dynamic_extent> {
     return rev_iterator(begin());
   }
 
-  _SYCL_SPAN_INLINE_VISIBILITY span<const byte, dynamic_extent>
+  _SYCL_SPAN_INLINE_VISIBILITY span<const std::byte, dynamic_extent>
   __as_bytes() const noexcept {
-    return {reinterpret_cast<const byte *>(data()), size_bytes()};
+    return {reinterpret_cast<const std::byte *>(data()), size_bytes()};
   }
 
-  _SYCL_SPAN_INLINE_VISIBILITY span<byte, dynamic_extent>
+  _SYCL_SPAN_INLINE_VISIBILITY span<std::byte, dynamic_extent>
   __as_writable_bytes() const noexcept {
-    return {reinterpret_cast<byte *>(data()), size_bytes()};
+    return {reinterpret_cast<std::byte *>(data()), size_bytes()};
   }
 
 private:

sycl/include/CL/sycl/types.hpp

@@ -46,12 +46,13 @@
 #error "SYCL device compiler is built without ext_vector_type support"
 #endif // __HAS_EXT_VECTOR_TYPE__
 
-#include <CL/sycl/aliases.hpp>
 #include <CL/sycl/access/access.hpp>
+#include <CL/sycl/aliases.hpp>
 #include <CL/sycl/detail/common.hpp>
 #include <CL/sycl/detail/helpers.hpp>
 #include <CL/sycl/detail/type_traits.hpp>
 #include <CL/sycl/half_type.hpp>
+#include <CL/sycl/marray.hpp>
 #include <CL/sycl/multi_ptr.hpp>
 
 #include <array>
@@ -2333,6 +2334,12 @@ struct is_device_copyable<std::tuple<T, Ts...>>
     : detail::bool_constant<is_device_copyable<T>::value &&
                             is_device_copyable<std::tuple<Ts...>>::value> {};
 
+// marray is device copyable if element type is device copyable
+template <typename T, std::size_t N>
+struct is_device_copyable<sycl::marray<T, N>,
+                          std::enable_if_t<is_device_copyable<T>::value>>
+    : std::true_type {};
+
 namespace detail {
 template <typename T, typename = void>
 struct IsDeprecatedDeviceCopyable : std::false_type {};

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

@@ -60,15 +60,36 @@ struct interop<backend::level_zero,
   using type = ze_image_handle_t;
 };
 
+namespace ext {
+namespace oneapi {
+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 oneapi
+} // namespace ext
+
 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;
@@ -80,15 +101,9 @@ template <> struct InteropFeatureSupportMap<backend::level_zero> {
 namespace ext {
 namespace oneapi {
 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);
@@ -107,13 +122,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));
@@ -130,6 +147,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) {
@@ -164,11 +182,21 @@ T make(const context &Context,
   return make_event(Context, reinterpret_cast<pi_native_handle>(Interop),
                     Ownership == ownership::keep);
 }
-
 } // namespace level_zero
 } // namespace oneapi
 } // namespace ext
 
+// 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 __SYCL2020_DEPRECATED("use 'ext::oneapi::level_zero' instead")
     level_zero {
   using namespace ext::oneapi::level_zero;