Home | History | Annotate | Download | only in Support 
      1 //===-CachePruning.cpp - LLVM Cache Directory Pruning ---------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This file implements the pruning of a directory based on least recently used.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "llvm/Support/CachePruning.h"
     15 
     16 #include "llvm/Support/Debug.h"
     17 #include "llvm/Support/Errc.h"
     18 #include "llvm/Support/FileSystem.h"
     19 #include "llvm/Support/Path.h"
     20 #include "llvm/Support/raw_ostream.h"
     21 
     22 #define DEBUG_TYPE "cache-pruning"
     23 
     24 #include <set>
     25 
     26 using namespace llvm;
     27 
     28 /// Write a new timestamp file with the given path. This is used for the pruning
     29 /// interval option.
     30 static void writeTimestampFile(StringRef TimestampFile) {
     31   std::error_code EC;
     32   raw_fd_ostream Out(TimestampFile.str(), EC, sys::fs::F_None);
     33 }
     34 
     35 /// Prune the cache of files that haven't been accessed in a long time.
     36 bool CachePruning::prune() {
     37   if (Path.empty())
     38     return false;
     39 
     40   bool isPathDir;
     41   if (sys::fs::is_directory(Path, isPathDir))
     42     return false;
     43 
     44   if (!isPathDir)
     45     return false;
     46 
     47   if (Expiration == 0 && PercentageOfAvailableSpace == 0) {
     48     DEBUG(dbgs() << "No pruning settings set, exit early\n");
     49     // Nothing will be pruned, early exit
     50     return false;
     51   }
     52 
     53   // Try to stat() the timestamp file.
     54   SmallString<128> TimestampFile(Path);
     55   sys::path::append(TimestampFile, "llvmcache.timestamp");
     56   sys::fs::file_status FileStatus;
     57   sys::TimeValue CurrentTime = sys::TimeValue::now();
     58   if (auto EC = sys::fs::status(TimestampFile, FileStatus)) {
     59     if (EC == errc::no_such_file_or_directory) {
     60       // If the timestamp file wasn't there, create one now.
     61       writeTimestampFile(TimestampFile);
     62     } else {
     63       // Unknown error?
     64       return false;
     65     }
     66   } else {
     67     if (Interval) {
     68       // Check whether the time stamp is older than our pruning interval.
     69       // If not, do nothing.
     70       sys::TimeValue TimeStampModTime = FileStatus.getLastModificationTime();
     71       auto TimeInterval = sys::TimeValue(sys::TimeValue::SecondsType(Interval));
     72       auto TimeStampAge = CurrentTime - TimeStampModTime;
     73       if (TimeStampAge <= TimeInterval) {
     74         DEBUG(dbgs() << "Timestamp file too recent (" << TimeStampAge.seconds()
     75                      << "s old), do not prune.\n");
     76         return false;
     77       }
     78     }
     79     // Write a new timestamp file so that nobody else attempts to prune.
     80     // There is a benign race condition here, if two processes happen to
     81     // notice at the same time that the timestamp is out-of-date.
     82     writeTimestampFile(TimestampFile);
     83   }
     84 
     85   bool ShouldComputeSize = (PercentageOfAvailableSpace > 0);
     86 
     87   // Keep track of space
     88   std::set<std::pair<uint64_t, std::string>> FileSizes;
     89   uint64_t TotalSize = 0;
     90   // Helper to add a path to the set of files to consider for size-based
     91   // pruning, sorted by size.
     92   auto AddToFileListForSizePruning =
     93       [&](StringRef Path) {
     94         if (!ShouldComputeSize)
     95           return;
     96         TotalSize += FileStatus.getSize();
     97         FileSizes.insert(
     98             std::make_pair(FileStatus.getSize(), std::string(Path)));
     99       };
    100 
    101   // Walk the entire directory cache, looking for unused files.
    102   std::error_code EC;
    103   SmallString<128> CachePathNative;
    104   sys::path::native(Path, CachePathNative);
    105   auto TimeExpiration = sys::TimeValue(sys::TimeValue::SecondsType(Expiration));
    106   // Walk all of the files within this directory.
    107   for (sys::fs::directory_iterator File(CachePathNative, EC), FileEnd;
    108        File != FileEnd && !EC; File.increment(EC)) {
    109     // Do not touch the timestamp.
    110     if (File->path() == TimestampFile)
    111       continue;
    112 
    113     // Look at this file. If we can't stat it, there's nothing interesting
    114     // there.
    115     if (sys::fs::status(File->path(), FileStatus)) {
    116       DEBUG(dbgs() << "Ignore " << File->path() << " (can't stat)\n");
    117       continue;
    118     }
    119 
    120     // If the file hasn't been used recently enough, delete it
    121     sys::TimeValue FileAccessTime = FileStatus.getLastAccessedTime();
    122     auto FileAge = CurrentTime - FileAccessTime;
    123     if (FileAge > TimeExpiration) {
    124       DEBUG(dbgs() << "Remove " << File->path() << " (" << FileAge.seconds()
    125                    << "s old)\n");
    126       sys::fs::remove(File->path());
    127       continue;
    128     }
    129 
    130     // Leave it here for now, but add it to the list of size-based pruning.
    131     AddToFileListForSizePruning(File->path());
    132   }
    133 
    134   // Prune for size now if needed
    135   if (ShouldComputeSize) {
    136     auto ErrOrSpaceInfo = sys::fs::disk_space(Path);
    137     if (!ErrOrSpaceInfo) {
    138       report_fatal_error("Can't get available size");
    139     }
    140     sys::fs::space_info SpaceInfo = ErrOrSpaceInfo.get();
    141     auto AvailableSpace = TotalSize + SpaceInfo.free;
    142     auto FileAndSize = FileSizes.rbegin();
    143     DEBUG(dbgs() << "Occupancy: " << ((100 * TotalSize) / AvailableSpace)
    144                  << "% target is: " << PercentageOfAvailableSpace << "\n");
    145     // Remove the oldest accessed files first, till we get below the threshold
    146     while (((100 * TotalSize) / AvailableSpace) > PercentageOfAvailableSpace &&
    147            FileAndSize != FileSizes.rend()) {
    148       // Remove the file.
    149       sys::fs::remove(FileAndSize->second);
    150       // Update size
    151       TotalSize -= FileAndSize->first;
    152       DEBUG(dbgs() << " - Remove " << FileAndSize->second << " (size "
    153                    << FileAndSize->first << "), new occupancy is " << TotalSize
    154                    << "%\n");
    155       ++FileAndSize;
    156     }
    157   }
    158   return true;
    159 }
    160