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