State cache: bound it by size as well as count 736ae87ef318

    /// Its estimated size in bytes (`weight`).

    weight: usize,

/// A loaded state's estimated size: its rendered text three times over (the

/// text, and the line graphs it was rendered from), plus a kilobyte per

/// change. Rough, but proportional: a repository of large files weighs

/// more than one of small ones.

fn weight(l: &Loaded) -> usize {

    let text: usize = l

        .snapshot

        .files

        .values()

        .map(|f| match &f.content {

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

            _ => 64,

        })

        .sum();

    text.saturating_mul(3).saturating_add(l.state.len().saturating_mul(1024))

}

/// What the state cache may hold, in bytes: OXYHUB_STATE_CACHE_MB, else

/// 3 GiB. A count alone let a few large repositories' states grow the hub

/// to 17 GB.

fn budget() -> usize {

    std::env::var("OXYHUB_STATE_CACHE_MB").ok().and_then(|v| v.parse::<usize>().ok()).unwrap_or(3 * 1024).saturating_mul(1 << 20)

}

    /// Bytes of estimated state it may hold (`budget`).

    budget: usize,

        StateCache::with_budget(capacity, budget())

    }

    pub fn with_budget(capacity: usize, budget: usize) -> StateCache {

        StateCache { capacity: capacity.max(1), budget, inner: Mutex::new((HashMap::new(), 0)), summaries: Mutex::new((HashMap::new(), 0)) }

        let w = weight(&loaded);

        // The oldest go until it fits by count and by size; the new one

        // stays even when it alone is over the budget.

        let budget = self.budget;

        let mut total: usize = map.values().map(|e| e.weight).sum::<usize>() + w;

        while !map.is_empty() && (map.len() >= self.capacity || total > budget) {

            let Some(oldest) = map.iter().min_by_key(|(_, e)| e.last_used).map(|(k, _)| k.clone()) else {

                break;

            };

            if let Some(e) = map.remove(&oldest) {

                total -= e.weight;

        map.insert(key, Entry { loaded: loaded.clone(), last_used: *tick, weight: w });

    }

    #[test]

    fn a_size_budget_evicts_the_oldest_and_keeps_the_newest() {

        let dir = tempfile::tempdir().unwrap();

        let repo = Repo::init(dir.path()).unwrap();

        std::fs::write(dir.path().join("a.txt"), "a\n".repeat(1000)).unwrap();

        let one = repo.commit("one", &[]).unwrap();

        std::fs::write(dir.path().join("b.txt"), "b\n".repeat(1000)).unwrap();

        let two = repo.commit("two", &[]).unwrap();

        // Room for nothing: each load stays, the one before goes.

        let cache = StateCache::with_budget(64, 0);

        cache.load(&repo, &[one]).unwrap();

        assert_eq!(cache.len(), 1, "kept though over the budget");

        cache.load(&repo, &[two]).unwrap();

        assert_eq!(cache.len(), 1, "the older one went");

        // Room for plenty: both stay.

        let roomy = StateCache::with_budget(64, 1 << 30);

        roomy.load(&repo, &[one]).unwrap();

        roomy.load(&repo, &[two]).unwrap();

        assert_eq!(roomy.len(), 2);