Store last access time of a cache entry in a file

Author: uditagarwal97

sycl/include/sycl/detail/os_util.hpp

@@ -12,10 +12,10 @@
 
 #include <sycl/detail/export.hpp> // for __SYCL_EXPORT
 
-#include <cstdlib>    // for size_t
+#include <cstdlib> // for size_t
+#include <functional>
 #include <string>     // for string
 #include <sys/stat.h> // for stat
-#include <vector>     // for vector
 
 #ifdef _WIN32
 #define __SYCL_RT_OS_WINDOWS
@@ -100,12 +100,10 @@ size_t getDirectorySize(const std::string &Path, bool ignoreError);
 // Get size of file in bytes.
 size_t getFileSize(const std::string &Path);
 
-// Get list of all files in the directory along with its last modification time.
-std::vector<std::pair<uint64_t, std::string>>
-getFilesWithLastModificationTime(const std::string &Path, bool ignoreError);
-
-// Function to update file modification time with current time.
-void updateFileModificationTime(const std::string &Path);
+// Function to recursively iterate over the directory and execute
+// 'Func' on each regular file.
+void fileTreeWalk(const std::string Path,
+                  std::function<void(const std::string)> Func);
 
 } // namespace detail
 } // namespace _V1

sycl/source/detail/os_util.cpp

@@ -285,106 +285,43 @@ int OSUtil::makeDir(const char *Dir) {
   return 0;
 }
 
-// Get size of a directory in bytes.
-size_t getDirectorySize(const std::string &Path, bool IgnoreError = false) {
-  size_t DirSizeVar = 0;
-  std::error_code EC;
-  for (auto It = fs::recursive_directory_iterator(Path, EC);
-       It != fs::recursive_directory_iterator(); It.increment(EC)) {
-    // Errors can happen if a file was removed/added during the iteration.
-    if (EC && !IgnoreError)
-      throw sycl::exception(make_error_code(errc::runtime),
-                            "Failed to get directory size: " + Path + "\n" +
-                                EC.message());
-
-    if (fs::is_regular_file(It->path()))
-      DirSizeVar += getFileSize(It->path().string());
-  }
-  return DirSizeVar;
-}
-
 // Get size of file in bytes.
 size_t getFileSize(const std::string &Path) {
   return static_cast<size_t>(fs::file_size(Path));
 }
 
-// Get list of all files in the directory along with its last modification time.
-std::vector<std::pair<uint64_t, std::string>>
-getFilesWithLastModificationTime(const std::string &Path,
-                                 bool IgnoreError = false) {
-  std::vector<std::pair<uint64_t, std::string>> Files = {};
+// Function to recursively iterate over the directory and execute
+// 'Func' on each regular file.
+void fileTreeWalk(const std::string Path,
+                  std::function<void(const std::string)> Func) {
+
   std::error_code EC;
   for (auto It = fs::recursive_directory_iterator(Path, EC);
        It != fs::recursive_directory_iterator(); It.increment(EC)) {
+
     // Errors can happen if a file was removed/added during the iteration.
-    if (EC && !IgnoreError)
-      throw sycl::exception(make_error_code(errc::runtime),
-                            "Failed to get files with access time: " + Path +
-                                "\n" + EC.message());
-
-    const std::string FileName = It->path().string();
-    if (fs::is_regular_file(It->path())) {
-// For Linux and Darwin, use stats.
-#if defined(__SYCL_RT_OS_LINUX) || defined(__SYCL_RT_OS_DARWIN)
-      struct stat StatBuf;
-      if (stat(FileName.c_str(), &StatBuf) == 0)
-        Files.push_back({StatBuf.st_atim.tv_nsec, FileName});
-#elif defined(__SYCL_RT_OS_WINDOWS)
-      // Use GetFileAttributeExA to get file modification time.
-      WIN32_FILE_ATTRIBUTE_DATA FileAttr;
-      if (GetFileAttributesExA(FileName.c_str(), GetFileExInfoStandard,
-                               &FileAttr)) {
-        ULARGE_INTEGER AccessTime;
-        AccessTime.HighPart = FileAttr.ftLastWriteTime.dwHighDateTime;
-        AccessTime.LowPart = FileAttr.ftLastWriteTime.dwLowDateTime;
-        Files.push_back({AccessTime.QuadPart, FileName});
-      } else
-        throw sycl::exception(make_error_code(errc::runtime),
-                              "Failed to get file attributes for: " + FileName);
-#endif // __SYCL_RT_OS
-    }
-  }
+    if (EC)
+      throw sycl::exception(
+          make_error_code(errc::runtime),
+          "Failed to do File Tree Walk. Ensure that the directory is not "
+          "getting updated while FileTreeWalk is in progress.: " +
+              Path + "\n" + EC.message());
 
-  return Files;
+    if (fs::is_regular_file(It->path()))
+      Func(It->path().string());
+  }
 }
 
-// Function to update file modification time with current time.
-void updateFileModificationTime(const std::string &Path) {
-
-#if defined(__SYCL_RT_OS_WINDOWS)
-  // For Windows, use SetFileTime to update file access time.
-
-  // Open file with FILE_FLAG_WRITE_THROUGH and FILE_FLAG_NO_BUFFERING flags
-  // to ensure that the file time is updated on disk, asap.
-  HANDLE hFile = CreateFileA(
-      Path.c_str(), GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
-      FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING,
-      NULL);
-  if (hFile != INVALID_HANDLE_VALUE) {
-    FILETIME ft;
-    GetSystemTimeAsFileTime(&ft);
-    if (!SetFileTime(hFile, NULL, NULL, &ft)) {
-      // Print full error.
-      char *errorText = nullptr;
-      FormatMessageA(
-          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER |
-              FORMAT_MESSAGE_IGNORE_INSERTS,
-          NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-          (LPSTR)&errorText, 0, NULL);
-
-      throw sycl::exception(make_error_code(errc::runtime),
-                            "Failed to update file access time: " + Path);
-    }
-    CloseHandle(hFile);
-  } else {
-    throw sycl::exception(make_error_code(errc::runtime),
-                          "Failed to open file: " + Path);
-  }
+// Get size of a directory in bytes.
+size_t getDirectorySize(const std::string &Path, bool IgnoreError = false) {
+  size_t DirSizeVar = 0;
 
-#elif defined(__SYCL_RT_OS_LINUX) || defined(__SYCL_RT_OS_DARWIN)
-  // For Linux and Darwin, use utimensat to update file modification time.
-  utimensat(0, Path.c_str(), nullptr, 0);
-#endif // __SYCL_RT_OS
+  auto CollectFIleSize = [&DirSizeVar](const std::string Path) {
+    DirSizeVar += getFileSize(Path);
+  };
+  fileTreeWalk(Path, CollectFIleSize);
+
+  return DirSizeVar;
 }
 
 } // namespace detail

sycl/source/detail/persistent_device_code_cache.cpp

@@ -180,6 +180,25 @@ getProgramBinaryData(const ur_program_handle_t &NativePrg,
   return Result;
 }
 
+// Save the current time in a file.
+void PersistentDeviceCodeCache::saveCurrentTimeInAFile(std::string FileName) {
+  // Lock the file to prevent concurrent writes.
+  LockCacheItem Lock{FileName};
+  if (Lock.isOwned()) {
+    try {
+      std::ofstream FileStream{FileName, std::ios::trunc};
+      FileStream << std::chrono::high_resolution_clock::now()
+                        .time_since_epoch()
+                        .count();
+      FileStream.close();
+    } catch (std::exception &e) {
+      throw sycl::exception(make_error_code(errc::runtime),
+                            "Failed to save current time in a file: " +
+                                FileName + "\n" + std::string(e.what()));
+    }
+  }
+}
+
 // Check if cache_size.txt file is present in the cache root directory.
 // If not, create it and populate it with the size of the cache directory.
 void PersistentDeviceCodeCache::repopulateCacheSizeFile(
@@ -245,16 +264,25 @@ void PersistentDeviceCodeCache::evictItemsFromCache(
   // modification time.
   std::vector<std::pair<uint64_t, std::string>> FilesWithAccessTime;
 
-  // getFileWithLastModificationTime can throw if any new file is created or
-  // removed during the iteration. Retry in that case. When eviction is in
-  // progress,, we don't insert any new item but processes can still read the
-  // cache. Reading from cache can create/remove .lock file which can cause the
-  // exception.
+  auto CollectFileAccessTime = [&FilesWithAccessTime](const std::string File) {
+    if (File.find("_access_time.txt") != std::string::npos) {
+      std::ifstream FileStream{File};
+      uint64_t AccessTime;
+      FileStream >> AccessTime;
+      FilesWithAccessTime.push_back({AccessTime, File});
+    }
+  };
+
+  // fileTreeWalk can throw if any new file is created or removed during the
+  // iteration. Retry in that case. When eviction is in progress, we don't
+  // insert any new item but processes can still read the cache. Reading from
+  // cache can create/remove .lock file which can cause the exception.
   while (true) {
     try {
-      FilesWithAccessTime = getFilesWithLastModificationTime(CacheRoot, false);
+      fileTreeWalk(CacheRoot, CollectFileAccessTime);
       break;
     } catch (...) {
+      FilesWithAccessTime.clear();
       // If the cache directory is removed during the iteration, retry.
       continue;
     }
@@ -272,14 +300,8 @@ void PersistentDeviceCodeCache::evictItemsFromCache(
   size_t CurrCacheSize = CacheSize;
   for (const auto &File : FilesWithAccessTime) {
 
-    // Remove .bin/.src/.lock extension from the file name.
-    auto ExtLoc = File.second.find_last_of(".");
-    const std::string FileNameWOExt = File.second.substr(0, ExtLoc);
-    const std::string Extension = File.second.substr(ExtLoc);
-
-    if (Extension != ".bin")
-      continue;
-
+    int pos = File.second.find("_access_time.txt");
+    const std::string FileNameWOExt = File.second.substr(0, pos);
     const std::string BinFile = FileNameWOExt + ".bin";
     const std::string SrcFile = FileNameWOExt + ".src";
 
@@ -404,10 +426,6 @@ void PersistentDeviceCodeCache::putItemToDisc(
     const SerializedObj &SpecConsts, const std::string &BuildOptionsString,
     const ur_program_handle_t &NativePrg) {
 
-#ifdef __SYCL_INSTRUMENT_PERSISTENT_CACHE
-  InstrumentCache Instrument{"putItemToDisc: "};
-#endif
-
   if (!areImagesCacheable(Imgs))
     return;
 
@@ -451,6 +469,8 @@ void PersistentDeviceCodeCache::putItemToDisc(
         // Update Total cache size after adding the new items.
         TotalSize += getFileSize(FileName + ".src");
         TotalSize += getFileSize(FileName + ".bin");
+
+        saveCurrentTimeInAFile(FileName + "_access_time.txt");
       } else {
         PersistentDeviceCodeCache::trace("cache lock not owned " + FileName);
       }
@@ -466,12 +486,8 @@ void PersistentDeviceCodeCache::putItemToDisc(
   }
 
   // Update the cache size file and trigger cache eviction if needed.
-  if (TotalSize) {
-#ifdef __SYCL_INSTRUMENT_PERSISTENT_CACHE
-    InstrumentCache Instrument{"Eviction: "};
-#endif
+  if (TotalSize)
     updateCacheFileSizeAndTriggerEviction(getRootDir(), TotalSize);
-  }
 }
 
 void PersistentDeviceCodeCache::putCompiledKernelToDisc(
@@ -523,10 +539,6 @@ std::vector<std::vector<char>> PersistentDeviceCodeCache::getItemFromDisc(
   if (!areImagesCacheable(Imgs))
     return {};
 
-#ifdef __SYCL_INSTRUMENT_PERSISTENT_CACHE
-  InstrumentCache Instrument{"getItemFromDisc: "};
-#endif
-
   std::vector<const RTDeviceBinaryImage *> SortedImgs = getSortedImages(Imgs);
   std::vector<std::vector<char>> Binaries(Devices.size());
   std::string FileNames;
@@ -552,12 +564,8 @@ std::vector<std::vector<char>> PersistentDeviceCodeCache::getItemFromDisc(
 
           // Explicitly update the access time of the file. This is required for
           // eviction.
-          if (isEvictionEnabled()) {
-#ifdef __SYCL_INSTRUMENT_PERSISTENT_CACHE
-            InstrumentCache Instrument{"Updating file access time: "};
-#endif
-            updateFileModificationTime(FileName + ".bin");
-          }
+          if (isEvictionEnabled())
+            saveCurrentTimeInAFile(FileName + "_access_time.txt");
 
           FileNames += FullFileName + ";";
           break;

sycl/source/detail/persistent_device_code_cache.hpp

@@ -21,12 +21,6 @@
 #include <thread>
 #include <vector>
 
-#define __SYCL_INSTRUMENT_PERSISTENT_CACHE
-
-#ifdef __SYCL_INSTRUMENT_PERSISTENT_CACHE
-#include <chrono>
-#endif
-
 namespace sycl {
 inline namespace _V1 {
 namespace detail {
@@ -97,29 +91,6 @@ class PersistentDeviceCodeCache {
    *  - on cache read operation it is treated as cache miss.
    */
 private:
-#ifdef __SYCL_INSTRUMENT_PERSISTENT_CACHE
-  // Class to instrument cache operations.
-  class InstrumentCache {
-    std::string PrintMsg;
-    std::chrono::high_resolution_clock::time_point StartTime;
-
-  public:
-    InstrumentCache(const std::string &Name) : PrintMsg(Name) {
-      // Store start time.
-      StartTime = std::chrono::high_resolution_clock::now();
-    }
-    ~InstrumentCache() {
-      // Calculate time spent and print message.
-      auto EndTime = std::chrono::high_resolution_clock::now();
-      auto Duration = std::chrono::duration_cast<std::chrono::nanoseconds>(
-                          EndTime - StartTime)
-                          .count();
-      PersistentDeviceCodeCache::trace(PrintMsg + std::to_string(Duration) +
-                                       "ns");
-    }
-  };
-#endif
-
   /* Write built binary to persistent cache
    * Format: BinarySize, Binary
    */
@@ -259,6 +230,8 @@ class PersistentDeviceCodeCache {
   static void evictItemsFromCache(const std::string &CacheRoot,
                                   size_t CacheSize, size_t MaxCacheSize);
 
+  static void saveCurrentTimeInAFile(std::string FileName);
+
   // Check if eviction is enabled.
   static bool isEvictionEnabled() {
     return SYCLConfig<SYCL_CACHE_MAX_SIZE>::isPersistentCacheEvictionEnabled();