clang 24.0.0git
InProcessModuleCache.cpp
Go to the documentation of this file.
1//===- InProcessModuleCache.cpp - Implicit Module Cache ---------*- C++ -*-===//
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
10
14#include "llvm/Support/AdvisoryLock.h"
15#include "llvm/Support/Chrono.h"
16#include "llvm/Support/Error.h"
17#include "llvm/Support/FileSystem.h"
18#include "llvm/Support/IOSandbox.h"
19#include "llvm/Support/MemoryBuffer.h"
20#include "llvm/Support/Path.h"
21
22using namespace clang;
23using namespace dependencies;
24
26#ifndef NDEBUG
27 SmallString<256> Canonical(Path);
28 assert(llvm::sys::path::is_absolute(Path) &&
29 !llvm::sys::path::remove_dots(Canonical, /*remove_dot_dot=*/true) &&
30 "invalidated paths must be spelled like ModuleDeps::DirectoryDeps");
31#endif
32 {
33 std::lock_guard<std::mutex> Lock(InvalidatedPathsMutex);
34 InvalidatedPaths.insert(Path);
35 }
36 AnyInvalidatedPaths.store(true, std::memory_order_release);
37}
38
39std::optional<bool>
42 return std::nullopt;
43 if (!AnyInvalidatedPaths.load(std::memory_order_acquire))
44 return false;
45 std::lock_guard<std::mutex> Lock(InvalidatedPathsMutex);
46 return InvalidatedPaths.contains(Directory);
47}
48
50 assert(!Flusher.joinable() && "Concurrent flushing was not stopped");
51}
52
54 // We're not flushing at all, nothing to schedule.
55 if (!Flusher.joinable())
56 return;
57
58 {
59 std::lock_guard<std::mutex> Lock(FlushMutex);
60 FlushEntries.push_back(&MapEntry);
61 }
62 FlushCondVar.notify_one();
63}
64
66 assert(!Flusher.joinable() && "Already started concurrent flushing");
67 Flusher = std::thread([this, &Logger] {
68 std::unique_lock<std::mutex> PendingLock(FlushMutex);
69 while (true) {
70 FlushCondVar.wait(PendingLock,
71 [&] { return StopFlushing || !FlushEntries.empty(); });
72 // Leave the remaining entries to flushLeftovers().
73 if (StopFlushing)
74 return;
75 ModuleCacheMapEntry &MapEntry = *FlushEntries.front();
76 FlushEntries.pop_front();
77 PendingLock.unlock();
78 flushEntry(MapEntry.getKey(), *MapEntry.second, Logger,
79 /*ReadBack=*/true);
80 PendingLock.lock();
81 }
82 });
83}
84
86 assert(Flusher.joinable() && "Never started concurrent flushing");
87 {
88 std::lock_guard<std::mutex> Lock(FlushMutex);
89 StopFlushing = true;
90 }
91 FlushCondVar.notify_one();
92 Flusher.join();
93}
94
96 assert(!Flusher.joinable() && "Flushing leftovers concurrently");
97 for (auto &[Name, Entry] : llvm::make_pointee_range(FlushEntries))
98 flushEntry(Name, *Entry, Logger, /*ReadBack=*/false);
99}
100
101void ModuleCacheEntries::flushEntry(StringRef Path, ModuleCacheEntry &Entry,
102 AtomicLineLogger &Logger, bool ReadBack) {
103 // This is a compiler-internal output, let's bypass the sandbox.
104 auto BypassSandbox = llvm::sys::sandbox::scopedDisable();
105
106 std::shared_ptr<const llvm::MemoryBuffer> InMemoryBuffer;
107 {
108 std::lock_guard<std::mutex> Lock(Entry.Mutex);
110 return;
111 InMemoryBuffer = Entry.Buffer;
112 }
113
114 off_t Size;
115 time_t ModTime;
116 auto Written = writeImpl(Path, *InMemoryBuffer, Size, ModTime, ReadBack);
117 if (!Written) {
118 // Best-effort: keep the buffer in memory and let flush() try again.
119 Logger.log() << "pcm_flush_failed: " << Path;
120 return;
121 }
122 Logger.log() << "pcm_flush: " << Path;
123
124 std::lock_guard<std::mutex> Lock(Entry.Mutex);
125 // Note: We keep Entry.ModTime, since that's what readers have already seen.
126 Entry.Buffer = std::move(*Written);
128}
129
130namespace {
131/// A buffer that keeps the contents of a \c ModuleCacheEntry alive.
132class SharedMemoryBuffer : public llvm::MemoryBuffer {
133 std::shared_ptr<const llvm::MemoryBuffer> Underlying;
134
135public:
136 SharedMemoryBuffer(std::shared_ptr<const llvm::MemoryBuffer> Underlying)
137 : Underlying(std::move(Underlying)) {
138 init(this->Underlying->getBufferStart(), this->Underlying->getBufferEnd(),
139 /*RequiresNullTerminator=*/false);
140 }
141
142 StringRef getBufferIdentifier() const override {
143 return Underlying->getBufferIdentifier();
144 }
145
146 BufferKind getBufferKind() const override {
147 return Underlying->getBufferKind();
148 }
149};
150
151class ReaderWriterLock : public llvm::AdvisoryLock {
152 ModuleCacheEntry &Entry;
153 std::optional<unsigned> OwnedGeneration;
154
155public:
156 ReaderWriterLock(ModuleCacheEntry &Entry) : Entry(Entry) {}
157
158 Expected<bool> tryLock() override {
159 std::lock_guard<std::mutex> Lock(Entry.Mutex);
160 if (Entry.Locked)
161 return false;
162 Entry.Locked = true;
163 OwnedGeneration = Entry.Generation;
164 return true;
165 }
166
167 llvm::WaitForUnlockResult
168 waitForUnlockFor(std::chrono::seconds MaxSeconds) override {
169 assert(!OwnedGeneration);
170 std::unique_lock<std::mutex> Lock(Entry.Mutex);
171 unsigned CurrentGeneration = Entry.Generation;
172 bool Success = Entry.CondVar.wait_for(Lock, MaxSeconds, [&] {
173 // We check not only Locked, but also Generation to break the wait in case
174 // of unsafeUnlock() and successful tryLock().
175 return !Entry.Locked || Entry.Generation != CurrentGeneration;
176 });
177 return Success ? llvm::WaitForUnlockResult::Success
178 : llvm::WaitForUnlockResult::Timeout;
179 }
180
181 std::error_code unsafeUnlock() override {
182 {
183 std::lock_guard<std::mutex> Lock(Entry.Mutex);
184 Entry.Generation += 1;
185 Entry.Locked = false;
186 }
187 Entry.CondVar.notify_all();
188 return {};
189 }
190
191 ~ReaderWriterLock() override {
192 if (OwnedGeneration) {
193 {
194 std::lock_guard<std::mutex> Lock(Entry.Mutex);
195 // Avoid stomping over the state managed by someone else after
196 // unsafeUnlock() and successful tryLock().
197 if (*OwnedGeneration == Entry.Generation)
198 Entry.Locked = false;
199 }
200 Entry.CondVar.notify_all();
201 }
202 }
203};
204
205class InProcessModuleCache : public ModuleCache {
206 ModuleCacheEntries &Entries;
207
208 // TODO: If we changed the InMemoryModuleCache API and relied on strict
209 // context hash, we could probably create more efficient thread-safe
210 // implementation of the InMemoryModuleCache such that it doesn't need to be
211 // recreated for each translation unit.
212 InMemoryModuleCache InMemory;
213
214 ModuleCacheMapEntry &getOrCreateMapEntry(StringRef Filename) {
215 std::lock_guard<std::mutex> Lock(Entries.Mutex);
216 auto &MapEntry = *Entries.Map.try_emplace(Filename).first;
217 if (!MapEntry.second)
218 MapEntry.second = std::make_unique<ModuleCacheEntry>();
219 return MapEntry;
220 }
221
222 ModuleCacheEntry &getOrCreateEntry(StringRef Filename) {
223 return *getOrCreateMapEntry(Filename).second;
224 }
225
226public:
227 InProcessModuleCache(ModuleCacheEntries &Entries, AtomicLineLogger &Logger)
228 : ModuleCache(Logger), Entries(Entries), InMemory(Logger) {}
229
230 std::unique_ptr<llvm::AdvisoryLock> getLock(StringRef Filename) override {
231 auto &Entry = getOrCreateEntry(Filename);
232 return std::make_unique<ReaderWriterLock>(Entry);
233 }
234
235 std::time_t getModuleTimestamp(StringRef Filename) override {
236 auto &Timestamp = getOrCreateEntry(Filename).Timestamp;
237
238 Logger.log() << "timestamp_read: " << Filename;
239 return Timestamp.load();
240 }
241
242 void updateModuleTimestamp(StringRef Filename) override {
243 // Note: This essentially replaces FS contention with mutex contention.
244 auto &Timestamp = getOrCreateEntry(Filename).Timestamp;
245
246 Logger.log() << "timestamp_write: " << Filename;
247 Timestamp.store(llvm::sys::toTimeT(std::chrono::system_clock::now()));
248 }
249
250 std::optional<bool> isDirectoryInvalidated(StringRef Directory) override {
251 return Entries.isDirectoryInvalidated(Directory);
252 }
253
254 void maybePrune(StringRef Path, time_t PruneInterval,
255 time_t PruneAfter) override {
256 // FIXME: This only needs to be ran once per build, not in every
257 // compilation. Call it once per service.
258 maybePruneImpl(Path, PruneInterval, PruneAfter);
259 }
260
261 InMemoryModuleCache &getInMemoryModuleCache() override { return InMemory; }
262 const InMemoryModuleCache &getInMemoryModuleCache() const override {
263 return InMemory;
264 }
265
266 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
267 write(StringRef Path, std::unique_ptr<llvm::MemoryBuffer> Buffer, off_t &Size,
268 time_t &ModTime) override {
269 ModuleCacheMapEntry &MapEntry = getOrCreateMapEntry(Path);
270 ModuleCacheEntry &Entry = *MapEntry.second;
271 std::lock_guard<std::mutex> Lock(Entry.Mutex);
272 Logger.log() << "pcm_write: " << Path;
273 if (Entry.State == ModuleCacheEntry::S_Written ||
275 assert(Entry.Buffer && "Wrote PCM with no contents");
276 assert(Entry.Buffer->getBuffer() == Buffer->getBuffer() &&
277 "Wrote the same PCM with different contents");
278 Size = Entry.Buffer->getBufferSize();
279 ModTime = Entry.ModTime;
280 return std::make_unique<SharedMemoryBuffer>(Entry.Buffer);
281 }
282 // Readers of the previous buffer (if any) keep it alive on their own.
283 Entry.Buffer = std::move(Buffer);
284 Entry.ModTime = llvm::sys::toTimeT(std::chrono::system_clock::now());
286 Entries.scheduleFlush(MapEntry);
287 Size = Entry.Buffer->getBufferSize();
288 ModTime = Entry.ModTime;
289 return std::make_unique<SharedMemoryBuffer>(Entry.Buffer);
290 }
291
292 Expected<std::unique_ptr<llvm::MemoryBuffer>>
293 read(StringRef FileName, off_t &Size, time_t &ModTime) override {
294 Logger.log() << "pcm_read_disk: " << FileName;
295 ModuleCacheEntry &Entry = getOrCreateEntry(FileName);
296 std::lock_guard<std::mutex> Lock(Entry.Mutex);
297 if (Entry.State == ModuleCacheEntry::S_Unknown) {
298 // This is a compiler-internal input/output, let's bypass the sandbox.
299 auto BypassSandbox = llvm::sys::sandbox::scopedDisable();
300 off_t ReadSize;
301 time_t ReadModTime;
302 auto ReadBuffer = readImpl(FileName, ReadSize, ReadModTime);
303 if (!ReadBuffer)
304 return ReadBuffer.takeError();
305 Entry.Buffer = std::move(*ReadBuffer);
306 Entry.ModTime = ReadModTime;
308 }
309 Size = Entry.Buffer->getBufferSize();
310 ModTime = Entry.ModTime;
311 return std::make_unique<SharedMemoryBuffer>(Entry.Buffer);
312 }
313};
314} // namespace
315
316std::shared_ptr<ModuleCache>
318 AtomicLineLogger &Logger) {
319 return std::make_shared<InProcessModuleCache>(Entries, Logger);
320}
Defines a logger where each line is written atomically to the file.
llvm::StringMapEntry< std::unique_ptr< ModuleCacheEntry > > ModuleCacheMapEntry
std::shared_ptr< ModuleCache > makeInProcessModuleCache(ModuleCacheEntries &Entries, AtomicLineLogger &Logger)
Top level wrappers for InstallAPI frontend operations.
Expected< std::unique_ptr< llvm::MemoryBuffer > > readImpl(StringRef FileName, off_t &Size, time_t &ModTime)
Shared implementation of ModuleCache::read().
@ Success
Annotation was successful.
Definition Parser.h:65
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > writeImpl(StringRef Path, llvm::MemoryBufferRef Buffer, off_t &Size, time_t &ModTime, bool ReadBack)
Shared implementation of ModuleCache::write().
void maybePruneImpl(StringRef Path, time_t PruneInterval, time_t PruneAfter, bool PruneTopLevel=false, llvm::function_ref< void(StringRef)> OnPrune={})
Shared implementation of ModuleCache::maybePrune().
llvm::StringMap< std::unique_ptr< ModuleCacheEntry > > Map
void stopBackgroundFlushing()
Stops the background thread as soon as it finishes flushing the current PCM.
void startBackgroundFlushing(AtomicLineLogger &Logger)
Starts a background thread that flushes PCMs built in-process to disk as soon as they're written,...
void scheduleFlush(ModuleCacheMapEntry &MapEntry)
Adds MapEntry into the queue of entries to be flushed.
std::optional< bool > isDirectoryInvalidated(StringRef Directory) const
void flushLeftovers(AtomicLineLogger &Logger)
Flushes all PCMs built in-process that haven't been flushed yet.
enum clang::dependencies::ModuleCacheEntry::@010254116217305143125116322142262271134241253225 State
@ S_Flushed
Written to the module cache and flushed to disk.
@ S_Written
Written to the module cache, but only kept in memory.
time_t ModTime
The modification time of the entry.
std::shared_ptr< const llvm::MemoryBuffer > Buffer
The buffer we've read from disk or written to the module cache, if any.