[SYCL] Fix enabling of persistent device code cache in unit-tests (#6062)

The persistent device code cache currently only parse the configurations
indicating if it is enabled once, caching the result. This can cause
unit-tests for the cache to fail as they may be run after other tests
that may have populated the cached result. To fix this, the persistent
code cache now exposes a new function forcing the configuration to be
reparsed.
Additionally, the unit-tests will reset the SYCL_CACHE_PERSISTENT after
each test case if it was set during.

Signed-off-by: Larsen, Steffen <steffen.larsen@intel.com>

Author: steffenlarsen

sycl/source/detail/persistent_device_code_cache.cpp

@@ -6,12 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <cstdio>
 #include <detail/device_impl.hpp>
 #include <detail/persistent_device_code_cache.hpp>
 #include <detail/plugin.hpp>
 #include <detail/program_manager/program_manager.hpp>
 
+#include <cstdio>
+#include <optional>
+
 #if defined(__SYCL_RT_OS_LINUX)
 #include <unistd.h>
 #else
@@ -379,11 +381,28 @@ static bool parsePersistentCacheConfig() {
   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.
  */
 bool PersistentDeviceCodeCache::isEnabled() {
-  static bool Val = parsePersistentCacheConfig();
-  return Val;
+  if (!CacheIsEnabled)
+    reparseConfig();
+  return *CacheIsEnabled;
 }
 
 /* Returns path for device code cache root directory

sycl/source/detail/persistent_device_code_cache.hpp

@@ -184,6 +184,12 @@ class PersistentDeviceCodeCache {
                             const std::string &BuildOptionsString,
                             const RT::PiProgram &NativePrg);
 
+  /* 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.
+   */
+  static void reparseConfig();
+
   /* Sends message to std:cerr stream when SYCL_CACHE_TRACE environemnt is set*/
   static void trace(const std::string &msg) {
     static const char *TraceEnabled = SYCLConfig<SYCL_CACHE_TRACE>::get();

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

@@ -16,6 +16,7 @@
 #include <gtest/gtest.h>
 #include <helpers/PiMock.hpp>
 #include <llvm/Support/FileSystem.h>
+#include <optional>
 #include <vector>
 
 #define ASSERT_NO_ERROR(x)                                                     \
@@ -28,9 +29,12 @@
 // 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);
+  (void)_putenv_s(name, value ? value : "");
 #else
-  (void)setenv(name, value, /*overwrite*/ 1);
+  if (value)
+    (void)setenv(name, value, /*overwrite*/ 1);
+  else
+    (void)unsetenv(name);
 #endif
 }
 
@@ -88,12 +92,47 @@ class PersistenDeviceCodeCache : public ::testing::Test {
     return _putenv_s(name, value);
   }
 #endif
+
+  std::optional<std::string> SYCLCachePersistentBefore;
+  bool SYCLCachePersistentChanged = false;
+
+  // Caches the initial value of the SYCL_CACHE_PERSISTENT environment variable
+  // before overwriting it with the new value.
+  // Tear-down will reset the environment variable.
+  void SetSYCLCachePersistentEnv(const char *NewValue) {
+    char *SYCLCachePersistent = getenv("SYCL_CACHE_PERSISTENT");
+    // We can skip if the new value is the same as the old one.
+    if ((!NewValue && !SYCLCachePersistent) ||
+        (NewValue && SYCLCachePersistent &&
+         !strcmp(NewValue, SYCLCachePersistent)))
+      return;
+
+    // Cache the old value of SYCL_CACHE_PERSISTENT if it is not already saved.
+    if (!SYCLCachePersistentChanged && SYCLCachePersistent)
+      SYCLCachePersistentBefore = std::string{SYCLCachePersistent};
+
+    // Set the environment variable and signal the configuration file and the
+    // persistent cache.
+    set_env("SYCL_CACHE_PERSISTENT", NewValue);
+    sycl::detail::SYCLConfig<sycl::detail::SYCL_CACHE_PERSISTENT>::reset();
+    detail::PersistentDeviceCodeCache::reparseConfig();
+    SYCLCachePersistentChanged = true;
+  }
+
   virtual void SetUp() {
     EXPECT_NE(getenv("SYCL_CACHE_DIR"), nullptr)
         << "Please set SYCL_CACHE_DIR environment variable pointing to cache "
            "location.";
   }
 
+  virtual void TearDown() {
+    // If we changed the cache, set it back to the old value.
+    if (SYCLCachePersistentChanged)
+      SetSYCLCachePersistentEnv(SYCLCachePersistentBefore
+                                    ? SYCLCachePersistentBefore->c_str()
+                                    : nullptr);
+  }
+
   PersistenDeviceCodeCache() : Plt{default_selector()} {
 
     if (Plt.is_host() || Plt.get_backend() != backend::opencl) {
@@ -119,8 +158,7 @@ class PersistenDeviceCodeCache : public ::testing::Test {
       return;
     }
 
-    set_env("SYCL_CACHE_PERSISTENT", "1");
-    sycl::detail::SYCLConfig<sycl::detail::SYCL_CACHE_PERSISTENT>::reset();
+    SetSYCLCachePersistentEnv("1");
 
     std::string BuildOptions{"--concurrent-access=" +
                              std::to_string(ThreadCount)};
@@ -188,8 +226,7 @@ TEST_F(PersistenDeviceCodeCache, KeysWithNullTermSymbol) {
     return;
   }
 
-  set_env("SYCL_CACHE_PERSISTENT", "1");
-  sycl::detail::SYCLConfig<sycl::detail::SYCL_CACHE_PERSISTENT>::reset();
+  SetSYCLCachePersistentEnv("1");
 
   std::string Key{'1', '\0', '3', '4', '\0'};
   std::vector<unsigned char> SpecConst(Key.begin(), Key.end());
@@ -247,8 +284,7 @@ TEST_F(PersistenDeviceCodeCache, CorruptedCacheFiles) {
     return;
   }
 
-  set_env("SYCL_CACHE_PERSISTENT", "1");
-  sycl::detail::SYCLConfig<sycl::detail::SYCL_CACHE_PERSISTENT>::reset();
+  SetSYCLCachePersistentEnv("1");
 
   std::string BuildOptions{"--corrupted-file"};
   std::string ItemDir = detail::PersistentDeviceCodeCache::getCacheItemPath(
@@ -318,8 +354,7 @@ TEST_F(PersistenDeviceCodeCache, LockFile) {
     return;
   }
 
-  set_env("SYCL_CACHE_PERSISTENT", "1");
-  sycl::detail::SYCLConfig<sycl::detail::SYCL_CACHE_PERSISTENT>::reset();
+  SetSYCLCachePersistentEnv("1");
 
   std::string BuildOptions{"--obsolete-lock"};
   std::string ItemDir = detail::PersistentDeviceCodeCache::getCacheItemPath(
@@ -375,8 +410,7 @@ TEST_F(PersistenDeviceCodeCache, AccessDeniedForCacheDir) {
     return;
   }
 
-  set_env("SYCL_CACHE_PERSISTENT", "1");
-  sycl::detail::SYCLConfig<sycl::detail::SYCL_CACHE_PERSISTENT>::reset();
+  SetSYCLCachePersistentEnv("1");
 
   std::string BuildOptions{"--build-options"};
   std::string ItemDir = detail::PersistentDeviceCodeCache::getCacheItemPath(