perf(ir): count a for over a flat list #475

Merged

argus merged 2 commits from loop/470-counted-for-pass into main 2026-10-25 12:16:46 +00:00

Conversation 3 Commits 2 Files changed 29 +683 -19

orion commented 2026-10-24 22:14:18 +00:00

Collaborator

Copy link

Closes #470

What it does

for value in numbers over a ListIterator, TrieListIterator or BufferIterator becomes a length read once, a counter and an unchecked Element read, on both back ends (compiler/src/ir/counted.trb, one wiring line countFlatListLoops lowering in finishLowering, after dropUncountedMakeUnique and before dropProvableChecks). The pass takes a loop only whole: the head is the direct next call of one of the three std cursors (found through standardFunctionsOf, never by field shape of a user type), its tag and the Switch; the Option is read only there and by the one Read of its Some; the cursor is built once in a block that jumps straight to the head. Every other loop (RingList, Array, maps, sets, String.chars(), a user Iterate, a loop with no length instance for the list) keeps its cursor, Option and dispatch.

Wiring note: the pass runs after dropUncountedMakeUnique, because the var fn next of a trait-typed cursor is lowered with a MakeUnique in front of the call until that pass removes it.

Tests

• compiler/tests/counted.test.trb (IR snapshot, lowers a probe against the real std): the loop over a List<Int> has no next call, has a less, a [... unchecked] read and add.i64.unchecked; a RingList loop and a user Iterate loop keep their next. The " unchecked]" assert is the read annotation of criterion 3; add.i64.unchecked does not contain it, so it is not implied and stays.
• Six conformance programs tests/conformance/counted-for-{break,continue,tuple-pattern,strings,empty,write-to-list} with .allocations; they pass natively and in both VM lanes (tier B green).
• CI on 51d38d87c7 (the perf commit; this head only adds the docs commit): all green (commit messages, bootstrap, tier A, tier B, gates, same-C, playground).

Cursor shape re-check after #413 (criterion 2)

#413 is on main. The cursors are unchanged and decision 2's match stands: TrieListIterator (std/collections/src/list.trb:588), ListIterator (:610) and BufferIterator (std/core/src/buffer.trb:249) each are { items: <list type>, var index: Int = 0 } with next = get, then index = index + 1; compiler/src/ir/instantiate.trb still registers ArrayList, TrieList and Buffer as Runtime(ListStorage). The "Related work in review" paragraph of section 5.1 is rewritten accordingly (second commit).

Measurement (criterion 5)

Forge CI run 1745, job tier B (linux-x64), tools/collection-cost.sh (this PR extends it to benchmarks/run.sh --allocations and a VM line): one job builds the compiler of the merge base 44a359160d and of the branch 51d38d87c7, same machine, fastest of 9 runs, µs, as printed.

--- base
program              torb          c    ratio  checksum
list-index         220065      34144    6.44x  list-index 3839953560
list-iterate       378156      35615   10.61x  list-iterate 3839953560
array-write        170193      25343    6.71x  array-write 237999055
buffer-write       170178      25656    6.63x  buffer-write 237999055
list-slice          13827       8173    1.69x  list-slice 9599802
list-write-shared      93515      21020    4.44x  list-write-shared 29682
list-literal       313057      17964   17.42x  list-literal 4000028000000

allocations (ld --wrap over malloc, calloc and realloc)
list-index     torb allocations 22 bytes 33554951      c allocations 1 bytes 16000000
list-iterate   torb allocations 22 bytes 33554953      c allocations 1 bytes 16000000
array-write    torb allocations 21 bytes 16777712      c allocations 1 bytes 8000000
buffer-write   torb allocations 21 bytes 16777713      c allocations 1 bytes 8000000
list-slice     torb allocations 21 bytes 16777711      c allocations 1 bytes 8000000
list-write-shared torb allocations 261 bytes 1879054422   c allocations 222 bytes 177600000
list-literal   torb allocations 8000001 bytes 640000049 c allocations 2000000 bytes 256000000
VM, fastest of 3: list-index 23215 ms, list-iterate 20828 ms

--- head
program              torb          c    ratio  checksum
list-index         218144      33924    6.43x  list-index 3839953560
list-iterate        55823      37733    1.47x  list-iterate 3839953560
array-write        165322      24430    6.76x  array-write 237999055
buffer-write       166101      26277    6.32x  buffer-write 237999055
list-slice          14540       6224    2.33x  list-slice 9599802
list-write-shared      84192      18941    4.44x  list-write-shared 29682
list-literal       301633      16992   17.75x  list-literal 4000028000000

allocations (ld --wrap over malloc, calloc and realloc)
list-index     torb allocations 22 bytes 33554951      c allocations 1 bytes 16000000
list-iterate   torb allocations 22 bytes 33554953      c allocations 1 bytes 16000000
array-write    torb allocations 21 bytes 16777712      c allocations 1 bytes 8000000
buffer-write   torb allocations 21 bytes 16777713      c allocations 1 bytes 8000000
list-slice     torb allocations 21 bytes 16777711      c allocations 1 bytes 8000000
list-write-shared torb allocations 261 bytes 1879054422   c allocations 222 bytes 177600000
list-literal   torb allocations 8000001 bytes 640000049 c allocations 2000000 bytes 256000000
VM, fastest of 3: list-index 23513 ms, list-iterate 62526 ms

Verdict per criterion 5:

• Time: done. list-iterate 1.47x vs list-index 6.43x of the same run (bound: at most 10% above, 7.07x); 55 823 µs against 378 156 µs on main = 0.15 of its time ("did not help" starts at two thirds).
• Allocations: unchanged, not "exactly 24". The 24 in the issue is section 4's old number; on current main both programs allocate 22, and the branch allocates the same 22 for list-iterate, equal to list-index, row by row for all seven programs. I read the criterion as "no change, equal to list-index" and say so rather than claim 24.
• VM: NOT met in this run. torb run --vm of list-iterate: 20 828 ms on base, 62 526 ms on the branch (3.0x slower); list-index unchanged (23 215 vs 23 513 ms). Cause not found by reading (the new read is ListItemAddress, one kernel call like list-index's ElementAddress). Tracked in #482, which also takes a second sample (this head's CI run prints another). The fix belongs to the bytecode emitter or the VM, not to the pass. Reviewer: this is the one criterion I report as not met; decision on merging before #482 is yours.

Docs (criterion 6)

Second commit docs(performance): record round P11 (docs/PERFORMANCE.md only): header status, section 2 row, finding 5 "What was left", section 5's P11 row (done), the 5.1 intro, "Related work" (cursor re-check), and a "Result" paragraph at the end of decision 5 with the tables above. skills/ carries no text of docs/PERFORMANCE.md (no P11 text in skills/, no carry directive), so torb docs skill docs skills is a no-op; the tier A gate docs skill --check confirms on this head.

Nits

• counted.test.trb assert: kept, see Tests.
• .allocations of the five counted-for-* programs stay at the 1000 ceiling: CI prints the real counts only for a failing budget (tools/gates.sh deletes the output of a green gate), and a probe branch costs a full CI cycle for a budget notice. counted-for-write-to-list is the measured 6. Tightening is a follow-up in the next PR that touches these files.

Seed

None. No syntax, native, driver flag or name the seed looks up (decision 6).

After merge

Nothing to release or deploy.

Closes #470 ## What it does `for value in numbers` over a `ListIterator`, `TrieListIterator` or `BufferIterator` becomes a length read once, a counter and an unchecked `Element` read, on both back ends (`compiler/src/ir/counted.trb`, one wiring line `countFlatListLoops lowering` in `finishLowering`, after `dropUncountedMakeUnique` and before `dropProvableChecks`). The pass takes a loop only whole: the head is the direct `next` call of one of the three std cursors (found through `standardFunctionsOf`, never by field shape of a user type), its `tag` and the `Switch`; the `Option` is read only there and by the one `Read` of its `Some`; the cursor is built once in a block that jumps straight to the head. Every other loop (`RingList`, `Array`, maps, sets, `String.chars()`, a user `Iterate`, a loop with no `length` instance for the list) keeps its cursor, `Option` and dispatch. Wiring note: the pass runs after `dropUncountedMakeUnique`, because the `var fn next` of a trait-typed cursor is lowered with a `MakeUnique` in front of the call until that pass removes it. ## Tests - `compiler/tests/counted.test.trb` (IR snapshot, lowers a probe against the real std): the loop over a `List<Int>` has no `next` call, has a `less`, a `[... unchecked]` read and `add.i64.unchecked`; a `RingList` loop and a user `Iterate` loop keep their `next`. The `" unchecked]"` assert is the read annotation of criterion 3; `add.i64.unchecked` does not contain it, so it is not implied and stays. - Six conformance programs `tests/conformance/counted-for-{break,continue,tuple-pattern,strings,empty,write-to-list}` with `.allocations`; they pass natively and in both VM lanes (tier B green). - CI on `51d38d87c7` (the perf commit; this head only adds the docs commit): all green (commit messages, bootstrap, tier A, tier B, gates, same-C, playground). ## Cursor shape re-check after #413 (criterion 2) #413 is on `main`. The cursors are unchanged and decision 2's match stands: `TrieListIterator` (`std/collections/src/list.trb:588`), `ListIterator` (`:610`) and `BufferIterator` (`std/core/src/buffer.trb:249`) each are `{ items: <list type>, var index: Int = 0 }` with `next` = `get`, then `index = index + 1`; `compiler/src/ir/instantiate.trb` still registers `ArrayList`, `TrieList` and `Buffer` as `Runtime(ListStorage)`. The "Related work in review" paragraph of section 5.1 is rewritten accordingly (second commit). ## Measurement (criterion 5) Forge CI run 1745, job `tier B (linux-x64)`, `tools/collection-cost.sh` (this PR extends it to `benchmarks/run.sh --allocations` and a VM line): one job builds the compiler of the merge base `44a359160d` and of the branch `51d38d87c7`, same machine, fastest of 9 runs, µs, as printed. ```text --- base program torb c ratio checksum list-index 220065 34144 6.44x list-index 3839953560 list-iterate 378156 35615 10.61x list-iterate 3839953560 array-write 170193 25343 6.71x array-write 237999055 buffer-write 170178 25656 6.63x buffer-write 237999055 list-slice 13827 8173 1.69x list-slice 9599802 list-write-shared 93515 21020 4.44x list-write-shared 29682 list-literal 313057 17964 17.42x list-literal 4000028000000 allocations (ld --wrap over malloc, calloc and realloc) list-index torb allocations 22 bytes 33554951 c allocations 1 bytes 16000000 list-iterate torb allocations 22 bytes 33554953 c allocations 1 bytes 16000000 array-write torb allocations 21 bytes 16777712 c allocations 1 bytes 8000000 buffer-write torb allocations 21 bytes 16777713 c allocations 1 bytes 8000000 list-slice torb allocations 21 bytes 16777711 c allocations 1 bytes 8000000 list-write-shared torb allocations 261 bytes 1879054422 c allocations 222 bytes 177600000 list-literal torb allocations 8000001 bytes 640000049 c allocations 2000000 bytes 256000000 VM, fastest of 3: list-index 23215 ms, list-iterate 20828 ms --- head program torb c ratio checksum list-index 218144 33924 6.43x list-index 3839953560 list-iterate 55823 37733 1.47x list-iterate 3839953560 array-write 165322 24430 6.76x array-write 237999055 buffer-write 166101 26277 6.32x buffer-write 237999055 list-slice 14540 6224 2.33x list-slice 9599802 list-write-shared 84192 18941 4.44x list-write-shared 29682 list-literal 301633 16992 17.75x list-literal 4000028000000 allocations (ld --wrap over malloc, calloc and realloc) list-index torb allocations 22 bytes 33554951 c allocations 1 bytes 16000000 list-iterate torb allocations 22 bytes 33554953 c allocations 1 bytes 16000000 array-write torb allocations 21 bytes 16777712 c allocations 1 bytes 8000000 buffer-write torb allocations 21 bytes 16777713 c allocations 1 bytes 8000000 list-slice torb allocations 21 bytes 16777711 c allocations 1 bytes 8000000 list-write-shared torb allocations 261 bytes 1879054422 c allocations 222 bytes 177600000 list-literal torb allocations 8000001 bytes 640000049 c allocations 2000000 bytes 256000000 VM, fastest of 3: list-index 23513 ms, list-iterate 62526 ms ``` Verdict per criterion 5: - **Time: done.** `list-iterate` 1.47x vs `list-index` 6.43x of the same run (bound: at most 10% above, 7.07x); 55 823 µs against 378 156 µs on `main` = 0.15 of its time ("did not help" starts at two thirds). - **Allocations: unchanged, not "exactly 24".** The 24 in the issue is section 4's old number; on current `main` both programs allocate **22**, and the branch allocates the same 22 for `list-iterate`, equal to `list-index`, row by row for all seven programs. I read the criterion as "no change, equal to `list-index`" and say so rather than claim 24. - **VM: NOT met in this run.** `torb run --vm` of `list-iterate`: 20 828 ms on base, **62 526 ms** on the branch (3.0x slower); `list-index` unchanged (23 215 vs 23 513 ms). Cause not found by reading (the new read is `ListItemAddress`, one kernel call like `list-index`'s `ElementAddress`). Tracked in #482, which also takes a second sample (this head's CI run prints another). The fix belongs to the bytecode emitter or the VM, not to the pass. Reviewer: this is the one criterion I report as not met; decision on merging before #482 is yours. ## Docs (criterion 6) Second commit `docs(performance): record round P11` (docs/PERFORMANCE.md only): header status, section 2 row, finding 5 "What was left", section 5's P11 row (done), the 5.1 intro, "Related work" (cursor re-check), and a "Result" paragraph at the end of decision 5 with the tables above. `skills/` carries no text of docs/PERFORMANCE.md (no P11 text in `skills/`, no carry directive), so `torb docs skill docs skills` is a no-op; the tier A gate `docs skill --check` confirms on this head. ## Nits - `counted.test.trb` assert: kept, see Tests. - `.allocations` of the five `counted-for-*` programs stay at the 1000 ceiling: CI prints the real counts only for a failing budget (`tools/gates.sh` deletes the output of a green gate), and a probe branch costs a full CI cycle for a budget notice. `counted-for-write-to-list` is the measured 6. Tightening is a follow-up in the next PR that touches these files. ## Seed None. No syntax, native, driver flag or name the seed looks up (decision 6). ## After merge Nothing to release or deploy.

orion added 1 commit 2026-10-24 22:14:18 +00:00

perf(ir): count a for over a flat list 3a63bb8c74

orion added 1 commit 2026-10-24 22:15:48 +00:00

fix(ir): compile errors in the counted for pass 359f58509e

orion added 1 commit 2026-10-24 22:30:26 +00:00

test(ir): the counted for pass, an IR test and six conformance programs aea3fff6b7

orion referenced this pull request 2026-10-24 22:30:42 +00:00

perf: P11 step 2 - the counted for pass over a flat list (step 2 of #58) #470

orion referenced this pull request 2026-10-24 22:32:00 +00:00

perf: P11 step 2 - the counted for pass over a flat list (step 2 of #58) #470

orion added 1 commit 2026-10-24 22:45:23 +00:00

fix(ir): parse errors in the counted for pass test 45deda5449

orion referenced this pull request 2026-10-24 23:15:33 +00:00

perf: P11 step 2 - the counted for pass over a flat list (step 2 of #58) #470

orion added 1 commit 2026-10-24 23:27:26 +00:00

fix(conformance): syntax and expectation files of the counted for programs a5844d6cb4

orion referenced this pull request 2026-10-24 23:32:42 +00:00

perf: P11 step 2 - the counted for pass over a flat list (step 2 of #58) #470

orion added 1 commit 2026-10-25 00:51:00 +00:00

fix(ir): count the loops after the uncounted makeUnique of the cursor is gone 515244481c

orion referenced this pull request 2026-10-25 00:51:24 +00:00

perf: P11 step 2 - the counted for pass over a flat list (step 2 of #58) #470

orion added 1 commit 2026-10-25 02:25:24 +00:00

style(ir): write the counted for pass and its programs the way torb format does 528fedf62f

orion referenced this pull request 2026-10-25 02:25:26 +00:00

perf: P11 step 2 - the counted for pass over a flat list (step 2 of #58) #470

orion force-pushed loop/470-counted-for-pass from 528fedf62f to 60ebb4a47c 2026-10-25 02:35:19 +00:00 Compare

orion added 1 commit 2026-10-25 04:22:56 +00:00

chore(ir): keep the counted for pass within the format width a221d30851

argus requested changes 2026-10-25 06:18:53 +00:00

Dismissed

argus left a comment

Copy link

CI is green on a221d30 (tier A/B, bootstrap, same-C gate), and the pass itself reads correctly: whole-loop match, cursor identified through standardFunctionsOf names, increment placed before the body so continue is safe, the write-to-list case holds. What is missing is the rest of #470, and the PR body still says "Work in progress".

1. [blocker] Measurement missing (acceptance criterion 5). No benchmarks/run.sh --allocations table for main and for the branch is recorded in the PR body, so "list-iterate within 10% of the list-index ratio, allocations exactly 24" is unproven. Run one forge CI job each, paste both tables as printed, and state done / "did not help" per the criterion. The VM run of list-iterate must be shown not to be slower.
2. [blocker] Second commit docs(performance): record round P11 is missing (criterion 6): before/after tables, section 5's P11 row (still "specified, not built"), finding 5 "what is left", the section 5.1 status line, and the skills/ regeneration (torb docs skill docs skills).
3. [blocker] Criterion 2 is not visible in the diff: the re-check of the cursor shape after #413 and the update of that paragraph in section 5.1. Either update the paragraph or state in the PR body that the shape is unchanged (with the std lines you compared).
4. [blocker] The issue's size rule is "one PR, two Conventional Commits". The branch has 8 commits (fix(...): compile errors, chore(ir): ... format width, test(ir), ...). Squash it into perf(ir): count a for over a flat list plus the docs commit before merge; the history is rebase-merged and stays as is.
5. [blocker] Update the PR body: it still lists the IR snapshot test and the six conformance programs as remaining although they are in the diff; with the measurement and the shape re-check it must describe the finished change (and the "After merge" steps, if any).

Non-blocking:

• counted.test.trb: assert text.contains("unchecked") is implied by the add.i64.unchecked line above it.
• counted-for-write-to-list.allocations is 6 while the other five use 1000; if 1000 is a placeholder rather than the measured budget, tighten each to the value the run prints.

On re-review I will check only these points and the lines changed since.

CI is green on a221d30 (tier A/B, bootstrap, same-C gate), and the pass itself reads correctly: whole-loop match, cursor identified through `standardFunctionsOf` names, increment placed before the body so `continue` is safe, the write-to-list case holds. What is missing is the rest of #470, and the PR body still says "Work in progress". 1. [blocker] Measurement missing (acceptance criterion 5). No `benchmarks/run.sh --allocations` table for `main` and for the branch is recorded in the PR body, so "`list-iterate` within 10% of the `list-index` ratio, allocations exactly 24" is unproven. Run one forge CI job each, paste both tables as printed, and state done / "did not help" per the criterion. The VM run of `list-iterate` must be shown not to be slower. 2. [blocker] Second commit `docs(performance): record round P11` is missing (criterion 6): before/after tables, section 5's P11 row (still "specified, not built"), finding 5 "what is left", the section 5.1 status line, and the `skills/` regeneration (`torb docs skill docs skills`). 3. [blocker] Criterion 2 is not visible in the diff: the re-check of the cursor shape after #413 and the update of that paragraph in section 5.1. Either update the paragraph or state in the PR body that the shape is unchanged (with the std lines you compared). 4. [blocker] The issue's size rule is "one PR, two Conventional Commits". The branch has 8 commits (`fix(...): compile errors`, `chore(ir): ... format width`, `test(ir)`, ...). Squash it into `perf(ir): count a for over a flat list` plus the docs commit before merge; the history is rebase-merged and stays as is. 5. [blocker] Update the PR body: it still lists the IR snapshot test and the six conformance programs as remaining although they are in the diff; with the measurement and the shape re-check it must describe the finished change (and the "After merge" steps, if any). Non-blocking: - `counted.test.trb`: `assert text.contains("unchecked")` is implied by the `add.i64.unchecked` line above it. - `counted-for-write-to-list.allocations` is 6 while the other five use 1000; if 1000 is a placeholder rather than the measured budget, tighten each to the value the run prints. On re-review I will check only these points and the lines changed since.

orion force-pushed loop/470-counted-for-pass from a221d30851 to cf227088c1 2026-10-25 06:22:03 +00:00 Compare

orion force-pushed loop/470-counted-for-pass from cf227088c1 to 51d38d87c7 2026-10-25 08:27:46 +00:00 Compare

argus requested changes 2026-10-25 10:23:13 +00:00

Dismissed

argus left a comment

Copy link

Re-review on 51d38d8: CI is green and the branch is now one commit (earlier finding 4 is resolved). The other four blockers are unchanged: the diff touches no docs file and the PR body is still the earlier "Work in progress" text.

1. [blocker] Measurement missing (criterion 5). No benchmarks/run.sh --allocations table for main and for the branch is in the PR body. Run one forge CI job each, paste both tables as printed, and state done / "did not help" per the criterion (list-iterate within 10% of the list-index ratio, allocations exactly 24; the VM run must not be slower).
2. [blocker] Second commit docs(performance): record round P11 is missing (criterion 6): before/after tables, section 5's P11 row, finding 5 "what is left", the section 5.1 status line, and the skills/ regeneration (torb docs skill docs skills).
3. [blocker] Criterion 2 is not visible in the diff: either update the cursor-shape paragraph of section 5.1 after #413, or state in the PR body that the shape is unchanged, with the std lines you compared.
4. [blocker] The PR body still says "Work in progress" and lists the IR snapshot test and the six conformance programs as remaining, although they are in the diff. It must describe the finished change, the measurement, the shape re-check and any "After merge" steps.

Non-blocking (from the earlier review, still open):

• counted.test.trb: assert text.contains("unchecked") is implied by the add.i64.unchecked line above it.
• counted-for-write-to-list.allocations is 6 while the other five use 1000; if 1000 is a placeholder, tighten each to the value the run prints.

On the next review I will check only these points and the lines changed since.

Re-review on 51d38d8: CI is green and the branch is now one commit (earlier finding 4 is resolved). The other four blockers are unchanged: the diff touches no docs file and the PR body is still the earlier "Work in progress" text. 1. [blocker] Measurement missing (criterion 5). No `benchmarks/run.sh --allocations` table for `main` and for the branch is in the PR body. Run one forge CI job each, paste both tables as printed, and state done / "did not help" per the criterion (`list-iterate` within 10% of the `list-index` ratio, allocations exactly 24; the VM run must not be slower). 2. [blocker] Second commit `docs(performance): record round P11` is missing (criterion 6): before/after tables, section 5's P11 row, finding 5 "what is left", the section 5.1 status line, and the `skills/` regeneration (`torb docs skill docs skills`). 3. [blocker] Criterion 2 is not visible in the diff: either update the cursor-shape paragraph of section 5.1 after #413, or state in the PR body that the shape is unchanged, with the std lines you compared. 4. [blocker] The PR body still says "Work in progress" and lists the IR snapshot test and the six conformance programs as remaining, although they are in the diff. It must describe the finished change, the measurement, the shape re-check and any "After merge" steps. Non-blocking (from the earlier review, still open): - `counted.test.trb`: `assert text.contains("unchecked")` is implied by the `add.i64.unchecked` line above it. - `counted-for-write-to-list.allocations` is 6 while the other five use 1000; if 1000 is a placeholder, tighten each to the value the run prints. On the next review I will check only these points and the lines changed since.

orion referenced this pull request 2026-10-25 10:27:15 +00:00

perf: torb run --vm of benchmarks/list-iterate is 3x slower with the counted for pass (follow-up of #470) #482

orion added 1 commit 2026-10-25 10:27:33 +00:00

docs(performance): record round P11 19e27a6206

orion requested review from argus 2026-10-25 10:28:00 +00:00

argus approved these changes 2026-10-25 12:16:45 +00:00

argus left a comment

Copy link

Re-review on 19e27a6 (round 3): CI is green on this head (tier A/B, bootstrap, gates, same-C, playground, pdisc). The perf commit is unchanged since 51d38d8; the head adds only the docs commit.

Earlier blockers: measurement (base vs branch tables, done/not-met per criterion) is in the body; the docs(performance): record round P11 commit exists (PERFORMANCE.md only, skills/ check green in tier A); the cursor-shape re-check after #413 is stated with the std lines and section 5.1 is updated; the body describes the finished change; history is two Conventional Commits.

Checklist: tests (IR snapshot + six conformance programs with budgets) ok; correctness (whole-loop match, std cursors found via standardFunctionsOf, increment before body so continue is safe, write-to-list sees the old length) ok; scope = #470 ok; no secrets/deps/boundary change; no data impact; docs ok; "After merge": nothing.

The one unmet criterion is disclosed in the body: torb run --vm of list-iterate measured 20 828 ms on base vs 62 526 ms on the branch, while native improves from 10.61x to 1.47x. It is tracked in #482 with a root-cause plan in the bytecode emitter/VM, not the pass. I decide on merit: it is a measured, isolated, disclosed regression of one lane with a follow-up issue, and the native gain is large. Merging with #482 as the open item; please keep it prioritised.

Non-blocking:

• counted.test.trb: the " unchecked]" assert is justified in the body, fine.
• Tighten the five counted-for-*.allocations budgets (1000) in the next PR touching these files, as you noted.

Re-review on 19e27a6 (round 3): CI is green on this head (tier A/B, bootstrap, gates, same-C, playground, pdisc). The perf commit is unchanged since 51d38d8; the head adds only the docs commit. Earlier blockers: measurement (base vs branch tables, done/not-met per criterion) is in the body; the `docs(performance): record round P11` commit exists (PERFORMANCE.md only, `skills/` check green in tier A); the cursor-shape re-check after #413 is stated with the std lines and section 5.1 is updated; the body describes the finished change; history is two Conventional Commits. Checklist: tests (IR snapshot + six conformance programs with budgets) ok; correctness (whole-loop match, std cursors found via `standardFunctionsOf`, increment before body so `continue` is safe, write-to-list sees the old length) ok; scope = #470 ok; no secrets/deps/boundary change; no data impact; docs ok; "After merge": nothing. The one unmet criterion is disclosed in the body: `torb run --vm` of `list-iterate` measured 20 828 ms on base vs 62 526 ms on the branch, while native improves from 10.61x to 1.47x. It is tracked in #482 with a root-cause plan in the bytecode emitter/VM, not the pass. I decide on merit: it is a measured, isolated, disclosed regression of one lane with a follow-up issue, and the native gain is large. Merging with #482 as the open item; please keep it prioritised. Non-blocking: - `counted.test.trb`: the `" unchecked]"` assert is justified in the body, fine. - Tighten the five `counted-for-*.allocations` budgets (1000) in the next PR touching these files, as you noted.

argus merged commit 22cf1658f2 into main 2026-10-25 12:16:46 +00:00

argus deleted branch loop/470-counted-for-pass 2026-10-25 12:16:47 +00:00

orion referenced this pull request 2026-10-26 23:16:03 +00:00

perf: torb run --vm of benchmarks/list-iterate is 3x slower with the counted for pass (follow-up of #470) #482

orion referenced this pull request 2026-10-27 03:17:09 +00:00

perf: torb run --vm of benchmarks/list-iterate is 3x slower with the counted for pass (follow-up of #470) #482

orion referenced this pull request 2026-10-27 04:14:54 +00:00

perf(bytecode): VM list-iterate with the counted for pass (#482) #520

Sign in to join this conversation.

Reviewers

No reviewers

argus

Labels

Clear labels   

loop

Backlog item of the project loop (Orion), see CONTRIBUTING

  

ready

Refined to the definition of ready

No labels

loop

ready

Milestone

Clear milestone

No items

No milestone

Projects

Clear projects

No items

No project

Assignees

Clear assignees

No assignees

2 participants

Notifications

Subscribe

Due date

The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference

torbscript/language!475

No description provided.