Update SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD env variable

Author: uditagarwal97

sycl/doc/EnvironmentVariables.md

@@ -14,7 +14,7 @@ compiler and runtime.
 | `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_IN_MEM` | '1' or '0' | Enable ('1') or disable ('0') in-memory caching of device compiled code. When cache is enabled SYCL runtime will try to cache and reuse JIT-compiled binaries. Default is '1'. |
-| `SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD` | See [below](#sycl_in_mem_cache_eviction_threshold) | Controls cache eviction of in-memory caches. |
+| `SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD` | Positive integer  | `SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD` accepts an integer that specifies the maximum size of the in-memory Program cache in bytes. Eviction is performed when the cache size exceeds the threshold. The default value is 0 which means that eviction is disabled.  |
 | `SYCL_CACHE_EVICTION_DISABLE` | Any(\*) | Switches persistent cache eviction off when the variable is set. |
 | `SYCL_CACHE_MAX_SIZE` | Positive integer | Persistent 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 | Persistent cache eviction threshold in days (default value is 7 for 1 week). Set to 0 for disabling time-based cache eviction. |
@@ -139,12 +139,6 @@ If this environment variable is not set, the preferred work-group size for reduc
 
 Note that conflicting configuration tuples in the same list will favor the last entry. For example, a list `cpu:32,gpu:32,cpu:16` will set the preferred work-group size of reductions to 32 for GPUs and 16 for CPUs. This also applies to `*`, for example `cpu:32,*:16` sets the preferred work-group size of reductions on all devices to 16, while `*:16,cpu:32` sets the preferred work-group size of reductions to 32 on CPUs and to 16 on all other devices.
 
-### `SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD`
-
-`SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD` accepts a string value of the form "ProgramCacheSize:KernelCache_size:FastKernelCacheSize", where ProgramCacheSize, KernelCacheSize, and FastKernelCacheSize are the maximum size of the in-memory Program, kernel, and fast kernel cache. Cache eviction is performed when the cache size exceeds the threshold. The thresholds are specified in bytes and parsed as integers.
-
-The default value is "0:0:0" which means that eviction is disabled.
-
 ## Range Rounding Environment Variables
 
 For a description of parallel for range rounding in DPC++ see

sycl/source/detail/config.def

@@ -27,7 +27,7 @@ CONFIG(SYCL_HOST_UNIFIED_MEMORY, 1, __SYCL_HOST_UNIFIED_MEMORY)
 // 260 (Windows limit) - 12 (filename) - 84 (cache directory structure)
 CONFIG(SYCL_CACHE_DIR, 164, __SYCL_CACHE_DIR)
 CONFIG(SYCL_CACHE_TRACE, 4, __SYCL_CACHE_TRACE)
-CONFIG(SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD, 1024,
+CONFIG(SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD, 16,
        __SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD)
 CONFIG(SYCL_CACHE_DISABLE_PERSISTENT, 1, __SYCL_CACHE_DISABLE_PERSISTENT)
 CONFIG(SYCL_CACHE_PERSISTENT, 1, __SYCL_CACHE_PERSISTENT)

sycl/source/detail/config.hpp

@@ -756,75 +756,45 @@ template <> class SYCLConfig<SYCL_CACHE_TRACE> {
   }
 };
 
-// SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD accepts a string value of the form
-// "ProgramCacheSize:KernelCache_size:FastKernelCacheSize", where
-// ProgramCacheSize, KernelCacheSize, and FastKernelCacheSize are
-// the maximum size of the in-memory Program, kernel, and fast kernel cache.
+// SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD accepts an integer that specifies
+// the maximum size of the in-memory Program cache.
 // Cache eviction is performed when the cache size exceeds the threshold.
-// The thresholds are specified in bytes and parsed as integers.
-// The default value is "0:0:0" which means that eviction is disabled.
+// The thresholds are specified in bytes.
+// The default value is "0" which means that eviction is disabled.
 template <> class SYCLConfig<SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD> {
   using BaseT = SYCLConfigBase<SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD>;
 
 public:
-  static std::tuple<int, int, int> get() { return getCachedValue(); }
+  static int get() { return getCachedValue(); }
   static void reset() { (void)getCachedValue(true); }
 
-  static int getProgramCacheSize() { return std::get<0>(getCachedValue()); }
-  static int getKernelCacheSize() { return std::get<1>(getCachedValue()); }
-  static int getFastKernelCacheSize() { return std::get<2>(getCachedValue()); }
+  static int getProgramCacheSize() { return getCachedValue(); }
 
   static bool isProgramCacheEvictionEnabled() {
     return getProgramCacheSize() > 0;
   }
-  static bool isKernelCacheEvictionEnabled() {
-    return getKernelCacheSize() > 0;
-  }
-  static bool isFastKernelCacheEvictionEnabled() {
-    return getFastKernelCacheSize() > 0;
-  }
 
 private:
-  static std::tuple<int, int, int> getCachedValue(bool ResetCache = false) {
+  static int getCachedValue(bool ResetCache = false) {
     const auto Parser = []() {
       const char *ValStr = BaseT::getRawValue();
 
-      // Ensure the the input string is not null and in correct format.
+      // Disable eviction by default.
       if (!ValStr)
-        return std::tuple<int, int, int>{0, 0, 0};
-
-      std::string InputString{ValStr};
-      size_t Pos = 0;
-      std::array<int, 3> CacheSizes;
+        return 0;
 
-      // Ensure that input has exactly 2 ":"
-      if (std::count(InputString.begin(), InputString.end(), ':') != 2) {
+      int CacheSize = 0;
+      try {
+        CacheSize = std::stoi(ValStr);
+        if (CacheSize < 0)
+          throw INVALID_CONFIG_EXCEPTION(BaseT, "Value must be non-negative");
+      } catch (...) {
         std::string Msg = std::string{
             "Invalid input to SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD"};
         throw exception(make_error_code(errc::runtime), Msg);
       }
 
-      for (int &CacheSize : CacheSizes) {
-        size_t NextPos = InputString.find(':', Pos);
-        if (NextPos == std::string::npos)
-          NextPos = InputString.size();
-        std::string CacheSizeStr = InputString.substr(Pos, NextPos - Pos);
-        try {
-          CacheSize = std::stoi(CacheSizeStr);
-          // This exception will anyway be caught by the catch block.
-          if (CacheSize < 0)
-            throw exception(make_error_code(errc::runtime), "");
-        } catch (...) {
-
-          std::string Msg = std::string{
-              "Invalid input to SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD"};
-          throw exception(make_error_code(errc::runtime), Msg);
-        }
-        Pos = NextPos + 1;
-      }
-
-      return std::tuple<int, int, int>{CacheSizes[0], CacheSizes[1],
-                                       CacheSizes[2]};
+      return CacheSize;
     };
 
     static auto EvictionThresholds = Parser();

sycl/unittests/config/ConfigTests.cpp

@@ -325,33 +325,21 @@ TEST(ConfigTests, CheckSyclCacheTraceTest) {
   TestConfig(0, 0, 0, 0);
 }
 
-// SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD accepts a string value of the form
-// "ProgramCacheSize:KernelCache_size:FastKernelCacheSize", where
-// ProgramCacheSize, KernelCacheSize, and FastKernelCacheSize are
-// the maximum size of the in-memory Program, kernel, and fast kernel cache.
+// SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD accepts an integer that specifies
+// the maximum size of the in-memory Program cache.
 // Cache eviction is performed when the cache size exceeds the threshold.
-// The thresholds are specified in bytes and parsed as integers.
-// The default value is "0:0:0" which means that eviction is disabled.
+// The thresholds are specified in bytes.
+// The default value is "0" which means that eviction is disabled.
 TEST(ConfigTests, CheckSyclCacheEvictionThresholdTest) {
 
   using InMemEvicType =
       sycl::detail::SYCLConfig<SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD>;
 
   // Lambda to test parsing of SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD
-  auto TestConfig = [](int expectedProgramCacheSize,
-                       int expectedKernelCacheSize,
-                       int expectedFastKernelCacheSize) {
+  auto TestConfig = [](int expectedProgramCacheSize) {
     EXPECT_EQ(expectedProgramCacheSize, InMemEvicType::getProgramCacheSize());
-    EXPECT_EQ(expectedKernelCacheSize, InMemEvicType::getKernelCacheSize());
-    EXPECT_EQ(expectedFastKernelCacheSize,
-              InMemEvicType::getFastKernelCacheSize());
-
     EXPECT_EQ(expectedProgramCacheSize > 0,
               InMemEvicType::isProgramCacheEvictionEnabled());
-    EXPECT_EQ(expectedKernelCacheSize > 0,
-              InMemEvicType::isKernelCacheEvictionEnabled());
-    EXPECT_EQ(expectedFastKernelCacheSize > 0,
-              InMemEvicType::isFastKernelCacheEvictionEnabled());
   };
 
   // Lambda to set SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD
@@ -369,31 +357,25 @@ TEST(ConfigTests, CheckSyclCacheEvictionThresholdTest) {
     SetSyclInMemCacheEvictionThresholdEnv(value);
     try {
       InMemEvicType::reset();
-      TestConfig(0, 0, 0);
+      TestConfig(0);
       FAIL() << errMsg;
     } catch (...) {
     }
   };
 
   // Test eviction threshold with zero.
-  SetSyclInMemCacheEvictionThresholdEnv("0:0:0");
+  SetSyclInMemCacheEvictionThresholdEnv("0");
   sycl::detail::readConfig(true);
-  TestConfig(0, 0, 0);
+  TestConfig(0);
 
   // Test invalid values.
-  TestInvalidValues("-1:0:0", "Should throw exception for negative value");
-  TestInvalidValues("a:0:0", "Should throw exception for non-integer value");
-  TestInvalidValues("0:a:0", "Should throw exception for non-integer value");
-  TestInvalidValues("0:0:a", "Should throw exception for non-integer value");
-  TestInvalidValues("", "Should throw exception for empty value");
-  TestInvalidValues("0:0", "Should throw exception for invalid input");
-  TestInvalidValues("0", "Should throw exception for invalid input");
-  TestInvalidValues("random", "Should throw exception for invalid input");
+  TestInvalidValues("-1", "Should throw exception for negative value");
+  TestInvalidValues("a", "Should throw exception for non-integer value");
 
   // Test valid values.
-  SetSyclInMemCacheEvictionThresholdEnv("1024:2048:4096");
+  SetSyclInMemCacheEvictionThresholdEnv("1024");
   InMemEvicType::reset();
-  TestConfig(1024, 2048, 4096);
+  TestConfig(1024);
 
   // When SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD is not set, it should default to
   // 0:0:0.
@@ -403,5 +385,5 @@ TEST(ConfigTests, CheckSyclCacheEvictionThresholdTest) {
   unsetenv("SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD");
 #endif
   InMemEvicType::reset();
-  TestConfig(0, 0, 0);
+  TestConfig(0);
 }