Commit takes a status's snapshot from the cache; the stat check lends its stats to the snapshot (refs #41) e226a6cc2f71

- **Status twice as fast as Git on the Linux tree (#41).** With uncommitted work, `oxy status` answers from a status cache while every file is as the last snapshot left it, and the manifest keeps every directory's time, so the tree is listed only when a directory's entries changed. One edited file is 0.10 to 0.12 s (from 0.44 s; Git 0.22 s) and a clean status 0.09 to 0.12 s (Git 0.20 to 0.26 s), in 80 MB. `oxy diff` renders the working copy from the cache too (0.20 s, from 0.41 s; Git 0.08 s). A commit after a status takes that status's snapshot instead of walking the tree again (0.37 s, from 0.68 s; Git 0.15 s). A file written within the racy window is now hashed by the prompt's check too, as it was by status.

        // or time moving (a coarse clock): those entries are hashed. One

        // that changed still lets the directory check below hand its stats

        // to the snapshot that follows.

        let racy = self.racy_change(manifest).is_some();

        if let Some(differs) = self.disk_differs_by_dirs_keeping(manifest, keep, racy) {

            return Ok(differs || racy);

        }

        if racy {

    #[cfg(test)]

        self.disk_differs_by_dirs_keeping(manifest, false, false)

    }

    /// [`Repo::disk_differs_by_dirs`]; with `keep`, when a file differs

    /// (or `racy` says one does), the stats taken become the listing of the

    /// snapshot that follows: no directory's entries changed, so the

    /// manifest's files are the tree's.

    fn disk_differs_by_dirs_keeping(

        &self,

        manifest: &Manifest,

        keep: bool,

        racy: bool,

    ) -> Option<bool> {

        }

        // Each tracked path as it is now: a file's stat, a symlink's target.

        enum Now {

            File(PathBuf, fs::Metadata),

            Link(Vec<u8>),

        let differs_from = |me: &ManifestEntry, path: &Path, now: &Now| match now {

            Now::Link(t) => *blake3::hash(t).as_bytes() != me.hash,

            Now::File(_, m) => {

                m.len() != me.size

                    || super::is_executable(m) != me.exec

                    || (mtime_ns(m) != me.mtime_ns

                        && !fs::read(path).is_ok_and(|b| *blake3::hash(&b).as_bytes() == me.hash))

            }

        };

        let stat = |rel: &str| -> Option<Now> {

            let path = root.join(rel);

            let m = fs::symlink_metadata(&path).ok()?;

                let t = fs::read_link(&path).ok()?;

                Some(Now::Link(t.to_string_lossy().as_bytes().to_vec()))

            } else if m.is_file() {

                Some(Now::File(path, m))

            } else {

                None

        };

        let differs = if !keep {

            manifest

                .entries

                .par_iter()

                .any(|(rel, me)| match stat(rel) {

                    Some(now) => differs_from(me, &root.join(rel.as_str()), &now),

                    None => true,

                })

        } else {

            let now: Vec<(&String, Option<Now>)> = manifest

                .entries

                .par_iter()

                .map(|(rel, _)| (rel, stat(rel)))

                .collect();

            // A path gone or no longer a file: its directory moved, unless

            // within a clock tick; list the tree to be sure.

            if now.iter().any(|(_, n)| n.is_none()) {

                return None;

            }

            let differs = now.par_iter().any(|(rel, n)| {

                let me = &manifest.entries[*rel];

                differs_from(me, &root.join(rel.as_str()), n.as_ref().unwrap())

            });

            if differs || racy {

                let mut listing = super::walk::Listing {

                    dirs: manifest.dirs.clone(),

                    nested: manifest.nested.iter().map(|n| root.join(n)).collect(),

                    ..Default::default()

                };

                for (rel, n) in now {

                    match n.unwrap() {

                        Now::File(path, m) => listing.files.push((rel.clone(), path, m)),

                        Now::Link(t) => listing.symlinks.push((rel.clone(), t)),

                    }

                }

                *self.listing_cache.borrow_mut() = Some(listing);

            }

            differs

        };

                        // The executable bit too: a mode change moves

                        // neither size nor time.

                        me.hash != hash || me.exec != e.exec || stat != Some((me.size, me.mtime_ns))

        let mut snap = match self.snapshot_from_cache()? {

            Some(snap) => snap,

            None => self.snapshot_as("oxy commit", true, true)?,

        };

    }

    /// The snapshot a command would take, without taking it, when the

    /// status cache holds: every file is as the last snapshot left it, so

    /// that snapshot's working-copy change is the answer. Its base comes

    /// from the state index, the `.oxyattributes` files from disk. `None`

    /// when a snapshot must be taken, and when there is nothing to commit

    /// (the snapshot then says so). A conflicted base never gets here: the

    /// cache does not hold for one.

    pub(crate) fn snapshot_from_cache(&self) -> Result<Option<SnapshotResult>> {

        let Some(statuses) = self.status_by_manifest()? else {

            return Ok(None);

        };

        if statuses.is_empty() {

            return Ok(None);

        }

        let _t = crate::timing::phase("snapshot: from the status cache");

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

        let base = self.load_state_indexed(&wc.deps)?;

        let (base, base_snapshot) = self.render_base_for(&wc, base)?;

        let attribute_files: Vec<(String, Vec<u8>)> = match self.read_manifest()? {

            Some((_, _, m)) => m

                .entries

                .keys()

                .filter(|p| is_attributes(p))

                .filter_map(|p| fs::read(self.root.join(p)).ok().map(|b| (p.clone(), b)))

                .collect(),

            None => Vec::new(),

        };

        let attributes = crate::attributes::Attributes::from_files(

            attribute_files

                .iter()

                .map(|(p, b)| (p.as_str(), b.as_slice())),

        );

        Ok(Some(SnapshotResult {

            wc_hash,

            wc,

            base,

            base_snapshot,

            statuses,

            changed: false,

            resolves: false,

            contributors: Vec::new(),

            attributes,

            untracked_nested: self.untracked_nested.borrow().clone(),

        }))

/// oxygen#41: a commit right after a status takes the snapshot the status

/// left (the status cache holds) rather than walking again, and commits

/// exactly what a snapshot would have.

#[test]

fn a_commit_after_a_status_uses_the_cached_snapshot() {

    hermetic();

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

    let root = dir.path();

    let repo = Repo::init(root).unwrap();

    write(root, "a.txt", b"a\nb\n");

    write(root, ".oxyattributes", b"*.bin binary\n");

    repo.commit("base", &[]).unwrap();

    write(root, "a.txt", b"a\nB\n");

    write(root, "new.txt", b"new\n");

    let snap = repo.snapshot_status("oxy status").unwrap();

    let cached = repo

        .snapshot_from_cache()

        .unwrap()

        .expect("the cache holds");

    assert_eq!(cached.wc_hash, snap.wc_hash);

    assert_eq!(cached.statuses, snap.statuses);

    assert!(

        !cached.attributes.is_empty(),

        "the .oxyattributes file was read"

    );

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

    let c = repo.store().get_change(&h).unwrap();

    assert_eq!(

        c.tree_ops.len() + c.edits.len(),

        snap.wc.tree_ops.len() + snap.wc.edits.len()

    );

    assert_eq!(

        repo.status_by_manifest().unwrap(),

        Some(vec![]),

        "clean after the commit"

    );

    assert_eq!(fs::read(root.join("a.txt")).unwrap(), b"a\nB\n");

}

### Commit, one file (2026-10-01, oxygen#41)

`~/bench/commit-vs-git.sh`: commits go forward and both repositories are

put back at the end (an `oxy undo` between runs dropped the manifest, and

its rehash of the tree evicted the page cache Git's runs relied on, which

made both sides' numbers meaningless). Load average 3 to 4.

| | before | after | Git `commit -am` |

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

| commit after a status | 0.68 s | **0.36 to 0.44 s** | 0.14 to 0.17 s |

| commit straight after the edit | 0.68 s | 0.62 to 0.69 s | 0.14 to 0.17 s |

After a status, the commit takes the status's snapshot from the cache.

Straight after an edit, the stat check now hands its stats to the

snapshot as its listing (8 ms instead of 122 ms), but checks every file

rather than stopping at the first difference, so the gain is small. What

remains is mostly durability: 18 fsyncs take 210 ms of the commit (one

alone 120 ms). Git does not sync loose objects by default.