Snapshots use every core e7ddd552b619

 "rayon",

name = "rayon"

version = "1.12.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"

dependencies = [

 "either",

 "rayon-core",

]

[[package]]

name = "rayon-core"

version = "1.13.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"

dependencies = [

 "crossbeam-deque",

 "crossbeam-utils",

]

[[package]]

rayon = "1"

        let mut files: Vec<(String, PathBuf, fs::Metadata)> = Vec::new();

                files.push((rel, path.to_path_buf(), meta));

            }

        }

        // Reading files is most of a walk's cost; do it in parallel.

        {

            use rayon::prelude::*;

            let read: Vec<(String, FsEntry)> = files

                .par_iter()

                .map(|(rel, path, meta)| {

                    Ok((rel.clone(), read_file_entry(rel, path, meta, cache)?))

                })

                .collect::<Result<Vec<_>>>()?;

            for (rel, mut e) in read {

                // A cached blob the store lost (gc, a partial clone): read the file after all.

                if e.content.is_empty() && e.blob.is_some_and(|b| !self.store.has(&b)) {

                    e.content = fs::read(self.root.join(&rel))?;

                    e.blob = None;

                }

        let mut e = read_file_entry(rel, path, meta, cache)?;

        if e.content.is_empty() && e.blob.is_some_and(|b| !self.store.has(&b)) {

            e.content = fs::read(path)?;

            e.blob = None;

        }

        Ok(e)

/// One regular file's entry from disk, or from the stat cache when its

/// size and mtime match the manifest outside the racy window. Touches no

/// repository state, so the walk runs it in parallel; the caller checks

/// that a cached blob is still in the store.

fn read_file_entry(

    rel: &str,

    path: &Path,

    meta: &fs::Metadata,

    cache: Option<&prompt::Manifest>,

) -> Result<FsEntry> {

    let exec = is_executable(meta);

    let cached = cache.and_then(|m| {

        let e = m.entries.get(rel)?;

        let mtime_ns = prompt::mtime_ns(meta);

        let racy = mtime_ns + 2_000_000_000 >= m.written_ns;

        (e.size == meta.len() && e.mtime_ns == mtime_ns && !racy).then_some(e)

    });

    Ok(match cached {

        Some(e) if e.blob.is_some() => FsEntry {

            kind: NodeKind::File,

            exec,

            content: vec![],

            blob: e.blob,

            content_hash: Some(e.hash.clone()),

        },

        Some(e) => FsEntry {

            kind: NodeKind::File,

            exec,

            content: fs::read(path)?,

            blob: None,

            content_hash: Some(e.hash.clone()),

        },

        None => FsEntry::new(NodeKind::File, exec, fs::read(path)?),

    })

}

        // File graphs are independent; build them in parallel.

        {

            use rayon::prelude::*;

            let graphs = o::array(o::field(m, 3, "files")?, "files")?

                .par_iter()

                .map(|f| {

                    let e = o::array(f, "file")?;

                    if e.len() != 2 {

                        return Err(ObjectError::Schema("file: expected [node, graph]".into()));

                    }

                    let node = NodeId::from_slice(o::bytes(&e[0], "node")?)

                        .ok_or_else(|| ObjectError::Schema("node: expected 16 bytes".into()))?;

                    Ok((node, FileGraph::from_value(&e[1])?))

                })

                .collect::<Result<Vec<_>, ObjectError>>()?;

            st.files.extend(graphs);

    /// Every file rendered, in parallel: files are independent, and

    /// rendering them is most of a snapshot's cost in a large tree.

        use rayon::prelude::*;

        let entries: Vec<(&String, &crate::tree::TreeEntry)> = tree.entries.iter().collect();

        let rendered: Vec<(String, FileState)> = entries

            .par_iter()

            .map(|(path, e)| (path.to_string(), self.file_state(e)))

            .collect();

        let files: BTreeMap<String, FileState> = rendered.into_iter().collect();

        Snapshot { tree, files }

    }

    fn file_state(&self, e: &crate::tree::TreeEntry) -> FileState {

        {

            FileState {

                node: e.node,

                kind: e.kind,

                mode: e.mode,

                content,

            }

- [x] O10b Parallel snapshot work: rendering the base state's files, building file graphs from a checkpoint, and reading working-copy files now run on every core (rayon).

- [ ] O10c Snapshot without the whole base (rest of O10): load only the file graphs a snapshot needs (a checkpoint split per file or indexed), skip reading and rendering files whose stat matches a manifest written for the same base, cache materialized states. Needs a spec change to the checkpoint format; target spec §25.