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]>

@@ -216,6 +216,7 @@ Pipeline-cache file ownership, temporary storage and failure behavior are descri
 | `RX_VK_SKIP_PROG=<prefix>,...` | Leaves out the draws of these programs (default `53509044401d78d2`; `-` leaves out none) |
 | `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`) |

@@ -6840,3 +6840,3 @@
         PROF_EXACT();
         const auto t0 = std::chrono::steady_clock::now();
-        jobs_wait(ready);
+        const int queued = jobs_pending();

@@ -6845,0 +6847,4 @@
+        static std::atomic<int> told{0};
+        if (here && told++ < 10)   // (longshot: that the steal ran, with the queue the wait would have stood behind)
+            logf("vk: a draw's %s ran where it waited, ahead of the queue (%d other jobs queued or running), in %.1f ms "
+                 "(RX_VK_JOB_STEAL=0: waited in turn)",