Hub memory: two allocator arenas, freed memory returned, cache in /health b210727578e8

 "libc",

[target.'cfg(unix)'.dependencies]

# The allocator's arenas and returning freed memory (main.rs).

libc = "0.2"

fn main() -> anyhow::Result<()> {

    tune_allocator();

    let rt = tokio::runtime::Builder::new_multi_thread().enable_all().build()?;

    rt.spawn(return_freed_memory());

    rt.block_on(run())

}

/// glibc's allocator gives each thread that allocates an arena of its own

/// and keeps what is freed in it: under the hub's worker threads, loaded

/// states that the cache had let go still held their pages, and the hub

/// grew to 12 GB with its state cache capped at 3 GiB (oxygenhub#117).

/// Two arenas, as oxy found for its own threads; MALLOC_ARENA_MAX in the

/// environment still has the last word. Called before any thread starts.

fn tune_allocator() {

    #[cfg(all(target_os = "linux", target_env = "gnu"))]

    if std::env::var_os("MALLOC_ARENA_MAX").is_none() {

        // SAFETY: mallopt is called once, before any other thread exists.

        unsafe {

            libc::mallopt(libc::M_ARENA_MAX, 2);

        }

    }

}

/// Hand freed memory back to the system every minute, so the hub's size

/// follows what it holds rather than its peak (oxygenhub#117).

async fn return_freed_memory() {

    #[cfg(all(target_os = "linux", target_env = "gnu"))]

    loop {

        tokio::time::sleep(std::time::Duration::from_secs(60)).await;

        // SAFETY: malloc_trim only releases free pages.

        let _ = tokio::task::spawn_blocking(|| unsafe { libc::malloc_trim(0) }).await;

    }

}

async fn run() -> anyhow::Result<()> {

pub fn budget() -> usize {

    /// What it holds: loaded states, their estimated bytes, and summaries.

    pub fn stats(&self) -> (usize, usize, usize) {

        let (entries, weight) = {

            let guard = self.inner.lock().unwrap();

            (guard.0.len(), guard.0.values().map(|e| e.weight).sum())

        };

        (entries, weight, self.summaries.lock().unwrap().0.len())

    }

    let (states, weight, summaries) = app.repos.cache().stats();

        // What the state cache holds, beside the process's size (#117).

        "state_cache": {

            "states": states,

            "estimated_mb": weight >> 20,

            "budget_mb": crate::repos::cache::budget() >> 20,

            "summaries": summaries,

        },

    let h: serde_json::Value = serde_json::from_str(&health).unwrap();

    assert!(h["state_cache"]["budget_mb"].as_u64().is_some_and(|b| b > 0) && h["state_cache"]["states"].is_u64(), "{health}");