On a 16 GB Steam Deck OLED (SteamOS, earlyoom on), guest shmem (4.7-6.0 GB),
renderer anonymous memory (up to 8.7 GB on main) and kernel-pinned VMA blocks
share one 16 GB memory pool while RADV's device-heap budget (~7.5 GB) stays
under 50% used. On Longshot main (39647e1a), loading into Kokiri Forest pushed
RSS to 10.3 GB (anon 8.7 GB, private 7.2 GB) and MemAvailable down to 277 MB
(17 dips under 500 MB with 2.7 GB swap free), triggering the low-memory guard /
earlyoom.

- linux_pressure.h: reads MemAvailable and SwapFree from /proc/meminfo on Linux
  and computes the shortfall below RX_VK_AVAIL_RESERVE_MB (default 1536 MB) and
  RX_VK_COMMIT_RESERVE_MB (default 2560 MB).
- vk_texture.cpp: when Linux memory pressure is active, lowers budget and
  rule_budget by the shortfall, drains the render-target pool (pool_pressed),
  runs VRAM compaction at its pressed thresholds (compact.pressed), frees idle
  staging arenas and checks malloc_trim every 120 presents (at >= 64 MB free).
- vk_memory.cpp: under Linux memory pressure, trims spare capture buffers to
  32 MB and adds the shortfall to imports_give_back() so idle unmirrored guest
  pool imports are unpinned even on < 12 GB system-heap budgets.
- vk_progcache.cpp, vk_draw.cpp: records each uncompressed stage's SPIR-V offset
  in longshot_programs.bin and, on Linux in pipeline_cache_play() after the
  start-up precompile finishes, lets go of ready programs' VkShaderModules
  whose pipelines were built in the precompile (remade on demand by
  program_cache_complete_graphics if play builds a new pipeline variant, while
  programs without a built graphics pipeline under RX_VK_PRECOMPILE_GRAPHICS=none
  keep their vertex and fragment modules for their first draw in play), keeps
  pcache intact so in-play builds hit the start's cache and RADV's on-disk
  cache, and calls malloc_trim(0).
- tests: adds tests/test_linux_pressure.py and tests/linux_pressure_test.cpp.
- docs: adds the switches to docs/development.md and the Steam Deck OLED runs
  to docs/tested-configurations.md.

Measured on Steam Deck OLED (16 GB shared, SteamOS, Kokiri moving route,
Quality preset Auto (this PC), warm caches, main @ 39647e1a vs this PR @
84f93b55):
- Peak RSS: 10,343 MB (main) -> 8,403 MB (this PR, -1.94 GB)
- Anon peak: 8,701 MB (main) -> 6,065 MB (this PR, -2.64 GB)
- Working set in Kokiri (vk: memory:): 10,073 MB / private 7,220 MB (main) ->
  4,450 MB / private 600 MB (this PR, 39,048 shader modules let go)
- Process swap peak: 2,860 MB (main) -> 914 MB (this PR, -1.95 GB)
- MemAvailable minimum: 277 MB, 17 dips < 500 MB (main, killed by guard ~3 min
  in) -> 854 MB, 0 dips < 500 MB, 6,487 MB swap free (this PR, completed route
  at 15.6 real / 29.6 shown fps, p95 68 ms).

Note on scope: keeps Linux/Deck memory pressure separate from Windows play-time
memory growth (d4nkn3ss, #993) and from shader-preparation set changes
(HumanBean, #158).

Co-authored-by: Copilot App <[email protected]>

@@ -2249,6 +2254,7 @@ PipeEntry* graphics_pipeline(const Program& p, const NvnState& s, const Targets&
     job->predicted = predicted;
     jobs_push([job] {
         // (over a linked one, which is left alone: draws recorded with it may still be on their way)
+        program_cache_complete_graphics(*job->p);

@@ -9742,0 +9755,4 @@
+    // programs without a built graphics pipeline (!graphics_built, as under RX_VK_PRECOMPILE_GRAPHICS=none) keep their vertex
+    // and fragment modules so in-play pipeline builds do not read the disk. pcache is kept so in-play builds still hit the
+    // start's pipeline cache and RADV's disk cache without copying every pipeline into play_cache. RX_VK_KEEP_MODULES=1 keeps all
+    if (!env_on("LONGSHOT_PREPARE_ONLY") && !prepare_left_workers()) {

@@ -841,0 +849,4 @@
+    for (const Stage& st : prog.stages) {
+        if (prog.fallback && (st.vk_stage & (VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_TASK_BIT_EXT | VK_SHADER_STAGE_MESH_BIT_EXT)))
+            continue;
+        if (!st.module && st.code_words) need = true;

@@ -841,0 +866,4 @@
+                ok = fread(spirv.data(), 4, spirv.size(), disk_in) == spirv.size();
+        }
+        if (ok) st.module = make_module(spirv);
+        if (!st.module) return false;

@@ -4156,2 +4165,2 @@
-            if (frame_no % 1800 == 0 && !busy.exchange(true))
-                jobs_push([] {
+            const bool log_malloc = frame_no % 600 == 0 && frame_no % 1800 == 0;
+            const bool check_malloc = log_malloc || (linux_pressed && frame_no % 120 == 0);

@@ -4383,0 +4404,4 @@
+    {
+        uint64_t avail_bytes = 0, swap_free_bytes = 0;
+        const uint64_t avail_res = linux_avail_reserve(), commit_res = commit_reserve();
+        if ((avail_res || commit_res) && linux_pressure::read_meminfo(&avail_bytes, &swap_free_bytes)) {

@@ -4383,0 +4408,4 @@
+            const uint64_t over = linux_pressure::shortfall(avail_bytes, swap_free_bytes, avail_res, commit_res);
+            linux_pressed = over != 0;
+            if (over) {
+                budget = std::min(budget, total_bytes > over ? total_bytes - over : 0);