Line data    Source code

       1             : //=- CachePruning.h - Helper to manage the pruning of a cache dir -*- C++ -*-=//
       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 pruning of a directory intended for cache storage, using
      11             : // various policies.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_SUPPORT_CACHE_PRUNING_H
      16             : #define LLVM_SUPPORT_CACHE_PRUNING_H
      17             : 
      18             : #include "llvm/ADT/StringRef.h"
      19             : #include <chrono>
      20             : 
      21             : namespace llvm {
      22             : 
      23             : template <typename T> class Expected;
      24             : 
      25             : /// Policy for the pruneCache() function. A default constructed
      26             : /// CachePruningPolicy provides a reasonable default policy.
      27        5525 : struct CachePruningPolicy {
      28             :   /// The pruning interval. This is intended to be used to avoid scanning the
      29             :   /// directory too often. It does not impact the decision of which file to
      30             :   /// prune. A value of 0 forces the scan to occur. A value of None disables
      31             :   /// pruning.
      32             :   llvm::Optional<std::chrono::seconds> Interval = std::chrono::seconds(1200);
      33             : 
      34             :   /// The expiration for a file. When a file hasn't been accessed for Expiration
      35             :   /// seconds, it is removed from the cache. A value of 0 disables the
      36             :   /// expiration-based pruning.
      37             :   std::chrono::seconds Expiration = std::chrono::hours(7 * 24); // 1w
      38             : 
      39             :   /// The maximum size for the cache directory, in terms of percentage of the
      40             :   /// available space on the disk. Set to 100 to indicate no limit, 50 to
      41             :   /// indicate that the cache size will not be left over half the available disk
      42             :   /// space. A value over 100 will be reduced to 100. A value of 0 disables the
      43             :   /// percentage size-based pruning.
      44             :   unsigned MaxSizePercentageOfAvailableSpace = 75;
      45             : 
      46             :   /// The maximum size for the cache directory in bytes. A value over the amount
      47             :   /// of available space on the disk will be reduced to the amount of available
      48             :   /// space. A value of 0 disables the absolute size-based pruning.
      49             :   uint64_t MaxSizeBytes = 0;
      50             : 
      51             :   /// The maximum number of files in the cache directory. A value of 0 disables
      52             :   /// the number of files based pruning.
      53             :   ///
      54             :   /// This defaults to 1000000 because with that many files there are
      55             :   /// diminishing returns on the effectiveness of the cache. Some systems have a
      56             :   /// limit on total number of files, and some also limit the number of files
      57             :   /// per directory, such as Linux ext4, with the default setting (block size is
      58             :   /// 4096 and large_dir disabled), there is a per-directory entry limit of
      59             :   /// 508*510*floor(4096/(40+8))~=20M for average filename length of 40.
      60             :   uint64_t MaxSizeFiles = 1000000;
      61             : };
      62             : 
      63             : /// Parse the given string as a cache pruning policy. Defaults are taken from a
      64             : /// default constructed CachePruningPolicy object.
      65             : /// For example: "prune_interval=30s:prune_after=24h:cache_size=50%"
      66             : /// which means a pruning interval of 30 seconds, expiration time of 24 hours
      67             : /// and maximum cache size of 50% of available disk space.
      68             : Expected<CachePruningPolicy> parseCachePruningPolicy(StringRef PolicyStr);
      69             : 
      70             : /// Peform pruning using the supplied policy, returns true if pruning
      71             : /// occurred, i.e. if Policy.Interval was expired.
      72             : ///
      73             : /// As a safeguard against data loss if the user specifies the wrong directory
      74             : /// as their cache directory, this function will ignore files not matching the
      75             : /// pattern "llvmcache-*".
      76             : bool pruneCache(StringRef Path, CachePruningPolicy Policy);
      77             : 
      78             : } // namespace llvm
      79             : 
      80             : #endif