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.
writeTimestampFile(StringRef TimestampFile)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.
prune()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