Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Python agentaianthropicclaude-codecompressioncontext-engineeringcontext-windowcursorfastapilangchainllmmcpopenaiprompt-engineeringproxypythonragtoken-optimizationtokenstypescript
fix(proxy): tune macOS libmalloc and trim allocator pages so long-lived RSS stays bounded (#2879)
Abhay Singh6d87825f62e4
diff --git a/headroom/cli/proxy.py b/headroom/cli/proxy.pyindex 73e2aee8a..9e9309dd8 100644--- a/headroom/cli/proxy.py+++ b/headroom/cli/proxy.py@@ -113,6 +113,35 @@ def _get_env_bool_optional(name: str) -> bool | None:return _get_env_bool(name, False)+# libmalloc reads these before main() runs, so they cannot be set from inside+# the current process — the proxy re-execs itself once to apply them. Without+# them, freed pages from large concurrent request bodies stay resident+# (``vmmap`` shows whole "MALLOC_LARGE (empty)" regions) and long-lived proxy+# RSS only ratchets upward (#2820). Vars the operator already set are left+# untouched; HEADROOM_MALLOC_TUNING=0 disables the re-exec entirely.+_MALLOC_TUNING = {+ "MallocAggressiveMadvise": "1", # madvise freed pages back to the OS eagerly+ "MallocLargeCache": "0", # no death-row cache for freed large allocations+}+++def _reexec_with_malloc_tuning() -> None:+ if sys.platform != "darwin":+ return+ if not _get_env_bool("HEADROOM_MALLOC_TUNING", True):+ return+ if os.environ.get("_HEADROOM_MALLOC_TUNED") == "1":+ return+ missing = {k: v for k, v in _MALLOC_TUNING.items() if k not in os.environ}+ # Set the loop guard before the re-exec so the replacement process (which+ # inherits this environment) skips this path instead of re-execing forever.+ os.environ["_HEADROOM_MALLOC_TUNED"] = "1"+ if not missing:+ return+ os.environ.update(missing)+ os.execv(sys.executable, [sys.executable, "-m", "headroom.cli", *sys.argv[1:]])++def _get_env_int_optional(name: str) -> int | None:val = os.environ.get(name)if val is None or val == "":@@ -1065,6 +1094,7 @@ def proxy(Usage with OpenAI-compatible clients:OPENAI_BASE_URL=http://localhost:8787/v1 your-app"""+ _reexec_with_malloc_tuning()ensure_proxy_dependencies()# Import here to avoid slow startup@@ -1261,6 +1291,10 @@ def proxy(rate_limit_requests_per_minute=rpm if rpm is not None else 60,rate_limit_tokens_per_minute=tpm if tpm is not None else 100_000,compress_user_messages=_get_env_bool("HEADROOM_COMPRESS_USER_MESSAGES", False),+ periodic_malloc_trim_enabled=_get_env_bool(+ "HEADROOM_MALLOC_TRIM", sys.platform == "darwin"+ ),+ malloc_trim_interval_seconds=_get_env_int("HEADROOM_MALLOC_TRIM_INTERVAL_SECONDS", 60),min_tokens_to_crush=_get_env_int("HEADROOM_MIN_TOKENS", 500),max_items_after_crush=_get_env_int("HEADROOM_MAX_ITEMS", 50),exclude_tools=_parse_exclude_tools(None) or None,diff --git a/headroom/proxy/malloc_trim.py b/headroom/proxy/malloc_trim.pynew file mode 100644index 000000000..d7cd06eff--- /dev/null+++ b/headroom/proxy/malloc_trim.py@@ -0,0 +1,135 @@+"""Return freed-but-retained allocator pages to the OS on long-lived proxies.++Large concurrent Anthropic bodies (0.5-1 MB of JSON parsed, deep-copied and+re-serialized per in-flight request) drive libmalloc and pymalloc to a+high-water mark that is never returned to the OS: after a burst the malloc+zones keep entire regions resident but empty (``vmmap`` lists them as+``MALLOC_LARGE (empty)`` / ``MALLOC_SMALL (empty)``), so process RSS only+ratchets upward. Over a multi-day proxy lifetime under Claude Code traffic+this reaches double-digit GB and starves the host.++Neither runtime returns these pages on its own. macOS exposes+``malloc_zone_pressure_relief(NULL, 0)`` to purge every zone's free pages;+glibc has ``malloc_trim(0)``. ``trim()`` calls that entry point directly: it is+a C call that releases the GIL and reclaims whatever is already on the+allocator's free lists. It deliberately does not run a Python ``gc.collect()``+-- a full cyclic collection holds the GIL, and this periodic task runs off the+event-loop thread precisely so it cannot stall request handling; freeing cyclic+garbage is left to CPython's own automatic collection.+"""++from __future__ import annotations++import asyncio+import ctypes+import logging+import sys+import time++logger = logging.getLogger(__name__)++# Interval bounds for the periodic trim task. A non-positive interval would make+# ``asyncio.sleep`` return immediately and spin a continuous collect/trim loop,+# so anything below the minimum falls back to the default.+_DEFAULT_TRIM_INTERVAL_SECONDS = 60+_MIN_TRIM_INTERVAL_SECONDS = 1++# Lazily resolved (platform_tag, foreign_function | None). ``None`` function+# means the platform has no supported trim call and trim() is a no-op.+_relief: tuple[str, object | None] | None = None+++def _resolve() -> tuple[str, object | None]:+ global _relief+ if _relief is not None:+ return _relief+ try:+ libc = ctypes.CDLL(None)+ if sys.platform == "darwin":+ fn = libc.malloc_zone_pressure_relief+ fn.argtypes = [ctypes.c_void_p, ctypes.c_size_t]+ fn.restype = ctypes.c_size_t+ _relief = ("darwin", fn)+ else:+ fn = libc.malloc_trim+ fn.argtypes = [ctypes.c_size_t]+ fn.restype = ctypes.c_int+ _relief = ("glibc", fn)+ except (OSError, AttributeError):+ _relief = ("unsupported", None)+ return _relief+++def trim() -> int:+ """Return allocator free pages to the OS.++ Calls the platform's allocator pressure-relief entry point+ (``malloc_zone_pressure_relief`` on macOS, ``malloc_trim`` on glibc). This+ is a C call that releases the GIL for its duration and reclaims pages+ already on the allocator's free lists. It deliberately does *not* run a+ Python ``gc.collect()`` (a full cyclic collection holds the GIL); cyclic+ garbage is left to CPython's automatic collection, so this off-thread+ periodic task never holds the GIL for a full-heap traversal.++ Returns the number of bytes freed on macOS (glibc's ``malloc_trim``+ reports only success, so 0 is returned there and on unsupported+ platforms).+ """+ kind, fn = _resolve()+ if fn is None:+ return 0+ if kind == "darwin":+ return int(fn(None, 0)) # type: ignore[operator]+ fn(0) # type: ignore[operator]+ return 0+++async def trim_periodically(interval_seconds: int = 60) -> None:+ """Background task that periodically returns allocator free pages to the OS.++ Runs in every worker process (allocator state is per-process). The trim is+ the platform's allocator pressure-relief C call+ (``malloc_zone_pressure_relief``/``malloc_trim``), dispatched via+ ``asyncio.to_thread`` so it runs off the event-loop thread. Because it is a+ C call that releases the GIL and runs no Python ``gc.collect()``, it holds+ the GIL only as briefly as the to_thread hand-off, so a slow purge on a+ large heap does not stall request handling. The task exits immediately on+ platforms with no supported trim call, so it is a true no-op there.++ Args:+ interval_seconds: How often to trim (default: 60 seconds). A value below+ ``_MIN_TRIM_INTERVAL_SECONDS`` (which would busy-loop) falls back to+ the default.+ """+ _, fn = _resolve()+ if fn is None:+ # No supported allocator-trim call on this platform (Windows, musl, ...);+ # do not spin a wakeup task that can only ever no-op.+ logger.debug("MallocTrim: no supported trim on %s; task disabled", sys.platform)+ return++ if interval_seconds < _MIN_TRIM_INTERVAL_SECONDS:+ logger.warning(+ "MallocTrim: interval %ss is below the %ds minimum; using default %ds",+ interval_seconds,+ _MIN_TRIM_INTERVAL_SECONDS,+ _DEFAULT_TRIM_INTERVAL_SECONDS,+ )+ interval_seconds = _DEFAULT_TRIM_INTERVAL_SECONDS++ while True:+ await asyncio.sleep(interval_seconds)+ try:+ start = time.perf_counter()+ # Off the event-loop thread: the C-level purge can pause for a while+ # on a large heap, and that pause must not stall proxy traffic.+ freed = await asyncio.to_thread(trim)+ elapsed_ms = (time.perf_counter() - start) * 1000+ log = logger.info if freed >= (16 << 20) else logger.debug+ log(+ "MallocTrim: returned %.1f MB to OS in %.0f ms",+ freed / 1048576,+ elapsed_ms,+ )+ except Exception as e:+ logger.debug("MallocTrim failed: %s", e)diff --git a/headroom/proxy/models.py b/headroom/proxy/models.pyindex 92c6ef366..f3331f46e 100644--- a/headroom/proxy/models.py+++ b/headroom/proxy/models.py@@ -7,6 +7,7 @@ Extracted from server.py to keep the codebase maintainable.from __future__ import annotationsimport logging+import sysfrom dataclasses import InitVar, dataclass, fieldfrom datetime import datetimefrom typing import Any, Literal@@ -439,6 +440,17 @@ class ProxyConfig:# Env: HEADROOM_PERIODIC_TOIN_STATS=0.periodic_toin_stats_enabled: bool = True+ # Periodic allocator trim. Long-lived proxies processing large concurrent+ # request bodies ratchet RSS through freed-but-retained allocator pages;+ # this returns them to the OS (malloc_zone_pressure_relief on macOS,+ # malloc_trim on glibc). Default-on only on macOS, where the retained-page+ # ratchet is the documented failure (#2820); an opt-in elsewhere via+ # HEADROOM_MALLOC_TRIM=1 so glibc deployments do not silently take on a+ # once-a-minute allocator purge they did not ask for. Envs:+ # HEADROOM_MALLOC_TRIM=0/1, HEADROOM_MALLOC_TRIM_INTERVAL_SECONDS.+ periodic_malloc_trim_enabled: bool = field(default_factory=lambda: sys.platform == "darwin")+ malloc_trim_interval_seconds: int = 60+# Stateless mode — disable all filesystem writes for read-only / container deploymentsstateless: bool = Falsediff --git a/headroom/proxy/server.py b/headroom/proxy/server.pyindex 5a15f5f4a..c3a137b5d 100644--- a/headroom/proxy/server.py+++ b/headroom/proxy/server.py@@ -144,6 +144,7 @@ from headroom.proxy.helpers import ()from headroom.proxy.loop_callback_failure_policy import is_known_websocket_callback_failurefrom headroom.proxy.loopback_guard import is_loopback_host+from headroom.proxy.malloc_trim import trim_periodicallyfrom headroom.proxy.memory_handler import MemoryConfig, MemoryHandler# Data models (extracted to headroom/proxy/models.py for maintainability)@@ -2601,6 +2602,7 @@ def create_app(config: ProxyConfig | None = None) -> FastAPI:app.state.ready = Falseapp.state.startup_error = Noneapp.state.periodic_toin_stats_task = None+ app.state.periodic_malloc_trim_task = Nonetry:try:@@ -2611,6 +2613,12 @@ def create_app(config: ProxyConfig | None = None) -> FastAPI:app.state.periodic_toin_stats_task = asyncio.create_task(_log_toin_stats_periodically())+ # Per-worker on purpose: allocator state is per-process, so+ # every worker must trim its own zones (no beacon-owner gate).+ if config.periodic_malloc_trim_enabled:+ app.state.periodic_malloc_trim_task = asyncio.create_task(+ trim_periodically(config.malloc_trim_interval_seconds)+ )if proxy.usage_reporter:await proxy.usage_reporter.start(proxy)if proxy.traffic_learner:@@ -2670,6 +2678,16 @@ def create_app(config: ProxyConfig | None = None) -> FastAPI:)app.state.periodic_toin_stats_task = None+ periodic_malloc_trim_task = app.state.periodic_malloc_trim_task+ if periodic_malloc_trim_task is not None:+ periodic_malloc_trim_task.cancel()+ await _timed(+ asyncio.gather(periodic_malloc_trim_task, return_exceptions=True),+ label="periodic_malloc_trim.stop",+ timeout=3.0,+ )+ app.state.periodic_malloc_trim_task = None+if _cc_reconciler is not None:await _timed(_cc_reconciler.stop(), label="cc_reconciler.stop", timeout=3.0)if _beacon_is_owner[0]:@@ -5160,6 +5178,10 @@ def _proxy_config_from_env() -> ProxyConfig:http2=_get_env_bool("HEADROOM_HTTP2", True),http_proxy=os.environ.get("HEADROOM_HTTP_PROXY") or None,periodic_toin_stats_enabled=_get_env_bool("HEADROOM_PERIODIC_TOIN_STATS", True),+ periodic_malloc_trim_enabled=_get_env_bool(+ "HEADROOM_MALLOC_TRIM", sys.platform == "darwin"+ ),+ malloc_trim_interval_seconds=_get_env_int("HEADROOM_MALLOC_TRIM_INTERVAL_SECONDS", 60),proxy_token=os.environ.get("HEADROOM_PROXY_TOKEN") or None,offline=_get_env_bool("HEADROOM_OFFLINE", False),# Default mode is CACHE (Headroom's coding posture): delta-only compressiondiff --git a/tests/test_malloc_tuning.py b/tests/test_malloc_tuning.pynew file mode 100644index 000000000..6b490242b--- /dev/null+++ b/tests/test_malloc_tuning.py@@ -0,0 +1,288 @@+"""macOS libmalloc tuning: pre-main re-exec gating + periodic allocator trim (#2820)."""++from __future__ import annotations++import asyncio++import pytest++import headroom.cli.proxy as proxy_cli+from headroom.proxy import malloc_trim+++class _ExecCalled(Exception):+ """Sentinel so a fake execv can stop execution the way real execv would."""+++def _fake_execv(recorder: dict):+ def _execv(path, argv): # noqa: ANN001+ recorder["path"] = path+ recorder["argv"] = list(argv)+ raise _ExecCalled++ return _execv++[email protected](autouse=True)+def _clean_malloc_env(monkeypatch):+ for var in (+ "HEADROOM_MALLOC_TUNING",+ "_HEADROOM_MALLOC_TUNED",+ "MallocAggressiveMadvise",+ "MallocLargeCache",+ ):+ monkeypatch.delenv(var, raising=False)+++# --------------------------------------------------------------------------- #+# _reexec_with_malloc_tuning+# --------------------------------------------------------------------------- #+def test_reexec_noop_off_darwin(monkeypatch):+ monkeypatch.setattr(proxy_cli.sys, "platform", "linux")+ rec: dict = {}+ monkeypatch.setattr(proxy_cli.os, "execv", _fake_execv(rec))+ proxy_cli._reexec_with_malloc_tuning() # must not raise / exec+ assert rec == {}+++def test_reexec_respects_opt_out(monkeypatch):+ monkeypatch.setattr(proxy_cli.sys, "platform", "darwin")+ monkeypatch.setenv("HEADROOM_MALLOC_TUNING", "0")+ rec: dict = {}+ monkeypatch.setattr(proxy_cli.os, "execv", _fake_execv(rec))+ proxy_cli._reexec_with_malloc_tuning()+ assert rec == {}+++def test_reexec_guard_prevents_loop(monkeypatch):+ monkeypatch.setattr(proxy_cli.sys, "platform", "darwin")+ monkeypatch.setenv("_HEADROOM_MALLOC_TUNED", "1")+ rec: dict = {}+ monkeypatch.setattr(proxy_cli.os, "execv", _fake_execv(rec))+ proxy_cli._reexec_with_malloc_tuning()+ assert rec == {}+++def test_reexec_skips_when_operator_already_set_vars(monkeypatch):+ monkeypatch.setattr(proxy_cli.sys, "platform", "darwin")+ monkeypatch.setenv("MallocAggressiveMadvise", "1")+ monkeypatch.setenv("MallocLargeCache", "0")+ rec: dict = {}+ monkeypatch.setattr(proxy_cli.os, "execv", _fake_execv(rec))+ proxy_cli._reexec_with_malloc_tuning()+ # No re-exec (vars present), but the guard is still stamped.+ assert rec == {}+ assert proxy_cli.os.environ.get("_HEADROOM_MALLOC_TUNED") == "1"+++def test_reexec_sets_vars_and_execs_once(monkeypatch):+ monkeypatch.setattr(proxy_cli.sys, "platform", "darwin")+ monkeypatch.setattr(proxy_cli.sys, "executable", "/usr/bin/python3")+ monkeypatch.setattr(proxy_cli.sys, "argv", ["headroom", "proxy", "--port", "8787"])+ rec: dict = {}+ monkeypatch.setattr(proxy_cli.os, "execv", _fake_execv(rec))++ with pytest.raises(_ExecCalled):+ proxy_cli._reexec_with_malloc_tuning()++ # The tuning knobs and the loop guard are exported to the replacement process.+ assert proxy_cli.os.environ["MallocAggressiveMadvise"] == "1"+ assert proxy_cli.os.environ["MallocLargeCache"] == "0"+ assert proxy_cli.os.environ["_HEADROOM_MALLOC_TUNED"] == "1"+ # Re-exec normalizes to `python -m headroom.cli <args>`, preserving the PID.+ assert rec["path"] == "/usr/bin/python3"+ assert rec["argv"] == ["/usr/bin/python3", "-m", "headroom.cli", "proxy", "--port", "8787"]+++# --------------------------------------------------------------------------- #+# malloc_trim.trim / trim_periodically+# --------------------------------------------------------------------------- #+def test_trim_calls_platform_fn(monkeypatch):+ def fake_fn(ptr, size): # noqa: ANN001 (mac signature)+ return 4096++ monkeypatch.setattr(malloc_trim, "_resolve", lambda: ("darwin", fake_fn))+ assert malloc_trim.trim() == 4096+++def test_trim_never_runs_python_gc(monkeypatch):+ # The periodic trim must NOT trigger a full cyclic collection: gc.collect()+ # holds the GIL for a whole-heap traversal, which would stall the event loop+ # even though the C purge itself is dispatched off-thread. Only the+ # GIL-releasing allocator C call may run.+ import gc++ ran: list[str] = []+ monkeypatch.setattr(gc, "collect", lambda *a, **k: ran.append("gc") or 0)+ monkeypatch.setattr(malloc_trim, "_resolve", lambda: ("glibc", lambda _size: 0))+ malloc_trim.trim()+ assert ran == []+++def test_trim_is_noop_on_unsupported_platform(monkeypatch):+ monkeypatch.setattr(malloc_trim, "_resolve", lambda: ("unsupported", None))+ assert malloc_trim.trim() == 0+++def test_trim_periodically_trims_each_interval(monkeypatch):+ monkeypatch.setattr(malloc_trim, "_resolve", lambda: ("glibc", object()))+ trims: list[int] = []+ monkeypatch.setattr(malloc_trim, "trim", lambda: trims.append(1) or 0)++ async def fake_sleep(_seconds):+ if len(trims) >= 2: # let two ticks run, then break the loop+ raise asyncio.CancelledError++ monkeypatch.setattr(malloc_trim.asyncio, "sleep", fake_sleep)++ with pytest.raises(asyncio.CancelledError):+ asyncio.run(malloc_trim.trim_periodically(interval_seconds=1))+ assert len(trims) == 2+++def test_trim_periodically_is_disabled_on_unsupported_platform(monkeypatch):+ # No supported trim call: the task must return at once, never scheduling a+ # wakeup (so it is a true no-op on Windows/musl, not a 60s spinner).+ monkeypatch.setattr(malloc_trim, "_resolve", lambda: ("unsupported", None))+ trims: list[int] = []+ monkeypatch.setattr(malloc_trim, "trim", lambda: trims.append(1) or 0)++ async def _no_sleep(_seconds):+ raise AssertionError("unsupported platform must not schedule a trim wakeup")++ monkeypatch.setattr(malloc_trim.asyncio, "sleep", _no_sleep)+ asyncio.run(malloc_trim.trim_periodically(interval_seconds=60)) # returns, no raise+ assert trims == []++[email protected]("bad_interval", [0, -5])+def test_trim_periodically_rejects_non_positive_interval(monkeypatch, bad_interval):+ # A non-positive interval would make asyncio.sleep return immediately and+ # spin a continuous collect/trim loop; it must fall back to the default.+ monkeypatch.setattr(malloc_trim, "_resolve", lambda: ("glibc", object()))+ monkeypatch.setattr(malloc_trim, "trim", lambda: 0)+ slept: list[float] = []++ async def capture_sleep(seconds):+ slept.append(seconds)+ raise asyncio.CancelledError # stop after the first sleep++ monkeypatch.setattr(malloc_trim.asyncio, "sleep", capture_sleep)+ with pytest.raises(asyncio.CancelledError):+ asyncio.run(malloc_trim.trim_periodically(interval_seconds=bad_interval))+ assert slept == [malloc_trim._DEFAULT_TRIM_INTERVAL_SECONDS]+++def test_trim_runs_off_the_event_loop_thread(monkeypatch):+ # The blocking trim must run in a worker thread (via asyncio.to_thread), not+ # on the event loop, so a slow trim cannot stall other async work.+ import threading++ monkeypatch.setattr(malloc_trim, "_resolve", lambda: ("glibc", object()))+ seen: dict[str, int] = {}++ def record():+ seen["thread"] = threading.get_ident()+ return 0++ monkeypatch.setattr(malloc_trim, "trim", record)+ calls = {"n": 0}++ async def sleeper(_seconds):+ calls["n"] += 1+ if calls["n"] >= 2: # first sleep returns; after the trim, stop+ raise asyncio.CancelledError++ monkeypatch.setattr(malloc_trim.asyncio, "sleep", sleeper)++ async def _run() -> int:+ loop_thread = threading.get_ident()+ with pytest.raises(asyncio.CancelledError):+ await malloc_trim.trim_periodically(interval_seconds=60)+ return loop_thread++ loop_thread = asyncio.run(_run())+ assert "thread" in seen # trim actually ran+ assert seen["thread"] != loop_thread # ran off the event-loop thread+++async def test_slow_trim_does_not_stop_unrelated_async_work(monkeypatch):+ # The periodic trim is dispatched off the event-loop thread via+ # asyncio.to_thread and runs no Python gc.collect(), so even a slow purge+ # must not freeze the loop. It is modeled here with a worker-thread park+ # which, like the real GIL-releasing allocator C call, does not hold the+ # GIL while it waits: unrelated coroutines keep making progress meanwhile.+ import threading++ monkeypatch.setattr(malloc_trim, "_resolve", lambda: ("glibc", object()))+ started = threading.Event()+ release = threading.Event()++ def slow_trim() -> int:+ started.set()+ release.wait(5.0) # hold the worker thread until the test lets go+ return 0++ monkeypatch.setattr(malloc_trim, "trim", slow_trim)++ # Fire the trim's interval immediately (the interval is >= 1s) while leaving+ # the counter's sub-second sleeps to behave normally.+ real_sleep = asyncio.sleep++ async def smart_sleep(seconds):+ if seconds >= 1:+ return+ await real_sleep(seconds)++ monkeypatch.setattr(malloc_trim.asyncio, "sleep", smart_sleep)++ ticks = 0++ async def counter() -> None:+ nonlocal ticks+ while True:+ await real_sleep(0.005)+ ticks += 1++ counter_task = asyncio.create_task(counter())+ trim_task = asyncio.create_task(malloc_trim.trim_periodically(interval_seconds=60))+ try:+ # Wait for the trim to actually start blocking a worker thread.+ for _ in range(400):+ if started.is_set():+ break+ await real_sleep(0.005)+ assert started.is_set(), "trim never started"++ # The trim is now parked off-loop. The event loop must keep ticking.+ ticks_before = ticks+ await real_sleep(0.2)+ ticks_during_trim = ticks - ticks_before+ finally:+ release.set()+ counter_task.cancel()+ trim_task.cancel()++ # On-loop blocking would freeze the counter (~0 ticks); off-thread it keeps+ # ticking (~40 in 0.2s). Generous floor for scheduler jitter.+ assert ticks_during_trim >= 10+++# --------------------------------------------------------------------------- #+# ProxyConfig wiring+# --------------------------------------------------------------------------- #+def test_proxy_config_malloc_trim_default_is_darwin_scoped(monkeypatch):+ # Default-on only on macOS (the platform with the documented RSS ratchet);+ # elsewhere it is opt-in, so glibc deployments do not silently take on a+ # once-a-minute allocator purge.+ from headroom.proxy import models++ monkeypatch.setattr(models.sys, "platform", "darwin")+ assert models.ProxyConfig().periodic_malloc_trim_enabled is True++ monkeypatch.setattr(models.sys, "platform", "linux")+ assert models.ProxyConfig().periodic_malloc_trim_enabled is False++ # The interval knob is platform-independent.+ assert models.ProxyConfig().malloc_trim_interval_seconds == 60