// The room the card and the system have, as a level per side (mem_budget.h): sampled every MEM_BUDGET_PERIOD_MS on the // "mem budget" thread, logged when a level changes, read by the owners of memory that can be given back (gfx_shader.c // "SPIR-V at rest" compresses sooner when the system is tight) and shown in the memory report (vk_memory.c system_log). // A sample is one driver query (vk_mem_vram) and two system calls (plat_commit_info, plat_mem_info): well under a // millisecond, never on a drawing thread. #include #include "cfg.h" #include "host.h" #include "mem_budget.h" #include "platform/platform.h" #include "vk.h" static struct { PlatOnce once; PlatMutex vram_lock; // held over a video memory sample: mem_budget_vram(0) waits for it int vram_on; // the device is up (under vram_lock) uint64_t test_mb[MEM_SIDES]; // MEM_BUDGET_TEST_VRAM_MB, MEM_BUDGET_TEST_RAM_MB; 0 off volatile int32_t level[MEM_SIDES]; volatile int32_t known[MEM_SIDES]; volatile uint32_t free_pm[MEM_SIDES]; } B = {PLAT_ONCE_INIT, PLAT_MUTEX_INIT, 0, {0, 0}, {MEM_NORMAL, MEM_NORMAL}, {0, 0}, {0, 0}}; static const char *const side_name[MEM_SIDES] = {"video memory", "system memory"}; // The video memory's room: the driver's budget (at most MEM_BUDGET_TEST_VRAM_MB) less this process's use. 0 while the // device is not up or the driver gives no figure. static int sample_vram(MemRoom *r, char *what, size_t cap) { uint64_t used = 0, budget = 0; int exact = 0, ok = 0; plat_mutex_lock(&B.vram_lock); if (B.vram_on) ok = vk_mem_vram(&used, &budget, &exact); plat_mutex_unlock(&B.vram_lock); if (!ok || !budget) return 0; uint64_t u = used >> 20, l = budget >> 20, t = B.test_mb[MEM_VRAM]; if (t && t < l) l = t; *r = mem_room(u, l); snprintf(what, cap, "%llu of %llu MiB in use%s%s", (unsigned long long)u, (unsigned long long)l, exact ? "" : ", the allocator's own estimate", t ? ", MEM_BUDGET_TEST_VRAM_MB" : ""); return 1; } // The system's room: the lower of the commit's headroom and the physical memory free; with MEM_BUDGET_TEST_RAM_MB // that many MiB less this process's commit. static int sample_ram(MemRoom *r, char *what, size_t cap) { double proc, used, limit; float pused, ptotal, pws; plat_commit_info(&proc, &used, &limit); plat_mem_info(&pused, &ptotal, &pws); uint64_t t = B.test_mb[MEM_RAM]; if (t) { if (proc < 0) return 0; *r = mem_room((uint64_t)proc, t); snprintf(what, cap, "this process's commit %.0f of %llu MiB, MEM_BUDGET_TEST_RAM_MB", proc, (unsigned long long)t); return 1; } int have_c = used >= 0 && limit > 0, have_p = pused >= 0 && ptotal > 0; if (!have_c && !have_p) return 0; MemRoom none = {1000, UINT64_MAX}; MemRoom c = have_c ? mem_room((uint64_t)used, (uint64_t)limit) : none; MemRoom p = have_p ? mem_room((uint64_t)pused, (uint64_t)ptotal) : none; *r = mem_room_min(c, p); snprintf(what, cap, "commit %.0f of %.0f MiB, physical memory %.0f of %.0f MiB in use", used, limit, (double)pused, (double)ptotal); return 1; } static void budget_main(void *arg) { (void)arg; for (;;) { for (int side = 0; side < MEM_SIDES; side++) { MemRoom r; char what[200]; if (!(side == MEM_VRAM ? sample_vram(&r, what, sizeof what) : sample_ram(&r, what, sizeof what))) continue; int known = __atomic_load_n(&B.known[side], __ATOMIC_RELAXED), was = B.level[side]; int now = mem_level_next(known ? was : MEM_ROOMY, r); // the first sample: its level as it is __atomic_store_n(&B.free_pm[side], r.free_pm, __ATOMIC_RELAXED); __atomic_store_n(&B.level[side], now, __ATOMIC_RELAXED); __atomic_store_n(&B.known[side], 1, __ATOMIC_RELEASE); if (!known || now != was) { char from[32] = ""; if (known) snprintf(from, sizeof from, ", was %s", mem_level_name[was]); rt_log("mem_budget: %s %s, %.1f%% free (%s%s)", side_name[side], mem_level_name[now], r.free_pm / 10.0, what, from); } } plat_sleep_ms(MEM_BUDGET_PERIOD_MS); } } static void budget_start(void *arg) { (void)arg; int tv = cfg_int("NX2NAVI_MEM_BUDGET_TEST_VRAM_MB"), tr = cfg_int("NX2NAVI_MEM_BUDGET_TEST_RAM_MB"); B.test_mb[MEM_VRAM] = tv > 0 ? (uint64_t)tv : 0, B.test_mb[MEM_RAM] = tr > 0 ? (uint64_t)tr : 0; if (B.test_mb[MEM_VRAM] || B.test_mb[MEM_RAM]) rt_log("mem_budget: a test pretends a smaller budget (video memory %llu MiB, system memory %llu MiB; 0: as it is): " "the levels follow it, the texture cache's own rules do not", (unsigned long long)B.test_mb[MEM_VRAM], (unsigned long long)B.test_mb[MEM_RAM]); if (!plat_thread_spawn(budget_main, NULL, "mem budget", 0)) rt_log("mem_budget: cannot start its thread; every level stays normal"); } void mem_budget_vram(int on) { plat_mutex_lock(&B.vram_lock); B.vram_on = on; plat_mutex_unlock(&B.vram_lock); if (on) plat_once(&B.once, budget_start, NULL); } int mem_budget_level(int side) { if (side < 0 || side >= MEM_SIDES) return MEM_NORMAL; return __atomic_load_n(&B.level[side], __ATOMIC_RELAXED); } void mem_budget_text(char *out, unsigned cap) { size_t k = 0; if (cap) out[0] = 0; for (int side = 0; side < MEM_SIDES && k < cap; side++) { int n; if (__atomic_load_n(&B.known[side], __ATOMIC_ACQUIRE)) n = snprintf(out + k, cap - k, "%s%s %s (%.1f%% free)", side ? ", " : "", side_name[side], mem_level_name[__atomic_load_n(&B.level[side], __ATOMIC_RELAXED)], __atomic_load_n(&B.free_pm[side], __ATOMIC_RELAXED) / 10.0); else n = snprintf(out + k, cap - k, "%s%s not sampled yet", side ? ", " : "", side_name[side]); if (n < 0) break; k += (size_t)n; } }