wai-quantum: energy-landscape jobs on a GPU, through WebGPU, CUDA and Metal, each member certified by the host #672

Merged

dcharlot merged 5 commits from wai/quantum-landscape-gpu into main 2026-11-07 01:28:30 -05:00

Conversation 0 Commits 5 Files changed 31 +47297 -3104

dcharlot commented 2026-11-06 08:21:14 -05:00

Owner

Copy link

The energy-landscape job's kernels on GPUs, as members the host certifies and checks like any other, on top of #664, which has landed. The second commit answers the review of #672 (35 findings), with tests for each fix. Main is merged in.

What is here

• Three GPU members of wai_quantum::quantum_landscape, each behind a feature:
  • webgpu (quantum_landscape_webgpu): Metal, Vulkan or DX12 through WebGPU, in 32-bit lanes. It declines a workload whose field bound is above 2³¹ − 1, and holds a cost above every field at its lanes' top. Its coloured kernel moves a colour class of cells at once.
  • cuda (quantum_landscape_cuda) and metal (quantum_landscape_metal): 64-bit fields, so they take every workload.
  • Every member runs the settle kernel one thread a cell, a dispatch a sweep; and the sampling kernel one thread a chain, its cells in the reference's order, the reference's draws, and the host's cut points for the fields the cells can reach, a window of sweeps a dispatch, each window waited for before the next is sent.
• One decline rule (extensions/quantum-landscape.md §5). A workload's field bound is the largest field any state can give a cell, max_i (|b_i| + deg_i) (§4.1). A member may decline a workload only where that is above 2³¹ − 1; the host never runs it on one it declines, however it is reached; the reference declines nothing.
• Placing a job (job::call_placed): the first member that is certified for every kernel the job runs, takes the workload and gives an answer the host's checks keep. Each member passed over, for any of those, is named under refusals with why, and the next is asked. Every answer says who ran it at what parity: a run its kernel's, a replay its member and kernel, a sweep and a compare each kernel they used.
• The budget holds a device's work. A sweep's table of cut points holds what the cells can reach (reach.rs), at most 4P + n entries however wide the fields, and a job counts it in its operations and its bytes (§2.0). The review's job that asked for 4.19 million entries a sweep now has 6.
• The meter bridge wai::sink_meter::RunCounter, in wai-rs, which sees both crates, so wai-quantum takes no dependency on wai-rs. It reads the counter through each call on a thread of its own and gives a figure only from a window in which the counter was live (energy-measurement §3.1: the same Liveness test CounterMeter applies) and which lasted the profile's minimum. The figure is labelled OnChipCounter: the operator's declared uncertainty, as CounterMeter takes it, combined with the register's step and the counter's measured refresh at each edge. NVML is metered only through RunCounter::nvml, which holds the counter to §9.3's plausibility itself and every window to 1.5 times the power limit. What it covers is said in the answer: joules.metered.scope (the whole rail or board, its idle draw and any other work on the device in the window, no share attributed to the run), with the window summed over a run's calls; the label claims a reading only in an answer that has one.
• The conformance set reaches what large jobs reach (§7): settles past a workgroup of cells and past a batch of sweeps; chains held hot to their last sweep, at the seeds where a 32-bit port of the generator first goes wrong, past a workgroup of chains, across a device's windows by table and by work; fields that only their full width tells apart; field bounds at 2³¹ − 1 and just past it by the couplings. A draws part pins the generator. The battery adds a ring of six, eight triangles side by side, a walked law that a schedule's end alone does not give, and fields past 16 and 32 bits.
• wai-quantum-landscape-devices.yml declares each host's members (WAI_LANDSCAPE_EXPECT): one missing, or whose kernels no longer compile, fails its leg with why. It reads the certificates from a report file rather than test output, runs the members' unit tests, holds the timings' bits, and keeps the Mac's target in the job's workspace on its external volume. Its path filters take the fabric code the members use.

Parity, found by member::certify on each device

The Mac Studio rows are from this head, main merged in. The framework-128gb rows are from 0675813de with the Radeon's expected name fixed, before the merge: that host's disk was under rb's floor afterwards. Main changed none of the landscape sources.

Host	Member	Settle	Sample
Mac Studio	Apple M3 Ultra through Metal	bit-exact	bit-exact
Mac Studio	Apple M3 Ultra through WebGPU on Metal	bit-exact	bit-exact; coloured: statistical
framework-128gb	Radeon 8060S (RADV) through Vulkan	bit-exact	bit-exact; coloured: statistical
framework-128gb	the software Vulkan driver, llvmpipe (class cpu)	bit-exact	bit-exact; coloured: statistical

Each device also passed the other device tests: every worked example at three temperatures over 50 seeds gives the reference's bits; jobs past every window and workgroup (a settle of 4096 cells, 600 sweeps of 1024 cells, wide fields with every window hot, more chains than a batch) give the reference's state, energy, verdict, work and replay digest from the device; a workload past 32 bits goes from WebGPU to the reference with the refusal named and is taken by Metal; a WebGPU wait covers one window (40 windows in 8.49 s with one wait at most 2.13 s on the M3 Ultra, in 5.66 s with at most 1.62 s on the Radeon, in 1.45 s with at most 0.31 s on llvmpipe), and a job the member cannot finish in its wait goes to the reference with the refusal named.

CUDA is not run at this head. jetson-hub is the only host with a CUDA device here, and its laptop GPU (NVIDIA GeForce RTX 4050 Laptop GPU) is off its bus (nvidia-smi: "Unable to determine the device handle … Unknown Error"). I did not run its leg. In CI that leg declares the CUDA member and the GPU through Vulkan, so it fails, naming them, until the card is back: it cannot read as a pass. The CUDA rows of the first version came from a run before the last tidy commit of the first version. The CUDA kernels' text gets the same edits as Metal's, and their compile test (cuda::tests) runs wherever the runtime compiler is, card or not. Thor's linux-arm64-hw runner, which wai-quantum-cuda.yml already uses, would give CUDA a second leg; that is the owner's call, so it is not added here.

Faults put into the kernels on a device, and the grade each left

The test every_fault_in_a_device_s_kernels_loses_its_grade puts each fault into the real kernel text (discover_with), certifies the faulted member on the device, and asserts the faulted kernel is not bit-exact. On the Mac Studio's M3 Ultra:

Fault	Member	Settle	Sample
a dropped carry in a 32 by 32 product	WebGPU on Metal	bit-exact	statistical
a draw compared with a cut point by its high word	WebGPU on Metal	bit-exact	statistical
settle fields held in 16 bits	WebGPU on Metal	uncertified	bit-exact
sampled fields held in 16 bits	WebGPU on Metal	bit-exact	uncertified
fields held in 32 bits	Metal	uncertified	uncertified
a draw counter that starts again at each window	both	bit-exact	statistical
cells taken last to first	both	bit-exact	statistical
a settle whose cells past one workgroup never move	both	uncertified	bit-exact

On framework-128gb, through WebGPU on Vulkan, every WGSL fault left the same grades on the Radeon 8060S and on llvmpipe as on the M3 Ultra: the 16-bit settle and sampled-field faults and the workgroup settle fault uncertified in their kernel; the dropped carry, the high-word compare, the per-window counter and cells last to first statistical.

Every fault costs its kernel bit-exact. Where one keeps statistical, this is why:

• the dropped carry and the high-word compare leave a sampler with draws that are not the reference's, which is what statistical grants; the vectors catch both bit for bit;
• cells last to first are a correct sampler in another order;
• the per-window draw counter keeps statistical only because no battery workload is long enough to cross a device's window, so the battery holds a sampler to its law inside one window and no further. The vectors catch it bit for bit. Closing it in the battery needs a workload whose exact law is known and whose schedule crosses every member's windows, which depends on each member's window; it is not done here.

The CPU stand-ins in tests/landscape_conformance.rs hold the same faults, and more (a check of the fields that forgets the couplings, a run that stops after one window, chains past the first 64 left alone, a settle that reports its end a sweep late, a member that declines below the line), against the vectors on every platform.

Timings, wall-clock, each the middle of three runs, the bits asserted

The hosts are shared; the load is the host's one-minute load average over its cores during the run.

Mac Studio, Apple M3 Ultra, load 23–25 on 32 cores, no other GPU job	CPU reference, one thread	WebGPU on Metal	Metal
4096 chains, 256 cells, 40 sweeps	0.287 s	0.019 s	0.011 s
4096 chains, 1024 cells, 40 sweeps	0.941 s	0.092 s	0.060 s
1024 chains, 4096 cells, 40 sweeps	1.091 s	0.627 s	0.485 s
settle, 4096 cells, 59 sweeps	0.006 s	0.006 s	0.002 s
replay of the talks, 2,000 seeds	0.193 s	0.053 s	0.049 s

framework-128gb, load 67–87 on 32 cores, before main was merged in	CPU reference, one thread	Radeon 8060S through Vulkan	llvmpipe through Vulkan
4096 chains, 256 cells, 40 sweeps	0.493 s	0.066 s	0.227 s
4096 chains, 1024 cells, 40 sweeps	1.575 s	0.301 s	0.654 s
1024 chains, 4096 cells, 40 sweeps	1.552 s	0.712 s	1.170 s
settle, 4096 cells, 59 sweeps	0.008 s	0.010 s	0.117 s
replay of the talks, 2,000 seeds	0.300 s	0.081 s	0.231 s

A settle of 1,024 cells (43 sweeps) took 0.001 s on the CPU and on Metal and 0.005 s through WebGPU on the Mac, and 0.002 s on the CPU against 0.019 s on the Radeon: too little work for a dispatch a sweep.

The meter

On the Mac Studio, the Metal member metered by IOReport's GPU channel through RunCounter ran 1,024 chains of 4,096 cells for 400 sweeps in 4.92 s and read 53,584,622 µJ over a live window of 4,900,878 µs, labelled OnChipCounter, filtering Unknown, 100,035 ppm: the hand run's declared 100,000 ppm, a coarse choice and not an evaluation of the counter's own error, with the meter's own terms. Its scope, as the answer gives it: "the graphics processor's whole rail as IOReport's GPU Energy channel reports it, over the windows of this run's calls: this run's work, the rail's idle draw and any other work on the graphics processor in those windows, with no share attributed to this run". The host's load was about 94 on 32 cores, so the figure holds other work too. NVML was not run: jetson-hub's card is off its bus.

Checked

• Thor (Linux arm64, CPU only), this head: the landscape module 95 tests under full; landscape_conformance 12; the float read 1; the wai-rs meter tests 3; wai-quantum with full and every landscape feature, and wai-rs with sink_energy and the landscape features, each checked with its tests.
• framework-128gb (Linux x86-64), before the merge: the same module and conformance counts; wai-quantum under -D warnings with every landscape feature.
• Mac Studio (Apple M3 Ultra), this head: the members' unit tests 8; landscape_devices 7 and the timings 1, with WAI_LANDSCAPE_EXPECT=gpu:metal.apple-m3-ultra,gpu:wgpu-metal.apple-m3-ultra. The hand-run meter test 1, before the merge.
• framework-128gb (Radeon 8060S and llvmpipe), before the merge: the members' unit tests 8; landscape_devices 7 and the timings 1, with WAI_LANDSCAPE_EXPECT=gpu:wgpu-vulkan.radeon,cpu:wgpu-vulkan.llvmpipe. The first run of it found that the workflow declared this host's GPU as gpu:wgpu-vulkan.amd, while its adapter names itself "Radeon 8060S Graphics (RADV STRIX_HALO)"; the leg failed, naming the member it did not find, which is what the declaration is for. It now declares gpu:wgpu-vulkan.radeon. The same run found the coloured kernel's id cut off its device's hex on a long adapter name; it now keeps it (a_coloured_id_keeps_its_device_s_hex).
• wasip2, this head: 94 passed under wasmtime 50.0.1 on the iMac Pro, the workflow's command and settings: the native 95 less the_classes_are_the_fabric_s, which needs quantum_fabric.
• Repository checks: names (no hit in the changed files), spec references, section references, vanity metrics, comparative prose, workflow concurrency, changelog, wasmtime pin, tests in CI, orphan sources, main's wai.quantum names, operation doors and corpus licences, and the lockfiles (62, all current, on Thor).
• The workflows' pins: the module 95 (wasip2 94), conformance 12, the members' unit tests 9, 8 and 8, the device tests 7.

Beside the landscape

Merging main showed that engine::job's test a_host_never_seals_what_its_verifier_refuses calls qec with no feature gate, so the library's tests did not compile for quantum_engine,quantum_receipt, the feature set of this workflow's wasip2 job. It is gated on quantum_qec here, one line. full holds that feature, so nothing that ran it stops running it.

The two kernel labels are on main already, from #664's landing.

🤖 Generated with Claude Code

The energy-landscape job's kernels on GPUs, as members the host certifies and checks like any other, on top of #664, which has landed. The second commit answers the review of #672 (35 findings), with tests for each fix. Main is merged in. ## What is here - **Three GPU members** of `wai_quantum::quantum_landscape`, each behind a feature: - `webgpu` (`quantum_landscape_webgpu`): Metal, Vulkan or DX12 through WebGPU, in 32-bit lanes. It declines a workload whose field bound is above 2³¹ − 1, and holds a cost above every field at its lanes' top. Its coloured kernel moves a colour class of cells at once. - `cuda` (`quantum_landscape_cuda`) and `metal` (`quantum_landscape_metal`): 64-bit fields, so they take every workload. - Every member runs the settle kernel one thread a cell, a dispatch a sweep; and the sampling kernel one thread a chain, its cells in the reference's order, the reference's draws, and the host's cut points for the fields the cells can reach, a window of sweeps a dispatch, each window waited for before the next is sent. - **One decline rule** (`extensions/quantum-landscape.md` §5). A workload's field bound is the largest field any state can give a cell, `max_i (|b_i| + deg_i)` (§4.1). A member may decline a workload only where that is above 2³¹ − 1; the host never runs it on one it declines, however it is reached; the reference declines nothing. - **Placing a job** (`job::call_placed`): the first member that is certified for every kernel the job runs, takes the workload and gives an answer the host's checks keep. Each member passed over, for any of those, is named under `refusals` with why, and the next is asked. Every answer says who ran it at what parity: a `run` its kernel's, a `replay` its member and kernel, a `sweep` and a `compare` each kernel they used. - **The budget holds a device's work.** A sweep's table of cut points holds what the cells can reach (`reach.rs`), at most `4P + n` entries however wide the fields, and a job counts it in its operations and its bytes (§2.0). The review's job that asked for 4.19 million entries a sweep now has 6. - **The meter bridge** `wai::sink_meter::RunCounter`, in `wai-rs`, which sees both crates, so `wai-quantum` takes no dependency on `wai-rs`. It reads the counter through each call on a thread of its own and gives a figure only from a window in which the counter was live (energy-measurement §3.1: the same `Liveness` test `CounterMeter` applies) and which lasted the profile's minimum. The figure is labelled `OnChipCounter`: the operator's declared uncertainty, as `CounterMeter` takes it, combined with the register's step and the counter's measured refresh at each edge. NVML is metered only through `RunCounter::nvml`, which holds the counter to §9.3's plausibility itself and every window to 1.5 times the power limit. **What it covers is said in the answer**: `joules.metered.scope` (the whole rail or board, its idle draw and any other work on the device in the window, no share attributed to the run), with the window summed over a run's calls; the `label` claims a reading only in an answer that has one. - **The conformance set reaches what large jobs reach** (§7): settles past a workgroup of cells and past a batch of sweeps; chains held hot to their last sweep, at the seeds where a 32-bit port of the generator first goes wrong, past a workgroup of chains, across a device's windows by table and by work; fields that only their full width tells apart; field bounds at 2³¹ − 1 and just past it by the couplings. A `draws` part pins the generator. The battery adds a ring of six, eight triangles side by side, a walked law that a schedule's end alone does not give, and fields past 16 and 32 bits. - **`wai-quantum-landscape-devices.yml`** declares each host's members (`WAI_LANDSCAPE_EXPECT`): one missing, or whose kernels no longer compile, fails its leg with why. It reads the certificates from a report file rather than test output, runs the members' unit tests, holds the timings' bits, and keeps the Mac's target in the job's workspace on its external volume. Its path filters take the fabric code the members use. ## Parity, found by `member::certify` on each device The Mac Studio rows are from this head, main merged in. The framework-128gb rows are from `0675813de` with the Radeon's expected name fixed, before the merge: that host's disk was under `rb`'s floor afterwards. Main changed none of the landscape sources. | Host | Member | Settle | Sample | |---|---|---|---| | Mac Studio | Apple M3 Ultra through Metal | bit-exact | bit-exact | | Mac Studio | Apple M3 Ultra through WebGPU on Metal | bit-exact | bit-exact; coloured: statistical | | framework-128gb | Radeon 8060S (RADV) through Vulkan | bit-exact | bit-exact; coloured: statistical | | framework-128gb | the software Vulkan driver, llvmpipe (class `cpu`) | bit-exact | bit-exact; coloured: statistical | Each device also passed the other device tests: every worked example at three temperatures over 50 seeds gives the reference's bits; jobs past every window and workgroup (a settle of 4096 cells, 600 sweeps of 1024 cells, wide fields with every window hot, more chains than a batch) give the reference's state, energy, verdict, work and replay digest from the device; a workload past 32 bits goes from WebGPU to the reference with the refusal named and is taken by Metal; a WebGPU wait covers one window (40 windows in 8.49 s with one wait at most 2.13 s on the M3 Ultra, in 5.66 s with at most 1.62 s on the Radeon, in 1.45 s with at most 0.31 s on llvmpipe), and a job the member cannot finish in its wait goes to the reference with the refusal named. **CUDA is not run at this head.** jetson-hub is the only host with a CUDA device here, and its laptop GPU (NVIDIA GeForce RTX 4050 Laptop GPU) is off its bus (`nvidia-smi`: "Unable to determine the device handle … Unknown Error"). I did not run its leg. In CI that leg declares the CUDA member and the GPU through Vulkan, so it fails, naming them, until the card is back: it cannot read as a pass. The CUDA rows of the first version came from a run before the last tidy commit of the first version. The CUDA kernels' text gets the same edits as Metal's, and their compile test (`cuda::tests`) runs wherever the runtime compiler is, card or not. Thor's `linux-arm64-hw` runner, which `wai-quantum-cuda.yml` already uses, would give CUDA a second leg; that is the owner's call, so it is not added here. ## Faults put into the kernels on a device, and the grade each left The test `every_fault_in_a_device_s_kernels_loses_its_grade` puts each fault into the real kernel text (`discover_with`), certifies the faulted member on the device, and asserts the faulted kernel is not `bit-exact`. On the Mac Studio's M3 Ultra: | Fault | Member | Settle | Sample | |---|---|---|---| | a dropped carry in a 32 by 32 product | WebGPU on Metal | bit-exact | statistical | | a draw compared with a cut point by its high word | WebGPU on Metal | bit-exact | statistical | | settle fields held in 16 bits | WebGPU on Metal | **uncertified** | bit-exact | | sampled fields held in 16 bits | WebGPU on Metal | bit-exact | **uncertified** | | fields held in 32 bits | Metal | **uncertified** | **uncertified** | | a draw counter that starts again at each window | both | bit-exact | statistical | | cells taken last to first | both | bit-exact | statistical | | a settle whose cells past one workgroup never move | both | **uncertified** | bit-exact | On framework-128gb, through WebGPU on Vulkan, every WGSL fault left the same grades on the Radeon 8060S and on llvmpipe as on the M3 Ultra: the 16-bit settle and sampled-field faults and the workgroup settle fault `uncertified` in their kernel; the dropped carry, the high-word compare, the per-window counter and cells last to first `statistical`. Every fault costs its kernel `bit-exact`. Where one keeps `statistical`, this is why: - the dropped carry and the high-word compare leave a sampler with draws that are not the reference's, which is what `statistical` grants; the vectors catch both bit for bit; - cells last to first are a correct sampler in another order; - **the per-window draw counter keeps `statistical` only because no battery workload is long enough to cross a device's window**, so the battery holds a sampler to its law inside one window and no further. The vectors catch it bit for bit. Closing it in the battery needs a workload whose exact law is known and whose schedule crosses every member's windows, which depends on each member's window; it is not done here. The CPU stand-ins in `tests/landscape_conformance.rs` hold the same faults, and more (a check of the fields that forgets the couplings, a run that stops after one window, chains past the first 64 left alone, a settle that reports its end a sweep late, a member that declines below the line), against the vectors on every platform. ## Timings, wall-clock, each the middle of three runs, the bits asserted The hosts are shared; the load is the host's one-minute load average over its cores during the run. | Mac Studio, Apple M3 Ultra, load 23–25 on 32 cores, no other GPU job | CPU reference, one thread | WebGPU on Metal | Metal | |---|---|---|---| | 4096 chains, 256 cells, 40 sweeps | 0.287 s | 0.019 s | 0.011 s | | 4096 chains, 1024 cells, 40 sweeps | 0.941 s | 0.092 s | 0.060 s | | 1024 chains, 4096 cells, 40 sweeps | 1.091 s | 0.627 s | 0.485 s | | settle, 4096 cells, 59 sweeps | 0.006 s | 0.006 s | 0.002 s | | replay of the talks, 2,000 seeds | 0.193 s | 0.053 s | 0.049 s | | framework-128gb, load 67–87 on 32 cores, before main was merged in | CPU reference, one thread | Radeon 8060S through Vulkan | llvmpipe through Vulkan | |---|---|---|---| | 4096 chains, 256 cells, 40 sweeps | 0.493 s | 0.066 s | 0.227 s | | 4096 chains, 1024 cells, 40 sweeps | 1.575 s | 0.301 s | 0.654 s | | 1024 chains, 4096 cells, 40 sweeps | 1.552 s | 0.712 s | 1.170 s | | settle, 4096 cells, 59 sweeps | 0.008 s | 0.010 s | 0.117 s | | replay of the talks, 2,000 seeds | 0.300 s | 0.081 s | 0.231 s | A settle of 1,024 cells (43 sweeps) took 0.001 s on the CPU and on Metal and 0.005 s through WebGPU on the Mac, and 0.002 s on the CPU against 0.019 s on the Radeon: too little work for a dispatch a sweep. ## The meter On the Mac Studio, the Metal member metered by IOReport's GPU channel through `RunCounter` ran 1,024 chains of 4,096 cells for 400 sweeps in 4.92 s and read 53,584,622 µJ over a live window of 4,900,878 µs, labelled `OnChipCounter`, filtering `Unknown`, 100,035 ppm: the hand run's declared 100,000 ppm, a coarse choice and not an evaluation of the counter's own error, with the meter's own terms. Its scope, as the answer gives it: "the graphics processor's whole rail as IOReport's GPU Energy channel reports it, over the windows of this run's calls: this run's work, the rail's idle draw and any other work on the graphics processor in those windows, with no share attributed to this run". The host's load was about 94 on 32 cores, so the figure holds other work too. NVML was not run: jetson-hub's card is off its bus. ## Checked - **Thor (Linux arm64, CPU only), this head:** the landscape module 95 tests under `full`; `landscape_conformance` 12; the float read 1; the `wai-rs` meter tests 3; `wai-quantum` with `full` and every landscape feature, and `wai-rs` with `sink_energy` and the landscape features, each checked with its tests. - **framework-128gb (Linux x86-64), before the merge:** the same module and conformance counts; `wai-quantum` under `-D warnings` with every landscape feature. - **Mac Studio (Apple M3 Ultra), this head:** the members' unit tests 8; `landscape_devices` 7 and the timings 1, with `WAI_LANDSCAPE_EXPECT=gpu:metal.apple-m3-ultra,gpu:wgpu-metal.apple-m3-ultra`. The hand-run meter test 1, before the merge. - **framework-128gb (Radeon 8060S and llvmpipe), before the merge:** the members' unit tests 8; `landscape_devices` 7 and the timings 1, with `WAI_LANDSCAPE_EXPECT=gpu:wgpu-vulkan.radeon,cpu:wgpu-vulkan.llvmpipe`. The first run of it found that the workflow declared this host's GPU as `gpu:wgpu-vulkan.amd`, while its adapter names itself "Radeon 8060S Graphics (RADV STRIX_HALO)"; the leg failed, naming the member it did not find, which is what the declaration is for. It now declares `gpu:wgpu-vulkan.radeon`. The same run found the coloured kernel's id cut off its device's hex on a long adapter name; it now keeps it (`a_coloured_id_keeps_its_device_s_hex`). - **wasip2, this head:** 94 passed under wasmtime 50.0.1 on the iMac Pro, the workflow's command and settings: the native 95 less `the_classes_are_the_fabric_s`, which needs `quantum_fabric`. - **Repository checks:** names (no hit in the changed files), spec references, section references, vanity metrics, comparative prose, workflow concurrency, changelog, wasmtime pin, tests in CI, orphan sources, main's `wai.quantum` names, operation doors and corpus licences, and the lockfiles (62, all current, on Thor). - The workflows' pins: the module 95 (wasip2 94), conformance 12, the members' unit tests 9, 8 and 8, the device tests 7. ## Beside the landscape Merging main showed that `engine::job`'s test `a_host_never_seals_what_its_verifier_refuses` calls `qec` with no feature gate, so the library's tests did not compile for `quantum_engine,quantum_receipt`, the feature set of this workflow's wasip2 job. It is gated on `quantum_qec` here, one line. `full` holds that feature, so nothing that ran it stops running it. The two kernel labels are on main already, from #664's landing. 🤖 Generated with [Claude Code](https://claude.com/claude-code)

dcharlot added 2 commits 2026-11-06 08:21:14 -05:00

wai-quantum: a WebGPU member of the landscape fabric (work in progress) ... 578569fd02

The settle kernel (one invocation a cell, a dispatch a sweep) and the sampling
kernel (one invocation a chain, its cells in order, the reference's draws in
pairs of 32-bit words and the host's cut points) in WGSL, and a coloured kernel
that can be statistical at most. A member declines, before anything runs, a
workload beyond its 32-bit lanes (Member::takes), and job::call_placed gives the
job to the next member, naming the refusal. The host hands a member the starts
of several seeds at once. Certification holds a member to every vector it takes
and to every vector whose fields fit 32 bits.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: CUDA and Metal members of the landscape fabric, a meter bridge, and the decline rule ... d9277c8563

- quantum_landscape::cuda and quantum_landscape::metal run the settle kernel (one
  thread a cell, a launch a sweep and one to advance) and the sampling kernel
  (one thread a chain, its cells in order, the reference's draws and the host's
  cut points) with 64-bit fields, so a settle of any workload is taken.
  quantum_landscape::device holds what the GPU members share. WebGPU members
  are named gpu:wgpu-<backend>.… so that none reads as a native backend's.
- A member may decline only the vectors whose fields do not fit 32 bits;
  declining any other is failing it. Tested on the CPU with a stand-in of narrow
  lanes, and job::call_placed's refusals with it.
- wai::sink_meter::RunCounter makes a run meter of an on-chip counter
  (IOReport's GPU channel, NVML), labelled OnChipCounter with filtering Unknown
  and the uncertainty its caller declares; it gives no figure for a window under
  the profile's minimum. The hardware test that reads it is run by hand.
- The extension states declining, refusals, batches and the meter's reach; the
  schema takes refusals; the docs, the READMEs and a changelog entry say what is
  here; wai-quantum-landscape-devices.yml holds every member on jetson-hub,
  framework-128gb and the Mac Studio.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

dcharlot referenced this pull request from a commit 2026-11-06 14:32:34 -05:00

wai-quantum: the landscape GPU members held to what large jobs reach, placed only where certified, metered over what they cover

dcharlot added 1 commit 2026-11-06 14:32:35 -05:00

wai-quantum: the landscape GPU members held to what large jobs reach, placed only where certified, metered over what they cover ... 0675813de4

The review of #672 (35 findings), each fix with a test that fails first:

- The conformance set reaches what large jobs reach: settles past a workgroup
  and past a batch of sweeps; chains held hot to their last sweep, at the seeds
  where a 32-bit port of the generator first goes wrong, past a workgroup of
  chains, across a device's windows by table and by work; fields only their
  full width tells apart; field bounds at 2^31 - 1 and just past it. The
  battery adds a ring of six, eight triangles side by side, a walked law that
  a schedule's end alone does not give, and fields past 16 and 32 bits. Each
  fault a port can have, put into the kernels on a device, costs them the grade.
- Placement: call_placed passes over an uncertified kernel, a declining
  member and one that fails the job, naming each under refusals; no member is
  run on what it declines however it is reached; every answer says who ran it
  at what parity.
- Budget: a sweep's cut points cover the fields the cells can reach
  (reach.rs, at most 4P + n), counted in a job's operations and bytes; WebGPU
  waits once a window, and a member that times out passes the job on.
- RunCounter reads the counter through each call, gives a figure only from a
  live window of the profile's minimum, adds its own terms to the declared
  uncertainty, holds NVML to its plausibility itself, and says what its figure
  covers; readings are kept per thread and a run's windows are summed.
- The spec states one decline rule and defines the field bound; the schema,
  docs, READMEs and changelog follow; the devices workflow declares each
  host's members, reads a report rather than test output, runs the members'
  unit tests, and keeps the Mac's target off its internal disk.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

dcharlot changed target branch from wai/quantum-landscape-emulator to main 2026-11-06 23:37:02 -05:00

dcharlot added 2 commits 2026-11-07 01:26:54 -05:00

wai-quantum: main into the landscape GPU members ... f6cce35f6f

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: engine::job's seal test needs quantum_qec, and says so ... 44b284c9f1

Its test of a host's seals calls qec, so the library's tests did not compile
for quantum_engine,quantum_receipt, the landscape wasip2 job's feature set.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

dcharlot merged commit f9d2ec8148 into main 2026-11-07 01:28:30 -05:00

dcharlot referenced this pull request from a commit 2026-11-07 01:28:39 -05:00

Merge pull request 'wai-quantum: energy-landscape jobs on a GPU, through WebGPU, CUDA and Metal, each member certified by the host' (#672) from wai/quantum-landscape-gpu into main

Sign in to join this conversation.

Reviewers

No reviewers

Labels

Clear labels

No items

No labels

Milestone

Clear milestone

No items

No milestone

Projects

Clear projects

No items

No project

Assignees

Clear assignees

No assignees

1 participant

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

Transaction-Science/open-standards!672

No description provided.