Implement eviction for persistent cache

Author: uditagarwal97

sycl/include/sycl/detail/os_util.hpp

@@ -15,6 +15,7 @@
 #include <cstdlib>    // for size_t
 #include <string>     // for string
 #include <sys/stat.h> // for stat
+#include <vector>     // for vector
 
 #ifdef _WIN32
 #define __SYCL_RT_OS_WINDOWS
@@ -88,6 +89,16 @@ class __SYCL_EXPORT OSUtil {
     return !stat(Path.c_str(), &Stat);
 #endif
   }
+
+  // Get size of directory in bytes.
+  static size_t getDirectorySize(const std::string &Path);
+
+  // Get size of file in bytes.
+  static size_t getFileSize(const std::string &Path);
+
+  // Get list of all files in the directory along with its last access time.
+  static std::vector<std::pair<time_t, std::string>>
+  getFilesWithAccessTime(const std::string &Path);
 };
 
 } // namespace detail

sycl/source/detail/config.hpp

@@ -806,6 +806,56 @@ template <> class SYCLConfig<SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD> {
   }
 };
 
+// SYCL_CACHE_MAX_SIZE accepts an integer that specifies
+// the maximum size of the on-disk Program cache.
+// Cache eviction is performed when the cache size exceeds the threshold.
+// The thresholds are specified in bytes.
+// The default value is "0" which means that eviction is disabled.
+template <> class SYCLConfig<SYCL_CACHE_MAX_SIZE> {
+  using BaseT = SYCLConfigBase<SYCL_CACHE_MAX_SIZE>;
+
+public:
+  static int get() { return getCachedValue(); }
+  static void reset() { (void)getCachedValue(true); }
+
+  static int getProgramCacheSize() { return getCachedValue(); }
+
+  static bool isPersistentCacheEvictionEnabled() {
+    return getProgramCacheSize() > 0;
+  }
+
+private:
+  static int getCachedValue(bool ResetCache = false) {
+    const auto Parser = []() {
+      const char *ValStr = BaseT::getRawValue();
+
+      // Disable eviction by default.
+      if (!ValStr)
+        return 0;
+
+      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_CACHE_MAX_SIZE. Please try "
+                        "a positive integer."};
+        throw exception(make_error_code(errc::runtime), Msg);
+      }
+
+      return CacheSize;
+    };
+
+    static auto EvictionThresholds = Parser();
+    if (ResetCache)
+      EvictionThresholds = Parser();
+
+    return EvictionThresholds;
+  }
+};
+
 #undef INVALID_CONFIG_EXCEPTION
 
 } // namespace detail

sycl/source/detail/os_util.cpp

@@ -10,7 +10,6 @@
 
 #include <cassert>
 #include <limits>
-
 #if __GNUC__ && __GNUC__ < 8
 // Don't include <filesystem> for GCC versions less than 8
 #else
@@ -277,6 +276,67 @@ int OSUtil::makeDir(const char *Dir) {
   return 0;
 }
 
+// Get size of a directory in bytes.
+size_t OSUtil::getDirectorySize(const std::string &Path) {
+
+  size_t Size = 0;
+#if __GNUC__ && __GNUC__ < 8
+  // Should we worry about this case?
+  assert(false && "getDirectorySize is not implemented for GCC < 8");
+#else
+  // Use C++17 filesystem API to get the size of the directory.
+  for (const auto &entry :
+       std::filesystem::recursive_directory_iterator(Path)) {
+    if (entry.is_regular_file())
+      Size += entry.file_size();
+  }
+#endif
+  return Size;
+}
+
+// Get size of file in bytes.
+size_t OSUtil::getFileSize(const std::string &Path) {
+  size_t Size = 0;
+#if __GNUC__ && __GNUC__ < 8
+  // Should we worry about this case?
+  assert(false && "getFileSize is not implemented for GCC < 8");
+#else
+  std::filesystem::path FilePath(Path);
+  if (std::filesystem::exists(FilePath) &&
+      std::filesystem::is_regular_file(FilePath))
+    Size = std::filesystem::file_size(FilePath);
+#endif
+  return Size;
+}
+
+// Get list of all files in the directory along with its last access time.
+std::vector<std::pair<time_t, std::string>>
+OSUtil::getFilesWithAccessTime(const std::string &Path) {
+  std::vector<std::pair<time_t, std::string>> Files;
+#if __GNUC__ && __GNUC__ < 8
+  // Should we worry about this case?
+  assert(false && "getFilesWithAccessTime is not implemented for GCC < 8");
+#else
+  for (const auto &entry :
+       std::filesystem::recursive_directory_iterator(Path)) {
+    if (entry.is_regular_file()) {
+#if defined(__SYCL_RT_OS_LINUX) || defined(__SYCL_RT_OS_DARWIN)
+      struct stat StatBuf;
+      if (stat(entry.path().c_str(), &StatBuf) == 0)
+        Files.push_back({StatBuf.st_atime, entry.path().string()});
+#elif defined(__SYCL_RT_OS_WINDOWS)
+      WIN32_FILE_ATTRIBUTE_DATA FileData;
+      if (GetFileAttributesEx(entry.path().c_str(), GetFileExInfoStandard,
+                              &FileData))
+        Files.push_back(
+            {FileData.ftLastAccessTime.dwLowDateTime, entry.path().string()});
+#endif // __SYCL_RT_OS
+    }
+  }
+#endif
+  return Files;
+}
+
 } // namespace detail
 } // namespace _V1
 } // namespace sycl