[SYCL] Disable persistent device code caching by default. (#3891)

* [SYCL] Disable persistent device code caching by default.

Also introduce boolean config variable SYCL_CACHE_PERSISTENT for
finer grained control - to force on/off.

Signed-off-by: kbobrovs <[email protected]>

Author: kbobrovs

sycl/doc/EnvironmentVariables.md

@@ -38,8 +38,9 @@ subject to change. Do not rely on these variables in production code.
 | `SYCL_ENABLE_PCI` | Integer | When set to 1, enables obtaining the GPU PCI address when using the Level Zero backend. The default is 0. |
 | `SYCL_HOST_UNIFIED_MEMORY` | Integer | Enforce host unified memory support or lack of it for the execution graph builder. If set to 0, it is enforced as not supported by all devices. If set to 1, it is enforced as supported by all devices. |
 | `SYCL_CACHE_DIR` | Path | Path to persistent cache root directory. Default values are `%AppData%\libsycl_cache` for Windows and `$XDG_CACHE_HOME/libsycl_cache` on Linux, if `XDG_CACHE_HOME` is not set then `$HOME/.cache/libsycl_cache`. |
-| `SYCL_CACHE_TRACE` | Any(\*) | If the variable is set, messages are sent to std::cerr when non-blocking failures happen (e.g. unable to access cache item file). |
-| `SYCL_CACHE_DISABLE_PERSISTENT` | Any(\*) | Switches persistent cache switch off when the variable is set. |
+| `SYCL_CACHE_TRACE` | Any(\*) | If the variable is set, messages are sent to std::cerr when caching events or non-blocking failures happen (e.g. unable to access cache item file). |
+| `SYCL_CACHE_DISABLE_PERSISTENT (deprecated)` | Any(\*) | Has no effect. |
+| `SYCL_CACHE_PERSISTENT` | Integer | Controls persistent device compiled code cache. Turns it on if set to '1' and turns it off if set to '0'. When cache is enabled SYCL runtime will try to cache and reuse JIT-compiled binaries. Default is off. |
 | `SYCL_CACHE_EVICTION_DISABLE` | Any(\*) | Switches cache eviction off when the variable is set. |
 | `SYCL_CACHE_MAX_SIZE` | Positive integer | Cache eviction is triggered once total size of cached images exceeds the value in megabytes (default - 8 192 for 8 GB). Set to 0 to disable size-based cache eviction. |
 | `SYCL_CACHE_THRESHOLD` | Positive integer | Cache eviction threshold in days (default value is 7 for 1 week). Set to 0 for disabling time-based cache eviction. |

sycl/source/detail/config.def

@@ -24,6 +24,7 @@ CONFIG(SYCL_HOST_UNIFIED_MEMORY, 1, __SYCL_HOST_UNIFIED_MEMORY)
 CONFIG(SYCL_CACHE_DIR, 164, __SYCL_CACHE_DIR)
 CONFIG(SYCL_CACHE_TRACE, 1, __SYCL_CACHE_TRACE)
 CONFIG(SYCL_CACHE_DISABLE_PERSISTENT, 1, __SYCL_CACHE_DISABLE_PERSISTENT)
+CONFIG(SYCL_CACHE_PERSISTENT, 1, __SYCL_CACHE_PERSISTENT)
 CONFIG(SYCL_CACHE_EVICTION_DISABLE, 1, __SYCL_CACHE_EVICTION_DISABLE)
 CONFIG(SYCL_CACHE_MAX_SIZE, 16, __SYCL_CACHE_MAX_SIZE)
 CONFIG(SYCL_CACHE_THRESHOLD, 16, __SYCL_CACHE_THRESHOLD)

sycl/source/detail/config.hpp

@@ -106,6 +106,8 @@ template <ConfigID Config> class SYCLConfig {
 
   static void reset() { (void)getCachedValue(/*ResetCache=*/true); }
 
+  static const char *getName() { return BaseT::MConfigName; }
+
 private:
   static const char *getCachedValue(bool ResetCache = false) {
     static const char *ValStr = BaseT::getRawValue();

sycl/source/detail/persistent_device_code_cache.cpp

@@ -117,7 +117,9 @@ void PersistentDeviceCodeCache::putItemToDisc(
     OSUtil::makeDir(DirName.c_str());
     LockCacheItem Lock{FileName};
     if (Lock.isOwned()) {
-      writeBinaryDataToFile(FileName + ".bin", Result);
+      std::string FullFileName = FileName + ".bin";
+      writeBinaryDataToFile(FullFileName, Result);
+      trace("device binary has been cached: " + FullFileName);
       writeSourceItem(FileName + ".src", Device, Img, SpecConsts,
                       BuildOptionsString);
     }
@@ -153,7 +155,11 @@ std::vector<std::vector<char>> PersistentDeviceCodeCache::getItemFromDisc(
         isCacheItemSrcEqual(FileName + ".src", Device, Img, SpecConsts,
                             BuildOptionsString)) {
       try {
-        return readBinaryDataFromFile(FileName + ".bin");
+        std::string FullFileName = FileName + ".bin";
+        std::vector<std::vector<char>> res =
+            readBinaryDataFromFile(FullFileName);
+        trace("using cached device binary: " + FullFileName);
+        return res; // subject for NRVO
       } catch (...) {
         // If read was unsuccessfull try the next item
       }
@@ -323,13 +329,53 @@ std::string PersistentDeviceCodeCache::getCacheItemPath(
          std::to_string(StringHasher(BuildOptionsString));
 }
 
-/* Returns true if persistent cache enabled. The cache can be disabled by
- * setting SYCL_CACHE_EVICTION_DISABLE environmnet variable.
+// 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()) {
+    std::cerr
+        << "WARNING: " << SYCLConfig<SYCL_CACHE_DISABLE_PERSISTENT>::getName()
+        << " environment variable is deprecated "
+        << "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;
+}
+
+/* Returns true if persistent cache is enabled.
  */
 bool PersistentDeviceCodeCache::isEnabled() {
-  static const char *PersistenCacheDisabled =
-      SYCLConfig<SYCL_CACHE_DISABLE_PERSISTENT>::get();
-  return !PersistenCacheDisabled;
+  static bool Val = parsePersistentCacheConfig();
+  return Val;
 }
 
 /* Returns path for device code cache root directory

sycl/unittests/kernel-and-program/PersistentDeviceCodeCache.cpp

@@ -18,6 +18,23 @@
 #include <llvm/Support/FileSystem.h>
 #include <vector>
 
+// TODO: Introduce common unit tests header and move it there
+static void set_env(const char *name, const char *value) {
+#ifdef _WIN32
+  (void)_putenv_s(name, value);
+#else
+  (void)setenv(name, value, /*overwrite*/ 1);
+#endif
+}
+
+static void unset_env(const char *name) {
+#ifdef _WIN32
+  (void)_putenv_s(name, "");
+#else
+  unsetenv(name);
+#endif
+}
+
 namespace {
 constexpr auto sycl_read_write = cl::sycl::access::mode::read_write;
 using namespace cl::sycl;
@@ -98,6 +115,10 @@ class PersistenDeviceCodeCache : public ::testing::Test {
     if (Plt.is_host() || Plt.get_backend() != backend::opencl) {
       return;
     }
+
+    set_env("SYCL_CACHE_PERSISTENT", "1");
+    sycl::detail::SYCLConfig<sycl::detail::SYCL_CACHE_PERSISTENT>::reset();
+
     std::string BuildOptions{"--concurrent-access=" +
                              std::to_string(ThreadCount)};
     DeviceCodeID = ProgramID;
@@ -151,6 +172,10 @@ TEST_F(PersistenDeviceCodeCache, KeysWithNullTermSymbol) {
   if (Plt.is_host() || Plt.get_backend() != backend::opencl) {
     return;
   }
+
+  set_env("SYCL_CACHE_PERSISTENT", "1");
+  sycl::detail::SYCLConfig<sycl::detail::SYCL_CACHE_PERSISTENT>::reset();
+
   std::string Key{'1', '\0', '3', '4', '\0'};
   std::vector<unsigned char> SpecConst(Key.begin(), Key.end());
   std::string ItemDir = detail::PersistentDeviceCodeCache::getCacheItemPath(
@@ -204,6 +229,10 @@ TEST_F(PersistenDeviceCodeCache, CorruptedCacheFiles) {
   if (Plt.is_host() || Plt.get_backend() != backend::opencl) {
     return;
   }
+
+  set_env("SYCL_CACHE_PERSISTENT", "1");
+  sycl::detail::SYCLConfig<sycl::detail::SYCL_CACHE_PERSISTENT>::reset();
+
   std::string BuildOptions{"--corrupted-file"};
   std::string ItemDir = detail::PersistentDeviceCodeCache::getCacheItemPath(
       Dev, Img, {}, BuildOptions);
@@ -267,6 +296,10 @@ TEST_F(PersistenDeviceCodeCache, LockFile) {
   if (Plt.is_host() || Plt.get_backend() != backend::opencl) {
     return;
   }
+
+  set_env("SYCL_CACHE_PERSISTENT", "1");
+  sycl::detail::SYCLConfig<sycl::detail::SYCL_CACHE_PERSISTENT>::reset();
+
   std::string BuildOptions{"--obsolete-lock"};
   std::string ItemDir = detail::PersistentDeviceCodeCache::getCacheItemPath(
       Dev, Img, {}, BuildOptions);
@@ -318,6 +351,10 @@ TEST_F(PersistenDeviceCodeCache, AccessDeniedForCacheDir) {
   if (Plt.is_host() || Plt.get_backend() != backend::opencl) {
     return;
   }
+
+  set_env("SYCL_CACHE_PERSISTENT", "1");
+  sycl::detail::SYCLConfig<sycl::detail::SYCL_CACHE_PERSISTENT>::reset();
+
   std::string BuildOptions{"--build-options"};
   std::string ItemDir = detail::PersistentDeviceCodeCache::getCacheItemPath(
       Dev, Img, {}, BuildOptions);