Use nano seconds file timestamps for Linux

Author: uditagarwal97

sycl/source/detail/os_util.cpp

@@ -39,7 +39,6 @@ namespace fs = std::experimental::filesystem;
 #include <linux/limits.h> // for PATH_MAX
 #include <sys/stat.h>
 #include <sys/sysinfo.h>
-#include <utime.h>
 
 #elif defined(__SYCL_RT_OS_WINDOWS)
 
@@ -55,7 +54,6 @@ namespace fs = std::experimental::filesystem;
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
-#include <utime.h>
 
 #endif // __SYCL_RT_OS
 
@@ -330,7 +328,7 @@ getFilesWithLastModificationTime(const std::string &Path,
 #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_mtime, FileName});
+        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;
@@ -384,11 +382,8 @@ void updateFileModificationTime(const std::string &Path) {
   }
 
 #elif defined(__SYCL_RT_OS_LINUX) || defined(__SYCL_RT_OS_DARWIN)
-  // For Linux and Darwin, use utime to update file modification time.
-  struct utimbuf UtimeBuf;
-  UtimeBuf.actime = UtimeBuf.actime;
-  UtimeBuf.modtime = time(nullptr);
-  utime(Path.c_str(), &UtimeBuf);
+  // For Linux and Darwin, use utimensat to update file modification time.
+  utimensat(0, Path.c_str(), nullptr, 0);
 #endif // __SYCL_RT_OS
 }
 

sycl/source/detail/persistent_device_code_cache.cpp

@@ -282,32 +282,37 @@ void PersistentDeviceCodeCache::evictItemsFromCache(
     const std::string SrcFile = FileNameWOExt + ".src";
 
     while (OSUtil::isPathPresent(BinFile) || OSUtil::isPathPresent(SrcFile)) {
-      // Remove the file and subtract its size from the cache size.
-      auto RemoveFileAndSubtractSize =
-          [&CurrCacheSize](const std::string &FileName) {
-            // If the file is not present, return.
-            if (!OSUtil::isPathPresent(FileName))
-              return;
-
-            auto FileSize = getFileSize(FileName);
-            if (std::remove(FileName.c_str())) {
-              throw sycl::exception(make_error_code(errc::runtime),
-                                    "Failed to evict cache entry: " + FileName);
-            } else {
-              PersistentDeviceCodeCache::trace("File removed: " + FileName);
-              CurrCacheSize -= FileSize;
-            }
-          };
-
-      // If removal fails due to a race, retry.
-      // Races are rare, but can happen if another process is reading the file.
-      // Locking down the entire cache and blocking all readers would be
-      // inefficient.
-      try {
-        RemoveFileAndSubtractSize(SrcFile);
-        RemoveFileAndSubtractSize(BinFile);
-      } catch (...) {
-        continue;
+
+      // Lock to prevent race between writer and eviction thread.
+      LockCacheItem Lock{FileNameWOExt};
+      if (Lock.isOwned()) {
+        // Remove the file and subtract its size from the cache size.
+        auto RemoveFileAndSubtractSize = [&CurrCacheSize](
+                                             const std::string &FileName) {
+          // If the file is not present, return.
+          if (!OSUtil::isPathPresent(FileName))
+            return;
+
+          auto FileSize = getFileSize(FileName);
+          if (std::remove(FileName.c_str())) {
+            throw sycl::exception(make_error_code(errc::runtime),
+                                  "Failed to evict cache entry: " + FileName);
+          } else {
+            PersistentDeviceCodeCache::trace("File removed: " + FileName);
+            CurrCacheSize -= FileSize;
+          }
+        };
+
+        // If removal fails due to a race, retry.
+        // Races are rare, but can happen if another process is reading the
+        // file. Locking down the entire cache and blocking all readers would be
+        // inefficient.
+        try {
+          RemoveFileAndSubtractSize(SrcFile);
+          RemoveFileAndSubtractSize(BinFile);
+        } catch (...) {
+          continue;
+        }
       }
     }
 
@@ -426,7 +431,6 @@ void PersistentDeviceCodeCache::putItemToDisc(
       return;
 
     std::string FileName;
-    bool IsWriteSuccess = false;
     try {
       OSUtil::makeDir(DirName.c_str());
       FileName = getUniqueFilename(DirName);
@@ -437,7 +441,10 @@ void PersistentDeviceCodeCache::putItemToDisc(
         trace("device binary has been cached: " + FullFileName);
         writeSourceItem(FileName + ".src", Devices[DeviceIndex], SortedImgs,
                         SpecConsts, BuildOptionsString);
-        IsWriteSuccess = true;
+
+        // Update Total cache size after adding the new items.
+        TotalSize += getFileSize(FileName + ".src");
+        TotalSize += getFileSize(FileName + ".bin");
       } else {
         PersistentDeviceCodeCache::trace("cache lock not owned " + FileName);
       }
@@ -450,11 +457,6 @@ void PersistentDeviceCodeCache::putItemToDisc(
           std::string("error outputting persistent cache: ") +
           std::strerror(errno));
     }
-
-    if (IsWriteSuccess) {
-      TotalSize += getFileSize(FileName + ".src");
-      TotalSize += getFileSize(FileName + ".bin");
-    }
   }
 
   // Update the cache size file and trigger cache eviction if needed.

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

@@ -623,8 +623,8 @@ TEST_P(PersistentDeviceCodeCache, ConcurentReadWriteCacheFileSize) {
   ASSERT_NO_ERROR(llvm::sys::fs::remove_directories(CacheRoot));
   ASSERT_NO_ERROR(llvm::sys::fs::create_directories(CacheRoot));
 
-  // Insanely large value (1GB) to not trigger eviction. This test just checks
-  // for deadlocks/crashes when updating the size file concurrently.
+  // Insanely large value (1GB) to not trigger eviction. This test just
+  // checks for deadlocks/crashes when updating the size file concurrently.
   SetDiskCacheEvictionEnv("1000000000");
   ConcurentReadWriteCache(1, 100);
 }