Render faster in deep histories: memoised dependency answers, read locks, merges on every core aedfe465b611

## Unreleased

- **A long push goes in parts (#95).** `oxy push` sent a whole history in one request, held in memory on both sides; the full VS Code import would have passed a hub's 4 GiB limit. It now sends parts of about `push.batch-bytes` (default 256 MiB) in dependency order, objects alone, and the last part moves the bookmark; the spinner says which part is going. A server stores a part and reports it as `objects`.

- **A state index read only as far as it is used (#94).** Each file's history in the workspace's state index is stored after the rest with a hash of its own, and is read and checked only when a command builds that file, so a diff or a one-file cat no longer reads and hashes the histories of every file (67 MB of an 84 MB index on VS Code at 20 000 commits). Changes added on top of an index no longer decode the histories they touch. A history found damaged is an error that says so, and the index is removed and rebuilt by the next command. Under load on that repository, `diff` went from 85 ms to 63 ms and `cat`/`blame` from 102 ms to 80 ms.

    fn depends_on(&self, a: &ChangeHash, b: &ChangeHash) -> bool;

}

/// No change depends on any other: every pair commutes.

pub struct NoDeps;

impl DepOracle for NoDeps {

    /// Order the live atoms and locate conflicts.

    pub fn materialize(&self, deps: &dyn DepOracle) -> Materialized {

        let lines = |order: Vec<AtomKey>| Materialized {

            segments: if order.is_empty() {

                vec![]

};

use crate::tree::{TreeGraph, TreeView};

use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};

/// Checkpoint payload version 2 (spec §11): file graphs by reference.

pub const CHECKPOINT_INDEX_VERSION: u64 = 2;

    /// every change asked about grew with the square of history: #25). A

    /// mutex, not a `RefCell`, so a loaded state can be shared across

    /// threads by a host that caches it.

    /// Each change's level: 0 with no dependencies, else one more than its

    /// highest dependency. A change can only depend on changes of lower

    /// level, which bounds the walk [`DepOracle::depends_on`] does.

    /// `None` for a full state. For a history-only state (loaded for its

    /// changes and tree), the file graphs not built yet, by node: `files`

    /// holds only those loaded with [`State::load_graphs`].

            files: self.files.clone(),

            replaces: self.replaces.clone(),

            // A cache: the clone builds its own.

            deferred: self.deferred.clone(),

        }

    }

        self.apply_with(h, change, texts);

        self.changes.insert(h, Arc::new(meta));

        {

            m.sets.clear();

            m.held = 0;

        }

    /// Transitive dependencies of `h`, excluding `h` itself.

    pub fn closure(&self, h: &ChangeHash) -> Arc<HashSet<ChangeHash>> {

            return c.clone();

        }

        let mut out = HashSet::new();

            }

        }

        let rc = Arc::new(out);

        if memo.held + rc.len() > CLOSURE_MEMO_HASHES {

            memo.sets.clear();

            memo.held = 0;

    /// yet known, without recursion: histories are deeper than a stack. An

    /// unknown change has level 0.

    fn level(&self, h: &ChangeHash) -> u32 {

        if let Some(l) = levels.get(h) {

            return *l;

        }

        view: crate::tree::TreeView,

        paths: impl IntoIterator<Item = &'p str>,

    ) -> Snapshot {

            .into_iter()

            .collect();

        Snapshot {

            tree: view,

        if a == b {

            return true;

        }

            return c.contains(b);

        }

        if !self.changes.contains_key(b) {

        if self.level(a) <= lb {

            return false;

        }

        let mut stack: Vec<ChangeHash> = self

            .changes

            .get(a)

            let unknown = ObjectRef([0xee; 32]);

            for a in &all {

                let want = st.closure(a).clone();

                for b in all.iter().chain([&unknown]) {

                    assert_eq!(

                        st.depends_on(a, b),

                    );

                }

            }

        }

    }