[SYCL] Deprecate some SYCL 1.2.1 APIs in SYCL2020 mode

sycl/include/CL/sycl/INTEL/online_compiler.hpp

@@ -61,7 +61,7 @@ class device_arch {
 class online_compile_error : public sycl::exception {
 public:
   online_compile_error() = default;
-  online_compile_error(const string_class &Msg) : sycl::exception(Msg) {}
+  online_compile_error(const std::string &Msg) : sycl::exception(Msg) {}
 };
 
 /// Designates a source language for the online compiler.

sycl/include/CL/sycl/ONEAPI/reduction.hpp

@@ -80,7 +80,7 @@ template <typename... Ts> ReduTupleT<Ts...> makeReduTupleT(Ts... Elements) {
   return sycl::detail::make_tuple(Elements...);
 }
 
-__SYCL_EXPORT size_t reduGetMaxWGSize(shared_ptr_class<queue_impl> Queue,
+__SYCL_EXPORT size_t reduGetMaxWGSize(std::shared_ptr<queue_impl> Queue,
                                       size_t LocalMemBytesPerWorkItem);
 __SYCL_EXPORT size_t reduComputeWGSize(size_t NWorkItems, size_t MaxWGSize,
                                        size_t &NWorkGroups);
@@ -698,10 +698,10 @@ class reduction_impl : private reduction_impl_base {
   const T MIdentity;
 
   /// User's accessor to where the reduction must be written.
-  shared_ptr_class<rw_accessor_type> MRWAcc;
-  shared_ptr_class<dw_accessor_type> MDWAcc;
+  std::shared_ptr<rw_accessor_type> MRWAcc;
+  std::shared_ptr<dw_accessor_type> MDWAcc;
 
-  shared_ptr_class<buffer<T, buffer_dim>> MOutBufPtr;
+  std::shared_ptr<buffer<T, buffer_dim>> MOutBufPtr;
 
   /// USM pointer referencing the memory to where the result of the reduction
   /// must be written. Applicable/used only for USM reductions.
@@ -1584,13 +1584,14 @@ size_t reduAuxCGFunc(handler &CGH, size_t NWorkItems, size_t MaxWGSize,
   return NWorkGroups;
 }
 
-inline void reduSaveFinalResultToUserMemHelper(
-    std::vector<event> &, shared_ptr_class<detail::queue_impl>, bool) {}
+inline void
+reduSaveFinalResultToUserMemHelper(std::vector<event> &,
+                                   std::shared_ptr<detail::queue_impl>, bool) {}
 
 template <typename Reduction, typename... RestT>
 std::enable_if_t<Reduction::is_usm>
 reduSaveFinalResultToUserMemHelper(std::vector<event> &Events,
-                                   shared_ptr_class<detail::queue_impl> Queue,
+                                   std::shared_ptr<detail::queue_impl> Queue,
                                    bool IsHost, Reduction &, RestT... Rest) {
   // Reductions initialized with USM pointer currently do not require copying
   // because the last kernel write directly to USM memory.
@@ -1599,7 +1600,7 @@ reduSaveFinalResultToUserMemHelper(std::vector<event> &Events,
 
 template <typename Reduction, typename... RestT>
 std::enable_if_t<!Reduction::is_usm> reduSaveFinalResultToUserMemHelper(
-    std::vector<event> &Events, shared_ptr_class<detail::queue_impl> Queue,
+    std::vector<event> &Events, std::shared_ptr<detail::queue_impl> Queue,
     bool IsHost, Reduction &Redu, RestT... Rest) {
   if (Redu.hasUserDiscardWriteAccessor()) {
     handler CopyHandler(Queue, IsHost);
@@ -1620,16 +1621,16 @@ std::enable_if_t<!Reduction::is_usm> reduSaveFinalResultToUserMemHelper(
 /// Returns the event to the last kernel copying data or nullptr if no
 /// additional kernels created.
 template <typename... Reduction, size_t... Is>
-shared_ptr_class<event>
-reduSaveFinalResultToUserMem(shared_ptr_class<detail::queue_impl> Queue,
+std::shared_ptr<event>
+reduSaveFinalResultToUserMem(std::shared_ptr<detail::queue_impl> Queue,
                              bool IsHost, std::tuple<Reduction...> &ReduTuple,
                              std::index_sequence<Is...>) {
   std::vector<event> Events;
   reduSaveFinalResultToUserMemHelper(Events, Queue, IsHost,
                                      std::get<Is>(ReduTuple)...);
   if (!Events.empty())
     return std::make_shared<event>(Events.back());
-  return shared_ptr_class<event>();
+  return std::shared_ptr<event>();
 }
 
 template <typename Reduction> size_t reduGetMemPerWorkItemHelper(Reduction &) {

sycl/include/CL/sycl/aliases.hpp

@@ -71,7 +71,7 @@ using half = cl::sycl::detail::half_impl::half;
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
-using byte = std::uint8_t;
+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/level_zero.hpp

@@ -86,7 +86,7 @@ enum class ownership { transfer, keep };
 __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 vector_class<device> &DeviceList,
+__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,
@@ -120,7 +120,7 @@ T make(const platform &Platform,
 ///
 template <typename T, typename std::enable_if<
                           std::is_same<T, context>::value>::type * = nullptr>
-T make(const vector_class<device> &DeviceList,
+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),

sycl/include/CL/sycl/buffer.hpp

@@ -118,7 +118,7 @@ class buffer {
             allocator));
   }
 
-  buffer(const shared_ptr_class<T> &hostData,
+  buffer(const std::shared_ptr<T> &hostData,
          const range<dimensions> &bufferRange, AllocatorT allocator,
          const property_list &propList = {})
       : Range(bufferRange) {
@@ -129,7 +129,7 @@ class buffer {
             allocator));
   }
 
-  buffer(const shared_ptr_class<T[]> &hostData,
+  buffer(const std::shared_ptr<T[]> &hostData,
          const range<dimensions> &bufferRange, AllocatorT allocator,
          const property_list &propList = {})
       : Range(bufferRange) {
@@ -140,7 +140,7 @@ class buffer {
             allocator));
   }
 
-  buffer(const shared_ptr_class<T> &hostData,
+  buffer(const std::shared_ptr<T> &hostData,
          const range<dimensions> &bufferRange,
          const property_list &propList = {})
       : Range(bufferRange) {
@@ -150,7 +150,7 @@ class buffer {
         make_unique_ptr<detail::SYCLMemObjAllocatorHolder<AllocatorT>>());
   }
 
-  buffer(const shared_ptr_class<T[]> &hostData,
+  buffer(const std::shared_ptr<T[]> &hostData,
          const range<dimensions> &bufferRange,
          const property_list &propList = {})
       : Range(bufferRange) {
@@ -389,7 +389,7 @@ class buffer {
   }
 
 private:
-  shared_ptr_class<detail::buffer_impl> impl;
+  std::shared_ptr<detail::buffer_impl> impl;
   template <class Obj>
   friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);
   template <typename A, int dims, typename C, typename Enable>
@@ -404,7 +404,7 @@ class buffer {
   bool IsSubBuffer = false;
 
   // Reinterpret contructor
-  buffer(shared_ptr_class<detail::buffer_impl> Impl,
+  buffer(std::shared_ptr<detail::buffer_impl> Impl,
          range<dimensions> reinterpretRange, size_t reinterpretOffset,
          bool isSubBuffer)
       : impl(Impl), Range(reinterpretRange), OffsetInBytes(reinterpretOffset),

sycl/include/CL/sycl/context.hpp

@@ -120,7 +120,7 @@ class __SYCL_EXPORT context {
   ///
   /// \param DeviceList is a list of SYCL device instances.
   /// \param PropList is an instance of property_list.
-  explicit context(const vector_class<device> &DeviceList,
+  explicit context(const std::vector<device> &DeviceList,
                    const property_list &PropList = {});
 
   /// Constructs a SYCL context instance using list of devices.
@@ -136,7 +136,7 @@ class __SYCL_EXPORT context {
   /// \param DeviceList is a list of SYCL device instances.
   /// \param AsyncHandler is an instance of async_handler.
   /// \param PropList is an instance of property_list.
-  explicit context(const vector_class<device> &DeviceList,
+  explicit context(const std::vector<device> &DeviceList,
                    async_handler AsyncHandler,
                    const property_list &PropList = {});
 
@@ -209,7 +209,7 @@ class __SYCL_EXPORT context {
   /// Gets devices associated with this SYCL context.
   ///
   /// \return a vector of valid SYCL device instances.
-  vector_class<device> get_devices() const;
+  std::vector<device> get_devices() const;
 
   /// Gets the native handle of the SYCL context.
   ///
@@ -222,11 +222,11 @@ class __SYCL_EXPORT context {
 
 private:
   /// Constructs a SYCL context object from a valid context_impl instance.
-  context(shared_ptr_class<detail::context_impl> Impl);
+  context(std::shared_ptr<detail::context_impl> Impl);
 
   pi_native_handle getNative() const;
 
-  shared_ptr_class<detail::context_impl> impl;
+  std::shared_ptr<detail::context_impl> impl;
   template <class Obj>
   friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);
 
@@ -245,7 +245,7 @@ class __SYCL_EXPORT context {
 namespace std {
 template <> struct hash<cl::sycl::context> {
   size_t operator()(const cl::sycl::context &Context) const {
-    return hash<cl::sycl::shared_ptr_class<cl::sycl::detail::context_impl>>()(
+    return hash<std::shared_ptr<cl::sycl::detail::context_impl>>()(
         cl::sycl::detail::getSyclObjImpl(Context));
   }
 };

sycl/include/CL/sycl/detail/accessor_impl.hpp

@@ -129,15 +129,15 @@ class __SYCL_EXPORT AccessorImplHost {
   bool MIsESIMDAcc;
 };
 
-using AccessorImplPtr = shared_ptr_class<AccessorImplHost>;
+using AccessorImplPtr = std::shared_ptr<AccessorImplHost>;
 
 class AccessorBaseHost {
 public:
   AccessorBaseHost(id<3> Offset, range<3> AccessRange, range<3> MemoryRange,
                    access::mode AccessMode, detail::SYCLMemObjI *SYCLMemObject,
                    int Dims, int ElemSize, int OffsetInBytes = 0,
                    bool IsSubBuffer = false) {
-    impl = shared_ptr_class<AccessorImplHost>(new AccessorImplHost(
+    impl = std::shared_ptr<AccessorImplHost>(new AccessorImplHost(
         Offset, AccessRange, MemoryRange, AccessMode, SYCLMemObject, Dims,
         ElemSize, OffsetInBytes, IsSubBuffer));
   }
@@ -180,12 +180,12 @@ class __SYCL_EXPORT LocalAccessorImplHost {
   std::vector<char> MMem;
 };
 
-using LocalAccessorImplPtr = shared_ptr_class<LocalAccessorImplHost>;
+using LocalAccessorImplPtr = std::shared_ptr<LocalAccessorImplHost>;
 
 class LocalAccessorBaseHost {
 public:
   LocalAccessorBaseHost(sycl::range<3> Size, int Dims, int ElemSize) {
-    impl = shared_ptr_class<LocalAccessorImplHost>(
+    impl = std::shared_ptr<LocalAccessorImplHost>(
         new LocalAccessorImplHost(Size, Dims, ElemSize));
   }
   sycl::range<3> &getSize() { return impl->MSize; }
@@ -202,7 +202,7 @@ class LocalAccessorBaseHost {
   template <class Obj>
   friend decltype(Obj::impl) getSyclObjImpl(const Obj &SyclObject);
 
-  shared_ptr_class<LocalAccessorImplHost> impl;
+  std::shared_ptr<LocalAccessorImplHost> impl;
 };
 
 using Requirement = AccessorImplHost;

sycl/include/CL/sycl/detail/buffer_impl.hpp

@@ -45,7 +45,7 @@ class __SYCL_EXPORT buffer_impl final : public SYCLMemObjT {
 
 public:
   buffer_impl(size_t SizeInBytes, size_t, const property_list &Props,
-              unique_ptr_class<SYCLMemObjAllocator> Allocator)
+              std::unique_ptr<SYCLMemObjAllocator> Allocator)
       : BaseT(SizeInBytes, Props, std::move(Allocator)) {
 
     if (Props.has_property<sycl::property::buffer::use_host_ptr>())
@@ -56,7 +56,7 @@ class __SYCL_EXPORT buffer_impl final : public SYCLMemObjT {
 
   buffer_impl(void *HostData, size_t SizeInBytes, size_t RequiredAlign,
               const property_list &Props,
-              unique_ptr_class<SYCLMemObjAllocator> Allocator)
+              std::unique_ptr<SYCLMemObjAllocator> Allocator)
       : BaseT(SizeInBytes, Props, std::move(Allocator)) {
 
     if (Props.has_property<
@@ -70,7 +70,7 @@ class __SYCL_EXPORT buffer_impl final : public SYCLMemObjT {
 
   buffer_impl(const void *HostData, size_t SizeInBytes, size_t RequiredAlign,
               const property_list &Props,
-              unique_ptr_class<SYCLMemObjAllocator> Allocator)
+              std::unique_ptr<SYCLMemObjAllocator> Allocator)
       : BaseT(SizeInBytes, Props, std::move(Allocator)) {
 
     if (Props.has_property<
@@ -83,9 +83,9 @@ class __SYCL_EXPORT buffer_impl final : public SYCLMemObjT {
   }
 
   template <typename T>
-  buffer_impl(const shared_ptr_class<T> &HostData, const size_t SizeInBytes,
+  buffer_impl(const std::shared_ptr<T> &HostData, const size_t SizeInBytes,
               size_t RequiredAlign, const property_list &Props,
-              unique_ptr_class<SYCLMemObjAllocator> Allocator)
+              std::unique_ptr<SYCLMemObjAllocator> Allocator)
       : BaseT(SizeInBytes, Props, std::move(Allocator)) {
 
     if (Props.has_property<
@@ -105,7 +105,7 @@ class __SYCL_EXPORT buffer_impl final : public SYCLMemObjT {
   buffer_impl(EnableIfNotConstIterator<InputIterator> First, InputIterator Last,
               const size_t SizeInBytes, size_t RequiredAlign,
               const property_list &Props,
-              unique_ptr_class<SYCLMemObjAllocator> Allocator)
+              std::unique_ptr<SYCLMemObjAllocator> Allocator)
       : BaseT(SizeInBytes, Props, std::move(Allocator)) {
 
     if (Props.has_property<sycl::property::buffer::use_host_ptr>())
@@ -125,7 +125,7 @@ class __SYCL_EXPORT buffer_impl final : public SYCLMemObjT {
   buffer_impl(EnableIfConstIterator<InputIterator> First, InputIterator Last,
               const size_t SizeInBytes, size_t RequiredAlign,
               const property_list &Props,
-              unique_ptr_class<SYCLMemObjAllocator> Allocator)
+              std::unique_ptr<SYCLMemObjAllocator> Allocator)
       : BaseT(SizeInBytes, Props, std::move(Allocator)) {
 
     if (Props.has_property<sycl::property::buffer::use_host_ptr>())
@@ -139,7 +139,7 @@ class __SYCL_EXPORT buffer_impl final : public SYCLMemObjT {
 
   buffer_impl(cl_mem MemObject, const context &SyclContext,
               const size_t SizeInBytes,
-              unique_ptr_class<SYCLMemObjAllocator> Allocator,
+              std::unique_ptr<SYCLMemObjAllocator> Allocator,
               event AvailableEvent)
       : BaseT(MemObject, SyclContext, SizeInBytes, std::move(AvailableEvent),
               std::move(Allocator)) {}