Author: Jan Svoboda Date: 2025-03-18T14:01:04-07:00 New Revision: 056264b838df94b689d3213424d78f8b9452041b
URL: https://github.com/llvm/llvm-project/commit/056264b838df94b689d3213424d78f8b9452041b DIFF: https://github.com/llvm/llvm-project/commit/056264b838df94b689d3213424d78f8b9452041b.diff LOG: [clang][deps] Implement efficient in-process `ModuleCache` (#129751) The dependency scanner uses implicitly-built Clang modules under the hood. This system was originally designed to handle multiple concurrent processes working on the same module cache, and mutual exclusion was implemented using file locks. The scanner, however, runs within single process, making file locks unnecessary. This patch virtualizes the interface for module cache locking and provides an implementation based on `std::shared_mutex`. This reduces `clang-scan-deps` runtime by ~17% on my benchmark. Note that even when multiple processes run a scan on the same module cache (and therefore don't coordinate efficiently), this should still be correct due to the strict context hash, the write-through `InMemoryModuleCache` and the logic for rebuilding out-of-date or incompatible modules. Added: clang/include/clang/Tooling/DependencyScanning/InProcessModuleCache.h clang/lib/Tooling/DependencyScanning/InProcessModuleCache.cpp Modified: clang/include/clang/Tooling/DependencyScanning/DependencyScanningService.h clang/lib/Tooling/DependencyScanning/CMakeLists.txt clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp Removed: ################################################################################ diff --git a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningService.h b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningService.h index 816e122eb3003..996a26716eea2 100644 --- a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningService.h +++ b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningService.h @@ -10,6 +10,7 @@ #define LLVM_CLANG_TOOLING_DEPENDENCYSCANNING_DEPENDENCYSCANNINGSERVICE_H #include "clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h" +#include "clang/Tooling/DependencyScanning/InProcessModuleCache.h" #include "llvm/ADT/BitmaskEnum.h" namespace clang { @@ -99,6 +100,8 @@ class DependencyScanningService { return SharedCache; } + ModuleCacheMutexes &getModuleCacheMutexes() { return ModuleCacheMutexes; } + private: const ScanningMode Mode; const ScanningOutputFormat Format; @@ -110,6 +113,8 @@ class DependencyScanningService { const bool TraceVFS; /// The global file system cache. DependencyScanningFilesystemSharedCache SharedCache; + /// The global module cache mutexes. + ModuleCacheMutexes ModuleCacheMutexes; }; } // end namespace dependencies diff --git a/clang/include/clang/Tooling/DependencyScanning/InProcessModuleCache.h b/clang/include/clang/Tooling/DependencyScanning/InProcessModuleCache.h new file mode 100644 index 0000000000000..a22647584d8c5 --- /dev/null +++ b/clang/include/clang/Tooling/DependencyScanning/InProcessModuleCache.h @@ -0,0 +1,31 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_TOOLING_DEPENDENCYSCANNING_INPROCESSMODULECACHE_H +#define LLVM_CLANG_TOOLING_DEPENDENCYSCANNING_INPROCESSMODULECACHE_H + +#include "clang/Serialization/ModuleCache.h" +#include "llvm/ADT/StringMap.h" + +#include <shared_mutex> + +namespace clang { +namespace tooling { +namespace dependencies { +struct ModuleCacheMutexes { + std::mutex Mutex; + llvm::StringMap<std::unique_ptr<std::shared_mutex>> Map; +}; + +IntrusiveRefCntPtr<ModuleCache> +makeInProcessModuleCache(ModuleCacheMutexes &Mutexes); +} // namespace dependencies +} // namespace tooling +} // namespace clang + +#endif diff --git a/clang/lib/Tooling/DependencyScanning/CMakeLists.txt b/clang/lib/Tooling/DependencyScanning/CMakeLists.txt index 6b500a183bcfc..993dc093a781c 100644 --- a/clang/lib/Tooling/DependencyScanning/CMakeLists.txt +++ b/clang/lib/Tooling/DependencyScanning/CMakeLists.txt @@ -10,6 +10,7 @@ add_clang_library(clangDependencyScanning DependencyScanningService.cpp DependencyScanningWorker.cpp DependencyScanningTool.cpp + InProcessModuleCache.cpp ModuleDepCollector.cpp DEPENDS diff --git a/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp b/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp index 697f26ee5d12f..ca15a088c308d 100644 --- a/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp +++ b/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp @@ -22,6 +22,7 @@ #include "clang/Lex/PreprocessorOptions.h" #include "clang/Serialization/ObjectFilePCHContainerReader.h" #include "clang/Tooling/DependencyScanning/DependencyScanningService.h" +#include "clang/Tooling/DependencyScanning/InProcessModuleCache.h" #include "clang/Tooling/DependencyScanning/ModuleDepCollector.h" #include "clang/Tooling/Tooling.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" @@ -315,9 +316,11 @@ class DependencyScanningAction : public tooling::ToolAction { Scanned = true; // Create a compiler instance to handle the actual work. - ScanInstanceStorage.emplace(std::move(PCHContainerOps)); + auto ModCache = makeInProcessModuleCache(Service.getModuleCacheMutexes()); + ScanInstanceStorage.emplace(std::move(PCHContainerOps), ModCache.get()); CompilerInstance &ScanInstance = *ScanInstanceStorage; ScanInstance.setInvocation(std::move(Invocation)); + ScanInstance.setBuildingModule(false); // Create the compiler's actual diagnostics engine. sanitizeDiagOpts(ScanInstance.getDiagnosticOpts()); diff --git a/clang/lib/Tooling/DependencyScanning/InProcessModuleCache.cpp b/clang/lib/Tooling/DependencyScanning/InProcessModuleCache.cpp new file mode 100644 index 0000000000000..0ffe20ae52bcd --- /dev/null +++ b/clang/lib/Tooling/DependencyScanning/InProcessModuleCache.cpp @@ -0,0 +1,87 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "clang/Tooling/DependencyScanning/InProcessModuleCache.h" + +#include "clang/Serialization/InMemoryModuleCache.h" +#include "llvm/Support/AdvisoryLock.h" + +#include <mutex> + +using namespace clang; +using namespace tooling; +using namespace dependencies; + +namespace { +class ReaderWriterLock : public llvm::AdvisoryLock { + // TODO: Consider using std::atomic::{wait,notify_all} when we move to C++20. + std::unique_lock<std::shared_mutex> OwningLock; + +public: + ReaderWriterLock(std::shared_mutex &Mutex) + : OwningLock(Mutex, std::defer_lock) {} + + Expected<bool> tryLock() override { return OwningLock.try_lock(); } + + llvm::WaitForUnlockResult + waitForUnlockFor(std::chrono::seconds MaxSeconds) override { + assert(!OwningLock); + // We do not respect the timeout here. It's very generous for implicit + // modules, so we'd typically only reach it if the owner crashed (but so did + // we, since we run in the same process), or encountered deadlock. + (void)MaxSeconds; + std::shared_lock Lock(*OwningLock.mutex()); + return llvm::WaitForUnlockResult::Success; + } + + std::error_code unsafeMaybeUnlock() override { + // Unlocking the mutex here would trigger UB and we don't expect this to be + // actually called when compiling scanning modules due to the no-timeout + // guarantee above. + return {}; + } + + ~ReaderWriterLock() override = default; +}; + +class InProcessModuleCache : public ModuleCache { + ModuleCacheMutexes &Mutexes; + + // TODO: If we changed the InMemoryModuleCache API and relied on strict + // context hash, we could probably create more efficient thread-safe + // implementation of the InMemoryModuleCache such that it doesn't need to be + // recreated for each translation unit. + InMemoryModuleCache InMemory; + +public: + InProcessModuleCache(ModuleCacheMutexes &Mutexes) : Mutexes(Mutexes) {} + + void prepareForGetLock(StringRef Filename) override {} + + std::unique_ptr<llvm::AdvisoryLock> getLock(StringRef Filename) override { + auto &Mtx = [&]() -> std::shared_mutex & { + std::lock_guard Lock(Mutexes.Mutex); + auto &Mutex = Mutexes.Map[Filename]; + if (!Mutex) + Mutex = std::make_unique<std::shared_mutex>(); + return *Mutex; + }(); + return std::make_unique<ReaderWriterLock>(Mtx); + } + + InMemoryModuleCache &getInMemoryModuleCache() override { return InMemory; } + const InMemoryModuleCache &getInMemoryModuleCache() const override { + return InMemory; + } +}; +} // namespace + +IntrusiveRefCntPtr<ModuleCache> +dependencies::makeInProcessModuleCache(ModuleCacheMutexes &Mutexes) { + return llvm::makeIntrusiveRefCnt<InProcessModuleCache>(Mutexes); +} _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
