[SYCL] Speed up device compilation for half and bfloat16 (#20050)

* `std::istream`/`std::ostream` aren't usable on device, so limit
`operator<<`/`operator>>` to declaration only to limit device includes
to `<iosfwd>` instead of much heavier `<istream>`/`<ostream>`.
* Use "lighter" `<optional>` to get `std::hash`

Author: aelovikov-intel

sycl/include/sycl/detail/vector_arith.hpp

@@ -14,6 +14,8 @@
 #include <sycl/detail/type_traits/vec_marray_traits.hpp>
 #include <sycl/ext/oneapi/bfloat16.hpp>
 
+#include <functional>
+
 namespace sycl {
 inline namespace _V1 {
 namespace detail {

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

@@ -115,19 +115,6 @@ struct is_esimd_arithmetic_type<half_raw_type, void> : std::true_type {};
 template <>
 struct is_esimd_arithmetic_type<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;
-}
-
 } // namespace ext::intel::esimd::detail
 } // namespace _V1
 } // namespace sycl

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

@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include <sycl/aliases.hpp>                   // for half
-#include <sycl/bit_cast.hpp>                  // for bit_cast
-#include <sycl/detail/defines_elementary.hpp> // for __DPCPP_SYCL_EXTERNAL
-#include <sycl/half_type.hpp>                 // for half
+#include <sycl/aliases.hpp>
+#include <sycl/bit_cast.hpp>
+#include <sycl/detail/defines_elementary.hpp>
+#include <sycl/half_type.hpp>
 
-#include <cstdint> // for uint16_t, uint32_t
+#include <cstdint>
 
 namespace sycl {
 inline namespace _V1 {
@@ -126,6 +126,12 @@ class bfloat16 {
   // for floating-point types.
 
   // Stream Operator << and >>
+#ifdef __SYCL_DEVICE_ONLY__
+  // std::istream/std::ostream aren't usable on device, so don't provide a
+  // definition to save compile time by using lightweight `<iosfwd>`.
+  inline friend std::ostream &operator<<(std::ostream &O, bfloat16 const &rhs);
+  inline friend std::istream &operator>>(std::istream &I, bfloat16 &rhs);
+#else
   inline friend std::ostream &operator<<(std::ostream &O, bfloat16 const &rhs) {
     O << static_cast<float>(rhs);
     return O;
@@ -137,6 +143,7 @@ class bfloat16 {
     rhs = ValFloat;
     return I;
   }
+#endif
 
 private:
   Bfloat16StorageT value;

sycl/include/sycl/half_type.hpp

@@ -10,18 +10,25 @@
 
 #include <sycl/bit_cast.hpp>              // for bit_cast
 #include <sycl/detail/export.hpp>         // for __SYCL_EXPORT
-#include <sycl/detail/iostream_proxy.hpp> // for istream, ostream
 
 #ifdef __SYCL_DEVICE_ONLY__
 #include <sycl/aspects.hpp>
 #endif
 
-#include <cstddef>     // for size_t
-#include <cstdint>     // for uint16_t, uint32_t, uint8_t
-#include <functional>  // for hash
+#include <cstddef>
+#include <cstdint>
 #include <limits>      // for float_denorm_style, float_r...
-#include <string_view> // for hash
-#include <type_traits> // for enable_if_t
+#include <type_traits>
+
+// For std::hash, seems to be the most lightweight header provide it under
+// C++17:
+#include <optional>
+
+#ifdef __SYCL_DEVICE_ONLY__
+#include <iosfwd>
+#else
+#include <sycl/detail/iostream_proxy.hpp>
+#endif
 
 #if !defined(__has_builtin) || !__has_builtin(__builtin_expect)
 #define __builtin_expect(a, b) (a)
@@ -478,6 +485,13 @@ class [[__sycl_detail__::__uses_aspects__(aspect::fp16)]] half {
 #endif // __SYCL_DEVICE_ONLY__
 
   // Operator << and >>
+#ifdef __SYCL_DEVICE_ONLY__
+  // std::istream/std::ostream aren't usable on device, so don't provide a
+  // definition to save compile time by using lightweight `<iosfwd>`.
+  inline friend std::ostream &operator<<(std::ostream &O,
+                                         sycl::half const &rhs);
+  inline friend std::istream &operator>>(std::istream &I, sycl::half &rhs);
+#else
   inline friend std::ostream &operator<<(std::ostream &O,
                                          sycl::half const &rhs) {
     O << static_cast<float>(rhs);
@@ -490,6 +504,7 @@ class [[__sycl_detail__::__uses_aspects__(aspect::fp16)]] half {
     rhs = ValFloat;
     return I;
   }
+#endif
 
   template <typename Key> friend struct std::hash;