perf: occasional malloc_trim to bound v1 worker RSS

[mikasenghaas]

Summary

• A v1 rollout parses large base64 request bodies (e.g. screenshots) per turn via the interception server and frees them, but glibc keeps the freed arenas — so a long-lived eval / env-server worker's resting RSS climbs and never drops back.
• Add a best-effort trim_memory() (malloc_trim(0) via ctypes) in verifiers/v1/utils.py, resolved once and cached; a no-op off glibc (musl, macOS).
• Call it occasionally — once every _TRIM_EVERY_ROLLOUTS (16) finished rollouts, gated in Episode.run — so freed arenas go back to the OS without putting the arena walk on the hot path. Both the eval runner and the env-server training worker drive rollouts through Episode.run, so both are covered.
• Run the trim off the event loop: malloc_trim(0) walks every arena's free lists and can block for tens of ms on exactly the large/fragmented heaps this targets. Inline that would stall the whole event loop — and under the multiplexed env server, every concurrent rollout with it. trim_memory_periodically() offloads via asyncio.to_thread; ctypes releases the GIL during the call, so the heap walk runs concurrently with the loop.

---

Note

Low Risk
Operational memory tuning only; best-effort no-op on non-glibc platforms and runs off the hot path in a background thread.

Overview
Adds periodic glibc heap trimming so long-lived v1 workers (eval runner and env-server) don’t keep climbing resting RSS after rollouts free large per-turn bodies (e.g. base64 screenshots) that glibc still holds in arenas.

New helpers in verifiers/v1/utils.py: trim_memory() resolves and caches malloc_trim(0) via ctypes (no-op off glibc), and trim_memory_periodically() runs it every 16 finished rollouts on a worker thread via asyncio.to_thread so the arena walk doesn’t block the event loop.

Episode.run awaits trim_memory_periodically() after each rollout completes, so every path that drives rollouts through episodes gets the behavior without per-caller wiring.

^{Reviewed by Cursor Bugbot for commit 8700a46. Bugbot is set up for automated code reviews on this repo. Configure here.}

Note

Call malloc_trim periodically in v1 workers to bound RSS growth

• Adds trim_memory_periodically() in utils.py that calls glibc's malloc_trim(0) every 16 rollouts via asyncio.to_thread, returning freed per-turn request body memory to the OS.
• On non-glibc platforms, trim_memory resolves to a no-op after the first failed ctypes lookup.
• episode.py awaits trim_memory_periodically() after each rollout completes.
• Risk: introduces a worker-thread dispatch every 16 rollouts; negligible on glibc, no-op elsewhere.

^{Macroscope summarized 8700a46.}

[macroscopeapp]

Approvability

Verdict: Approved

This PR adds a memory optimization that periodically calls glibc's malloc_trim to reduce worker RSS. The change is purely operational (no functional behavior changes), defensive (no-op on non-glibc systems), and well-isolated. The author is the primary maintainer of this v1 module.

^{You can customize Macroscope's approvability policy. Learn more.}