small chagnes

Author: raaiq1

sycl/include/CL/sycl/detail/pi.hpp

@@ -21,7 +21,7 @@
 #include <cassert>
 #include <cstdint>
 #include <memory>
-#include <sstream>
+//#include <sstream>
 #include <string>
 #include <vector>
 
@@ -82,11 +82,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 str = string.c_str();
+  auto msg = string.c_str();
   die(msg);
 }
 

sycl/include/CL/sycl/half_type.hpp

@@ -587,18 +587,18 @@ class half {
   }
 
   // Operator << and >>
-  inline friend std::ostream &operator<<(std::ostream &O,
-                                         cl::sycl::half const &rhs) {
-    O << static_cast<float>(rhs);
-    return O;
-  }
-
-  inline friend std::istream &operator>>(std::istream &I, cl::sycl::half &rhs) {
-    float ValFloat = 0.0f;
-    I >> ValFloat;
-    rhs = ValFloat;
-    return I;
-  }
+  // inline friend std::ostream &operator<<(std::ostream &O,
+  //                                        cl::sycl::half const &rhs) {
+  //   O << static_cast<float>(rhs);
+  //   return O;
+  // }
+
+  // inline friend std::istream &operator>>(std::istream &I, cl::sycl::half &rhs) {
+  //   float ValFloat = 0.0f;
+  //   I >> ValFloat;
+  //   rhs = ValFloat;
+  //   return I;
+  // }
 
   template <typename Key> friend struct std::hash;
 

sycl/include/sycl/sycl.hpp

@@ -8,4 +8,4 @@
 
 #pragma once
 
-#include <CL/sycl.hpp>
+#include <CL/sycl.hpp>

sycl/source/detail/config.hpp

@@ -21,6 +21,7 @@
 #include <mutex>
 #include <string>
 #include <utility>
+#include <iostream>
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {

sycl/source/detail/persistent_device_code_cache.cpp

@@ -348,63 +348,6 @@ std::string PersistentDeviceCodeCache::getCacheItemPath(
 }
 
 
-// TODO Currently parsing configuration variables and error reporting is not
-// centralized, and is basically re-implemented (with different level of
-// reliability) for each particular variable. As a variant, this can go into
-// the SYCLConfigBase class, which can be templated by value type, default value
-// and value parser (combined with error checker). It can also have typed get()
-// function returning one-time parsed and error-checked value.
-
-// Parses persistent cache configuration and checks it for errors.
-// Returns true if it is enabled, false otherwise.
-static bool parsePersistentCacheConfig() {
-  constexpr bool Default = false; // default is disabled
-
-  // Check if deprecated opt-out env var is used, then warn.
-  if (SYCLConfig<SYCL_CACHE_DISABLE_PERSISTENT>::get()) {
-    fprintf(stderr,
-           "WARNING: %s%s%s%s%s%s",SYCLConfig<SYCL_CACHE_DISABLE_PERSISTENT>::getName(),
-           "and has no effect. By default, persistent device code caching is ",
-           (Default ? "enabled." : "disabled."), " Use ",
-           SYCLConfig<SYCL_CACHE_PERSISTENT>::getName(),
-           "=1/0 to enable/disable.\n");
-  }
-  bool Ret = Default;
-  const char *RawVal = SYCLConfig<SYCL_CACHE_PERSISTENT>::get();
-
-  if (RawVal) {
-    if (!std::strcmp(RawVal, "0")) {
-      Ret = false;
-    } else if (!std::strcmp(RawVal, "1")) {
-      Ret = true;
-    } else {
-      std::string Msg =
-          std::string{"Invalid value for bool configuration variable "} +
-          SYCLConfig<SYCL_CACHE_PERSISTENT>::getName() + std::string{": "} +
-          RawVal;
-      throw runtime_error(Msg, PI_INVALID_OPERATION);
-    }
-  }
-  PersistentDeviceCodeCache::trace(Ret ? "enabled" : "disabled");
-  return Ret;
-}
-
-/* Cached static variable signalling if the persistent cache is enabled.
- * The variable can have three values:
- *  - None  : The configuration has not been parsed.
- *  - true  : The persistent cache is enabled.
- *  - false : The persistent cache is disabled.
- */
-static std::optional<bool> CacheIsEnabled;
-
-/* Forces a reparsing of the information used to determine if the persistent
- * cache is enabled. This is primarily used for unit-testing where the
- * corresponding configuration variable is set by the individual tests.
- */
-void PersistentDeviceCodeCache::reparseConfig() {
-  CacheIsEnabled = parsePersistentCacheConfig();
-}
-
 
 /* Returns true if persistent cache is enabled.
  */