clang-tools-extra/clangd/support/FileCache.cpp

   1 //===--- FileCache.cpp ----------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "support/FileCache.h"
  10 #include "llvm/ADT/ScopeExit.h"
  11 #include <optional>
  12
  13 namespace clang {
  14 namespace clangd {
  15
  16 // Sentinel values for the Size cache key. In both cases, a successful stat of
  17 // the file will never result in the cached value being reused.
  18
  19 // The cached value does not reflect the current content on disk.
  20 static constexpr uint64_t CacheDiskMismatch =
  21     std::numeric_limits<uint64_t>::max();
  22 // The cached value reflects that the file doesn't exist.
  23 static constexpr uint64_t FileNotFound = CacheDiskMismatch - 1;
  24
  25 FileCache::FileCache(llvm::StringRef Path)
  26     : Path(Path), ValidTime(std::chrono::steady_clock::time_point::min()),
  27       ModifiedTime(), Size(CacheDiskMismatch) {
  28   assert(llvm::sys::path::is_absolute(Path));
  29 }
  30
  31 void FileCache::read(
  32     const ThreadsafeFS &TFS, std::chrono::steady_clock::time_point FreshTime,
  33     llvm::function_ref<void(std::optional<llvm::StringRef>)> Parse,
  34     llvm::function_ref<void()> Read) const {
  35
  36   std::lock_guard<std::mutex> Lock(Mu);
  37   // We're going to update the cache and return whatever's in it.
  38   auto Return = llvm::make_scope_exit(Read);
  39
  40   // Return any sufficiently recent result without doing any further work.
  41   if (ValidTime > FreshTime)
  42     return;
  43
  44   // Ensure we always bump ValidTime, so that FreshTime imposes a hard limit on
  45   // how often we do IO.
  46   auto BumpValidTime = llvm::make_scope_exit(
  47       [&] { ValidTime = std::chrono::steady_clock::now(); });
  48
  49   // stat is cheaper than opening the file. It's usually unchanged.
  50   assert(llvm::sys::path::is_absolute(Path));
  51   auto FS = TFS.view(/*CWD=*/std::nullopt);
  52   auto Stat = FS->status(Path);
  53   if (!Stat || !Stat->isRegularFile()) {
  54     if (Size != FileNotFound) // Allow "not found" value to be cached.
  55       Parse(std::nullopt);
  56     // Ensure the cache key won't match any future stat().
  57     Size = FileNotFound;
  58     return;
  59   }
  60   // If the modified-time and size match, assume the content does too.
  61   if (Size == Stat->getSize() &&
  62       ModifiedTime == Stat->getLastModificationTime())
  63     return;
  64
  65   // OK, the file has actually changed. Update cache key, compute new value.
  66   Size = Stat->getSize();
  67   ModifiedTime = Stat->getLastModificationTime();
  68   // Now read the file from disk.
  69   if (auto Buf = FS->getBufferForFile(Path)) {
  70     Parse(Buf->get()->getBuffer());
  71     // Result is cacheable if the actual read size matches the new cache key.
  72     // (We can't update the cache key, because we don't know the new mtime).
  73     if (Buf->get()->getBufferSize() != Size)
  74       Size = CacheDiskMismatch;
  75   } else {
  76     // File was unreadable. Keep the old value and try again next time.
  77     Size = CacheDiskMismatch;
  78   }
  79 }
  80
  81 } // namespace clangd
  82 } // namespace clang