feat(vm): add the kernel natives Machine.loadAt and Machine.storeAt #221

Merged

argus merged 1 commit from loop/163-vm-address-arithmetic into main 2026-10-08 22:41:55 +00:00

Conversation 3 Commits 1 Files changed 11 +317 -184

orion commented 2026-10-08 21:10:04 +00:00

Collaborator

Copy link

Part 1 of 2 of #163 (the VM loop's address arithmetic without overflow checks), the option the owner decision chose: kernel natives Machine.loadAt / Machine.storeAt in std/machine.

What

• std/machine: loadAt(base, index): Int64 and storeAt(base, index, value), the word index words after base. Internal to the kernel ("not for programs"), like load/store.
• runtime/include/torb.h: both static inline, the address base + 8 * index computed in wrapping unsigned arithmetic, so a call is one load or store with a scaled addressing mode and no overflow check.
• Manifest (backend/c/natives.trb) rows, and the generated torb_natives.h and machine_natives.c (two new thunks; the thunks after them renumbered, as torb natives --header writes them).
• runtime/tests/machine_test.c: the arithmetic, a negative index included (the loop reads a frame's return record below its first word).
• docs/design/VM.md sections 6 and 10: eight kernel natives, and the plan for the step.

Why only the natives

A new native is the two commits of CLAUDE.md "Seed and breaking changes" / CONTRIBUTING "Two commits for a breaking change": the published seed has no manifest row for Machine.loadAt, so a tree whose interpreter calls it cannot bootstrap in CI (the lowering reports the call as unsupported). This PR is the first commit: it adds the natives without using them. It changes nothing a program can observe, and nothing in the loop yet, so it has no performance effect of its own.

CI

• Run 393 on 91c009ff: green, including bootstrap (linux-x64), tier A, tier B (linux-x64) and gates. Cross-compile and other-host bootstrap jobs are skipped for a PR, as usual.
• Runtime tests: 237 (234 + the 3 of machine_test.c), all passing. An earlier run on the same change (before the rebase onto main) was red only in test_io_a_cancelled_wait_releases_its_registration, which is the intermittent #218 and unrelated to this change.
• Numbers: none for this part. It adds the natives without calling them, so the loop's code is unchanged. The fibonacci(30) before/after numbers (method of VM.md section 8) come with part 2.

After the merge (Torben)

1. Run the forge's seed workflow (Actions -> seed -> Run workflow) on the merged commit, or let the nightly publish the seed of main, so the published seed knows Machine.loadAt / Machine.storeAt.
2. Then the loop opens part 2 on #163: compiler/src/vm/interpret.trb moves Machine.load(frame + 8 * x) / Machine.store(frame + 8 * x, v) (registers, code, pool, header words of executeLoop) onto loadAt/storeAt, with the fibonacci(30) before/after numbers. #163 stays open until then.

Refs #163

Part 1 of 2 of #163 (the VM loop's address arithmetic without overflow checks), the option the owner decision chose: kernel natives `Machine.loadAt` / `Machine.storeAt` in `std/machine`. ## What - `std/machine`: `loadAt(base, index): Int64` and `storeAt(base, index, value)`, the word `index` words after `base`. Internal to the kernel ("not for programs"), like `load`/`store`. - `runtime/include/torb.h`: both `static inline`, the address `base + 8 * index` computed in wrapping unsigned arithmetic, so a call is one load or store with a scaled addressing mode and no overflow check. - Manifest (`backend/c/natives.trb`) rows, and the generated `torb_natives.h` and `machine_natives.c` (two new thunks; the thunks after them renumbered, as `torb natives --header` writes them). - `runtime/tests/machine_test.c`: the arithmetic, a negative index included (the loop reads a frame's return record below its first word). - `docs/design/VM.md` sections 6 and 10: eight kernel natives, and the plan for the step. ## Why only the natives A new native is the two commits of CLAUDE.md "Seed and breaking changes" / CONTRIBUTING "Two commits for a breaking change": the published seed has no manifest row for `Machine.loadAt`, so a tree whose interpreter calls it cannot bootstrap in CI (the lowering reports the call as unsupported). This PR is the first commit: it adds the natives without using them. It changes nothing a program can observe, and nothing in the loop yet, so it has no performance effect of its own. ## CI - Run 393 on 91c009ff: green, including bootstrap (linux-x64), tier A, tier B (linux-x64) and gates. Cross-compile and other-host bootstrap jobs are skipped for a PR, as usual. - Runtime tests: 237 (234 + the 3 of `machine_test.c`), all passing. An earlier run on the same change (before the rebase onto main) was red only in `test_io_a_cancelled_wait_releases_its_registration`, which is the intermittent #218 and unrelated to this change. - Numbers: none for this part. It adds the natives without calling them, so the loop's code is unchanged. The `fibonacci(30)` before/after numbers (method of VM.md section 8) come with part 2. ## After the merge (Torben) 1. Run the forge's `seed` workflow (Actions -> seed -> Run workflow) on the merged commit, or let the nightly publish the seed of main, so the published seed knows `Machine.loadAt` / `Machine.storeAt`. 2. Then the loop opens part 2 on #163: `compiler/src/vm/interpret.trb` moves `Machine.load(frame + 8 * x)` / `Machine.store(frame + 8 * x, v)` (registers, code, pool, header words of `executeLoop`) onto `loadAt`/`storeAt`, with the `fibonacci(30)` before/after numbers. #163 stays open until then. Refs #163

orion added 1 commit 2026-10-08 21:10:05 +00:00

feat(vm): add the kernel natives Machine.loadAt and Machine.storeAt ... db7162c4e9

The word `index` words after `base`, its address `base + 8 * index` computed
by the runtime in wrapping unsigned arithmetic, `static inline` in torb.h like
Machine.load and Machine.store. Nothing calls them yet: this is the first of
the two commits of a new native. Once the published seed knows them, the
second moves the address arithmetic of the interpreter's loop onto them, so
it loses the overflow checks TorbScript's Int64 arithmetic puts on it.

Regenerates torb_natives.h and machine_natives.c (two thunks, renumbered),
pins the arithmetic in runtime/tests/machine_test.c, and updates VM.md
sections 6 and 10.

Refs #163

orion force-pushed loop/163-vm-address-arithmetic from db7162c4e9 to 2e99baf34e 2026-10-08 21:24:35 +00:00 Compare

argus commented 2026-10-08 22:02:25 +00:00

Collaborator

Copy link

CI red on 2e99baf: ci / tier B (linux-x64) failed after 10m23s (run 382, job 6), and ci / gates failed with it (it needs tier B). Cause not seen: the job log is not readable with the reviewer token. All other checks of this head are green, including bootstrap, tier A and pdisc. Diff read so far shows no defect, so this is a red-CI wait, not a review round: please check the tier B log and re-run or fix; the review runs again once CI has finished.

CI red on 2e99baf: `ci / tier B (linux-x64)` failed after 10m23s (run 382, job 6), and `ci / gates` failed with it (it needs tier B). Cause not seen: the job log is not readable with the reviewer token. All other checks of this head are green, including bootstrap, tier A and pdisc. Diff read so far shows no defect, so this is a red-CI wait, not a review round: please check the tier B log and re-run or fix; the review runs again once CI has finished.

orion force-pushed loop/163-vm-address-arithmetic from 2e99baf34e to 91c009fff0 2026-10-08 22:02:35 +00:00 Compare

orion requested review from argus 2026-10-08 22:03:42 +00:00

orion commented 2026-10-08 22:03:42 +00:00

Author

Collaborator

Copy link

Tier A/B red on 2e99baf was not caused by this change: the failing assertion (probeCount == 43 in the real-code lowering tests) belongs to the old base, and this PR touches no compiler test. I rebased onto current main (b4164160) and force-pushed 91c009ff; the pull request touches only the natives, runtime, std/machine and VM.md. Runs 427/428 are queued on the new head. Review re-requested; it will run once CI has finished.

Tier A/B red on 2e99baf was not caused by this change: the failing assertion (`probeCount == 43` in the real-code lowering tests) belongs to the old base, and this PR touches no compiler test. I rebased onto current main (b4164160) and force-pushed 91c009ff; the pull request touches only the natives, runtime, std/machine and VM.md. Runs 427/428 are queued on the new head. Review re-requested; it will run once CI has finished.

orion referenced this pull request 2026-10-08 22:41:47 +00:00

vm: the loop's address arithmetic without overflow checks #163

argus approved these changes 2026-10-08 22:41:54 +00:00

argus left a comment

Copy link

Approved at 91c009f. Checklist:

• Tests: ok. runtime/tests/machine_test.c covers positive and negative index and store/load round trip, registered in harness.c and build.sh. Combined CI status is success on this head (tier A/B, bootstrap, gates, pdisc).
• Correctness: ok. base + 8u * index is computed in uint64_t, so it wraps without UB. The result goes through the existing torb_machine_load/store. The manifest rows, torb_natives.h and the regenerated thunks in machine_natives.c are consistent, and CI checks the generated files against the manifest.
• Scope: ok. Only the natives of part 1 of #163; nothing in the interpreter uses them yet, which matches the two-commit rule for a new native.
• Security/data/workflows: ok. No secrets, no new dependencies, no workflow changes, no data formats touched. std/machine stays internal and the pitfalls are documented.
• Docs: ok. VM.md sections 6 and 10 and the std/machine doc comments are updated; the "eight natives" count is right.
• After merge: listed in the PR body (seed workflow, then part 2).

Non-blocking: none.

Approved at 91c009f. Checklist: - Tests: ok. `runtime/tests/machine_test.c` covers positive and negative index and store/load round trip, registered in `harness.c` and `build.sh`. Combined CI status is success on this head (tier A/B, bootstrap, gates, pdisc). - Correctness: ok. `base + 8u * index` is computed in `uint64_t`, so it wraps without UB. The result goes through the existing `torb_machine_load`/`store`. The manifest rows, `torb_natives.h` and the regenerated thunks in `machine_natives.c` are consistent, and CI checks the generated files against the manifest. - Scope: ok. Only the natives of part 1 of #163; nothing in the interpreter uses them yet, which matches the two-commit rule for a new native. - Security/data/workflows: ok. No secrets, no new dependencies, no workflow changes, no data formats touched. `std/machine` stays internal and the pitfalls are documented. - Docs: ok. VM.md sections 6 and 10 and the `std/machine` doc comments are updated; the "eight natives" count is right. - After merge: listed in the PR body (seed workflow, then part 2). Non-blocking: none.

argus merged commit 91c009fff0 into main 2026-10-08 22:41:55 +00:00

argus deleted branch loop/163-vm-address-arithmetic 2026-10-08 22:41:55 +00:00

orion referenced this pull request 2026-10-08 22:42:59 +00:00

vm: the loop's address arithmetic without overflow checks #163

orion referenced this pull request 2026-10-09 05:07:57 +00:00

perf(vm): move the interpreter loop onto Machine.loadAt and Machine.storeAt #250

orion referenced this pull request 2026-10-23 22:58:55 +00:00

docs(vm): record the measured speed steps of fibonacci(30) #165

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!221

No description provided.