[llvm-branch-commits] [lld] [lld-macho] Collect markLive roots in parallel (PR #241684)
Jez Ng via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Thu Nov 12 23:31:03 PST 2026
https://github.com/int3 updated https://github.com/llvm/llvm-project/pull/241684
>From 5a8cc0cac338cce62d5a7d8af23be06a094674c1 Mon Sep 17 00:00:00 2001
From: Jez Ng <me at jezng.com>
Date: Mon, 9 Nov 2026 12:55:24 -0800
Subject: [PATCH] [lld-macho] Collect markLive roots in parallel
With the traversal parallel, most of markLive's remaining time goes to
the serial loops around it: finding the GC roots, which visits every
global symbol, every object file's local symbols and every input
section, and the S_ATTR_LIVE_SUPPORT scan over every input section.
Run those loops on all threads. The type-erased MarkLive interface now
takes a shard index with each root: each thread adds the roots it finds
to its own shard, and moves them to nextLevel after every chunk, so with
one thread the order is unchanged. The live-support scan does the same
with the sections it marks live, reading the live bits of sections that
other threads may be marking at the same time through the thread-safe
isLive(). A live-support section that refers only to another one marked
by the same scan may be found by the next iteration of the loop around
it instead; the final live set is the same.
Co-Authored-By: Claude Opus 5.5 <noreply at anthropic.com>
---
lld/MachO/MarkLive.cpp | 217 +++++++++++++++++----------
lld/test/MachO/dead-strip-parallel.s | 34 +++++
2 files changed, 172 insertions(+), 79 deletions(-)
create mode 100644 lld/test/MachO/dead-strip-parallel.s
diff --git a/lld/MachO/MarkLive.cpp b/lld/MachO/MarkLive.cpp
index b76d5fb8fca59..8e34f88684585 100644
--- a/lld/MachO/MarkLive.cpp
+++ b/lld/MachO/MarkLive.cpp
@@ -38,8 +38,14 @@ struct WhyLiveEntry {
// graph.
class MarkLive {
public:
- virtual void enqueue(InputSection *isec, uint64_t off) = 0;
- virtual void addSym(Symbol *s) = 0;
+ // These add roots to worklist `shard`. We have one shard per thread.
+ virtual void enqueue(InputSection *isec, uint64_t off, size_t shard = 0) = 0;
+ virtual void addSym(Symbol *s, size_t shard = 0) = 0;
+ // Moves the roots in `shard` into `nextLevel`. Exposed as a performance
+ // optimization; flushing shortly after the worklist is populated means its
+ // entries are likely still in cache.
+ virtual void flush(size_t shard) = 0;
+ // Flushes all the shards into `nextLevel` before doing the marking.
virtual void markTransitively() = 0;
virtual ~MarkLive() = default;
};
@@ -53,6 +59,23 @@ static bool tryClaim(bool &flag) {
!atomicFlag.exchange(true, std::memory_order_relaxed);
}
+// Splits `items` into chunks of `chunkSize` and calls fn(worker, chunk) for
+// each chunk on all threads. `worker` is below parallel::getThreadCount() and
+// no two threads use the same one at once, so fn can use it to index
+// per-thread state. Chunks are claimed in increasing order.
+template <class T, class Fn>
+static void parallelForChunks(ArrayRef<T> items, size_t chunkSize, Fn fn) {
+ const size_t numThreads = parallel::getThreadCount();
+ // Each worker starts with the chunk at its own index and then claims the
+ // chunks after the first numThreads.
+ std::atomic<size_t> next{numThreads * chunkSize};
+ parallelFor(0, numThreads, [&](size_t worker) {
+ for (size_t begin = worker * chunkSize; begin < items.size();
+ begin = next.fetch_add(chunkSize, std::memory_order_relaxed))
+ fn(worker, items.slice(begin, std::min(chunkSize, items.size() - begin)));
+ });
+}
+
// Marks liveness on as many threads as are available. -why_live output is
// deterministic only with --threads=1.
template <bool RecordWhyLive> class MarkLiveImpl : public MarkLive {
@@ -65,10 +88,14 @@ template <bool RecordWhyLive> class MarkLiveImpl : public MarkLive {
std::conditional_t<RecordWhyLive, WhyLiveEntry, InputSection>;
using Worklist = SmallVector<WorklistEntry *, 0>;
- void enqueue(InputSection *isec, uint64_t off) override {
- enqueue(isec, off, nullptr, nextLevel);
+ MarkLiveImpl() : shards(parallel::getThreadCount()) {}
+ void enqueue(InputSection *isec, uint64_t off, size_t shard) override {
+ enqueue(isec, off, nullptr, shards[shard]);
}
- void addSym(Symbol *s) override { addSym(s, nullptr, nextLevel); }
+ void addSym(Symbol *s, size_t shard) override {
+ addSym(s, nullptr, shards[shard]);
+ }
+ void flush(size_t shard) override;
void markTransitively() override;
private:
@@ -87,6 +114,8 @@ template <bool RecordWhyLive> class MarkLiveImpl : public MarkLive {
const InputSection *getInputSection(const WorklistEntry *) const;
WorklistEntry *makeEntry(InputSection *, const WorklistEntry *prev) const;
+ std::vector<Worklist> shards;
+ std::mutex nextLevelMutex;
// Sections that have been marked live and that the next level of drain() will
// visit. Literal sections cannot contain references to other sections, so we
// only store ConcatInputSections here.
@@ -243,35 +272,53 @@ MarkLiveImpl<RecordWhyLive>::makeEntry(
}
}
+template <bool RecordWhyLive>
+void MarkLiveImpl<RecordWhyLive>::flush(size_t shard) {
+ Worklist &worklist = shards[shard];
+ if (worklist.empty())
+ return;
+ std::lock_guard<std::mutex> lock(nextLevelMutex);
+ nextLevel.append(worklist.begin(), worklist.end());
+ worklist.clear();
+}
+
template <bool RecordWhyLive>
void MarkLiveImpl<RecordWhyLive>::markTransitively() {
+ for (size_t shard = 0; shard != shards.size(); ++shard)
+ flush(shard);
do {
// Mark things reachable from GC roots as live.
drain();
// S_ATTR_LIVE_SUPPORT sections are live if they point _to_ a live
// section. Process them in a second pass.
- for (ConcatInputSection *isec : inputSections) {
- // FIXME: Check if copying all S_ATTR_LIVE_SUPPORT sections into a
- // separate vector and only walking that here is faster.
- if (!(isec->getFlags() & S_ATTR_LIVE_SUPPORT) || isec->live)
- continue;
-
- for (const Relocation &r : isec->relocs) {
- if (auto *s = dyn_cast<Symbol *>(r.referent)) {
- if (s->isLive()) {
- InputSection *referentIsec = nullptr;
- if (auto *d = dyn_cast<Defined>(s))
- referentIsec = d->isec();
- enqueue(isec, 0, makeEntry(referentIsec, nullptr), nextLevel);
+ parallelForChunks(
+ ArrayRef(inputSections), 256,
+ [&](size_t shard, ArrayRef<ConcatInputSection *> chunk) {
+ for (ConcatInputSection *isec : chunk) {
+ // FIXME: Check if copying all S_ATTR_LIVE_SUPPORT sections into a
+ // separate vector and only walking that here is faster.
+ if (!(isec->getFlags() & S_ATTR_LIVE_SUPPORT) || isec->isLive(0))
+ continue;
+
+ for (const Relocation &r : isec->relocs) {
+ InputSection *referentIsec = nullptr;
+ if (auto *s = dyn_cast<Symbol *>(r.referent)) {
+ if (!s->isLive())
+ continue;
+ if (auto *d = dyn_cast<Defined>(s))
+ referentIsec = d->isec();
+ } else {
+ referentIsec = cast<InputSection *>(r.referent);
+ if (!referentIsec->isLive(r.getAddend()))
+ continue;
+ }
+ enqueue(isec, 0, makeEntry(referentIsec, nullptr), shards[shard]);
+ break;
+ }
}
- } else {
- auto *referentIsec = cast<InputSection *>(r.referent);
- if (referentIsec->isLive(r.getAddend()))
- enqueue(isec, 0, makeEntry(referentIsec, nullptr), nextLevel);
- }
- }
- }
+ flush(shard);
+ });
// S_ATTR_LIVE_SUPPORT could have marked additional sections live,
// which in turn could mark additional S_ATTR_LIVE_SUPPORT sections live.
@@ -293,70 +340,82 @@ void markLive() {
// Add GC roots.
if (config->entry)
marker->addSym(config->entry);
- for (Symbol *sym : symtab->getSymbols()) {
- if (auto *defined = dyn_cast<Defined>(sym)) {
- // -exported_symbol(s_list)
- if (!config->exportedSymbols.empty() &&
- config->exportedSymbols.match(defined->getName())) {
- // NOTE: Even though exporting private externs is an ill-defined
- // operation, we are purposely not checking for privateExtern in
- // order to follow ld64's behavior of treating all exported private
- // extern symbols as live, irrespective of whether they are autohide.
- marker->addSym(defined);
- continue;
- }
+ parallelForChunks(
+ symtab->getSymbols(), 256, [&](size_t shard, ArrayRef<Symbol *> chunk) {
+ for (Symbol *sym : chunk) {
+ auto *defined = dyn_cast<Defined>(sym);
+ if (!defined)
+ continue;
+ // -exported_symbol(s_list)
+ if (!config->exportedSymbols.empty() &&
+ config->exportedSymbols.match(defined->getName())) {
+ // NOTE: Even though exporting private externs is an ill-defined
+ // operation, we are purposely not checking for privateExtern in
+ // order to follow ld64's behavior of treating all exported private
+ // extern symbols as live, irrespective of whether they are
+ // autohide.
+ marker->addSym(defined, shard);
+ continue;
+ }
- // public symbols explicitly marked .no_dead_strip
- if (defined->referencedDynamically || defined->noDeadStrip) {
- marker->addSym(defined);
- continue;
- }
+ // public symbols explicitly marked .no_dead_strip
+ if (defined->referencedDynamically || defined->noDeadStrip) {
+ marker->addSym(defined, shard);
+ continue;
+ }
- // FIXME: When we implement these flags, make symbols from them GC
- // roots:
- // * -reexported_symbol(s_list)
- // * -alias_list
- // * -init
-
- // In dylibs and bundles and in executables with -export_dynamic,
- // all external functions are GC roots.
- bool externsAreRoots =
- config->outputType != MH_EXECUTE || config->exportDynamic;
- if (externsAreRoots && !defined->privateExtern) {
- marker->addSym(defined);
- continue;
- }
- }
- }
+ // FIXME: When we implement these flags, make symbols from them GC
+ // roots:
+ // * -reexported_symbol(s_list)
+ // * -alias_list
+ // * -init
+
+ // In dylibs and bundles and in executables with -export_dynamic,
+ // all external functions are GC roots.
+ bool externsAreRoots =
+ config->outputType != MH_EXECUTE || config->exportDynamic;
+ if (externsAreRoots && !defined->privateExtern)
+ marker->addSym(defined, shard);
+ }
+ marker->flush(shard);
+ });
// -u symbols
for (Symbol *sym : config->explicitUndefineds)
marker->addSym(sym);
// local symbols explicitly marked .no_dead_strip
- for (const InputFile *file : inputFiles)
- if (auto *objFile = dyn_cast<ObjFile>(file))
- for (Symbol *sym : objFile->symbols)
- if (auto *defined = dyn_cast_or_null<Defined>(sym))
- if (!defined->isExternal() && defined->noDeadStrip)
- marker->addSym(defined);
+ ArrayRef<InputFile *> files = inputFiles.getArrayRef();
+ parallelForChunks(files, 1, [&](size_t shard, ArrayRef<InputFile *> chunk) {
+ for (InputFile *file : chunk)
+ if (auto *objFile = dyn_cast<ObjFile>(file))
+ for (Symbol *sym : objFile->symbols)
+ if (auto *defined = dyn_cast_or_null<Defined>(sym))
+ if (!defined->isExternal() && defined->noDeadStrip)
+ marker->addSym(defined, shard);
+ marker->flush(shard);
+ });
if (auto *stubBinder =
dyn_cast_or_null<DylibSymbol>(symtab->find("dyld_stub_binder")))
marker->addSym(stubBinder);
- for (ConcatInputSection *isec : inputSections) {
- // Sections marked no_dead_strip
- if (isec->getFlags() & S_ATTR_NO_DEAD_STRIP) {
- marker->enqueue(isec, 0);
- continue;
- }
+ parallelForChunks(
+ ArrayRef(inputSections), 256,
+ [&](size_t shard, ArrayRef<ConcatInputSection *> chunk) {
+ for (ConcatInputSection *isec : chunk) {
+ // Sections marked no_dead_strip
+ if (isec->getFlags() & S_ATTR_NO_DEAD_STRIP) {
+ marker->enqueue(isec, 0, shard);
+ continue;
+ }
- // mod_init_funcs, mod_term_funcs sections
- if (sectionType(isec->getFlags()) == S_MOD_INIT_FUNC_POINTERS ||
- sectionType(isec->getFlags()) == S_MOD_TERM_FUNC_POINTERS) {
- assert(!config->emitInitOffsets ||
- sectionType(isec->getFlags()) != S_MOD_INIT_FUNC_POINTERS);
- marker->enqueue(isec, 0);
- continue;
- }
- }
+ // mod_init_funcs, mod_term_funcs sections
+ if (sectionType(isec->getFlags()) == S_MOD_INIT_FUNC_POINTERS ||
+ sectionType(isec->getFlags()) == S_MOD_TERM_FUNC_POINTERS) {
+ assert(!config->emitInitOffsets ||
+ sectionType(isec->getFlags()) != S_MOD_INIT_FUNC_POINTERS);
+ marker->enqueue(isec, 0, shard);
+ }
+ }
+ marker->flush(shard);
+ });
for (ConcatInputSection *isec : in.initOffsets->inputs())
marker->enqueue(isec, 0);
diff --git a/lld/test/MachO/dead-strip-parallel.s b/lld/test/MachO/dead-strip-parallel.s
new file mode 100644
index 0000000000000..b69364cde585e
--- /dev/null
+++ b/lld/test/MachO/dead-strip-parallel.s
@@ -0,0 +1,34 @@
+# REQUIRES: x86
+## The symbol table here spans several chunks of the parallel root scan. Check
+## that one and eight threads mark the same sections live.
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos %s -o %t.o
+# RUN: %lld -dead_strip --threads=1 %t.o -o %t1 -final_output out
+# RUN: %lld -dead_strip --threads=8 %t.o -o %t8 -final_output out
+# RUN: cmp %t1 %t8
+# RUN: llvm-nm %t8 | grep _live | count 1000
+# RUN: llvm-nm %t8 | grep _callee | count 1000
+# RUN: llvm-nm %t8 | FileCheck %s --implicit-check-not=_dead
+# CHECK: _main
+
+.text
+.globl _main
+_main:
+ ret
+
+.macro funcs
+.globl _live\@, _dead\@
+.no_dead_strip _live\@
+_live\@:
+ callq _callee\@
+ ret
+_callee\@:
+ ret
+_dead\@:
+ ret
+.endm
+
+.rept 1000
+funcs
+.endr
+
+.subsections_via_symbols
More information about the llvm-branch-commits
mailing list