Bookmark summaries: stop walking every state through the cache 2e640ffa6c93

/// What the bookmark lists and a change's "in bookmarks" need of a state:

/// small, so many are kept, and computed without filling the state cache.

/// A repository with more bookmarks than the state cache holds otherwise

/// cycled through it on every such page, so nothing stayed cached

/// (metalgear's 128 bookmarks: 7.7 s per change page, and every page of

/// every repository slower after it).

pub struct Summary {

    pub changes: std::collections::HashSet<ChangeHash>,

    pub latest_ms: u64,

    pub conflicted: bool,

}

/// Summaries kept; each is the state's change set, a few hundred kilobytes

/// for a long history.

const SUMMARIES: usize = 2048;

/// Summaries by heads, each with when it was last used, and the clock.

type Summaries = (HashMap<Key, (Arc<Summary>, u64)>, u64);

    summaries: Mutex<Summaries>,

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

    }

    /// The summary of the state with these heads: from the state cache when

    /// it holds the state, else loaded and dropped, the state cache left as

    /// it was.

    pub fn summary(&self, repo: &Repo, heads: &[ChangeHash]) -> Result<Arc<Summary>, oxy_core::repo::RepoError> {

        let mut sorted = heads.to_vec();

        sorted.sort();

        sorted.dedup();

        let key = Key { repo: repo.id()?, heads: sorted.clone() };

        {

            let mut guard = self.summaries.lock().unwrap();

            let (map, tick) = &mut *guard;

            *tick += 1;

            if let Some(e) = map.get_mut(&key) {

                e.1 = *tick;

                return Ok(e.0.clone());

            }

        }

        let held = self.inner.lock().unwrap().0.get(&key).map(|e| e.loaded.clone());

        let summary = Arc::new(match held {

            Some(l) => summarise(&l.state, &l.snapshot),

            None => {

                let state = repo.load_state(&sorted)?;

                let snapshot = state.materialize();

                summarise(&state, &snapshot)

            }

        });

        let mut guard = self.summaries.lock().unwrap();

        let (map, tick) = &mut *guard;

        if map.len() >= SUMMARIES {

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

                map.remove(&oldest);

            }

        }

        map.insert(key, (summary.clone(), *tick));

        Ok(summary)

fn summarise(state: &State, snapshot: &Snapshot) -> Summary {

    Summary {

        changes: state.changes().map(|(h, _)| *h).collect(),

        latest_ms: state.changes().map(|(_, m)| m.hlc.wall_ms).max().unwrap_or(0),

        conflicted: snapshot.is_conflicted(),

    }

}

    }

    #[test]

    fn summaries_leave_the_state_cache_alone() {

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

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

        let cache = StateCache::new(2);

        let a = cache.summary(&repo, &[]).unwrap();

        assert_eq!(cache.len(), 0, "a summary does not fill the state cache");

        assert!(Arc::ptr_eq(&a, &cache.summary(&repo, &[]).unwrap()), "kept");

        assert!(a.changes.is_empty() && !a.conflicted);

        assert!(cache.summary(&repo, &[oxy_core::hash::ObjectRef([3; 32])]).is_err());

        if cache.summary(repo, &b.heads)?.changes.contains(hash) {

        if cache.summary(repo, &t.heads)?.changes.contains(hash) {

        let s = cache.summary(repo, &b.heads)?;

            changes: s.changes.len(),

            conflicted: s.conflicted,

            latest_ms: s.latest_ms,

        // Only a conflicted state is loaded whole.

        if !cache.summary(repo, &b.heads)?.conflicted {

            continue;

        }