[klimovich008]

What this fixes

With A64_WRITE_TRACK, every non-SP guest store marks its page with two release byte stores. Lifted code spends a measurable share of game-thread time on those marks.

Why merge

A group of stores through one base register, in a straight-line run spanning at most 4 KB, now gets one shared A64_MARK. It covers the same two pages, placed before anything that ends the run. Mark stores drop from 2,521,896 to 1,454,508 (−42.3%) on lifted v2.0.6 code.

Change

• nx2/lift.py edit_c runs the text patches first, then a64_lift.group_marks once over the written C. This keeps oot_patches.py's exact-text edits intact (the review's blocker).
• On the supported build's full lift, each output-size edit must apply, or be already applied, exactly once. Otherwise the lift stops before compiling. Other patches still only warn.
• What ends a run: labels, branches, returns, unbalanced braces, STLR/LDAR, and any call not on a short list of plain loads, stores and pure helpers.
• chunks.write clears an earlier lift's hot pieces before patching.
• A64_MARK_EACH=1 turns grouping off.

Tested

tests/test_mark_groups.py, 21 cases:

• patches-then-groups through edit_c, with the old order as a control that must fail;
• the patched function compiled and run with and without groups, with the same memory and pages;
• address forms, the 4 KB span, a hot rebuild, and duplicate or mixed patch counts.

All 21 deliberate sabotages fail it.

Not covered

• test_insn/test_leaf not run (needs Unicorn and a game dump). No full lift or game run of this revision.
• The earlier CPU result (68.0 vs 69.7 ms/frame) was a batch build. It doesn't isolate this change.

🤖 Generated with Claude Code

[klimovich008]

Thanks, all addressed in 3fa6300 and 816a472 (rebased on current main):

1. Blocker: the lift no longer groups. nx2/lift.py edit_c runs oot_patches, then a64_lift.group_marks once over the written code_*.c. On real v2.0.6 C taken back to its unpatched text, the old order loses OUT_EDITS[0] and the new order patches it.
2. Required edits: on the supported build's whole standalone lift, each OUT_EDITS place must be found exactly once, or the lift stops before its key is written. Other builds, --max-func and the other patches only warn.
3. Counting: made places plus raw places outside made ones, per file. Made twice, or made and raw, is rejected; made once is accepted.
4. Hot rebuilds: chunks.write removes the earlier lift's code_hot_*.c before any patcher runs, so the old patched pieces aren't counted again.
5. STLR/LDAR: recomp_storeN(c,c->x[N], and recomp_loadN(c,c->x[N]) end the run.
6. Braces: a line whose braces don't balance ends the run. One-line { _b ... } blocks still group.
7. Calls: any call-like token outside a short list of plain loads, stores and pure helpers ends the run (f_, hos_, A64_*, atomics, unknown helpers).
8. Stats: L.stats is passed in and printed by report(). There's one REG_WRITE (now with ++/--).
9. Perf: about 6x faster (0.93 s vs 5.7 s per 24 MB chunk), roughly 55 s per full lift.
10. Tests: your list, MARK_EACH, idempotence, a page-set check, a hot rebuild, the count cases, and the patched function compiled and run with and without groups. The old order is kept as a failing control, and 21 sabotages each fail.
11. Benefit: 2,521,896 to 1,454,508 mark stores on v2.0.6 C (-42.3%, vs -43.1% before).

Not rerun here: test_insn and test_leaf (no capstone/unicorn or game), and no game run.

[klimovich008]

Thanks. Fixed in 1c5258f: stubbing lz4 got past that import, but lift.py also pulls in numpy (via adr_entries) and the rest of the lifter at load time. So edit_c now lives in nx2/chunks.py, beside chunks.write, which already writes those files and imports a64_lift. lift.py calls chunks.edit_c, and the tests import chunks directly with no module stand-ins. CI is green on both runners now, and the three order tests run there.

On the nits: yes, the supported lift stopping under A64_LOCAL_REGS is intended, since its output-size edits can't apply then. And the costs from before grouping in chunk_costs.txt are fine as a slight overestimate.