[SYCL] Initial changes for C++11 ABI=0 support

sycl/include/sycl/detail/string.hpp

@@ -0,0 +1,45 @@
+//==----------------- string.hpp - SYCL standard header file ---------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+namespace sycl {
+inline namespace _V1 {
+namespace detail {
+
+class string {
+  const char *str;         // used to send existing std::string to libsycl
+  char *ret_str = nullptr; // set from libsycl
+
+public:
+  string() : str(nullptr), ret_str(nullptr) {}
+  string(const char *ptr) : str(ptr) {}
+  string(std::string strn) : str(strn.c_str()) {}
+
+  bool operator==(const char *st) { return strcmp(str, st) == 0; }
+
+  std::string marshall() { return std::string(ret_str); }
+
+  std::string marshall() const { return std::string(ret_str); }
+
+  void unmarshall(std::string &strn) { strcpy(ret_str, strn.c_str()); }
+
+  void allocate(int size) { ret_str = new char[size]; }
+
+  void deallocate() { delete[] ret_str; }
+
+  const char *getPtr() { return str; }
+
+  const char *getPtr() const { return str; }
+
+  char *getRetPtr() { return ret_str; }
+};
+
+} // namespace detail
+} // namespace _V1
+} // namespace sycl

sycl/include/sycl/device.hpp

@@ -8,14 +8,15 @@
 
 #pragma once
 
-#include <sycl/aspects.hpp>                                     // for aspect
-#include <sycl/backend_types.hpp>                               // for backend
-#include <sycl/detail/defines_elementary.hpp>                   // for __SY...
-#include <sycl/detail/export.hpp>                               // for __SY...
-#include <sycl/detail/info_desc_helpers.hpp>                    // for is_d...
-#include <sycl/detail/owner_less_base.hpp>                      // for Owne...
-#include <sycl/detail/pi.h>                                     // for pi_n...
-#include <sycl/device_selector.hpp>                             // for Enab...
+#include <sycl/aspects.hpp>                   // for aspect
+#include <sycl/backend_types.hpp>             // for backend
+#include <sycl/detail/defines_elementary.hpp> // for __SY...
+#include <sycl/detail/export.hpp>             // for __SY...
+#include <sycl/detail/info_desc_helpers.hpp>  // for is_d...
+#include <sycl/detail/owner_less_base.hpp>    // for Owne...
+#include <sycl/detail/pi.h>                   // for pi_n...
+#include <sycl/detail/string.hpp>             // for c++11 abi compatibility
+#include <sycl/device_selector.hpp>           // for Enab...
 #include <sycl/ext/oneapi/experimental/device_architecture.hpp> // for arch...
 #include <sycl/info/info_desc.hpp>                              // for part...
 #include <sycl/platform.hpp>                                    // for plat...
@@ -24,8 +25,9 @@
 #include <memory>      // for shar...
 #include <string>      // for string
 #include <type_traits> // for add_...
-#include <variant>     // for hash
-#include <vector>      // for vector
+#include <typeinfo>
+#include <variant> // for hash
+#include <vector>  // for vector
 
 namespace sycl {
 inline namespace _V1 {
@@ -214,8 +216,30 @@ 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 {
+    // For C++11_ABI compatibility, we handle these string Param types
+    // separately.
+    if constexpr (std::is_same_v<Param, info::device::name> ||
+                  std::is_same_v<Param, info::device::vendor> ||
+                  std::is_same_v<Param, info::device::driver_version> ||
+                  std::is_same_v<Param, info::device::version> ||
+                  std::is_same_v<Param, info::device::profile>) {
+
+      detail::string Info = typeid(Param).name();
+      Info.allocate(100);
+      get_device_info(Info);
+      std::string DeviceInfo = Info.marshall();
+      Info.deallocate();
+      return DeviceInfo;
+    }
+    return get_info_internal<Param>();
+  }
+#else
   template <typename Param>
   typename detail::is_device_info_desc<Param>::return_type get_info() const;
+#endif
 
   /// Check SYCL extension support by device
   ///
@@ -291,6 +315,14 @@ class __SYCL_EXPORT device : public detail::OwnerLessBase<device> {
   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::is_device_info_desc<Param>::return_type
+  get_info_internal() const;
+  // proxy of get_info_internal() to handle C++11-ABI compatibility separately.
+  void get_device_info(detail::string &Type) const;
+#endif
 };
 
 } // namespace _V1

sycl/include/sycl/exception.hpp

@@ -127,8 +127,16 @@ 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/handler.hpp

@@ -25,6 +25,7 @@
 #include <sycl/detail/pi.h>
 #include <sycl/detail/pi.hpp>
 #include <sycl/detail/reduction_forward.hpp>
+#include <sycl/detail/string.hpp>
 #include <sycl/device.hpp>
 #include <sycl/event.hpp>
 #include <sycl/exception.hpp>
@@ -548,7 +549,11 @@ class __SYCL_EXPORT handler {
                   bool IsKernelCreatedFromSource, bool IsESIMD);
 
   /// \return a string containing name of SYCL kernel.
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  detail::string getKernelName();
+#else
   std::string getKernelName();
+#endif
 
   template <typename LambdaNameT> bool lambdaAndKernelHaveEqualName() {
     // TODO It is unclear a kernel and a lambda/functor must to be equal or not
@@ -558,8 +563,13 @@ class __SYCL_EXPORT handler {
     // values of arguments for the kernel.
     assert(MKernel && "MKernel is not initialized");
     const std::string LambdaName = detail::KernelInfo<LambdaNameT>::getName();
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+    detail::string KernelName = getKernelName();
+    return LambdaName == KernelName.marshall();
+#else
     const std::string KernelName = getKernelName();
     return LambdaName == KernelName;
+#endif
   }
 
   /// Saves the location of user's code passed in \p CodeLoc for future usage in
@@ -842,7 +852,15 @@ 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) {
+    detail::string Name = detail::string(KernelName);
+    verifyUsedKernelBundleInternal(Name);
+  }
+  void verifyUsedKernelBundleInternal(detail::string &KernelName);
+#else
   void verifyUsedKernelBundle(const std::string &KernelName);
+#endif
 
   /// Stores lambda to the template-free object
   ///
@@ -3294,7 +3312,11 @@ class __SYCL_EXPORT handler {
   std::vector<detail::ArgDesc> MAssociatedAccesors;
   /// Struct that encodes global size, local size, ...
   detail::NDRDescT MNDRDesc;
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  detail::string MKernelName;
+#else
   std::string MKernelName;
+#endif
   /// Storage for a sycl::kernel object.
   std::shared_ptr<detail::kernel_impl> MKernel;
   /// Type of the command group, e.g. kernel, fill. Can also encode version.
@@ -3396,17 +3418,35 @@ 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(Name), Ptr, Size, Block);
+  }
+  void ext_intel_read_host_pipe(const detail::string &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(Name), Ptr, Size, Block);
+  }
+  void ext_intel_write_host_pipe(const detail::string &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;
 
   bool DisableRangeRounding();

sycl/include/sycl/platform.hpp

@@ -16,6 +16,7 @@
 #include <sycl/detail/info_desc_helpers.hpp>  // for is_platform_info_desc
 #include <sycl/detail/owner_less_base.hpp>    // for OwnerLessBase
 #include <sycl/detail/pi.h>                   // for pi_native_handle
+#include <sycl/detail/string.hpp>             // for c++11 ABI compatibility
 #include <sycl/device_selector.hpp>           // for EnableIfSYCL2020DeviceS...
 #include <sycl/info/info_desc.hpp>            // for device_type
 
@@ -144,9 +145,29 @@ class __SYCL_EXPORT platform : public detail::OwnerLessBase<platform> {
   /// Queries this SYCL platform for info.
   ///
   /// The return type depends on information being queried.
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  template <typename Param>
+  typename detail::is_platform_info_desc<Param>::return_type get_info() const {
+    // For C++11_ABI compatibility, we handle these string Param types
+    // separately.
+    if constexpr (std::is_same_v<Param, info::platform::name> ||
+                  std::is_same_v<Param, info::platform::vendor> ||
+                  std::is_same_v<Param, info::platform::version> ||
+                  std::is_same_v<Param, info::platform::profile>) {
+
+      detail::string Info = typeid(Param).name();
+      Info.allocate(100);
+      get_platform_info(Info);
+      std::string PlatformInfo = Info.marshall();
+      Info.deallocate();
+      return PlatformInfo;
+    }
+    return get_info_internal<Param>();
+  }
+#else
   template <typename Param>
   typename detail::is_platform_info_desc<Param>::return_type get_info() const;
-
+#endif
   /// Returns all available SYCL platforms in the system.
   ///
   /// The resulting vector always contains a single SYCL host platform instance.
@@ -204,6 +225,14 @@ class __SYCL_EXPORT platform : public detail::OwnerLessBase<platform> {
   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::is_platform_info_desc<Param>::return_type
+  get_info_internal() const;
+  // proxy of get_info_internal() to handle C++11-ABI compatibility separately.
+  void get_platform_info(detail::string &Type) const;
+#endif
 }; // class platform
 } // namespace _V1
 } // namespace sycl

sycl/source/detail/queue_impl.hpp

@@ -802,11 +802,16 @@ class queue_impl {
       bool KernelUsesAssert = false;
 
       if (IsKernel)
-        // Kernel only uses assert if it's non interop one
+      // Kernel only uses assert if it's non interop one
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+        KernelUsesAssert = !(Handler.MKernel && Handler.MKernel->isInterop()) &&
+                           ProgramManager::getInstance().kernelUsesAssert(
+                               Handler.MKernelName.marshall());
+#else
         KernelUsesAssert =
             !(Handler.MKernel && Handler.MKernel->isInterop()) &&
             ProgramManager::getInstance().kernelUsesAssert(Handler.MKernelName);
-
+#endif
       finalizeHandler(Handler, Type, Event);
 
       (*PostProcess)(IsKernel, KernelUsesAssert, Event);