perf(vk): the shader preparation's graphics pipelines go side by side on Intel's Arc A-series and Core Ultra GPUs #2101

Merged
HumanBean merged 2 commits from HumanBean/Longshot:perf/intel-prep-side-by-side into main 2026-11-21 19:20:13 +00:00
Owner

Summary

On Intel's Arc A-series cards and the Arc iGPUs of Core Ultra laptops, Windows, the shader preparation takes hours.

  • #1706: an Arc A730M (driver 101.9175). The start-up screen showed 12,750 of 36,682 pipelines and "about 1187 min left", with the GPU at 5%.
  • #2011: a Core Ultra 7 155H's Arc iGPU (driver 101.9175). Prepare shaders was at 77% after 7 h 35 min, with the CPU and the GPU both at 8%.

The cause: IntelDriverGate (gpu/vk/vk_internal.h) lets one thread at a time into Intel's Windows compiler. The row's Auto turns that off only on the Arc B-series (intel_compiles.h, #500). Everywhere else, every preparation worker (16 on a 20-thread laptop) queues on one mutex. That is about one CPU busy, the 8% in #2011's screenshot.

Evidence that side by side works there: #1717 is the same A730M on the same driver with RX_VK_NO_INTEL_SERIAL=1 (the launcher's Side by side). It built 25,005 of 32,623 noted pipelines in 2,753 s on 16 threads, 5 to 35 a second, with no driver fault. What ended that run was memory: a C++ allocation refused (at the commit limit?), then pipelines not made (-3), on 16 GB.

Why the gate is still needed for what it fixed: the fault it was put in for (#252: igvk64 read 0x170 on a UHD, driver 101.7088) was traced to vkGetPipelineCacheData running beside builds. pcache_fetch_lock (#190) keeps those apart on every Intel GPU on Windows, and this PR leaves that lock alone. The other reason the gate stays: four compute pipelines at once froze a PC (compute_builds_serial).

What changes, only on Intel's Windows driver 101.9175 or newer with the Intel shader compiles row on Auto:

  • vk: the preparation's threads build their graphics pipelines and shader modules side by side. Those threads are prepare_run (not in play), warm_libraries, predict_run, precompile_run and precompile_warm. Each one is marked with IntelPrepareLane, and IntelDriverGate(ask, prepare_ok) lets a marked thread through when intel_prepare_open() is true. Compute pipelines still take the gate (cached_compute, warm_compute and the renderer's own pipelines), and so does everything play builds.
  • vk: prepare_pipeline_threads holds the pipeline steps' threads to the free memory, 768 MB per thread past 4 GB (intel_prepare_workers, the per-worker figure from prepare_workers.h). On that 16 GB A730M this means about 6 to 10 threads instead of 16. It logs vk: preparation (<step>): Intel's compiler takes the graphics pipelines side by side on N threads of M (X MB free).
  • menu: the row's Auto hint names the new behaviour. The row's One at a time and RX_VK_NO_INTEL_SERIAL=0 keep the preparation one at a time, as does the weak-laptop button.
  • Drivers before 101.9175 do not change. That covers the Iris Xe and UHD legacy drivers, where the fault was seen.
  • Other GPUs and Linux do not change: intel_gate_on() is false there, so the lane does nothing and the thread counts are the same.

Read first: gpu/vk/intel_compiles.h (the rule and its evidence), gpu/vk/vk_internal.h (IntelPrepareLane, intel_prepare_open, IntelDriverGate), and prepare_pipeline_threads in gpu/vk/vk_draw.cpp.

Fixes #1706, fixes #2011. See #1717 (the crash at the commit limit: this lowers the thread count there, but the memory is not measured on Intel yet), #407, #1830 (the countdown display).

Testing

Tested: Linux, RTX 3090, NVIDIA 620.70.06, this PR as a pack over main's base, through the job queue: a memory tour from kokiri-start to Kokiri Forest and Hyrule Field, in play, clean quit, no crash, and no "Intel's compiler" line (the new code is gated to Intel's Windows driver, so nothing changes here). The branch was then rebased onto current main with no conflicts; the Intel path itself needs the Test Farm.

  • tests/test_intel_prepare_side_by_side.py (new) cuts out the real gate (vk_internal.h), the row's questions (menu/intel.cpp) and the real cached_graphics and cached_compute (vk_draw.cpp). It compiles them with a driver stand-in that counts how many builds are inside it at once, then runs 4 threads for 12 cases: the A730M, a Core Ultra iGPU, an A770 on a newer driver, the B580, a UHD on 101.7088, an Iris Xe below 101.9175, rows 0, 1 and 2, preparation threads against play threads, and graphics against compute. It also checks 12 intel_prepare_workers counts, and that the five preparation steps are marked and their thread counts held.
  • On main, the first case fails because the A730M builds the preparation's graphics pipelines one at a time. Not run on this PC (no test suites here): CI runs it.
  • Updated: tests/test_intel_compiler_gate.py now expects cached_graphics's and make_module's new second argument, and cached_compute keeps its old line. The stand-ins in program_cache_one_variant_test.cpp and program_cache_cleanup_test.cpp take the second argument.
  • Compiled here: gpu/vk/intel_compiles.h with g++ -std=c++17 -Wall -Wextra -fsyntax-only. Nothing else was compiled.

Still to test:

  • Linux, RTX 3090: a cold-cache --prepare-shaders, main against this PR, twice each, interleaved. Expect the same time and no Intel's compiler line (by hand, run plan).
  • Windows, Arc A-series (A750/A770/A580 or an A730M laptop), driver 101.9175 or newer, Auto: a cold-cache Prepare shaders, main against this PR. Expect the log line above, several times faster than main, no driver faulted line, no device loss, and the game reaching play (@Beanstalk, below).
  • Windows, Core Ultra Arc iGPU (Meteor Lake or Lunar Lake), driver 101.9175 or newer, Auto: the same. Also watch the private memory peak against RAM, because the iGPU shares it (@Beanstalk, below).
  • Windows, Arc B580: the same Prepare shaders, which should not change, because Auto was already side by side there (@Beanstalk).
@Beanstalk On Windows with an Intel Arc A-series card (A380/A580/A750/A770 or an A730M/A770M laptop) and on a Core Ultra laptop's Arc iGPU (Meteor Lake 155H/165H or Lunar Lake), each on Intel driver 101.9175 or newer with the Intel shader compiles row on Auto: build this PR and main, and time a cold-cache shader preparation for each (empty game cache folder, Intel's shader cache cleared, launcher's Prepare shaders or `longshot.exe --prepare-shaders --compile-shaders most`), main then PR then main then PR. Report the wall time, the log's "vk: prepared ... in N s" and "vk: precompile: ... in N s" lines, the "vk: preparation (...): Intel's compiler takes the graphics pipelines side by side on N threads" lines, the peak private memory, any "driver faulted", "not made (-3)" or "commit limit" lines, and whether the game then reaches Kokiri Forest and plays for 2 minutes without a crash or device loss.

Measurements

Verdict: nothing to measure on this PC (the change runs only on Intel's Windows driver); the Arc numbers come from Beanstalk. The evidence is the reporters' logs (#1717: side by side on the A730M at 5 to 35 pipelines a second over 16 threads; #2011: one at a time at 8% CPU for over 7 hours). The 3090 run should show no change, and the Arc numbers come from Beanstalk.

Setup: Linux, RTX 3090: a cold-cache --prepare-shaders (run plan). Windows Arc A-series and Core Ultra iGPU: Beanstalk.

Before: main @ 16376e40 After: this PR @ e496ea8a
RTX 3090 unchanged: the code is gated to Intel's Windows driver unchanged (in play, no Intel line)
Arc A-series, cold Prepare shaders
Core Ultra Arc iGPU, cold Prepare shaders

Risks

  • A fault in Intel's compiler with two threads inside it, on a GPU or driver not yet run side by side. That is mainly the Core Ultra iGPUs: the only side-by-side evidence on 101.9175 is the A730M's. A shader the driver faults on during the preparation is caught by guarded_graphics or guarded_shader_module and left out, and is written to longshot_driver_faults.txt. A crash inside a step leaves its .warming marker, and after two such crashes the step is skipped and those pipelines are built in play. To turn it off, set the row to One at a time or RX_VK_NO_INTEL_SERIAL=0, which the launcher's "One at a time" sets. A revert also undoes it.
  • Memory: side by side holds more memory at once. The thread count is held to the free memory at 768 MB per thread. That figure comes from AMD (prepare_workers.h) and is not measured on Intel, so Beanstalk's peak-memory numbers should confirm it. On iGPUs memory is shared with the GPU.
  • After updating: nothing changes for saves, longshot_options.ini or the caches. Play's builds are unchanged.

Checklist

Ready for review

  • One topic, on current main; the title is a Conventional Commit.
  • Tested on my own PC, in the game for a change the game runs, as Testing says.
  • mise run test passes (any failure that also fails on main is named). (Not run on this PC by policy: CI runs it.)
  • Measured against main, or Measurements says why there is nothing to measure. (Waiting on the 3090 run and Beanstalk.)
  • No game files, build output or hand-edited generated files; third_party/ untouched; nothing GPL-incompatible.

When it applies

  • A fix: a game-free test that fails on main and passes here. (Written to fail on main at its first case. Not run here: CI.)
  • A check under tests/ that reads changed source is updated, not weakened.
  • Docs updated. (docs/dev/reference/switches.md "Intel's compiler on Windows", docs/user/graphics-and-controls.md.)
  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.

Ready to merge

  • Everything in Still to test has run, its results in Tested.
  • Tier 1 hardware it can affect is tested (docs/dev/standards.md, "Hardware tiers").
  • Approved in review, every comment answered.
  • CI passes on the head; on current main, measured again or a comment says why the numbers still hold.

🤖 Generated with Claude Code

https://claude.ai/code/session_017vw8e2uxGKQxzDeQ15jjNK

https://claude.ai/code/session_017vw8e2uxGKQxzDeQ15jjNK

## Summary On Intel's Arc A-series cards and the Arc iGPUs of Core Ultra laptops, Windows, the shader preparation takes hours. - [#1706](https://git.magicbean.dev/MagicBeanDev/Longshot/issues/1706): an Arc A730M (driver 101.9175). The start-up screen showed 12,750 of 36,682 pipelines and "about 1187 min left", with the GPU at 5%. - [#2011](https://git.magicbean.dev/MagicBeanDev/Longshot/issues/2011): a Core Ultra 7 155H's Arc iGPU (driver 101.9175). Prepare shaders was at 77% after 7 h 35 min, with the CPU and the GPU both at 8%. **The cause:** `IntelDriverGate` (`gpu/vk/vk_internal.h`) lets one thread at a time into Intel's Windows compiler. The row's Auto turns that off only on the Arc B-series (`intel_compiles.h`, [#500](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/500)). Everywhere else, every preparation worker (16 on a 20-thread laptop) queues on one mutex. That is about one CPU busy, the 8% in #2011's screenshot. **Evidence that side by side works there:** [#1717](https://git.magicbean.dev/MagicBeanDev/Longshot/issues/1717) is the same A730M on the same driver with `RX_VK_NO_INTEL_SERIAL=1` (the launcher's Side by side). It built 25,005 of 32,623 noted pipelines in 2,753 s on 16 threads, 5 to 35 a second, with no driver fault. What ended that run was memory: `a C++ allocation refused (at the commit limit?)`, then pipelines `not made (-3)`, on 16 GB. **Why the gate is still needed for what it fixed:** the fault it was put in for ([#252](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/252): igvk64 read 0x170 on a UHD, driver 101.7088) was traced to `vkGetPipelineCacheData` running beside builds. `pcache_fetch_lock` ([#190](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/190)) keeps those apart on every Intel GPU on Windows, and this PR leaves that lock alone. The other reason the gate stays: four compute pipelines at once froze a PC (`compute_builds_serial`). **What changes**, only on Intel's Windows driver 101.9175 or newer with the Intel shader compiles row on Auto: - vk: the preparation's threads build their graphics pipelines and shader modules side by side. Those threads are `prepare_run` (not in play), `warm_libraries`, `predict_run`, `precompile_run` and `precompile_warm`. Each one is marked with `IntelPrepareLane`, and `IntelDriverGate(ask, prepare_ok)` lets a marked thread through when `intel_prepare_open()` is true. Compute pipelines still take the gate (`cached_compute`, `warm_compute` and the renderer's own pipelines), and so does everything play builds. - vk: `prepare_pipeline_threads` holds the pipeline steps' threads to the free memory, 768 MB per thread past 4 GB (`intel_prepare_workers`, the per-worker figure from `prepare_workers.h`). On that 16 GB A730M this means about 6 to 10 threads instead of 16. It logs `vk: preparation (<step>): Intel's compiler takes the graphics pipelines side by side on N threads of M (X MB free)`. - menu: the row's Auto hint names the new behaviour. The row's One at a time and `RX_VK_NO_INTEL_SERIAL=0` keep the preparation one at a time, as does the weak-laptop button. - Drivers before 101.9175 do not change. That covers the Iris Xe and UHD legacy drivers, where the fault was seen. - Other GPUs and Linux do not change: `intel_gate_on()` is false there, so the lane does nothing and the thread counts are the same. Read first: `gpu/vk/intel_compiles.h` (the rule and its evidence), `gpu/vk/vk_internal.h` (`IntelPrepareLane`, `intel_prepare_open`, `IntelDriverGate`), and `prepare_pipeline_threads` in `gpu/vk/vk_draw.cpp`. Fixes #1706, fixes #2011. See #1717 (the crash at the commit limit: this lowers the thread count there, but the memory is not measured on Intel yet), #407, #1830 (the countdown display). ## Testing **Tested:** Linux, RTX 3090, NVIDIA 620.70.06, this PR as a pack over main's base, through the job queue: a memory tour from `kokiri-start` to Kokiri Forest and Hyrule Field, in play, clean quit, no crash, and no "Intel's compiler" line (the new code is gated to Intel's Windows driver, so nothing changes here). The branch was then rebased onto current main with no conflicts; the Intel path itself needs the Test Farm. - `tests/test_intel_prepare_side_by_side.py` (new) cuts out the real gate (`vk_internal.h`), the row's questions (`menu/intel.cpp`) and the real `cached_graphics` and `cached_compute` (`vk_draw.cpp`). It compiles them with a driver stand-in that counts how many builds are inside it at once, then runs 4 threads for 12 cases: the A730M, a Core Ultra iGPU, an A770 on a newer driver, the B580, a UHD on 101.7088, an Iris Xe below 101.9175, rows 0, 1 and 2, preparation threads against play threads, and graphics against compute. It also checks 12 `intel_prepare_workers` counts, and that the five preparation steps are marked and their thread counts held. - On `main`, the first case fails because the A730M builds the preparation's graphics pipelines one at a time. Not run on this PC (no test suites here): CI runs it. - Updated: `tests/test_intel_compiler_gate.py` now expects `cached_graphics`'s and `make_module`'s new second argument, and `cached_compute` keeps its old line. The stand-ins in `program_cache_one_variant_test.cpp` and `program_cache_cleanup_test.cpp` take the second argument. - Compiled here: `gpu/vk/intel_compiles.h` with `g++ -std=c++17 -Wall -Wextra -fsyntax-only`. Nothing else was compiled. **Still to test:** - Linux, RTX 3090: a cold-cache `--prepare-shaders`, main against this PR, twice each, interleaved. Expect the same time and no `Intel's compiler` line (by hand, run plan). - Windows, Arc A-series (A750/A770/A580 or an A730M laptop), driver 101.9175 or newer, Auto: a cold-cache Prepare shaders, main against this PR. Expect the log line above, several times faster than main, no `driver faulted` line, no device loss, and the game reaching play (@Beanstalk, below). - Windows, Core Ultra Arc iGPU (Meteor Lake or Lunar Lake), driver 101.9175 or newer, Auto: the same. Also watch the private memory peak against RAM, because the iGPU shares it (@Beanstalk, below). - Windows, Arc B580: the same Prepare shaders, which should not change, because Auto was already side by side there (@Beanstalk). ``` @Beanstalk On Windows with an Intel Arc A-series card (A380/A580/A750/A770 or an A730M/A770M laptop) and on a Core Ultra laptop's Arc iGPU (Meteor Lake 155H/165H or Lunar Lake), each on Intel driver 101.9175 or newer with the Intel shader compiles row on Auto: build this PR and main, and time a cold-cache shader preparation for each (empty game cache folder, Intel's shader cache cleared, launcher's Prepare shaders or `longshot.exe --prepare-shaders --compile-shaders most`), main then PR then main then PR. Report the wall time, the log's "vk: prepared ... in N s" and "vk: precompile: ... in N s" lines, the "vk: preparation (...): Intel's compiler takes the graphics pipelines side by side on N threads" lines, the peak private memory, any "driver faulted", "not made (-3)" or "commit limit" lines, and whether the game then reaches Kokiri Forest and plays for 2 minutes without a crash or device loss. ``` ## Measurements **Verdict:** nothing to measure on this PC (the change runs only on Intel's Windows driver); the Arc numbers come from Beanstalk. The evidence is the reporters' logs (#1717: side by side on the A730M at 5 to 35 pipelines a second over 16 threads; #2011: one at a time at 8% CPU for over 7 hours). The 3090 run should show no change, and the Arc numbers come from Beanstalk. Setup: Linux, RTX 3090: a cold-cache `--prepare-shaders` (run plan). Windows Arc A-series and Core Ultra iGPU: Beanstalk. | | Before: main @ 16376e40 | After: this PR @ e496ea8a | |---|---|---| | RTX 3090 | unchanged: the code is gated to Intel's Windows driver | unchanged (in play, no Intel line) | | Arc A-series, cold Prepare shaders | | | | Core Ultra Arc iGPU, cold Prepare shaders | | | ## Risks - **A fault in Intel's compiler with two threads inside it, on a GPU or driver not yet run side by side.** That is mainly the Core Ultra iGPUs: the only side-by-side evidence on 101.9175 is the A730M's. A shader the driver faults on during the preparation is caught by `guarded_graphics` or `guarded_shader_module` and left out, and is written to `longshot_driver_faults.txt`. A crash inside a step leaves its `.warming` marker, and after two such crashes the step is skipped and those pipelines are built in play. To turn it off, set the row to One at a time or `RX_VK_NO_INTEL_SERIAL=0`, which the launcher's "One at a time" sets. A revert also undoes it. - **Memory:** side by side holds more memory at once. The thread count is held to the free memory at 768 MB per thread. That figure comes from AMD (`prepare_workers.h`) and is not measured on Intel, so Beanstalk's peak-memory numbers should confirm it. On iGPUs memory is shared with the GPU. - **After updating:** nothing changes for saves, `longshot_options.ini` or the caches. Play's builds are unchanged. ## Checklist ### Ready for review - [x] One topic, on current `main`; the title is a Conventional Commit. - [x] Tested on my own PC, in the game for a change the game runs, as Testing says. - [ ] `mise run test` passes (any failure that also fails on `main` is named). (Not run on this PC by policy: CI runs it.) - [ ] Measured against `main`, or Measurements says why there is nothing to measure. (Waiting on the 3090 run and Beanstalk.) - [x] No game files, build output or hand-edited generated files; `third_party/` untouched; nothing GPL-incompatible. ### When it applies - [x] A fix: a game-free test that fails on `main` and passes here. (Written to fail on `main` at its first case. Not run here: CI.) - [x] A check under `tests/` that reads changed source is updated, not weakened. - [x] Docs updated. (`docs/dev/reference/switches.md` "Intel's compiler on Windows", `docs/user/graphics-and-controls.md`.) - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. ### Ready to merge - [ ] Everything in Still to test has run, its results in Tested. - [ ] Tier 1 hardware it can affect is tested (docs/dev/standards.md, "Hardware tiers"). - [ ] Approved in review, every comment answered. - [ ] CI passes on the head; on current `main`, measured again or a comment says why the numbers still hold. 🤖 Generated with [Claude Code](https://claude.com/claude-code) https://claude.ai/code/session_017vw8e2uxGKQxzDeQ15jjNK https://claude.ai/code/session_017vw8e2uxGKQxzDeQ15jjNK
The real gate (vk_internal.h), the row's questions (menu/intel.cpp) and cached_graphics/cached_compute (vk_draw.cpp)
cut out and compiled with a driver stand-in that counts the builds inside it at once. Fails on main: an Arc A730M and a
Core Ultra's Arc iGPU on driver 101.9175, row on Auto, build the preparation's graphics pipelines one at a time.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_017vw8e2uxGKQxzDeQ15jjNK
perf(vk): the shader preparation's graphics pipelines go side by side on Intel's Arc A-series and Core Ultra GPUs (#1706, #2011)
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
Website / Website on Cloudflare (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 20s
Website / Website on Cloudflare (pull_request_target) Has been skipped
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 28s
CI / Workflow lint (actionlint) (pull_request) Successful in 32s
Third-party parts / As their notes say (pull_request) Successful in 36s
beanstalk/approval can't be tested as asked: see the farm's comment
PR description / Description follows the template (pull_request_target) Failing after 17s
CI / Website build and checks (pull_request) Failing after 53s
e496ea8ab8
On driver 101.9175 or newer with the Intel shader compiles row on Auto, the preparation's graphics pipelines and shader
modules pass IntelDriverGate (IntelPrepareLane, intel_prepare_open); its compute pipelines and every build in play keep
the gate. The gate's fault (#252) was the pipeline cache's fetch beside builds, which pcache_fetch_lock keeps apart. The
threads that build pipelines there are held to the free memory (intel_prepare_workers, 768 MB each past 4 GB): 16 on a
16 GB A730M ran into the commit limit (#1717). Docs: switches.md, graphics-and-controls.md.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_017vw8e2uxGKQxzDeQ15jjNK
Author
Owner

Tested in game: Linux, RTX 3090, NVIDIA 620.70.06, through the job queue: memory tour from kokiri-start to Kokiri Forest and Hyrule Field, in play, clean quit, no crash; no Intel line (the change is gated to Intel's Windows driver). The Intel path needs the Test Farm.

Tested in game: Linux, RTX 3090, NVIDIA 620.70.06, through the job queue: memory tour from kokiri-start to Kokiri Forest and Hyrule Field, in play, clean quit, no crash; no Intel line (the change is gated to Intel's Windows driver). The Intel path needs the Test Farm.
Author
Owner

@Beanstalk On Windows with an Intel Arc A-series card (A380/A580/A750/A770 or an A730M/A770M laptop) and on a Core Ultra laptop's Arc iGPU (Meteor Lake 155H/165H or Lunar Lake), each on Intel driver 101.9175 or newer with the Intel shader compiles row on Auto: build this PR and main, and time a cold-cache shader preparation for each (empty game cache folder, Intel's shader cache cleared, launcher's Prepare shaders or longshot.exe --prepare-shaders --compile-shaders most), main then PR then main then PR. Report the wall time, the log's "vk: prepared ... in N s" and "vk: precompile: ... in N s" lines, the "vk: preparation (...): Intel's compiler takes the graphics pipelines side by side on N threads" lines, the peak private memory, any "driver faulted", "not made (-3)" or "commit limit" lines, and whether the game then reaches Kokiri Forest and plays for 2 minutes without a crash or device loss.

@Beanstalk On Windows with an Intel Arc A-series card (A380/A580/A750/A770 or an A730M/A770M laptop) and on a Core Ultra laptop's Arc iGPU (Meteor Lake 155H/165H or Lunar Lake), each on Intel driver 101.9175 or newer with the Intel shader compiles row on Auto: build this PR and main, and time a cold-cache shader preparation for each (empty game cache folder, Intel's shader cache cleared, launcher's Prepare shaders or `longshot.exe --prepare-shaders --compile-shaders most`), main then PR then main then PR. Report the wall time, the log's "vk: prepared ... in N s" and "vk: precompile: ... in N s" lines, the "vk: preparation (...): Intel's compiler takes the graphics pipelines side by side on N threads" lines, the peak private memory, any "driver faulted", "not made (-3)" or "commit limit" lines, and whether the game then reaches Kokiri Forest and plays for 2 minutes without a crash or device loss. ```
Member

Beanstalk test farm · ⛔ can't be tested as asked

Commit e496ea8 · approved by HumanBean (untrusted) · dashboard

Not run: the farm can't test this as asked, so nothing is built or run:

The requested Windows cold-cache preparation-only comparison cannot be run: the farm cannot clear both caches on Windows or launch the specified preparation command, and it cannot enforce the driver version. Normal startup and gameplay on matching Intel hardware could be tested instead.

⚠️ Note: The integrated-GPU target is broader than the requested Meteor Lake and Lunar Lake models; the farm cannot enforce the requested driver version or Intel shader compiles row.
⚠️ Note: The alternative does not measure preparation-only wall time or peak private memory, and its worker-count log may be unjudged if that preparation path is not reached.

What it could test instead: The alternative plan compares normal startup and two minutes in Kokiri Forest on Windows Intel Arc A-series cards and Arc integrated GPUs. It records shader preparation time, process memory, worker-count logs and fault indicators; crashes or fault indicators fail the PR. Each target takes about 25 minutes and waits for matching hardware to come online. No tester online now matches windows+intel+dgpu+gpu-a380_a580_a730m_a750_a770_a770m, windows+intel+igpu+gpu-arc*: those targets wait for one.

A member of BigBeans can comment @Beanstalk <new words> to ask for something else, or @Beanstalk test it anyway to run the plan regardless.

<!-- beanstalk:sticky --> ### Beanstalk test farm · ⛔ can't be tested as asked Commit `e496ea8` · approved by HumanBean (untrusted) · [dashboard](https://beanstalk.magicbean.dev/prs/2101) **Not run: the farm can't test this as asked**, so nothing is built or run: > The requested Windows cold-cache preparation-only comparison cannot be run: the farm cannot clear both caches on Windows or launch the specified preparation command, and it cannot enforce the driver version. Normal startup and gameplay on matching Intel hardware could be tested instead. ⚠️ **Note:** The integrated-GPU target is broader than the requested Meteor Lake and Lunar Lake models; the farm cannot enforce the requested driver version or Intel shader compiles row. ⚠️ **Note:** The alternative does not measure preparation-only wall time or peak private memory, and its worker-count log may be unjudged if that preparation path is not reached. What it could test instead: The alternative plan compares normal startup and two minutes in Kokiri Forest on Windows Intel Arc A-series cards and Arc integrated GPUs. It records shader preparation time, process memory, worker-count logs and fault indicators; crashes or fault indicators fail the PR. Each target takes about 25 minutes and waits for matching hardware to come online. No tester online now matches windows+intel+dgpu+gpu-a380_a580_a730m_a750_a770_a770m, windows+intel+igpu+gpu-arc*: those targets wait for one. A member of `BigBeans` can comment `@Beanstalk <new words>` to ask for something else, or `@Beanstalk test it anyway` to run the plan regardless.
HumanBean changed title from WIP: perf(vk): the shader preparation's graphics pipelines go side by side on Intel's Arc A-series and Core Ultra GPUs to perf(vk): the shader preparation's graphics pipelines go side by side on Intel's Arc A-series and Core Ultra GPUs 2026-11-21 19:19:58 +00:00
HumanBean deleted branch perf/intel-prep-side-by-side 2026-11-21 19:20:16 +00:00
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
2 participants
Notifications
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
MagicBeanDev/Longshot!2101
No description provided.