perf(native): full-build `edges` +73% and `roles` +334% slower than WASM on 3.9.5 despite producing fewer outputs

[carlos-alm]

Summary

On the v3.9.5 self-build benchmark (same source, same worktree), native's Rust-orchestrated edges and roles phases are substantially slower than WASM's JS pipeline, even though native emits fewer edges and classifies fewer nodes. That inverts the expected native-is-faster ordering and is a distinct bug from:

• bug(parity): native engine emits ~7,200 excess string AST nodes vs WASM — 7.5% DB bloat in 3.9.5 #1010 (DB bloat from excess ast_nodes rows),
• bug(parity): native orchestrator still drops 49/743 files on 3.9.5 self-build (re-occurrence of #967) #1011 (native dropping ~7 % of files),
• perf(native): 1-file incremental rebuild is 4.3x slower than WASM on 3.9.5 (876ms vs 203ms — regressed from #882) #1012 (native 1-file incremental runs insert/roles globally).

Evidence

Full-build phase timings (median of 3), from today's npm run benchmark:

Phase	WASM	Native	Δ
edges	179 ms	310 ms	+131 (+73 %)
roles	62 ms	269 ms	+207 (+334 %)
ast	392 ms	405 ms	+13 (+3 %, parity)
insert	625	568	parity
structure	313	56	native faster
complexity	617	38	native 16× faster
cfg	374	233	native faster
dataflow	159	143	parity
parse	5 729	87	native 66× faster

And the outputs being produced by the slower phases:

	WASM	Native	Δ
edges rows	37 367	36 949	−418
nodes rows (input to roles)	17 984	17 727	−257

So native's edges phase is 73 % slower per-build while producing 1 % fewer edges, and its roles phase is 4.3× slower while classifying 1.4 % fewer nodes. Per-item cost is:

Phase	ms / item, WASM	ms / item, Native	Native overhead
edges	0.0048	0.0084	+75 %
roles	0.0034	0.0152	+347 %

Architectural note

src/domain/graph/builder/pipeline.ts shows these timings come from the Rust orchestrator:

const resultJson = ctx.nativeDb.buildGraph(...);
const result = JSON.parse(resultJson) as NativeOrchestratorResult;
const p = result.phases;
// …
edgesMs: +(p.edgesMs ?? 0).toFixed(1),
rolesMs: +(p.rolesMs ?? 0).toFixed(1),

So this is Rust-reported wall-time, not napi overhead from repeated JS↔Rust crossings. The Rust implementation of edge-building and role-classification is genuinely doing more work (or less efficient work) per unit than the JS pipeline does on WASM-parsed trees.

Investigation hints

• crates/codegraph-core/ — edges and roles phases of the native orchestrator. Likely candidates:
  • roles: full-table scans (e.g. per-role-check SELECTs instead of a single pass), or recomputing role metrics that the JS side caches/indexes.
  • edges: non-indexed resolution lookups, or redundant symbol-resolution passes that the JS side short-circuits.
• Compare SQL emitted by Rust roles vs src/domain/analysis/roles.ts (or wherever WASM's rolesMs is accumulated). A simple EXPLAIN QUERY PLAN diff on the hot queries may be sufficient to spot missing index use.
• The edges delta could compound with the missing ~418 edges — if some code path is doing an O(N²) lookup that short-circuits when an edge matches, fewer matches means more iterations.

Repro

rm -rf .codegraph && npx codegraph build --engine wasm   --verbose 2>&1 | grep -iE 'edges|roles'
rm -rf .codegraph && npx codegraph build --engine native --verbose 2>&1 | grep -iE 'edges|roles'

Or run the full benchmark: npm run benchmark — the JSON output includes per-phase ms under wasm.phases and native.phases.

Acceptance

• Native edges phase is ≤ 1.2× WASM on codegraph self-build.
• Native roles phase is ≤ 1.2× WASM on codegraph self-build.
• Benchmark asserts a ceiling on these ratios so re-regression is caught automatically.

Related

• bug(parity): native engine emits ~7,200 excess string AST nodes vs WASM — 7.5% DB bloat in 3.9.5 #1010 DB size bloat (distinct: row-count inflation in ast_nodes, not phase timings)
• bug(parity): native orchestrator still drops 49/743 files on 3.9.5 self-build (re-occurrence of #967) #1011 Native orchestrator drops files (distinct: file-count gap)
• perf(native): 1-file incremental rebuild is 4.3x slower than WASM on 3.9.5 (876ms vs 203ms — regressed from #882) #1012 Native 1-file incremental re-runs insert/roles globally (distinct: incremental path; this issue is the full-build path)
• perf: native engine full-build regression in 3.9.2 (9.4s vs WASM 7.2s) #903 (closed) perf: native engine full-build regression in 3.9.2 — historical precedent for native full-build perf tracking