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
26using namespace llvm;
27
28/// Write a new timestamp file with the given path. This is used for the pruning
29/// interval option.
30static 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.
36bool 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