[wasm-split] Precompute ownership info (NFC)

[aheejin]

Given a module element name, many parts of the code queries for its owning modules (where the module element has to be placed) or secondary modules using that module element. This adds OwnershipTracker, which precomputes and manages that information. All calls to getOwner or getUsingSecondaries that required computations iterating on all secondary modules which can be as many as thousands, has been replaced with a call that simply returns prcomputed information.

For the Jul 2026 version of the applications received from the Dart team, this reduces the running time of wasm-split by 17% for acx_gallery (30s -> 25s) and by 33% for essentials (230s -> 153s).

Suggested in #8832 (comment).

[tlively]

How do these two phases relate to the general process of splitting described in the comment at the top of the file?

[aheejin]

All of shareImportableItems (and computeUsedNames called from shareImportableItems and construction of OwnershipTracker inside computeUsedNames) correspond to this paragraph:

//   4. Export globals, tags, tables, and memories from the primary module and
//      import them in the secondary modules. If possible, move those module
//      items instead to the secondary modules.

The reason ADD_ITEM does two different things is, before we create OwnershipTracker, we build UsedName for each module, and used.field.insert(val); is done in this phase. After OwnershipTracker is created, we add more constraints. But unlike the straightforward first scanning phase this constraints can add one module item to multiple modules, and we need to keep track of which one should be the owner and such. So in this second phase we use tracker->insert.

[tlively]

So if I understand correctly, the first pass collects the used names and the second pass computes the owners.

What I'm not understanding yet is why we need two passes for this. Can't we just insert used names into the OwnershipTracker in a single pass and have it automatically update the owner to be the primary module as soon as it sees that two different modules have used the same item?

[aheejin]

The reason I used the two-phase thing was the first phase was using ParallelFunctionAnalysis:

binaryen/src/ir/module-splitting.cpp

Lines 704 to 728 in dae272c

	// Given a module, collect names used in the module
	auto scanModule = [&](Module& module) {
	UsedNames used;
	ModuleUtils::ParallelFunctionAnalysis<UsedNames> nameCollector(
	module, [&](Function* func, UsedNames& used) {
	if (!func->imported()) {
	NameCollector(used).walk(func->body);
	}
	});
	for (auto& [_, funcUsed] : nameCollector.map) {
	used.globals.insert(funcUsed.globals.begin(), funcUsed.globals.end());
	used.memories.insert(funcUsed.memories.begin(), funcUsed.memories.end());
	used.tables.insert(funcUsed.tables.begin(), funcUsed.tables.end());
	used.tags.insert(funcUsed.tags.begin(), funcUsed.tags.end());
	used.dataSegments.insert(funcUsed.dataSegments.begin(),
	funcUsed.dataSegments.end());
	used.elementSegments.insert(funcUsed.elementSegments.begin(),
	funcUsed.elementSegments.end());
	}
	NameCollector collector(used);
	return used;
	};

and if we use the OwnershipTracker from the beginning we can't use ParallelFunctionAnalysis anymore.

But is using ParallelFunctionAnalysis really faster? Several months ago I tried to use ParallelFunctionAnalysis for other functions that were not using it and it actually slowed the program down. I just tried to remove it from scanModule, and it apparently makes at least Dart applications on my local machine faster.

I uploaded the removing of ParallelFunctionAnalysis as a separate PR to make diffs clearer: #9007
After this we can remove this two phase and use the tracker from the beginning.

[aheejin]

Eliminated the two phase and use tracker.insert for all cases, on top of #9007: f03574f

This reduces the running time of acx_gallery from 25s to 23s. (Will update the PR description after running essentials too)

[tlively]

This macro implicitly using whatever owner happens to be in scope at the use site makes it harder to understand what's going on. Can we pass the owner in explicitly?

Also it's probably possible to use some template overloading magic to do something like tracker.insert<Memory>(segment->memory, owner) without using macros.

[aheejin]

I tried it. It looks we need an additional template<typename T> insert wrapper method: 8912e36
Do you prefer this?

(And in case you rather prefer the macro, f03574f added the owner explicitly to it)

[tlively]

So if I understand correctly, the first pass collects the used names and the second pass computes the owners.

What I'm not understanding yet is why we need two passes for this. Can't we just insert used names into the OwnershipTracker in a single pass and have it automatically update the owner to be the primary module as soon as it sees that two different modules have used the same item?