From dacaf41c33f4aef5ec8c57421b6e509f3419cf4b Mon Sep 17 00:00:00 2001 From: Hugo Date: Thu, 12 Nov 2026 06:56:20 +0100 Subject: [PATCH 1/7] build(deps): pin coretrace-compiler to its per-compilation working directory The pinned commit, from CoreTrace/coretrace-compiler#262, gives each compilation a file system of its own, whose working directory -working-directory moves while the process's stays. The analyzer does not use it yet: it still moves the process around each compilation, under its lock. Refs #271 --- cmake/compiler/coretrace-compiler.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/compiler/coretrace-compiler.cmake b/cmake/compiler/coretrace-compiler.cmake index fb853b9f..70a3bbb0 100644 --- a/cmake/compiler/coretrace-compiler.cmake +++ b/cmake/compiler/coretrace-compiler.cmake @@ -13,7 +13,7 @@ endif() FetchContent_Declare( cc GIT_REPOSITORY https://github.com/CoreTrace/coretrace-compiler.git - GIT_TAG b4ad33638e9020a93f052a7a299e4105bd48f975 # v0.10.0 + GIT_TAG b05bd18b35f5c4c42f3d9b245aecd2c464ccb52b # CoreTrace/coretrace-compiler#262 ) FetchContent_MakeAvailable(cc) From f56e9792ee1011590c8df14ce3df2bd97165dc12 Mon Sep 17 00:00:00 2001 From: Hugo Date: Thu, 12 Nov 2026 06:56:20 +0100 Subject: [PATCH 2/7] perf(input): compile sources in parallel, each in its directory Every compilation held one global lock and moved the whole process to its compile command's directory: the --jobs threads compiled one source at a time. coretrace-compiler now gives each compilation the directory of its -working-directory without moving the process: the analyzer passes the directory that way, and compilations share the lock. Some compilations still hold it alone, since they change state that the whole process shares: those with an option that Clang applies to LLVM's state (-mllvm, -mdebug-pass, -mlimit-float-precision, -ftime-report), and those with -fno-integrated-cc1, whose jobs run as programs, for which coretrace-compiler moves the process. A compile command whose directory does not exist still fails the analysis: coretrace-compiler reports a directory it cannot enter, but compiles to memory all the same, so the analyzer checks the directory itself, with the message it gave before. Refs #271 --- src/analysis/InputPipeline.cpp | 114 +++++++++++++++------------------ 1 file changed, 52 insertions(+), 62 deletions(-) diff --git a/src/analysis/InputPipeline.cpp b/src/analysis/InputPipeline.cpp index 0828f54e..a723665f 100644 --- a/src/analysis/InputPipeline.cpp +++ b/src/analysis/InputPipeline.cpp @@ -14,7 +14,9 @@ #include #include #include +#include #include +#include #include #include #include @@ -40,15 +42,29 @@ namespace ctrace::stack::analysis { namespace { - // compilerlib drives an in-process clang CompilerInstance. clang/LLVM keep global - // mutable state (target registry, cl options, timers); two worker threads compiling - // at once hung intermittently on the first compile of a run. Compilation is - // serialised here; module analysis stays parallel, and the IR cache makes the - // compile step cheap on repeated runs. A compile that needs its compile command's - // directory changes the working directory of the whole process: it holds the same - // lock from before that change until it is undone, so no other compile runs in a - // directory that is not its own, and two changes never interleave. - std::mutex gCompileInvokeMutex; + // coretrace-compiler compiles from several threads at once, each compilation in the + // directory of its -working-directory, without moving the process: compilations share + // this lock. Some change state that the whole process shares, and hold it alone: those + // with an option that Clang applies to LLVM's state, and those with -fno-integrated-cc1, + // whose jobs run as programs, for which coretrace-compiler moves the process to the + // directory. + std::shared_mutex gCompileInvokeMutex; + + bool compilesAlone(const std::vector& args) + { + static constexpr std::string_view kOptionsOfLLVMState[] = { + "-mllvm", "-mdebug-pass", "-mlimit-float-precision", "-ftime-report"}; + return std::any_of(args.begin(), args.end(), + [](const std::string& arg) + { + for (std::string_view option : kOptionsOfLLVMState) + { + if (std::string_view(arg).starts_with(option)) + return true; + } + return arg == "-fno-integrated-cc1"; + }); + } void appendIfMissing(std::vector& args, const std::string& flag) { @@ -745,43 +761,6 @@ namespace ctrace::stack::analysis return true; } - class ScopedCurrentPath - { - public: - explicit ScopedCurrentPath(const std::string& path, std::string& error) - { - if (path.empty()) - return; - std::error_code ec; - previousPath_ = std::filesystem::current_path(ec); - if (ec) - { - error = "Failed to read current working directory"; - return; - } - std::filesystem::current_path(path, ec); - if (ec) - { - error = "Failed to change working directory to: " + path; - return; - } - active_ = true; - } - - ~ScopedCurrentPath() - { - if (!active_) - return; - std::error_code ec; - std::filesystem::current_path(previousPath_, ec); - } - - private: - std::filesystem::path previousPath_; - std::uint64_t active_ : 1 = false; - std::uint64_t reservedFlags_ : 63 = 0; - }; - class ScopedFileCleanup { public: @@ -859,9 +838,7 @@ namespace ctrace::stack::analysis using ctrace::stack::analyzer::ScopedHotspot; ModuleLoadResult result; const ScopedHotspot totalHotspot(config.timing, "input.load_module.total"); - // A relative input resolves from the directory the analysis started in, not from the - // current one: another thread may be compiling from its compile command's directory, - // which the whole process shares meanwhile. + // A relative input resolves from the directory the analysis started in. std::error_code cwdErr; const std::filesystem::path baseDir = config.inputBaseDir.empty() ? std::filesystem::current_path(cwdErr) @@ -923,22 +900,35 @@ namespace ctrace::stack::analysis [&](const std::vector& compileArgs, compilerlib::OutputMode outputMode) -> std::optional { - std::lock_guard compileLock(gCompileInvokeMutex); - if (workingDir.empty()) + std::vector argsInWorkingDir; + argsInWorkingDir.reserve(compileArgs.size() + 2); + if (!workingDir.empty()) { - const ScopedHotspot hotspot(config.timing, "input.compiler.invoke"); - return compilerlib::compile(compileArgs, outputMode); + // coretrace-compiler reports a directory it cannot enter, yet compiles to + // memory all the same: the compilation fails here instead. + std::error_code directoryError; + if (!std::filesystem::is_directory(workingDir, directoryError)) + { + result.error = + "Failed to change working directory to: " + workingDir + "\n"; + return std::nullopt; + } + argsInWorkingDir.push_back("-working-directory"); + argsInWorkingDir.push_back(workingDir); } + argsInWorkingDir.insert(argsInWorkingDir.end(), compileArgs.begin(), + compileArgs.end()); - std::string cwdError; - ScopedCurrentPath cwdGuard(workingDir, cwdError); - if (!cwdError.empty()) - { - result.error = cwdError + "\n"; - return std::nullopt; - } - const ScopedHotspot hotspot(config.timing, "input.compiler.invoke.cwd"); - return compilerlib::compile(compileArgs, outputMode); + std::shared_lock shared(gCompileInvokeMutex, std::defer_lock); + std::unique_lock alone(gCompileInvokeMutex, std::defer_lock); + if (compilesAlone(compileArgs)) + alone.lock(); + else + shared.lock(); + const ScopedHotspot hotspot(config.timing, workingDir.empty() + ? "input.compiler.invoke" + : "input.compiler.invoke.cwd"); + return compilerlib::compile(argsInWorkingDir, outputMode); }; if (cachePaths.enabled) From dd3ba4157309e81dc38c0242cfc601f2268a43b8 Mon Sep 17 00:00:00 2001 From: Hugo Date: Thu, 12 Nov 2026 06:56:20 +0100 Subject: [PATCH 3/7] docs(readme): say that --jobs compiles the sources in parallel Refs #271 --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 420cbbdc..236ed64d 100644 --- a/README.md +++ b/README.md @@ -295,7 +295,7 @@ To generate `compile_commands.json` with CMake, configure with If analysis feels slow, `--compdb-fast` disables heavy flags (optimizations, sanitizers, profiling) while keeping include paths and macros. -For multi-file runs, `--jobs=` parallelizes input loading; with cross-TU enabled it also parallelizes summary construction. +For multi-file runs, `--jobs=` parallelizes input loading, compilations included; with cross-TU enabled it also parallelizes summary construction. `--compile-ir-cache-dir=` reuses compiled LLVM IR for unchanged translation units based on source/dependency stamps, which reduces repeated C/C++ frontend cost across runs. IR that another compiler produced (another coretrace-compiler revision or LLVM version) is compiled again. From d6420395fc47013b9106841edf49e0e181b28fd3 Mon Sep 17 00:00:00 2001 From: Hugo Date: Thu, 12 Nov 2026 06:56:20 +0100 Subject: [PATCH 4/7] docs(changelog): announce that sources compile in parallel Refs #271 --- CHANGELOG.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index c2ad54ff..fe38468c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -51,6 +51,12 @@ Notable changes are grouped by release. See [all releases](https://github.com/Co - Added an authors file and linked the repository documents from the README. - SARIF rules carry a title (`shortDescription`) and a description (`fullDescription`) instead of their id, and `describeRule` (`RuleCatalog.hpp`) gives them to programs linking the analyzer. +- With `--jobs` above 1, sources compile in parallel. Each compilation runs in its compile + command's directory through coretrace-compiler's `-working-directory`, instead of moving the + whole process there under a lock that let one source compile at a time. Compilations that pass + `-mllvm`, `-mdebug-pass`, `-mlimit-float-precision`, `-ftime-report` or `-fno-integrated-cc1` + still run one at a time. coretrace-compiler is pinned to a commit of + CoreTrace/coretrace-compiler#262, which gives each compilation a working directory of its own. ## v0.22.0 From e6ae53edbc1d1f92303fc47f4ba83de6de87f347 Mon Sep 17 00:00:00 2001 From: Hugo Date: Thu, 12 Nov 2026 07:14:36 +0100 Subject: [PATCH 5/7] build(deps): pin coretrace-compiler to its fix of the files -MJ writes The newer commit of CoreTrace/coretrace-compiler#262 also writes the fragment of -MJ, the statistics of -save-stats, the graph of -dependency-dot and the module cache in the directory of -working-directory, as the analyzer did when it moved the process there. Refs #271 --- cmake/compiler/coretrace-compiler.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/compiler/coretrace-compiler.cmake b/cmake/compiler/coretrace-compiler.cmake index 70a3bbb0..706a1b56 100644 --- a/cmake/compiler/coretrace-compiler.cmake +++ b/cmake/compiler/coretrace-compiler.cmake @@ -13,7 +13,7 @@ endif() FetchContent_Declare( cc GIT_REPOSITORY https://github.com/CoreTrace/coretrace-compiler.git - GIT_TAG b05bd18b35f5c4c42f3d9b245aecd2c464ccb52b # CoreTrace/coretrace-compiler#262 + GIT_TAG 8a99cf3d7be21dd6e15c1cc8f9523c685fd307ef # CoreTrace/coretrace-compiler#262 ) FetchContent_MakeAvailable(cc) From 18d032f59a144f40e343125822068ef878644bbf Mon Sep 17 00:00:00 2001 From: Hugo Date: Mon, 16 Nov 2026 02:32:51 +0100 Subject: [PATCH 6/7] fix(input): bring the process back after a compilation that moves it With -fno-integrated-cc1, the jobs of a compile command run as programs: coretrace-compiler moves the process to the command's directory and leaves it there. The scoped change of directory that this branch removed used to bring the process back. After a load of such a source, the process stayed in the command's directory, where a relative source without a compile command was no longer found. A compilation that holds the lock alone now puts the process back before it releases the lock. The compilations that share the lock do not move the process, and still run at once. Refs #271 --- src/analysis/InputPipeline.cpp | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/src/analysis/InputPipeline.cpp b/src/analysis/InputPipeline.cpp index a723665f..a9f5100d 100644 --- a/src/analysis/InputPipeline.cpp +++ b/src/analysis/InputPipeline.cpp @@ -47,9 +47,33 @@ namespace ctrace::stack::analysis // this lock. Some change state that the whole process shares, and hold it alone: those // with an option that Clang applies to LLVM's state, and those with -fno-integrated-cc1, // whose jobs run as programs, for which coretrace-compiler moves the process to the - // directory. + // directory and leaves it there (ProcessDirectoryScope). std::shared_mutex gCompileInvokeMutex; + // Brings the process back to the directory it was in. A compilation that holds + // gCompileInvokeMutex alone ends its scope before it releases the lock: the next + // compilation, and the relative paths of the host, start from that directory again. + class ProcessDirectoryScope + { + public: + ProcessDirectoryScope() : directory_(std::filesystem::current_path(error_)) {} + + ProcessDirectoryScope(const ProcessDirectoryScope&) = delete; + ProcessDirectoryScope& operator=(const ProcessDirectoryScope&) = delete; + + ~ProcessDirectoryScope() + { + if (error_) + return; + std::error_code ignored; + std::filesystem::current_path(directory_, ignored); + } + + private: + std::error_code error_; + std::filesystem::path directory_; + }; + bool compilesAlone(const std::vector& args) { static constexpr std::string_view kOptionsOfLLVMState[] = { @@ -921,8 +945,13 @@ namespace ctrace::stack::analysis std::shared_lock shared(gCompileInvokeMutex, std::defer_lock); std::unique_lock alone(gCompileInvokeMutex, std::defer_lock); + // After the locks: it ends before the one it was taken under is released. + std::optional processDirectory; if (compilesAlone(compileArgs)) + { alone.lock(); + processDirectory.emplace(); + } else shared.lock(); const ScopedHotspot hotspot(config.timing, workingDir.empty() From bbaab08a69bf1562c2806f7da7c0dfdc83671fa5 Mon Sep 17 00:00:00 2001 From: Hugo Date: Mon, 16 Nov 2026 02:32:55 +0100 Subject: [PATCH 7/7] test(unit): check that a load leaves the process in its directory A source whose compile command passes -fno-integrated-cc1 is loaded, then a relative source without a compile command. Before the fix, the process was left in the command's directory and the second load failed. Refs #271 --- test/unit/analyzer_module_unit_tests.cpp | 53 ++++++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/test/unit/analyzer_module_unit_tests.cpp b/test/unit/analyzer_module_unit_tests.cpp index f1e8ca0f..d32635fe 100644 --- a/test/unit/analyzer_module_unit_tests.cpp +++ b/test/unit/analyzer_module_unit_tests.cpp @@ -1,6 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 #include "StackUsageAnalyzer.hpp" #include "analysis/AnalyzerUtils.hpp" +#include "analysis/CompileCommands.hpp" #include "app/CrossTUSummaryDriver.hpp" #include "app/AnalyzerApp.hpp" #include "cli/ArgParser.hpp" @@ -3472,6 +3473,57 @@ namespace return report.failures == 0; } + /// With -fno-integrated-cc1, the jobs of a compile command run as programs: + /// coretrace-compiler moves the process to the command's directory and leaves it there. The + /// load must bring the process back. A source without a compile command is compiled by its + /// relative path, from the directory the process is in: left in the command's directory, + /// the process no longer finds it. + bool testLoadLeavesTheProcessDirectory(TestReport& report) + { + char rootTemplate[] = "/tmp/ctrace-load-directory-XXXXXX"; + if (mkdtemp(rootTemplate) == nullptr) + { + report.expect(false, "Load directory: no temporary directory"); + return false; + } + std::error_code ec; + const std::filesystem::path start = std::filesystem::current_path(ec); + const std::filesystem::path root = std::filesystem::canonical(rootTemplate, ec); + const std::filesystem::path project = root / "project"; + std::filesystem::create_directories(project, ec); + std::ofstream(project / "unit.c") << "int unit(void) { return 1; }\n"; + std::ofstream(root / "host.c") << "int host(void) { return 2; }\n"; + std::ofstream(project / "compile_commands.json") + << "[{\"directory\": \"" << project.string() << "\", \"file\": \"unit.c\", " + << "\"arguments\": [\"cc\", \"-fno-integrated-cc1\", \"-c\", \"unit.c\"]}]\n"; + + ctrace::stack::AnalysisConfig config; + std::string error; + config.compilationDatabase = ctrace::stack::analysis::CompilationDatabase::loadFromFile( + (project / "compile_commands.json").string(), error); + config.inputBaseDir = root.string(); + const auto loads = [&](const char* source) + { + llvm::LLVMContext context; + llvm::SMDiagnostic err; + return ctrace::stack::analysis::loadModuleForAnalysis(source, config, context, err) + .module != nullptr; + }; + + std::filesystem::current_path(root, ec); + const bool compiled = config.compilationDatabase && loads("project/unit.c"); + const bool stayed = + std::filesystem::equivalent(std::filesystem::current_path(ec), root, ec); + const bool found = loads("host.c"); + std::filesystem::current_path(start, ec); + std::filesystem::remove_all(root, ec); + + report.expect(compiled, "Load directory: a command whose jobs run as programs compiles"); + report.expect(stayed, "Load directory: the process is where it was before that load"); + report.expect(found, "Load directory: a relative source without a command then compiles"); + return compiled && stayed && found; + } + /// A ring of pointer variables with one array source, as -O0 code leaves it: p0 = buf, /// p1 = p0, ..., p0 = p(n-1). Every pointer must find the array, however far from it; the /// order of the accesses must not change the alias paths; and the walk must finish on a @@ -3609,6 +3661,7 @@ int main(int argc, char** argv) (void)testDuplicateIfIndexWidths(repoRoot, report); (void)testStackBufferPhiCycle(repoRoot, report); (void)testStackBufferPointerRing(report); + (void)testLoadLeavesTheProcessDirectory(report); (void)testResourceModelConditions(report); (void)testResourceRuleMatchesFunction(report); (void)testOwnershipFactCollector(repoRoot, report);