The hold lets go of live textures unused for 600 presents and the reserve for 1800: ten and thirty seconds at 60 fps, as
vram_compact.h says, but they were counted in presents. Below 60 fps they stretched: at 3.5 fps (Unity's UHD Graphics
laptop, i3-1115G4) three and nine minutes, and with 1,776 MB of textures held against a budget of 1,299 MB the hold
retired 0 to 13 textures a pass. A texture's age now goes to hold_target as at 60 fps (vram_compact::age_at_60), by the
presents a second over the last ten seconds, measured at each budget look. At 60 fps or more nothing changes.

The eviction's own wait (RX_VK_EVICT_MIN_UNUSED, 60) and the rendered textures' keep (keep_rendered.h) stay in presents
and still run first: the game samples some of those every so many of its frames, and a GPU-drawn one evicted between
two samples comes back empty. Under 2 fps (a load's stall) the age goes as at 2 fps. RX_VK_HOLD_BY_PRESENTS=1: as before.

Co-Authored-By: Cursor <[email protected]>

@@ -500,6 +500,7 @@ Pipeline-cache file ownership, temporary storage and failure behavior are descri
 | `RX_VK_AUTO_PRESET=0`, `RX_VK_AUTO_PRESET_VRAM_MB=<MB>` | A first start keeps the defaults instead of starting on the Quality preset Auto (this PC) (`gpu/vk/auto_settings.h`); the card's video memory taken as that many MB, to see what Auto chooses for a smaller or larger card |
 | `RX_VK_AUTO_TUNE=0` | Auto (this PC) keeps its Render resolution instead of measuring the GPU in play and stepping it: down while frames are missed with the GPU over 90% busy, up while the cap holds with it under half busy (`auto_settings.h` `tune`) |
 | `RX_VK_COMPACT=0`, `RX_VK_COMPACT_PCT=<50..90>`, `RX_VK_COMPACT_MB=<MB>` | VRAM compaction (on by default; `=0` turns it off): the textures that are not render targets in a pool of their own, moved out of sparsely used blocks a few a present so that the blocks go back to the driver, and the texture budget holding the driver's count at that share of what it allows (85) by letting go of the render targets drawn over since and of textures unused for ten seconds, with a reserve five points under it (80) where those unused for thirty seconds go (what the budget's size, the 90% rule and the driver's limit ask for on their own still goes from textures unused for a second, as with it off); the free space that starts a run (512; 192 while the count is over 90%) |
+| `RX_VK_EVICT_BY_PRESENTS=1` | The eviction's waits in seconds counted in presents whatever the frame rate, as before: the compaction's ten and thirty seconds (600 and 1800 presents) and the GPU-drawn textures' keep (a minute, 3600; 600 near the driver's limit). By default, below 60 fps, they go by the presents a second over the last ten seconds (`vram_compact::age_at_60`, `keep_rendered::at_rate`), so they are still those seconds (at 3.5 fps they were three, nine and seventeen minutes); the keep never under 120 presents, as the game samples some GPU-drawn textures every so many of its frames. Nothing changes at 60 fps or more |

@@ -18,0 +23,4 @@
+inline constexpr uint64_t kFloor = 120;
+inline uint64_t at_rate(uint64_t keep, double fps) {
+    if (!(fps > 0) || fps >= 60) return keep;
+    return std::max<uint64_t>((uint64_t)((double)keep * std::max(fps, 2.0) / 60.0), std::min(keep, kFloor));

@@ -4244,0 +4252,4 @@
+        marks.push_back({now, frame_no});
+        while (marks.size() > 2 && now - marks[1].first >= std::chrono::seconds(10)) marks.pop_front();
+        const double span = std::chrono::duration<double>(now - marks.front().first).count();
+        if (!by_presents && span >= 2) present_rate = (double)(frame_no - marks.front().second) / span;