Log, blame and fsck at the scale of the Linux tree 69816d688300

    /// Whether `heads` form a valid state: its history loads and every file

    /// graph builds. Graphs are built a batch at a time and dropped, so the

    /// check needs the memory of a batch, not of the whole tree.

    fn check_state(&self, heads: &[ChangeHash]) -> Result<()> {

        let mut st = self.load_state_history(heads)?;

        let nodes = st.unbuilt_nodes();

        for batch in nodes.chunks(2048) {

            self.load_graphs_of(&mut st, batch)?;

            st.drop_graphs(batch);

        }

        Ok(())

    }

            let mut checked: HashSet<ObjectRef> = HashSet::new();

                if !checked.insert(*st) {

                    continue;

                }

                if let Err(e) = self.check_state(&s.heads) {

        let change = self.store.get_change_meta(hash)?;

        change: &crate::state::ChangeMeta,

        let change = self.store.get_change_meta(hash)?;

        let (_, wc) = self.working_copy()?;

        self.blame_heads(path, &wc.deps, "the working copy's base state")

        self.blame_heads(path, heads, "that state")

    }

    /// Blame `path` in the state with these heads, building only its graph.

    fn blame_heads(&self, path: &str, heads: &[ChangeHash], what: &str) -> Result<Vec<BlameLine>> {

        self.blame_state(path, &state, &tree, what)

            Some(h) => self.store.get_change_meta(&h)?.change_id.short(8),

            stack.extend(self.store.get_change_meta(&h)?.deps);

            for d in self.store.get_change_meta(h)?.deps {

            for d in self.store.get_change_meta(&h)?.deps {

    /// Every file graph a history-only state has not built, deleted files'

    /// included.

    pub fn unbuilt_nodes(&self) -> Vec<NodeId> {

        self.deferred

            .as_ref()

            .map(|d| d.keys().copied().collect())

            .unwrap_or_default()

    }

    /// A change's metadata (id, dependencies, author, clock, message, kind)

    /// without its contents: read from its skeleton, so neither its text

    /// blobs nor its inline lines are read (spec §11).

    pub fn get_change_meta(&self, r: &ObjectRef) -> Result<crate::state::ChangeMeta> {

        Ok(crate::state::ChangeMeta::of(&self.get_change_lazy(r)?.0))

    }

### log, blame and fsck (2026-09-30, oxygen#35)

The first full run of `~/bench/linux-bench.sh` against this work found

`log -n 100` taking 28 s and 4.7 GB, and `blame` killed at 14 GB:

- **log.** Checking each change's signature read the whole change, and

  for the first change that meant all 1.8 GB of its text. Signature

  checks, the dependency walks of fetch and push, and the prompt now

  read a change's metadata from its skeleton, and log answers the

  working copy's state from the manifest when it proves it clean.

- **blame.** It took a full snapshot, building every graph, to blame one

  file; it now loads the base's history and builds that file's graph.

- **fsck.** A bookmark's state was checked by loading it whole. It is

  now checked a batch of graphs at a time, deleted files' graphs

  included.

| Linux tip | Before | Now | Git |

|---|---:|---:|---:|

| `log -n 100` | 28 s, 4.7 GB | 2.0 s, 435 MB | 0.16 s |

| `blame MAINTAINERS` | killed at 14 GB | 1.1 s, 315 MB | 0.31 s |

| `fsck` | killed at 14 GB | 123 s, 4.5 GB | to measure again |

    // Whether the working copy is clean and conflicted: from the manifest

    // when it proves the working copy clean, else from a snapshot.

    let (conflicted, clean) = if repo.clean_by_manifest()? {

        (false, true)

    } else {

        let snap = repo.snapshot_status("oxy log")?;

        (snap.base_snapshot.is_conflicted(), snap.statuses.is_empty())

    };

            let (_, wc) = repo.working_copy()?;

            let base = repo.load_state_history(&wc.deps)?.maximal(&wc.deps);

            repo.line_history(&base, p, first, last)?

            ui::dim(if clean {