Mako's 0d93fb19 (an RX 6600: one draw waited 118 s behind 26 queued jobs) adds a claim so that a draw
that must wait for its pipeline builds it itself when no worker has taken it. Longshot has had the same
since aafbaf5d: jobs_wait takes a job pushed with the flag it waits for out of the queue and runs it on
the waiting thread, and graphics_pipeline (mesh programs included) and both translation jobs are pushed
with their flags. A claim beside it would be a second mechanism for the same wait, so this keeps the
steal and closes what was left:

- RX_VK_JOB_STEAL was read with atoi: =true, =on or =yes turned the steal off. It now follows
  longshot_env.h's rule (off for 0, false, off, no), and is documented in docs/development.md.
- jobs_wait says whether it ran the job here; draw() logs the first 10 times a pipeline build or a
  translation ran where it waited, with the jobs queued or running, so a tester can see it happen.
- tests/test_jobs_wait_runs_queued: the stolen job runs once and leaves nothing queued; 2000 rounds of
  free workers racing two waiters for the same job never run it twice; RX_VK_JOB_STEAL=true and " 1 "
  keep it on (main: =true hangs, the steal off), 0/off/No turn it off.

Compute pipelines (dispatch, the mesh fallback's) are not waited for behind the queue: they are pushed
urgent and the dispatch waits 50 ms then is left out, so they are left as they are.

Ported from Mako, by sharkiix, 0d93fb1972

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Assisted-by: Claude Opus 5.5
Co-authored-by: Cursor <[email protected]>

@@ -0,0 +11,4 @@
+namespace quick_pipe {
+
+/// RX_VK_QUICK_MS unset: this budget on AMD's proprietary driver, where the slow optimizer was measured; none elsewhere
+constexpr double kQuickDefaultMs = 1000;

@@ -0,0 +73,4 @@
+        for (int i = 0; must && i < kOtherQuickPolls && e.quick.load(std::memory_order_acquire) == kMaking && !there() &&
+                        !e.ready.load(std::memory_order_acquire);
+             i++)
+            poll();

@@ -0,0 +88,4 @@
+    } else {
+        got = there() ? Got::kOther : Got::kNothing;
+    }
+    e.quick.store(kTried, std::memory_order_release);

@@ -2252,2 +2264,4 @@
+        }();
+        if (slow_ms > 0) std::this_thread::sleep_for(std::chrono::milliseconds(slow_ms));
         use_counters.made_how = 0;
         if (const VkPipeline full = build_graphics(*job->p, job->s, job->at, job->topo)) job->e->pipeline = full;

@@ -2249,3 +2252,3 @@
     job->predicted = predicted;
     jobs_push([job] {
-        // (over a linked one, which is left alone: draws recorded with it may still be on their way)
+        // (over a linked one or a quick one, which are left alone: draws recorded with them may still be on their way)

@@ -2488,3 +2507,2 @@
     if (gated) {
-        const auto gate = fault_quarantine().begin(p.key, !cold);
-        if (gate == driver_faults::Quarantine::kBusy) return *cold = true, VK_NULL_HANDLE;
+        const auto gate = fault_quarantine().begin(p.key, !cold && !quick_build);

@@ -6924,0 +7024,4 @@
+        // (longshot, from Mako) one to draw with until the full build is done: from the caches, or quick (quick_pipeline). Else a
+        // draw that may be left out first waits briefly for its build, moved to the queue's front (RX_VK_PIPE_WAIT_MS, off unless
+        // set), and one that may not waits for it, running it here if no worker has (jobs_wait)
+        if (!pe->pipeline.load(std::memory_order_acquire) && !quick_pipeline(*pe, p, s, at, topo, !may_skip)) {

@@ -222,6 +222,9 @@ Pipeline-cache file ownership, temporary storage and failure behavior are descri
 | `RX_VK_PIPE_SKIP=0`, `1` or `2` | Default/`1`: wait for shader translation (with `RX_VK_TRANSLATE_WAIT_MS` set, a draw whose targets hold an earlier frame waits at most that long a frame in all, then is left out). A pending pipeline can be skipped only for attachment-only draws whose targets hold an earlier frame. `0`: wait for every translation and pipeline. `2`: restore the old skip for untranslated draws with persistent targets at once; this can omit writes before the shader is known. Translated memory-writing draws still wait |
 | `RX_VK_TRANSLATE_WAIT_MS=<ms>` | Off by default: each shader still translating is waited out, as #1573 does. Set (`8` is the tested value): how long, in all, each recording thread waits in a frame for shaders still translating before leaving their draws on earlier frames' targets out. For first-visit pauses of 0.2-3 s on a cold or changed program bank; a translation slower than the bound can lose a memory write, since its writes are not known before it is translated. A negative value is off; anything but a number is ignored with a warning; the value in use is logged. Compute dispatches still wait their translation out |
 | `RX_VK_JOB_STEAL=0` | A draw that must wait for its shader translation or pipeline build waits for a worker to reach it, behind every job queued before it, as before. By default a job it waits for that no worker has started yet is taken out of the queue and run on the waiting thread (it runs once either way; one a worker has started is waited for). The log's `vk: a draw's ... ran where it waited` lines (the first 10) say when it happened. Off follows the on/off rule above (`0`, `false`, `off`, `no`) |
+| `RX_VK_QUICK_MS=<ms>` | Quick pipelines (ported from Mako, by sharkiix): a draw whose pipeline is still being built by a worker first asks the caches for the full one without compiling (where the driver has `pipelineCreationCacheControl`), else gets one made at once without the driver's optimizer, into no pipeline cache, and is drawn with it until the worker's full build replaces it. Up to this many ms of those a frame on each recording thread for draws that could be left out: a build is not started where the thread's last one would not fit in what is left, but a frame's first always is, so a frame runs past the budget by at most one build. Draws that must wait get one whatever the budget. Off by default on every driver until measured in the game (it is for AMD's proprietary driver, where the optimizer took 5-13 s a pipeline: Mako, Volvagia's intro a black silhouette); `8` is the suggested value (half a 60 fps frame, as `RX_VK_TRANSLATE_WAIT_MS`; Mako's 1000 trades a missing draw for a hitch of up to a second); `0` or unset: off. Not made where the full build is made without the optimizer already (`RX_VK_NOOPT`, AMD's task and mesh programs); while the driver-fault gate has another build of the program in the driver (AMD, often the entry's own full build) none is made then, and a later draw tries again. Not with `RX_VK_PIPE_SKIP=0`, which waits for every pipeline. Deliberately, a full build that fails (or that the driver faults on) leaves the quick pipeline drawn with for the session, where the draw was left out before. Memory: a quick pipeline the full build replaced is not destroyed (nothing tells when the recordings that used it are done on the GPU), so each entry that got one keeps one more pipeline, unoptimised, for the session; the log's quick pipeline lines count them. Quick builds are not counted in the stats' pipelines. Anything but a number is ignored with a warning; the value in use is logged. Untested in the game in Longshot |

@@ -0,0 +56,4 @@
+    /// frame): a frame runs past the budget by at most one build, not by every build started before it was spent
+    bool fits(uint64_t now, double total) {
+        const double l = left(now, total);
+        return l > 0 && (used <= 0 || build_ms <= l);

@@ -2252,2 +2271,3 @@
+        // pipeline stays for the session, one more per entry that got one, counted in quick_pipeline's log line)
         use_counters.made_how = 0;
-        if (const VkPipeline full = build_graphics(*job->p, job->s, job->at, job->topo)) job->e->pipeline = full;
+        slow_full_build = true;   // (RX_VK_TEST_SLOW_MS: held inside the driver-fault gate, build_graphics)

@@ -2489,2 +2526,2 @@
-        const auto gate = fault_quarantine().begin(p.key, !cold);
-        if (gate == driver_faults::Quarantine::kBusy) return *cold = true, VK_NULL_HANDLE;
+        const auto gate = fault_quarantine().begin(p.key, !cold && !quick_build);
+        if (gate == driver_faults::Quarantine::kBusy) return gate_busy = true, cold ? (*cold = true, VK_NULL_HANDLE) : VK_NULL_HANDLE;

@@ -0,0 +177,4 @@
+    {
+        FakeEntry g;
+        int asks = 0, builds = 0;
+        const auto ask_busy = [&](bool& busy) { return asks++, busy = true, 0; };