Add a ThinLTO cache policy for controlling the maximum cache size in bytes.

[pcc]

Summary

This is useful when an upper limit on the cache size needs to be
controlled independently of the amount of the amount of free space.

One use case is a machine with a large number of cache directories
(e.g. a buildbot slave hosting a large number of independent build
jobs). By imposing an upper size limit on each cache directory,
users can more easily estimate the server's capacity.

[pcc]

Depends on D34546

[mehdi_amini]

LGTM.

llvm/lib/Support/CachePruning.cpp

97 ↗

(On Diff #103683)

tolower() could be user-friendly?

[pcc]

llvm/lib/Support/CachePruning.cpp

97 ↗

(On Diff #103683)

Sure, makes sense.

[tejohnson]

LGTM

[pcc]

llvm/lib/Support/CachePruning.cpp

97 ↗

(On Diff #103683)

Done in r306129 (forgot to commit it as part of this change).

cfe/trunk/docs/ThinLTO.rst

 Possible key-value pairs are:
 
 - ``cache_size=X%``: The maximum size for the cache directory is ``X`` percent
   of the available space on the the disk. Set to 100 to indicate no limit,
   50 to indicate that the cache size will not be left over half the available
   disk space. A value over 100 is invalid. A value of 0 disables the percentage
   size-based pruning. The default is 75%.
 
+- ``cache_size_bytes=X``, ``cache_size_bytes=Xk``, ``cache_size_bytes=Xm``,
+  ``cache_size_bytes=Xg``:
+  Sets the maximum size for the cache directory to ``X`` bytes (or KB, MB,
+  GB respectively). A value over the amount of available space on the disk
+  will be reduced to the amount of available space. A value of 0 disables
+  the byte size-based pruning. The default is no byte size-based pruning.
+
+  Note that ThinLTO will apply both size-based pruning policies simultaneously,
+  and changing one does not affect the other. For example, a policy of
+  ``cache_size_bytes=1g`` on its own will cause both the 1GB and default 75%
+  policies to be applied unless the default ``cache_size`` is overridden.
+
 - ``prune_after=Xs``, ``prune_after=Xm``, ``prune_after=Xh``: Sets the
   expiration time for cache files to ``X`` seconds (or minutes, hours
   respectively).  When a file hasn't been accessed for ``prune_after`` seconds,
   it is removed from the cache. A value of 0 disables the expiration-based
   pruning. The default is 1 week.
 
 - ``prune_interval=Xs``, ``prune_interval=Xm``, ``prune_interval=Xh``:
   Sets the pruning interval to ``X`` seconds (or minutes, hours

lld/trunk/test/ELF/lto/cache.ll

 ; REQUIRES: x86
 
 ; RUN: opt -module-hash -module-summary %s -o %t.o
 ; RUN: opt -module-hash -module-summary %p/Inputs/cache.ll -o %t2.o
 
 ; RUN: rm -Rf %t.cache && mkdir %t.cache
 ; Create two files that would be removed by cache pruning due to age.
 ; We should only remove files matching the pattern "llvmcache-*".
 ; RUN: touch -t 197001011200 %t.cache/llvmcache-foo %t.cache/foo
 ; RUN: ld.lld --thinlto-cache-dir=%t.cache --thinlto-cache-policy prune_after=1h -o %t3 %t2.o %t.o
 
 ; Two cached objects, plus a timestamp file and "foo", minus the file we removed.
 ; RUN: ls %t.cache | count 4
 
+; Create a file of size 64KB.
+; RUN: %python -c "print ' ' * 65536" > %t.cache/llvmcache-foo
+
+; This should leave the file in place.
+; RUN: ld.lld --thinlto-cache-dir=%t.cache --thinlto-cache-policy cache_size_bytes=128k -o %t3 %t2.o %t.o
+; RUN: ls %t.cache | count 5
+
+; This should remove it.
+; RUN: ld.lld --thinlto-cache-dir=%t.cache --thinlto-cache-policy cache_size_bytes=32k -o %t3 %t2.o %t.o
+; RUN: ls %t.cache | count 4
+
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @globalfunc() #0 {
 entry:
   ret void
 }

llvm/trunk/include/llvm/LTO/legacy/ThinLTOCodeGenerator.h

public:
    *
    * The formula looks like:
    *  AvailableSpace = FreeSpace + ExistingCacheSize
    *  NewCacheSize = AvailableSpace * P/100
    *
    */
   void setMaxCacheSizeRelativeToAvailableSpace(unsigned Percentage) {
     if (Percentage)
-      CacheOptions.Policy.PercentageOfAvailableSpace = Percentage;
+      CacheOptions.Policy.MaxSizePercentageOfAvailableSpace = Percentage;
   }
 
   /**@}*/
 
   /// Set the path to a directory where to save temporaries at various stages of
   /// the processing.
   void setSaveTempsDir(std::string Path) { SaveTempsDir = std::move(Path); }
 

llvm/trunk/include/llvm/Support/CachePruning.h

struct CachePruningPolicy {
   /// seconds, it is removed from the cache. A value of 0 disables the
   /// expiration-based pruning.
   std::chrono::seconds Expiration = std::chrono::hours(7 * 24); // 1w
 
   /// The maximum size for the cache directory, in terms of percentage of the
   /// available space on the the disk. Set to 100 to indicate no limit, 50 to
   /// indicate that the cache size will not be left over half the available disk
   /// space. A value over 100 will be reduced to 100. A value of 0 disables the
-  /// size-based pruning.
-  unsigned PercentageOfAvailableSpace = 75;
+  /// percentage size-based pruning.
+  unsigned MaxSizePercentageOfAvailableSpace = 75;
+
+  /// The maximum size for the cache directory in bytes. A value over the amount
+  /// of available space on the disk will be reduced to the amount of available
+  /// space. A value of 0 disables the absolute size-based pruning.
+  uint64_t MaxSizeBytes = 0;
 };
 
 /// Parse the given string as a cache pruning policy. Defaults are taken from a
 /// default constructed CachePruningPolicy object.
 /// For example: "prune_interval=30s:prune_after=24h:cache_size=50%"
 /// which means a pruning interval of 30 seconds, expiration time of 24 hours
 /// and maximum cache size of 50% of available disk space.
 Expected<CachePruningPolicy> parseCachePruningPolicy(StringRef PolicyStr);

llvm/trunk/lib/Support/CachePruning.cpp

if (Key == "prune_interval") {
         return DurationOrErr.takeError();
       Policy.Interval = *DurationOrErr;
     } else if (Key == "prune_after") {
       auto DurationOrErr = parseDuration(Value);
       if (!DurationOrErr)
         return DurationOrErr.takeError();
       Policy.Expiration = *DurationOrErr;
     } else if (Key == "cache_size") {
-      if (Value.back() != '%')
-        return make_error<StringError>("'" + Value + "' must be a percentage",
-                                       inconvertibleErrorCode());
-      StringRef SizeStr = Value.slice(0, Value.size() - 1);
+      StringRef SizeStr = Value.drop_back();
       uint64_t Size;
       if (SizeStr.getAsInteger(0, Size))
         return make_error<StringError>("'" + SizeStr + "' not an integer",
                                        inconvertibleErrorCode());
       if (Size > 100)
         return make_error<StringError>("'" + SizeStr +
                                            "' must be between 0 and 100",
                                        inconvertibleErrorCode());
-      Policy.PercentageOfAvailableSpace = Size;
+      Policy.MaxSizePercentageOfAvailableSpace = Size;
+    } else if (Key == "cache_size_bytes") {
+      uint64_t Mult = 1;
+      switch (Value.back()) {
+      case 'k':
+        Mult = 1024;
+        Value = Value.drop_back();
+        break;
+      case 'm':
+        Mult = 1024 * 1024;
+        Value = Value.drop_back();
+        break;
+      case 'g':
+        Mult = 1024 * 1024 * 1024;
+        Value = Value.drop_back();
+        break;
+      }
+      uint64_t Size;
+      if (Value.getAsInteger(0, Size))
+        return make_error<StringError>("'" + Value + "' not an integer",
+                                       inconvertibleErrorCode());
+      Policy.MaxSizeBytes = Size * Mult;
     } else {
       return make_error<StringError>("Unknown key: '" + Key + "'",
                                      inconvertibleErrorCode());
     }
   }
 
   return Policy;
 }
 
 /// Prune the cache of files that haven't been accessed in a long time.
 bool llvm::pruneCache(StringRef Path, CachePruningPolicy Policy) {
   using namespace std::chrono;
 
   if (Path.empty())
     return false;
 
   bool isPathDir;
   if (sys::fs::is_directory(Path, isPathDir))
     return false;
 
   if (!isPathDir)
     return false;
 
-  Policy.PercentageOfAvailableSpace =
-      std::min(Policy.PercentageOfAvailableSpace, 100u);
+  Policy.MaxSizePercentageOfAvailableSpace =
+      std::min(Policy.MaxSizePercentageOfAvailableSpace, 100u);
 
   if (Policy.Expiration == seconds(0) &&
-      Policy.PercentageOfAvailableSpace == 0) {
+      Policy.MaxSizePercentageOfAvailableSpace == 0 &&
+      Policy.MaxSizeBytes == 0) {
     DEBUG(dbgs() << "No pruning settings set, exit early\n");
     // Nothing will be pruned, early exit
     return false;
   }
 
   // Try to stat() the timestamp file.
   SmallString<128> TimestampFile(Path);
   sys::path::append(TimestampFile, "llvmcache.timestamp");
if (Policy.Interval == seconds(0)) {
       }
     }
     // Write a new timestamp file so that nobody else attempts to prune.
     // There is a benign race condition here, if two processes happen to
     // notice at the same time that the timestamp is out-of-date.
     writeTimestampFile(TimestampFile);
   }
 
-  bool ShouldComputeSize = (Policy.PercentageOfAvailableSpace > 0);
+  bool ShouldComputeSize =
+      (Policy.MaxSizePercentageOfAvailableSpace > 0 || Policy.MaxSizeBytes > 0);
 
   // Keep track of space
   std::set<std::pair<uint64_t, std::string>> FileSizes;
   uint64_t TotalSize = 0;
   // Helper to add a path to the set of files to consider for size-based
   // pruning, sorted by size.
   auto AddToFileListForSizePruning =
       [&](StringRef Path) {
bool llvm::pruneCache(StringRef Path, CachePruningPolicy Policy) {
   // Prune for size now if needed
   if (ShouldComputeSize) {
     auto ErrOrSpaceInfo = sys::fs::disk_space(Path);
     if (!ErrOrSpaceInfo) {
       report_fatal_error("Can't get available size");
     }
     sys::fs::space_info SpaceInfo = ErrOrSpaceInfo.get();
     auto AvailableSpace = TotalSize + SpaceInfo.free;
-    auto FileAndSize = FileSizes.rbegin();
+
+    if (Policy.MaxSizePercentageOfAvailableSpace == 0)
+      Policy.MaxSizePercentageOfAvailableSpace = 100;
+    if (Policy.MaxSizeBytes == 0)
+      Policy.MaxSizeBytes = AvailableSpace;
+    auto TotalSizeTarget = std::min<uint64_t>(
+        AvailableSpace * Policy.MaxSizePercentageOfAvailableSpace / 100ull,
+        Policy.MaxSizeBytes);
+
     DEBUG(dbgs() << "Occupancy: " << ((100 * TotalSize) / AvailableSpace)
-                 << "% target is: " << Policy.PercentageOfAvailableSpace
-                 << "\n");
+                 << "% target is: " << Policy.MaxSizePercentageOfAvailableSpace
+                 << "%, " << Policy.MaxSizeBytes << " bytes\n");
+
+    auto FileAndSize = FileSizes.rbegin();
     // Remove the oldest accessed files first, till we get below the threshold
-    while (((100 * TotalSize) / AvailableSpace) >
-               Policy.PercentageOfAvailableSpace &&
-           FileAndSize != FileSizes.rend()) {
+    while (TotalSize > TotalSizeTarget && FileAndSize != FileSizes.rend()) {
       // Remove the file.
       sys::fs::remove(FileAndSize->second);
       // Update size
       TotalSize -= FileAndSize->first;
       DEBUG(dbgs() << " - Remove " << FileAndSize->second << " (size "
                    << FileAndSize->first << "), new occupancy is " << TotalSize
                    << "%\n");
       ++FileAndSize;
     }
   }
   return true;
 }

llvm/trunk/unittests/Support/CachePruningTest.cpp

 
 using namespace llvm;
 
 TEST(CachePruningPolicyParser, Empty) {
   auto P = parseCachePruningPolicy("");
   ASSERT_TRUE(bool(P));
   EXPECT_EQ(std::chrono::seconds(1200), P->Interval);
   EXPECT_EQ(std::chrono::hours(7 * 24), P->Expiration);
-  EXPECT_EQ(75u, P->PercentageOfAvailableSpace);
+  EXPECT_EQ(75u, P->MaxSizePercentageOfAvailableSpace);
 }
 
 TEST(CachePruningPolicyParser, Interval) {
   auto P = parseCachePruningPolicy("prune_interval=1s");
   ASSERT_TRUE(bool(P));
   EXPECT_EQ(std::chrono::seconds(1), P->Interval);
   P = parseCachePruningPolicy("prune_interval=2m");
   ASSERT_TRUE(bool(P));
   EXPECT_EQ(std::chrono::minutes(2), P->Interval);
   P = parseCachePruningPolicy("prune_interval=3h");
   ASSERT_TRUE(bool(P));
   EXPECT_EQ(std::chrono::hours(3), P->Interval);
 }
 
 TEST(CachePruningPolicyParser, Expiration) {
   auto P = parseCachePruningPolicy("prune_after=1s");
   ASSERT_TRUE(bool(P));
   EXPECT_EQ(std::chrono::seconds(1), P->Expiration);
 }
 
-TEST(CachePruningPolicyParser, PercentageOfAvailableSpace) {
+TEST(CachePruningPolicyParser, MaxSizePercentageOfAvailableSpace) {
   auto P = parseCachePruningPolicy("cache_size=100%");
   ASSERT_TRUE(bool(P));
-  EXPECT_EQ(100u, P->PercentageOfAvailableSpace);
+  EXPECT_EQ(100u, P->MaxSizePercentageOfAvailableSpace);
+  EXPECT_EQ(0u, P->MaxSizeBytes);
+}
+
+TEST(CachePruningPolicyParser, MaxSizeBytes) {
+  auto P = parseCachePruningPolicy("cache_size_bytes=1");
+  ASSERT_TRUE(bool(P));
+  EXPECT_EQ(75u, P->MaxSizePercentageOfAvailableSpace);
+  EXPECT_EQ(1u, P->MaxSizeBytes);
+  P = parseCachePruningPolicy("cache_size_bytes=2k");
+  ASSERT_TRUE(bool(P));
+  EXPECT_EQ(75u, P->MaxSizePercentageOfAvailableSpace);
+  EXPECT_EQ(2u * 1024u, P->MaxSizeBytes);
+  P = parseCachePruningPolicy("cache_size_bytes=3m");
+  ASSERT_TRUE(bool(P));
+  EXPECT_EQ(75u, P->MaxSizePercentageOfAvailableSpace);
+  EXPECT_EQ(3u * 1024u * 1024u, P->MaxSizeBytes);
+  P = parseCachePruningPolicy("cache_size_bytes=4g");
+  ASSERT_TRUE(bool(P));
+  EXPECT_EQ(75u, P->MaxSizePercentageOfAvailableSpace);
+  EXPECT_EQ(4ull * 1024ull * 1024ull * 1024ull, P->MaxSizeBytes);
 }
 
 TEST(CachePruningPolicyParser, Multiple) {
   auto P = parseCachePruningPolicy("prune_after=1s:cache_size=50%");
   ASSERT_TRUE(bool(P));
   EXPECT_EQ(std::chrono::seconds(1200), P->Interval);
   EXPECT_EQ(std::chrono::seconds(1), P->Expiration);
-  EXPECT_EQ(50u, P->PercentageOfAvailableSpace);
+  EXPECT_EQ(50u, P->MaxSizePercentageOfAvailableSpace);
 }
 
 TEST(CachePruningPolicyParser, Errors) {
   EXPECT_EQ("Duration must not be empty",
             toString(parseCachePruningPolicy("prune_interval=").takeError()));
   EXPECT_EQ("'foo' not an integer",
             toString(parseCachePruningPolicy("prune_interval=foos").takeError()));
   EXPECT_EQ("'24x' must end with one of 's', 'm' or 'h'",
             toString(parseCachePruningPolicy("prune_interval=24x").takeError()));
   EXPECT_EQ("'foo' must be a percentage",
             toString(parseCachePruningPolicy("cache_size=foo").takeError()));
   EXPECT_EQ("'foo' not an integer",
             toString(parseCachePruningPolicy("cache_size=foo%").takeError()));
   EXPECT_EQ("'101' must be between 0 and 100",
             toString(parseCachePruningPolicy("cache_size=101%").takeError()));
+  EXPECT_EQ(
+      "'foo' not an integer",
+      toString(parseCachePruningPolicy("cache_size_bytes=foo").takeError()));
+  EXPECT_EQ(
+      "'foo' not an integer",
+      toString(parseCachePruningPolicy("cache_size_bytes=foom").takeError()));
   EXPECT_EQ("Unknown key: 'foo'",
             toString(parseCachePruningPolicy("foo=bar").takeError()));
 }