State cache: weigh a loaded state by what it really costs d2077a57b1f9

/// A loaded state's estimated size (oxygenhub#246): five bytes per byte of

/// text and 384 per line (each file's line graph), and a kilobyte per change.

/// Measured on 2026-10-17 against what loading a state really adds to the

/// process (`measures_a_real_state`): oxygen's states ~85 MiB, oxygenhub's

/// ~70 MiB, which this puts at 88 and 75. The older "text three times over"

/// said 18 and 28, so a cache that thought it held 2.5 GB held 6-8 GB.

    let (mut text, mut lines) = (0usize, 0usize);

    for f in l.snapshot.files.values() {

        match &f.content {

            oxy_core::state::FileContent::Text { bytes, .. } => {

                text += bytes.len();

                lines += bytes.iter().filter(|b| **b == b'\n').count() + 1;

            }

            _ => text += 64,

        }

    }

    text.saturating_mul(5).saturating_add(lines.saturating_mul(384)).saturating_add(l.state.len().saturating_mul(1024))

    /// What a loaded state really costs against `weight` (oxygenhub#246):

    /// `OXYHUB_MEASURE_REPO=path cargo test -p oxygenhub --lib

    /// measures_a_real_state -- --ignored --nocapture`.

    #[test]

    #[ignore]

    fn measures_a_real_state() {

        fn rss_kib() -> usize {

            let s = std::fs::read_to_string("/proc/self/status").unwrap();

            s.lines().find(|l| l.starts_with("VmRSS:")).and_then(|l| l.split_whitespace().nth(1)).unwrap().parse().unwrap()

        }

        let path = std::env::var("OXYHUB_MEASURE_REPO").expect("OXYHUB_MEASURE_REPO");

        let repo = Repo::open(std::path::Path::new(&path)).unwrap();

        let view = repo.view().unwrap();

        // Kept alive, so each load's memory is new, not reused.

        let cache = StateCache::with_budget(64, usize::MAX);

        let mut held = Vec::new();

        for bookmark in view.bookmarks.keys().take(6).cloned().collect::<Vec<_>>() {

            let heads = repo.heads_of(&view, &bookmark).unwrap();

            let before = rss_kib();

            let loaded = cache.load(&repo, &heads).unwrap();

            let after = rss_kib();

            let files = loaded.snapshot.files.len();

            let (mut text, mut lines) = (0usize, 0usize);

            for f in loaded.snapshot.files.values() {

                if let oxy_core::state::FileContent::Text { bytes, .. } = &f.content {

                    text += bytes.len();

                    lines += bytes.iter().filter(|b| **b == b'\n').count();

                }

            }

            println!(

                "{bookmark}: {} changes, {files} files, {} KiB text, {lines} lines: weight {} MiB, resident +{} MiB",

                loaded.state.len(),

                text >> 10,

                weight(&loaded) >> 20,

                (after.saturating_sub(before)) >> 10

            );

            held.push(loaded);

        }

    }