[SYCL] Rename cuda, hip and fix renaming for level_zero backends (#4785)

According to SYCL spec, backend::cuda was renamed to backend::ext_oneapi_cuda,
and backend::hip was renamed to backend::ext_oneapi_hip. Old names were
marked as deprecated. The renaming is also applied in the sources, tests and
unit-tests. Renaming for the Level Zero backend was also applied for the sources,
tests and unit-tests.

The following properties were moved into namespaces reserved for extensions:
* ext::oneapi::cuda::property::context::use_primary_context,
* ext::oneapi::cuda::property::queue::use_default_stream.

The interop class template was re-defined in the sycl::detail namespace since
it is not an extension of the SYCL API but just an implementation detail. The parts
of CL/sycl/backend/opencl.hpp that contain specializations for the
sycl::detail::interop class template were moved into the new created
CL/sycl/detail/backend_traits_opencl.hpp header, as well as the same parts of the
sycl/ext/oneapi/backend/level_zero.hpp header. The whole
CL/sycl/backend/cuda.hpp header file was also renamed into the
CL/sycl/detail/backend_traits_cuda.hpp one since the file contains a number of
sycl::detail::interop class template specializations only. A warning was added into
the old file.

Author: Pavel Samolysov

sycl/include/CL/sycl.hpp

@@ -13,6 +13,9 @@
 #include <CL/sycl/atomic.hpp>
 #include <CL/sycl/atomic_fence.hpp>
 #include <CL/sycl/backend.hpp>
+#if SYCL_BACKEND_OPENCL
+#include <CL/sycl/backend/opencl.hpp>
+#endif
 #include <CL/sycl/buffer.hpp>
 #include <CL/sycl/builtins.hpp>
 #include <CL/sycl/context.hpp>
@@ -53,6 +56,9 @@
 #include <CL/sycl/usm.hpp>
 #include <CL/sycl/version.hpp>
 #include <sycl/ext/oneapi/atomic.hpp>
+#if SYCL_EXT_ONEAPI_BACKEND_LEVEL_ZERO
+#include <sycl/ext/oneapi/backend/level_zero.hpp>
+#endif
 #include <sycl/ext/oneapi/experimental/builtins.hpp>
 #include <sycl/ext/oneapi/filter_selector.hpp>
 #include <sycl/ext/oneapi/group_algorithm.hpp>

sycl/include/CL/sycl/backend.hpp

@@ -9,11 +9,20 @@
 #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>
 #include <CL/sycl/detail/backend_traits.hpp>
+#include <CL/sycl/feature_test.hpp>
+#if SYCL_BACKEND_OPENCL
+#include <CL/sycl/detail/backend_traits_opencl.hpp>
+#endif
+#if SYCL_EXT_ONEAPI_BACKEND_CUDA
+#include <CL/sycl/detail/backend_traits_cuda.hpp>
+#endif
+#if SYCL_EXT_ONEAPI_BACKEND_LEVEL_ZERO
+#include <CL/sycl/detail/backend_traits_level_zero.hpp>
+#endif
 #include <CL/sycl/detail/common.hpp>
 #include <CL/sycl/detail/export.hpp>
 #include <CL/sycl/detail/pi.h>
@@ -31,16 +40,6 @@ __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 
 namespace detail {
-template <backend Backend, typename T> struct BackendInput {
-  // TODO replace usage of interop with specializations.
-  using type = typename interop<Backend, T>::type;
-};
-
-template <backend Backend, typename T> struct BackendReturn {
-  // TODO replace usage of interop with specializations.
-  using type = typename interop<Backend, T>::type;
-};
-
 // TODO each backend can have its own custom errc enumeration
 // but the details for this are not fully specified yet
 enum class backend_errc : unsigned int {};
@@ -69,8 +68,10 @@ template <backend BackendName, class SyclObjectT>
 auto get_native(const SyclObjectT &Obj)
     -> backend_return_t<BackendName, SyclObjectT> {
   // TODO use SYCL 2020 exception when implemented
-  if (Obj.get_backend() != BackendName)
+  if (Obj.get_backend() != BackendName) {
     throw runtime_error("Backends mismatch", PI_INVALID_OPERATION);
+  }
+
   return Obj.template get_native<BackendName>();
 }
 
@@ -80,9 +81,9 @@ template <backend BackendName, typename DataT, int Dimensions,
           access::placeholder IsPlaceholder>
 auto get_native(const accessor<DataT, Dimensions, AccessMode, AccessTarget,
                                IsPlaceholder> &Obj) ->
-    typename interop<BackendName, accessor<DataT, Dimensions, AccessMode,
-                                           AccessTarget, IsPlaceholder>>::type =
-    delete;
+    typename detail::interop<
+        BackendName, accessor<DataT, Dimensions, AccessMode, AccessTarget,
+                              IsPlaceholder>>::type = delete;
 
 namespace detail {
 // Forward declaration

sycl/include/CL/sycl/backend/cuda.hpp

@@ -9,60 +9,6 @@
 
 #pragma once
 
-#include <CL/sycl/accessor.hpp>
-#include <CL/sycl/backend_types.hpp>
-#include <CL/sycl/context.hpp>
-#include <CL/sycl/detail/defines.hpp>
-#include <CL/sycl/device.hpp>
-#include <CL/sycl/event.hpp>
-#include <CL/sycl/queue.hpp>
+#include <CL/sycl/detail/defines_elementary.hpp>
 
-typedef int CUdevice;
-typedef struct CUctx_st *CUcontext;
-typedef struct CUstream_st *CUstream;
-typedef struct CUevent_st *CUevent;
-typedef struct CUmod_st *CUmodule;
-
-// As defined in the CUDA 10.1 header file. This requires CUDA version > 3.2
-#if defined(_WIN64) || defined(__LP64__)
-typedef unsigned long long CUdeviceptr;
-#else
-typedef unsigned int CUdeviceptr;
-#endif
-
-__SYCL_INLINE_NAMESPACE(cl) {
-namespace sycl {
-
-template <> struct interop<backend::cuda, device> { using type = CUdevice; };
-
-template <> struct interop<backend::cuda, context> { using type = CUcontext; };
-
-template <> struct interop<backend::cuda, queue> { using type = CUstream; };
-
-template <> struct interop<backend::cuda, event> { using type = CUevent; };
-
-#ifdef __SYCL_INTERNAL_API
-template <> struct interop<backend::cuda, program> { using type = CUmodule; };
-#endif
-
-template <typename DataT, int Dimensions, access::mode AccessMode>
-struct interop<backend::cuda,
-               accessor<DataT, Dimensions, AccessMode, access::target::device,
-                        access::placeholder::false_t>> {
-  using type = CUdeviceptr;
-};
-
-template <typename DataT, int Dimensions, access::mode AccessMode>
-struct interop<backend::cuda, accessor<DataT, Dimensions, AccessMode,
-                                       access::target::constant_buffer,
-                                       access::placeholder::false_t>> {
-  using type = CUdeviceptr;
-};
-
-template <typename DataT, int Dimensions, typename AllocatorT>
-struct interop<backend::cuda, buffer<DataT, Dimensions, AllocatorT>> {
-  using type = CUdeviceptr;
-};
-
-} // namespace sycl
-} // namespace cl
+__SYCL_WARNING("CL/sycl/backend/cuda.hpp is deprecated and no required anymore")

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

@@ -9,103 +9,13 @@
 
 #pragma once
 
-#include <CL/sycl/accessor.hpp>
 #include <CL/sycl/backend.hpp>
-#include <CL/sycl/backend_types.hpp>
-#include <CL/sycl/detail/backend_traits.hpp>
-#include <CL/sycl/detail/cl.h>
-#include <CL/sycl/kernel_bundle.hpp>
-
-#include <vector>
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
-
-template <> struct interop<backend::opencl, platform> {
-  using type = cl_platform_id;
-};
-
-template <> struct interop<backend::opencl, device> {
-  using type = cl_device_id;
-};
-
-template <> struct interop<backend::opencl, context> {
-  using type = cl_context;
-};
-
-template <> struct interop<backend::opencl, queue> {
-  using type = cl_command_queue;
-};
-
-#ifdef __SYCL_INTERNAL_API
-template <> struct interop<backend::opencl, program> {
-  using type = cl_program;
-};
-#endif
-
-template <> struct interop<backend::opencl, event> { using type = cl_event; };
-
-template <typename DataT, int Dimensions, access::mode AccessMode>
-struct interop<backend::opencl,
-               accessor<DataT, Dimensions, AccessMode, access::target::device,
-                        access::placeholder::false_t>> {
-  using type = cl_mem;
-};
-
-template <typename DataT, int Dimensions, access::mode AccessMode>
-struct interop<backend::opencl, accessor<DataT, Dimensions, AccessMode,
-                                         access::target::constant_buffer,
-                                         access::placeholder::false_t>> {
-  using type = cl_mem;
-};
-
-template <typename DataT, int Dimensions, access::mode AccessMode>
-struct interop<backend::opencl,
-               accessor<DataT, Dimensions, AccessMode, access::target::image,
-                        access::placeholder::false_t>> {
-  using type = cl_mem;
-};
-
-template <typename DataT, int Dimensions, typename AllocatorT>
-struct interop<backend::opencl, buffer<DataT, Dimensions, AllocatorT>> {
-  using type = cl_mem;
-};
-
-namespace detail {
-template <bundle_state State>
-struct BackendInput<backend::opencl, kernel_bundle<State>> {
-  using type = cl_program;
-};
-
-template <bundle_state State>
-struct BackendReturn<backend::opencl, kernel_bundle<State>> {
-  using type = std::vector<cl_program>;
-};
-
-template <> struct BackendInput<backend::opencl, kernel> {
-  using type = cl_kernel;
-};
-
-template <> struct BackendReturn<backend::opencl, kernel> {
-  using type = cl_kernel;
-};
-
-template <> struct InteropFeatureSupportMap<backend::opencl> {
-  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 MakeBuffer = true;
-  static constexpr bool MakeKernel = true;
-  static constexpr bool MakeKernelBundle = true;
-};
-} // namespace detail
-
 namespace opencl {
-
 // Implementation of various "make" functions resides in SYCL RT because
-// creating SYCL objects requires knowing details not acessible here.
+// creating SYCL objects requires knowing details not accessible here.
 // Note that they take opaque pi_native_handle that real OpenCL handles
 // are casted to.
 //
@@ -122,42 +32,46 @@ __SYCL_EXPORT queue make_queue(const context &Context,
 // Construction of SYCL platform.
 template <typename T, typename detail::enable_if_t<
                           std::is_same<T, platform>::value> * = nullptr>
-T make(typename interop<backend::opencl, T>::type Interop) {
+__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 detail::enable_if_t<
                           std::is_same<T, device>::value> * = nullptr>
-T make(typename interop<backend::opencl, T>::type Interop) {
+__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 detail::enable_if_t<
                           std::is_same<T, context>::value> * = nullptr>
-T make(typename interop<backend::opencl, T>::type Interop) {
+__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 program.
 #ifdef __SYCL_INTERNAL_API
 template <typename T, typename detail::enable_if_t<
                           std::is_same<T, program>::value> * = nullptr>
+__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_program free function")
 T make(const context &Context,
-       typename interop<backend::opencl, T>::type Interop) {
+       typename detail::interop<backend::opencl, T>::type Interop) {
   return make_program(Context, detail::pi::cast<pi_native_handle>(Interop));
 }
 #endif
 
 // 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::opencl, T>::type Interop) {
+       typename detail::interop<backend::opencl, T>::type Interop) {
   return make_queue(Context, detail::pi::cast<pi_native_handle>(Interop));
 }
-
 } // namespace opencl
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/backend_types.hpp

@@ -24,16 +24,16 @@ enum class backend : char {
   ext_oneapi_level_zero = 2,
   level_zero __SYCL2020_DEPRECATED("use 'ext_oneapi_level_zero' instead") =
       ext_oneapi_level_zero,
-  cuda = 3,
+  ext_oneapi_cuda = 3,
+  cuda __SYCL2020_DEPRECATED("use 'ext_oneapi_cuda' instead") = ext_oneapi_cuda,
   all = 4,
   ext_intel_esimd_emulator = 5,
   esimd_cpu __SYCL2020_DEPRECATED("use 'ext_oneapi_esimd_emulator' instead") =
       ext_intel_esimd_emulator,
-  hip = 6,
+  ext_oneapi_hip = 6,
+  hip __SYCL2020_DEPRECATED("use 'ext_oneapi_hip' instead") = ext_oneapi_hip,
 };
 
-template <backend Backend, typename SYCLObjectT> struct interop;
-
 template <backend Backend> class backend_traits;
 
 template <backend Backend, typename SYCLObjectT>
@@ -51,17 +51,17 @@ inline std::ostream &operator<<(std::ostream &Out, backend be) {
   case backend::opencl:
     Out << "opencl";
     break;
-  case backend::level_zero:
-    Out << "level_zero";
+  case backend::ext_oneapi_level_zero:
+    Out << "ext_oneapi_level_zero";
     break;
-  case backend::cuda:
-    Out << "cuda";
+  case backend::ext_oneapi_cuda:
+    Out << "ext_oneapi_cuda";
     break;
   case backend::ext_intel_esimd_emulator:
     Out << "ext_intel_esimd_emulator";
     break;
-  case backend::hip:
-    Out << "hip";
+  case backend::ext_oneapi_hip:
+    Out << "ext_oneapi_hip";
     break;
   case backend::all:
     Out << "all";

sycl/include/CL/sycl/context.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <CL/sycl/backend_types.hpp>
+#include <CL/sycl/detail/backend_traits.hpp>
 #include <CL/sycl/detail/common.hpp>
 #include <CL/sycl/detail/export.hpp>
 #include <CL/sycl/detail/stl_type_traits.hpp>
@@ -219,9 +219,10 @@ 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());
+  auto get_native() const ->
+      typename detail::interop<BackendName, context>::type {
+    return reinterpret_cast<
+        typename detail::interop<BackendName, context>::type>(getNative());
   }
 
 private:

sycl/include/CL/sycl/detail/assert_happened.hpp

@@ -10,6 +10,8 @@
 
 #include <CL/sycl/detail/defines_elementary.hpp>
 
+#include <cstdint>
+
 #ifdef __SYCL_DEVICE_ONLY__
 // Reads Flag of AssertHappened on device
 SYCL_EXTERNAL __attribute__((weak)) extern "C" void

sycl/include/CL/sycl/detail/backend_traits.hpp

@@ -14,6 +14,13 @@
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 namespace detail {
+
+template <backend Backend, typename SYCLObjectT> struct interop;
+
+template <backend Backend, typename T> struct BackendInput;
+
+template <backend Backend, typename T> struct BackendReturn;
+
 template <backend Backend> struct InteropFeatureSupportMap {
   static constexpr bool MakePlatform = false;
   static constexpr bool MakeDevice = false;