perf: populated delete is ~14x node after tombstones — the residual is IC retirement per delete, not the delete itself

[proggeramlug]

Where we are

Tombstone deletes shipped default-on (#9029 → #9038): bench_populated_delete went 2030 → ~315 ms on the Linux box (6.5×) and ~2100 → 332 ms on the Mac mini. The remaining gap vs node is ~14× (node 21-24 ms), and it is structural, not constant-factor — this issue records where the time is and the ranked options, so the next campaign doesn't re-derive it.

Self-contained repro

// bench_populated_delete.ts — 500 keys stay resident, one key churns.
const o: Record<string, number> = {};
for (let i = 0; i < 500; i++) o["k" + i] = i;
let s = 0;
const N = 200000;
const t = Date.now();
for (let i = 0; i < N; i++) {
  const k = "k" + (i % 500);
  delete o[k];
  o[k] = i;
  s += o[k];
}
console.log("popdel_ms=" + (Date.now() - t) + " chk=" + (s % 7));

Cross-engine, Mac mini, min-of-7 interleaved, self-timed: node 23 · perry 332 · porffor 113 · scriptc 24. The scriptc number is the data point that matters: an AOT competitor does this at node parity, almost certainly via dictionary-style storage — parity is achievable in an AOT setting.

Where the ~315 ms goes (perf, symbolized, flag-on, Linux)

The profile is a flat tail — after the tombstone work no symbol is above ~20%:

• shape_slot_lookup_verdict ~20% total, split by caller (DWARF callgraph): 8.5% the delete's own slot-find (js_object_delete_field → keys_find_slot_by_key_ptr), 3.8% read-path misses, 3.5% write-path misses. Per call it's TLS + RefCell borrow + two hash lookups (~35-40 ns) — call count × fixed cost, not list length.
• Publish machinery per delete: remove_descriptor_id_from_facts_index 2.8%, shape_descriptor_by_id 2.8%, shape_descriptor_ensure_with_holes 1.7%, plus FastKeyHasher 2.8% and from_utf8 2.8% (SSO decode during candidate validation).
• The rest: get_field_by_name tails, js_put_value_set, js_object_delete_field, accessor probes — each 1-3%.

The structural cause

Every delete mints a fresh shape token (this is forced: per-site dyn-IC ways live in generated-code globals the runtime cannot reach, so retiring a deleted key's cached (token, key) → slot entries requires changing the token — see #9029's description). Consequence: after each delete, EVERY inline cache on that receiver misses once — the loop's read and write both take their miss paths every iteration. Node doesn't pay this: V8's dictionary-mode ICs validate against the dictionary, not a shape, so an unrelated delete invalidates nothing.

Ranked options

1. Per-key invalidation instead of whole-token retirement (the real fix, larger design). Keep the shape token STABLE across tombstone deletes; make IC hits validate the cached slot's key content (one load+compare — the slot still holds the key unless tombstoned, and a tombstoned slot holds TAG_HOLE, which never content-matches) or check a per-object delete epoch only on the deleted key's hash class. Either kills the miss-per-delete for the 499 untouched keys. Risk surface: every IC hit gains a compare; measure on the write/read benches that currently BEAT node before accepting.
2. Cheapen the per-delete publish: the mint+sweep+facts-index dance is ~8-10% combined. With (1) in place most of it disappears entirely (no successor id needed per delete — only the hole write + epoch bump).
3. Verdict-lookup fixed cost (~20%): one-entry TLS memo (keys_id → *mut ShapeIndex) with Boxed ShapeIndex values for address stability, invalidated on any indices insert/remove. Saves the borrow + first hash lookup on the 3-4 lookups per op. Bounded win (~40-60 ms of 315).
4. Full dictionary mode — superseded as first move by (1), but it's what scriptc's parity suggests; the tombstone walkers already built the hole-skipping groundwork (feat(runtime): O(1) object deletes via tombstones (flag-gated; populated delete 6.5x on, -11% off) #9029's audit, DELETE_TOMBSTONES_DESIGN.md §3/§7).

Acceptance

• bench_populated_delete ≤ 3× node on the mini AND the Linux box, min-of-7 interleaved vs the exact main tip.
• No regression (±2%) on the benches that now beat node: plain write loop (21 vs 33), combined overwrite (34 vs 38), dynamic-prop overwrite (13 vs 19).
• The feat(runtime): O(1) object deletes via tombstones (flag-gated; populated delete 6.5x on, -11% off) #9029 differential battery (enumeration / adversarial / SSO / stale-slot + the two holed-JSON-array fixtures) byte-identical to node — option (1) changes IC validation, which is exactly what the stale-slot differential exists to catch.