[SYCL][ABI-break] Remove <iostream> headers from "sycl/sycl.hpp" and related files

sycl/include/sycl/backend_types.hpp

@@ -10,9 +10,6 @@
 
 #include <sycl/detail/defines.hpp>
 
-#include <fstream>
-#include <iostream>
-#include <istream>
 #include <string>
 
 __SYCL_INLINE_NAMESPACE(cl) {
@@ -31,7 +28,7 @@ enum class backend : char {
   esimd_cpu __SYCL2020_DEPRECATED("use 'ext_oneapi_esimd_emulator' instead") =
       ext_intel_esimd_emulator,
   ext_oneapi_hip = 6,
-  hip __SYCL2020_DEPRECATED("use 'ext_oneapi_hip' instead") = ext_oneapi_hip,
+  hip __SYCL2020_DEPRECATED("use 'ext_oneapi_hip' instead") = ext_oneapi_hip
 };
 
 template <backend Backend> class backend_traits;
@@ -43,30 +40,25 @@ template <backend Backend, typename SYCLObjectT>
 using backend_return_t =
     typename backend_traits<Backend>::template return_type<SYCLObjectT>;
 
-inline std::ostream &operator<<(std::ostream &Out, backend be) {
+inline std::string backend_to_string(const backend &be) {
+
   switch (be) {
   case backend::host:
-    Out << "host";
-    break;
+    return "host";
   case backend::opencl:
-    Out << "opencl";
-    break;
+    return "opencl";
   case backend::ext_oneapi_level_zero:
-    Out << "ext_oneapi_level_zero";
-    break;
+    return "ext_oneapi_level_zero";
   case backend::ext_oneapi_cuda:
-    Out << "ext_oneapi_cuda";
-    break;
+    return "ext_oneapi_cuda";
   case backend::ext_intel_esimd_emulator:
-    Out << "ext_intel_esimd_emulator";
-    break;
+    return "ext_intel_esimd_emulator";
   case backend::ext_oneapi_hip:
-    Out << "ext_oneapi_hip";
-    break;
+    return "ext_oneapi_hip";
   case backend::all:
-    Out << "all";
+    return "all";
   }
-  return Out;
+  return "";
 }
 
 } // namespace sycl

sycl/include/sycl/detail/common.hpp

@@ -116,14 +116,16 @@ static inline std::string codeToString(pi_int32 code) {
                           "Native API returns: "
 
 #ifndef __SYCL_SUPPRESS_PI_ERROR_REPORT
-#include <iostream>
+#include <cstdio>
 // TODO: rename all names with direct use of OCL/OPENCL to be backend agnostic.
 #define __SYCL_REPORT_PI_ERR_TO_STREAM(expr)                                   \
   {                                                                            \
     auto code = expr;                                                          \
+                                                                               \
     if (code != PI_SUCCESS) {                                                  \
-      std::cerr << __SYCL_PI_ERROR_REPORT                                      \
-                << cl::sycl::detail::codeToString(code) << std::endl;          \
+                                                                               \
+      fprintf(stderr, __SYCL_PI_ERROR_REPORT "%s\n",                           \
+              cl::sycl::detail::codeToString(code).c_str());                   \
     }                                                                          \
   }
 #endif

sycl/include/sycl/detail/device_binary_image.hpp

@@ -43,7 +43,7 @@ class RTDeviceBinaryImage : public pi::DeviceBinaryImage {
 
   void print() const override {
     pi::DeviceBinaryImage::print();
-    std::cerr << "    OSModuleHandle=" << ModuleHandle << "\n";
+    fprintf(stderr, "    OSModuleHandle=%lld\n", (long long int)ModuleHandle);
   }
 
 protected:
@@ -60,7 +60,7 @@ class DynRTDeviceBinaryImage : public RTDeviceBinaryImage {
 
   void print() const override {
     RTDeviceBinaryImage::print();
-    std::cerr << "    DYNAMICALLY CREATED\n";
+    fprintf(stderr, "    DYNAMICALLY CREATED\n");
   }
 
 protected:

sycl/include/sycl/detail/device_filter.hpp

@@ -12,7 +12,6 @@
 #include <sycl/detail/defines.hpp>
 #include <sycl/info/info_desc.hpp>
 
-#include <iostream>
 #include <string>
 
 __SYCL_INLINE_NAMESPACE(cl) {
@@ -30,8 +29,7 @@ struct device_filter {
 
   device_filter(){};
   device_filter(const std::string &FilterString);
-  friend std::ostream &operator<<(std::ostream &Out,
-                                  const device_filter &Filter);
+  inline operator std::string() const;
 };
 
 class device_filter_list {
@@ -47,37 +45,45 @@ class device_filter_list {
   bool deviceTypeCompatible(info::device_type DeviceType);
   bool deviceNumberCompatible(int DeviceNum);
   bool containsHost();
-  friend std::ostream &operator<<(std::ostream &Out,
-                                  const device_filter_list &List);
+  inline operator std::string() const;
 };
 
-inline std::ostream &operator<<(std::ostream &Out,
-                                const device_filter &Filter) {
-  Out << Filter.Backend << ":";
-  if (Filter.DeviceType == info::device_type::host) {
-    Out << "host";
-  } else if (Filter.DeviceType == info::device_type::cpu) {
-    Out << "cpu";
-  } else if (Filter.DeviceType == info::device_type::gpu) {
-    Out << "gpu";
-  } else if (Filter.DeviceType == info::device_type::accelerator) {
-    Out << "accelerator";
-  } else if (Filter.DeviceType == info::device_type::all) {
-    Out << "*";
-  } else {
-    Out << "unknown";
+inline device_filter::operator std::string() const {
+  std::string Out{};
+  Out += backend_to_string(this->Backend);
+  Out += ":";
+  switch (this->DeviceType) {
+  case info::device_type::host:
+    Out += "host";
+    break;
+  case info::device_type::cpu:
+    Out += "cpu";
+    break;
+  case info::device_type::gpu:
+    Out += "gpu";
+    break;
+  case info::device_type::accelerator:
+    Out += "accelerator";
+    break;
+  case info::device_type::all:
+    Out += "*";
+    break;
+  default:
+    Out += "unknown";
+    break;
   }
-  if (Filter.HasDeviceNum) {
-    Out << ":" << Filter.DeviceNum;
+
+  if (this->HasDeviceNum) {
+    Out += ":" + std::to_string(this->DeviceNum);
   }
   return Out;
 }
 
-inline std::ostream &operator<<(std::ostream &Out,
-                                const device_filter_list &List) {
-  for (const device_filter &Filter : List.FilterList) {
-    Out << Filter;
-    Out << ",";
+inline device_filter_list::operator std::string() const {
+  std::string Out;
+  for (const device_filter &Filter : this->FilterList) {
+    Out += Filter;
+    Out += ",";
   }
   return Out;
 }

sycl/include/sycl/detail/image_accessor_util.hpp

@@ -20,7 +20,6 @@
 #include <sycl/types.hpp>
 
 #include <cmath>
-#include <iostream>
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {

sycl/include/sycl/detail/pi.hpp

@@ -21,7 +21,6 @@
 #include <cassert>
 #include <cstdint>
 #include <memory>
-#include <sstream>
 #include <string>
 #include <vector>
 
@@ -82,11 +81,14 @@ __SYCL_EXPORT void assertion(bool Condition, const char *Message = nullptr);
 
 template <typename T>
 void handleUnknownParamName(const char *functionName, T parameter) {
-  std::stringstream stream;
-  stream << "Unknown parameter " << parameter << " passed to " << functionName
-         << "\n";
-  auto str = stream.str();
-  auto msg = str.c_str();
+  std::string string;
+  string += "Unknown parameter ";
+  string += parameter;
+  string += " passed to ";
+  string += functionName;
+  string += "\n";
+
+  auto msg = string.c_str();
   die(msg);
 }
 
@@ -232,15 +234,12 @@ class DeviceBinaryProperty {
   pi_uint32 asUint32() const;
   ByteArray asByteArray() const;
   const char *asCString() const;
+  operator std::string() const;
 
 protected:
-  friend std::ostream &operator<<(std::ostream &Out,
-                                  const DeviceBinaryProperty &P);
   const _pi_device_binary_property_struct *Prop;
 };
 
-std::ostream &operator<<(std::ostream &Out, const DeviceBinaryProperty &P);
-
 // C++ convenience wrapper over the pi_device_binary_struct structure.
 class DeviceBinaryImage {
 public:
@@ -298,7 +297,7 @@ class DeviceBinaryImage {
   DeviceBinaryImage() : Bin(nullptr){};
 
   virtual void print() const;
-  virtual void dump(std::ostream &Out) const;
+  virtual void dump(FILE *file) const;
 
   size_t getSize() const {
     assert(Bin && "binary image data not set");

sycl/include/sycl/ext/intel/esimd/detail/elem_type_traits.hpp

@@ -713,19 +713,6 @@ __esimd_wrapper_type_bitcast_from<sycl::half>(sycl::half Val) {
 template <>
 struct is_esimd_arithmetic_type<__raw_t<sycl::half>, void> : std::true_type {};
 
-// Misc
-inline std::ostream &operator<<(std::ostream &O, sycl::half const &rhs) {
-  O << static_cast<float>(rhs);
-  return O;
-}
-
-inline std::istream &operator>>(std::istream &I, sycl::half &rhs) {
-  float ValFloat = 0.0f;
-  I >> ValFloat;
-  rhs = ValFloat;
-  return I;
-}
-
 // The only other place which needs to be updated to support a new type is
 // the is_wrapper_elem_type_v meta function.
 

sycl/include/sycl/ext/intel/esimd/detail/types.hpp

@@ -10,14 +10,17 @@
 
 #pragma once
 
+#include <string>
 #include <sycl/detail/defines.hpp>
 #include <sycl/detail/stl_type_traits.hpp> // to define C++14,17 extensions
 #include <sycl/ext/intel/esimd/common.hpp>
 #include <sycl/ext/intel/esimd/detail/region.hpp>
 #include <sycl/half_type.hpp>
 
 #if defined(__ESIMD_DBG_HOST) && !defined(__SYCL_DEVICE_ONLY__)
-#define __esimd_dbg_print(a) std::cout << ">>> " << #a << "\n"
+#define __esimd_dbg_print(a)                                                   \
+  printf(">>> %s\n", #a);                                                      \
+  fflush(stdout);
 #else
 #define __esimd_dbg_print(a)
 #endif // defined(__ESIMD_DBG_HOST) && !defined(__SYCL_DEVICE_ONLY__)

sycl/include/sycl/ext/intel/esimd/simd.hpp

@@ -22,7 +22,7 @@
 #include <sycl/ext/oneapi/experimental/invoke_simd.hpp>
 
 #ifndef __SYCL_DEVICE_ONLY__
-#include <iostream>
+#include <cstdio>
 #endif // __SYCL_DEVICE_ONLY__
 
 __SYCL_INLINE_NAMESPACE(cl) {
@@ -125,9 +125,30 @@ class simd : public detail::simd_obj_impl<
     return sycl::ext::oneapi::experimental::simd<Ty, N1>(base_type::data());
   }
 
+  /// @ingroup sycl_esimd_misc
+  /// Prints a \c simd object to an output stream.
+  /// TODO: implemented for host code only.
+  operator std::string() const
+#ifdef __SYCL_DEVICE_ONLY__
+      {}
+#else
+  {
+    std::string OS;
+    OS += "{";
+    for (int I = 0; I < N; I++) {
+      OS += (*this)[I];
+      if (I < N - 1)
+        OS += ",";
+    }
+    OS += "}";
+    return OS;
+  }
+#endif // __SYCL_DEVICE_ONLY__
+
   /// Prefix increment, increments elements of this object.
   /// @return Reference to this object.
-  simd &operator++() {
+  simd &
+  operator++() {
     *this += 1;
     return *this;
   }
@@ -200,23 +221,3 @@ template <int N> using simd_mask = detail::simd_mask_type<N>;
 
 } // namespace __ESIMD_NS
 } // __SYCL_INLINE_NAMESPACE(cl)
-
-/// @ingroup sycl_esimd_misc
-/// Prints a \c simd object to an output stream.
-/// TODO: implemented for host code only.
-template <typename Ty, int N>
-std::ostream &operator<<(std::ostream &OS, const __ESIMD_NS::simd<Ty, N> &V)
-#ifdef __SYCL_DEVICE_ONLY__
-    {}
-#else
-{
-  OS << "{";
-  for (int I = 0; I < N; I++) {
-    OS << V[I];
-    if (I < N - 1)
-      OS << ",";
-  }
-  OS << "}";
-  return OS;
-}
-#endif // __SYCL_DEVICE_ONLY__