Cleanup

Author: uditagarwal97

sycl/source/detail/os_util.cpp

@@ -10,7 +10,6 @@
 #include <sycl/exception.hpp>
 
 #include <cassert>
-#include <iostream>
 #include <limits>
 
 // For GCC versions less than 8, use experimental/filesystem.
@@ -51,7 +50,6 @@ namespace fs = std::experimental::filesystem;
 #elif defined(__SYCL_RT_OS_DARWIN)
 
 #include <dlfcn.h>
-#include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 

sycl/source/detail/persistent_device_code_cache.cpp

@@ -12,12 +12,11 @@
 #include <detail/program_manager/program_manager.hpp>
 
 #include <cerrno>
+#include <chrono>
 #include <cstdio>
 #include <fstream>
 #include <optional>
 
-#include <time.h>
-
 #if defined(__SYCL_RT_OS_POSIX_SUPPORT)
 #include <unistd.h>
 #else
@@ -252,7 +251,7 @@ void PersistentDeviceCodeCache::evictItemsFromCache(
   // Create a file eviction_in_progress.lock to indicate that eviction is in
   // progress. This file is used to prevent two processes from evicting the
   // cache at the same time.
-  LockCacheItem Lock{CacheRoot + "/eviction_in_progress"};
+  LockCacheItem Lock{CacheRoot + EvictionInProgressFileSuffix};
   if (!Lock.isOwned()) {
     // If some other process is evicting the cache, return.
     PersistentDeviceCodeCache::trace(
@@ -265,7 +264,7 @@ void PersistentDeviceCodeCache::evictItemsFromCache(
   std::vector<std::pair<uint64_t, std::string>> FilesWithAccessTime;
 
   auto CollectFileAccessTime = [&FilesWithAccessTime](const std::string File) {
-    if (File.find("_access_time.txt") != std::string::npos) {
+    if (File.find(CacheEntryAccessTimeSuffix) != std::string::npos) {
       std::ifstream FileStream{File};
       uint64_t AccessTime;
       FileStream >> AccessTime;
@@ -300,7 +299,7 @@ void PersistentDeviceCodeCache::evictItemsFromCache(
   size_t CurrCacheSize = CacheSize;
   for (const auto &File : FilesWithAccessTime) {
 
-    int pos = File.second.find("_access_time.txt");
+    int pos = File.second.find(CacheEntryAccessTimeSuffix);
     const std::string FileNameWOExt = File.second.substr(0, pos);
     const std::string BinFile = FileNameWOExt + ".bin";
     const std::string SrcFile = FileNameWOExt + ".src";
@@ -434,7 +433,7 @@ void PersistentDeviceCodeCache::putItemToDisc(
   // Do not insert any new item if eviction is in progress.
   // Since evictions are rare, we can afford to spin lock here.
   const std::string EvictionInProgressFile =
-      getRootDir() + "/eviction_in_progress.lock";
+      getRootDir() + EvictionInProgressFileSuffix;
   // Stall until the other process finishes eviction.
   while (OSUtil::isPathPresent(EvictionInProgressFile))
     continue;
@@ -470,7 +469,7 @@ void PersistentDeviceCodeCache::putItemToDisc(
         TotalSize += getFileSize(FileName + ".src");
         TotalSize += getFileSize(FileName + ".bin");
 
-        saveCurrentTimeInAFile(FileName + "_access_time.txt");
+        saveCurrentTimeInAFile(FileName + CacheEntryAccessTimeSuffix);
       } else {
         PersistentDeviceCodeCache::trace("cache lock not owned " + FileName);
       }
@@ -565,7 +564,7 @@ std::vector<std::vector<char>> PersistentDeviceCodeCache::getItemFromDisc(
           // Explicitly update the access time of the file. This is required for
           // eviction.
           if (isEvictionEnabled())
-            saveCurrentTimeInAFile(FileName + "_access_time.txt");
+            saveCurrentTimeInAFile(FileName + CacheEntryAccessTimeSuffix);
 
           FileNames += FullFileName + ";";
           break;

sycl/source/detail/persistent_device_code_cache.hpp

@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include <chrono>
 #include <detail/config.hpp>
 #include <detail/device_binary_image.hpp>
 #include <fcntl.h>
@@ -236,6 +235,13 @@ class PersistentDeviceCodeCache {
   static bool isEvictionEnabled() {
     return SYCLConfig<SYCL_CACHE_MAX_SIZE>::isPersistentCacheEvictionEnabled();
   }
+
+  // Suffix for access time file. Every cache entry will have one.
+  static inline std::string CacheEntryAccessTimeSuffix = "_access_time.txt";
+  // Suffix for eviction in progress file. It is created when eviction is
+  // triggered and removed when eviction is done.
+  static inline std::string EvictionInProgressFileSuffix =
+      "_eviction_in_progress";
 };
 } // namespace detail
 } // namespace _V1

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

@@ -559,25 +559,15 @@ TEST_P(PersistentDeviceCodeCache, BasicEviction) {
 
   std::string BuildOptions{"--eviction"};
   // Put 3 items to the cache.
-  // On Windows, for NTFS, the file timestamp resolution is 100ns,
-  // but on Linux, for EXT4, the file timestamp resolution is few milliseconds.
-  // So, to make this test deterministic, we need to sleep for a while,
-  // say 20ms, between each putItemToDisc/getItemFromDisc call.
   detail::PersistentDeviceCodeCache::putItemToDisc({Dev}, {&Img}, {},
                                                    BuildOptions, NativeProg);
 
-  std::this_thread::sleep_for(std::chrono::milliseconds(20));
-
   detail::PersistentDeviceCodeCache::putItemToDisc({Dev}, {&Img}, {},
                                                    BuildOptions, NativeProg);
 
-  std::this_thread::sleep_for(std::chrono::milliseconds(20));
-
   detail::PersistentDeviceCodeCache::putItemToDisc({Dev}, {&Img}, {},
                                                    BuildOptions, NativeProg);
 
-  std::this_thread::sleep_for(std::chrono::milliseconds(20));
-
   // Retrieve 0.bin from the cache.
   auto Res = detail::PersistentDeviceCodeCache::getItemFromDisc(
       {Dev}, {&Img}, {}, BuildOptions);