Merge remote-tracking branch 'upstream/sycl' into georgi/test-hip-usm-copy2d

Author: GeorgeWeb

.github/workflows/sycl-containers.yaml

@@ -28,6 +28,8 @@ jobs:
     if: github.repository == 'intel/llvm'
     name: Base Ubuntu 22.04 Docker image
     runs-on: ubuntu-22.04
+    permissions:
+      packages: write
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -47,6 +49,8 @@ jobs:
     if: github.repository == 'intel/llvm'
     name: Build Ubuntu Docker image
     runs-on: ubuntu-22.04
+    permissions:
+      packages: write
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -69,6 +73,8 @@ jobs:
     if: github.repository == 'intel/llvm'
     name: Intel Drivers Ubuntu 22.04 Docker image
     runs-on: ubuntu-22.04
+    permissions:
+      packages: write
     needs: base_image_ubuntu2204
     steps:
       - name: Checkout
@@ -107,6 +113,8 @@ jobs:
     if: github.repository == 'intel/llvm'
     name: Intel Drivers (unstable) Ubuntu 22.04 Docker image
     runs-on: ubuntu-22.04
+    permissions:
+      packages: write
     needs: base_image_ubuntu2204
     steps:
       - name: Checkout

sycl/include/sycl/buffer.hpp

@@ -167,13 +167,8 @@ template <typename T, int dimensions = 1,
               typename std::enable_if_t<(dimensions > 0) && (dimensions <= 3)>>
 class buffer : public detail::buffer_plain,
                public detail::OwnerLessBase<buffer<T, dimensions, AllocatorT>> {
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   static_assert(is_device_copyable_v<T>,
                 "Underlying type of a buffer must be device copyable!");
-#else
-  static_assert(!std::is_same_v<T, std::string>,
-                "'std::string' is not a device copyable type");
-#endif
 
 public:
   using value_type = T;

sycl/include/sycl/detail/assert_happened.hpp

@@ -10,7 +10,7 @@
 
 #include <cstdint> // for uint64_t, int32_t
 
-#ifdef __SYCL_DEVICE_ONLY__
+#if defined(__SYCL_DEVICE_ONLY__) && __SYCL_USE_FALLBACK_ASSERT
 // Reads Flag of AssertHappened on device
 __DPCPP_SYCL_EXTERNAL __attribute__((weak)) extern "C" void
 __devicelib_assert_read(void *);

sycl/include/sycl/detail/defines_elementary.hpp

@@ -81,6 +81,13 @@
 static_assert(__cplusplus >= 201703L,
               "DPCPP does not support C++ version earlier than C++17.");
 
+// Helper macro to identify if fallback assert is needed
+#if defined(SYCL_FALLBACK_ASSERT)
+#define __SYCL_USE_FALLBACK_ASSERT SYCL_FALLBACK_ASSERT
+#else
+#define __SYCL_USE_FALLBACK_ASSERT 0
+#endif
+
 #if defined(_WIN32) && !defined(_DLL) && !defined(__SYCL_DEVICE_ONLY__)
 // SYCL library is designed such a way that STL objects cross DLL boundary,
 // which is guaranteed to work properly only when the application uses the same

sycl/include/sycl/detail/generic_type_lists.hpp

@@ -97,16 +97,8 @@ using scalar_vector_double_list =
 using double_list =
     tl_append<scalar_double_list, vector_double_list, marray_double_list>;
 
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 using scalar_floating_list = tl_append<scalar_float_list, scalar_double_list,
                                        scalar_half_list, scalar_bfloat16_list>;
-#else
-// Presently, this is used only by builtins_legacy_scalar.hpp for defining math
-// funcs. bfloat16 provides its own scalar math definitions so we skip its
-// inclusion.
-using scalar_floating_list =
-    tl_append<scalar_float_list, scalar_double_list, scalar_half_list>;
-#endif
 
 using vector_floating_list = tl_append<vector_float_list, vector_double_list,
                                        vector_half_list, vector_bfloat16_list>;

sycl/include/sycl/detail/util.hpp

@@ -11,9 +11,8 @@
 #ifndef __SYCL_DEVICE_ONLY
 
 #include <sycl/detail/defines.hpp>
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 #include <sycl/detail/string.hpp>
-#endif
+
 #include <cstring>
 #include <mutex>
 #include <vector>
@@ -69,7 +68,6 @@ struct CmpCStr {
 
 using SerializedObj = std::vector<unsigned char>;
 
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 template <typename T> struct ABINeutralT { using type = T; };
 // We need special handling of std::string to handle ABI incompatibility
 // for get_info<>() when it returns std::string and vector<std::string>.
@@ -85,10 +83,6 @@ template <> struct ABINeutralT<std::vector<std::string>> {
 };
 
 template <typename T> using ABINeutralT_t = typename ABINeutralT<T>::type;
-#else
-template <typename T> using ABINeutralT_t = T;
-#endif
-
 } // namespace detail
 } // namespace _V1
 } // namespace sycl

sycl/include/sycl/device.hpp

@@ -15,10 +15,8 @@
 #include <sycl/detail/info_desc_helpers.hpp>
 #include <sycl/detail/owner_less_base.hpp>
 #include <sycl/detail/pi.h>
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 #include <sycl/detail/string.hpp>
 #include <sycl/detail/string_view.hpp>
-#endif
 #include <sycl/detail/util.hpp>
 #include <sycl/device_selector.hpp>
 #include <sycl/ext/oneapi/experimental/device_architecture.hpp>
@@ -221,17 +219,10 @@ class __SYCL_EXPORT device : public detail::OwnerLessBase<device> {
   /// type associated with the param parameter.
   ///
   /// \return device info of type described in Table 4.20.
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   template <typename Param>
   typename detail::is_device_info_desc<Param>::return_type get_info() const {
     return detail::convert_from_abi_neutral(get_info_impl<Param>());
   }
-#else
-  template <typename Param>
-  detail::ABINeutralT_t<
-      typename detail::is_device_info_desc<Param>::return_type>
-  get_info() const;
-#endif
 
   /// Queries this SYCL device for SYCL backend-specific information.
   ///
@@ -377,12 +368,10 @@ class __SYCL_EXPORT device : public detail::OwnerLessBase<device> {
   friend auto get_native(const SyclObjectT &Obj)
       -> backend_return_t<BackendName, SyclObjectT>;
 
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   template <typename Param>
   typename detail::ABINeutralT_t<
       typename detail::is_device_info_desc<Param>::return_type>
   get_info_impl() const;
-#endif
 };
 
 } // namespace _V1

sycl/include/sycl/exception.hpp

@@ -74,21 +74,13 @@ class __SYCL_EXPORT exception : public virtual std::exception {
 
   exception(std::error_code, const char *Msg);
 
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   exception(std::error_code Ec, const std::string &Msg)
       : exception(Ec, nullptr, Msg.c_str()) {}
-#else
-  exception(std::error_code, const std::string &Msg);
-#endif
 
   // new SYCL 2020 constructors
   exception(std::error_code);
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   exception(int EV, const std::error_category &ECat, const std::string &WhatArg)
       : exception(EV, ECat, WhatArg.c_str()) {}
-#else
-  exception(int, const std::error_category &, const std::string &);
-#endif
   exception(int, const std::error_category &, const char *);
   exception(int, const std::error_category &);
 
@@ -137,16 +129,11 @@ class __SYCL_EXPORT exception : public virtual std::exception {
   // base constructor for all SYCL 2020 constructors
   // exception(context *ctxPtr, std::error_code Ec, const std::string
   // &what_arg);
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   exception(std::error_code Ec, std::shared_ptr<context> SharedPtrCtx,
             const std::string &what_arg)
       : exception(Ec, SharedPtrCtx, what_arg.c_str()) {}
   exception(std::error_code Ec, std::shared_ptr<context> SharedPtrCtx,
             const char *WhatArg);
-#else
-  exception(std::error_code Ec, std::shared_ptr<context> SharedPtrCtx,
-            const std::string &what_arg);
-#endif
 };
 
 class __SYCL2020_DEPRECATED(

sycl/include/sycl/ext/oneapi/bfloat16.hpp

@@ -21,13 +21,6 @@ __devicelib_ConvertBF16ToFINTEL(const uint16_t &) noexcept;
 
 namespace sycl {
 inline namespace _V1 {
-
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
-// forward declaration of sycl::isnan built-in.
-// extern __DPCPP_SYCL_EXTERNAL bool isnan(float a);
-bool isnan(float a);
-#endif
-
 namespace ext::oneapi {
 
 class bfloat16;
@@ -53,10 +46,6 @@ using Vec8StorageT = std::array<Bfloat16StorageT, 8>;
 using Vec16StorageT = std::array<Bfloat16StorageT, 16>;
 #endif
 } // namespace bf16
-
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
-inline bool float_is_nan(float x) { return x != x; }
-#endif
 } // namespace detail
 
 class bfloat16 {
@@ -77,13 +66,10 @@ class bfloat16 {
 
 private:
   static detail::Bfloat16StorageT from_float_fallback(const float &a) {
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
-    if (sycl::isnan(a))
-      return 0xffc1;
-#else
-    if (detail::float_is_nan(a))
+    // We don't call sycl::isnan because we don't want a data type to depend on
+    // builtins.
+    if (a != a)
       return 0xffc1;
-#endif
 
     union {
       uint32_t intStorage;

sycl/include/sycl/handler.hpp

@@ -21,10 +21,8 @@
 #include <sycl/detail/pi.h>
 #include <sycl/detail/pi.hpp>
 #include <sycl/detail/reduction_forward.hpp>
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 #include <sycl/detail/string.hpp>
 #include <sycl/detail/string_view.hpp>
-#endif
 #include <sycl/device.hpp>
 #include <sycl/event.hpp>
 #include <sycl/exception.hpp>
@@ -422,11 +420,6 @@ template <int Dims> bool range_size_fits_in_size_t(const range<Dims> &r) {
   }
   return true;
 }
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
-using string = std::string;
-using string_view = std::string;
-#endif
-
 } // namespace detail
 
 /// Command group handler class.
@@ -872,14 +865,10 @@ class __SYCL_EXPORT handler {
   ///
   /// \param KernelName is the name of the SYCL kernel to check that the used
   ///                   kernel bundle contains.
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   void verifyUsedKernelBundle(const std::string &KernelName) {
     verifyUsedKernelBundleInternal(detail::string_view{KernelName});
   }
   void verifyUsedKernelBundleInternal(detail::string_view KernelName);
-#else
-  void verifyUsedKernelBundle(const std::string &KernelName);
-#endif
 
   /// Stores lambda to the template-free object
   ///
@@ -1326,8 +1315,6 @@ class __SYCL_EXPORT handler {
                   "Kernel argument cannot have a sycl::nd_item type in "
                   "sycl::parallel_for with sycl::range");
 
-#if defined(SYCL2020_CONFORMANT_APIS) ||                                       \
-    defined(__INTEL_PREVIEW_BREAKING_CHANGES)
     static_assert(std::is_convertible_v<item<Dims>, LambdaArgType> ||
                       std::is_convertible_v<item<Dims, false>, LambdaArgType>,
                   "sycl::parallel_for(sycl::range) kernel must have the "
@@ -1340,7 +1327,6 @@ class __SYCL_EXPORT handler {
          std::is_invocable_v<KernelType, RefLambdaArgType, kernel_handler>),
         "SYCL kernel lambda/functor has an unexpected signature, it should be "
         "invocable with sycl::item and optionally sycl::kernel_handler");
-#endif
 
     // TODO: Properties may change the kernel function, so in order to avoid
     //       conflicts they should be included in the name.
@@ -1432,19 +1418,11 @@ class __SYCL_EXPORT handler {
     verifyUsedKernelBundle(detail::KernelInfo<NameT>::getName());
     using LambdaArgType =
         sycl::detail::lambda_arg_type<KernelType, nd_item<Dims>>;
-#if defined(SYCL2020_CONFORMANT_APIS) ||                                       \
-    defined(__INTEL_PREVIEW_BREAKING_CHANGES)
     static_assert(
         std::is_convertible_v<sycl::nd_item<Dims>, LambdaArgType>,
         "Kernel argument of a sycl::parallel_for with sycl::nd_range "
         "must be either sycl::nd_item or be convertible from sycl::nd_item");
     using TransformedArgType = sycl::nd_item<Dims>;
-#else
-    // If user type is convertible from sycl::item/sycl::nd_item, use
-    // sycl::item/sycl::nd_item to transport item information
-    using TransformedArgType =
-        typename TransformUserItemType<Dims, LambdaArgType>::type;
-#endif
 
     (void)ExecutionRange;
     (void)Props;
@@ -3414,35 +3392,25 @@ class __SYCL_EXPORT handler {
   ///        expr m_Storage member
   /// \param Size the size of data getting read back / to.
   /// \param Block if read operation is blocking, default to false.
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   void ext_intel_read_host_pipe(const std::string &Name, void *Ptr, size_t Size,
                                 bool Block = false) {
     ext_intel_read_host_pipe(detail::string_view(Name), Ptr, Size, Block);
   }
   void ext_intel_read_host_pipe(detail::string_view Name, void *Ptr,
                                 size_t Size, bool Block = false);
-#else
-  void ext_intel_read_host_pipe(const std::string &Name, void *Ptr, size_t Size,
-                                bool Block = false);
-#endif
 
   /// Write to host pipes given a host address and
   /// \param Name name of the host pipe to be passed into lower level runtime
   /// \param Ptr host pointer of host pipe as identified by address of its const
   /// expr m_Storage member
   /// \param Size the size of data getting read back / to.
   /// \param Block if write opeartion is blocking, default to false.
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   void ext_intel_write_host_pipe(const std::string &Name, void *Ptr,
                                  size_t Size, bool Block = false) {
     ext_intel_write_host_pipe(detail::string_view(Name), Ptr, Size, Block);
   }
   void ext_intel_write_host_pipe(detail::string_view Name, void *Ptr,
                                  size_t Size, bool Block = false);
-#else
-  void ext_intel_write_host_pipe(const std::string &Name, void *Ptr,
-                                 size_t Size, bool Block = false);
-#endif
   friend class ext::oneapi::experimental::detail::graph_impl;
   friend class ext::oneapi::experimental::detail::dynamic_parameter_impl;
 

sycl/include/sycl/kernel.hpp

@@ -15,10 +15,8 @@
 #include <sycl/detail/info_desc_helpers.hpp>  // for is_kernel_device_specif...
 #include <sycl/detail/owner_less_base.hpp>    // for OwnerLessBase
 #include <sycl/detail/pi.h>                   // for pi_native_handle
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 #include <sycl/detail/string.hpp>
 #include <sycl/detail/string_view.hpp>
-#endif
 #include <sycl/detail/util.hpp>
 #include <sycl/device.hpp>              // for device
 #include <sycl/kernel_bundle_enums.hpp> // for bundle_state
@@ -142,13 +140,9 @@ class __SYCL_EXPORT kernel : public detail::OwnerLessBase<kernel> {
   ///
   /// \return depends on information being queried.
   template <typename Param>
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   typename detail::is_kernel_info_desc<Param>::return_type get_info() const {
     return detail::convert_from_abi_neutral(get_info_impl<Param>());
   }
-#else
-  typename detail::is_kernel_info_desc<Param>::return_type get_info() const;
-#endif
 
   /// Queries the kernel object for SYCL backend-specific information.
   ///
@@ -201,12 +195,10 @@ class __SYCL_EXPORT kernel : public detail::OwnerLessBase<kernel> {
   template <backend BackendName, class SyclObjectT>
   friend auto get_native(const SyclObjectT &Obj)
       -> backend_return_t<BackendName, SyclObjectT>;
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   template <typename Param>
   typename detail::ABINeutralT_t<
       typename detail::is_kernel_info_desc<Param>::return_type>
   get_info_impl() const;
-#endif
 };
 } // namespace _V1
 } // namespace sycl