Benchmark harness and first numbers 1d360c91a289

//! Benchmark harness (spec §25): a repository of 10 000 files and 5 000

//! changes, then the everyday operations timed against thresholds.

//!

//! Not part of the ordinary test run. Run it with

//!

//!     cargo test --release -p oxy-core --test bench -- --ignored --nocapture

//!

//! `OXY_BENCH_FILES` and `OXY_BENCH_CHANGES` change the size and

//! `OXY_BENCH_DIR` the disk. The table it prints is what

//! `docs/benchmarks.md` records. Thresholds are for the default size on a

//! developer machine; they catch regressions of an order of magnitude,

//! not noise.

use oxy_core::repo::Repo;

use std::path::Path;

use std::time::{Duration, Instant};

fn hermetic() {

    static ONCE: std::sync::Once = std::sync::Once::new();

    static DIR: std::sync::OnceLock<tempfile::TempDir> = std::sync::OnceLock::new();

    ONCE.call_once(|| {

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

        std::env::set_var("OXY_HOME", d.path());

        DIR.set(d).ok();

    });

}

fn env_usize(name: &str, default: usize) -> usize {

    std::env::var(name)

        .ok()

        .and_then(|v| v.parse().ok())

        .unwrap_or(default)

}

fn write(root: &Path, rel: &str, content: &str) {

    let p = root.join(rel);

    std::fs::create_dir_all(p.parent().unwrap()).unwrap();

    std::fs::write(p, content).unwrap();

}

/// Peak resident memory of this process, from /proc (Linux only).

fn peak_rss_mib() -> Option<f64> {

    let s = std::fs::read_to_string("/proc/self/status").ok()?;

    let kb: f64 = s

        .lines()

        .find(|l| l.starts_with("VmHWM:"))?

        .split_whitespace()

        .nth(1)?

        .parse()

        .ok()?;

    Some(kb / 1024.0)

}

struct Row {

    what: String,

    took: Duration,

    limit: Duration,

}

fn time<T>(

    rows: &mut Vec<Row>,

    what: impl Into<String>,

    limit_ms: u64,

    f: impl FnOnce() -> T,

) -> T {

    let t = Instant::now();

    let out = f();

    rows.push(Row {

        what: what.into(),

        took: t.elapsed(),

        limit: Duration::from_millis(limit_ms),

    });

    out

}

fn file_name(i: usize) -> String {

    format!("src/d{:03}/f{:05}.txt", i / 100, i)

}

#[test]

#[ignore]

fn bench_ten_thousand_files_five_thousand_changes() {

    hermetic();

    let files = env_usize("OXY_BENCH_FILES", 10_000);

    let changes = env_usize("OXY_BENCH_CHANGES", 5_000);

    let dir = match std::env::var_os("OXY_BENCH_DIR") {

        Some(d) => tempfile::tempdir_in(d).unwrap(),

        None => tempfile::tempdir().unwrap(),

    };

    let root = dir.path();

    let work = root.join("work");

    let repo = Repo::init(&work).unwrap().with_home(root.join("home"));

    let mut rows = Vec::new();

    // Build: one import of every file, then small changes; one file in

    // ten changes is the hot file, so blame has a long history to walk.

    for i in 0..files {

        write(

            &work,

            &file_name(i),

            &format!("file {i}\n{}", "some line of text\n".repeat(20)),

        );

    }

    write(&work, "hot.txt", "");

    time(

        &mut rows,

        format!("commit: import {files} files"),

        60_000,

        || repo.commit("import", &[]).unwrap(),

    );

    let mut hot = String::new();

    let build = Instant::now();

    for c in 1..changes {

        if c % 10 == 0 {

            hot.push_str(&format!("line added by change {c}\n"));

            write(&work, "hot.txt", &hot);

        } else {

            let i = (c * 7919) % files;

            write(

                &work,

                &file_name(i),

                &format!(

                    "file {i} edited by change {c}\n{}",

                    "some line of text\n".repeat(20)

                ),

            );

        }

        repo.commit(&format!("change {c}"), &[]).unwrap();

    }

    let per_commit = build.elapsed() / (changes.max(2) - 1) as u32;

    rows.push(Row {

        what: format!("commit: one file (mean of {})", changes - 1),

        took: per_commit,

        limit: Duration::from_millis(250),

    });

    // Everyday operations on the finished repository.

    time(

        &mut rows,

        "status: clean working copy (stat crawl)",

        2_000,

        || assert!(!repo.snapshot("oxy status").unwrap().changed),

    );

    for i in 0..10 {

        write(&work, &file_name(i * 13), &format!("ten-file edit {i}\n"));

    }

    time(&mut rows, "status: 10 files modified", 2_000, || {

        assert!(repo.snapshot("oxy status").unwrap().changed)

    });

    time(&mut rows, "commit: 10 files", 500, || {

        repo.commit("ten files", &[]).unwrap()

    });

    let log = time(&mut rows, "log: whole bookmark", 2_000, || {

        repo.log().unwrap()

    });

    assert!(log.len() >= changes, "{} entries", log.len());

    let blame = time(

        &mut rows,

        format!("blame: hot file ({} lines)", changes / 10),

        2_000,

        || repo.blame("hot.txt").unwrap(),

    );

    assert_eq!(blame.len(), (changes - 1) / 10);

    time(&mut rows, "blame: ordinary file", 1_000, || {

        repo.blame(&file_name(1)).unwrap()

    });

    time(&mut rows, "checkpoint", 10_000, || {

        repo.checkpoint().unwrap()

    });

    time(&mut rows, "status after checkpoint", 2_000, || {

        repo.snapshot("oxy status").unwrap()

    });

    // Sync over a local path: a full push into an empty hosted repository, then a clone.

    let origin = root.join("origin");

    Repo::init_bare_unbound(&origin).unwrap();

    let mut repo = repo;

    repo.config

        .set("remote.origin.url", &origin.to_string_lossy())

        .unwrap();

    repo.save_config().unwrap();

    time(

        &mut rows,

        "push: everything to an empty remote",

        60_000,

        || assert!(repo.push("origin", false).unwrap().iter().all(|r| r.ok)),

    );

    time(&mut rows, "push: up to date", 1_000, || {

        repo.push("origin", false).unwrap()

    });

    let clone = time(

        &mut rows,

        "clone: everything, with checkout",

        60_000,

        || Repo::clone(&origin.to_string_lossy(), &root.join("clone")).unwrap(),

    );

    assert_eq!(

        clone.bookmark_heads().unwrap(),

        repo.bookmark_heads().unwrap()

    );

    let rep = time(&mut rows, "fsck", 60_000, || repo.fsck().unwrap());

    assert_eq!(rep.errors(), 0, "{:?}", rep.problems);

    time(&mut rows, "gc", 60_000, || repo.gc(true).unwrap());

    time(&mut rows, "status after gc", 2_000, || {

        repo.snapshot("oxy status").unwrap()

    });

    eprintln!("\n| Operation ({files} files, {changes} changes) | Time | Threshold | |");

    eprintln!("|---|---:|---:|---|");

    for r in &rows {

        let verdict = if r.took > r.limit { "over" } else { "ok" };

        eprintln!(

            "| {} | {:.1} ms | {} ms | {verdict} |",

            r.what,

            r.took.as_secs_f64() * 1000.0,

            r.limit.as_millis()

        );

    }

    if let Some(mib) = peak_rss_mib() {

        eprintln!("\nPeak resident memory of the whole run: {mib:.0} MiB");

    }

    let slow: Vec<&Row> = rows.iter().filter(|r| r.took > r.limit).collect();

    assert!(

        slow.is_empty(),

        "over threshold: {:?}",

        slow.iter().map(|r| (&r.what, r.took)).collect::<Vec<_>>()

    );

}

# Benchmarks

The harness is `crates/oxy-core/tests/bench.rs` (spec §25). It builds a

repository through the library, one commit at a time, then times the

everyday operations against thresholds:

    OXY_BENCH_DIR=~/.cache/oxy-bench \

      cargo test --release -p oxy-core --test bench -- --ignored --nocapture

`OXY_BENCH_FILES` (default 10 000) and `OXY_BENCH_CHANGES` (default

5 000) set the size. The data lands under `OXY_BENCH_DIR`; `/tmp` is often

a RAM disk, which hides the cost of `fsync`, so measure on a real disk.

## 2026-09-28: first run

Machine: 8 cores, x86-64, NVMe (ext4 on LVM), release build, warm cache.

Files are 21 lines each in 100 directories; one change in ten appends a

line to `hot.txt`, the rest rewrite one ordinary file.

| Operation (10 000 files, 5 000 changes) | Time | Threshold | |

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

| commit: import 10 000 files | 1 031 ms | 60 000 ms | ok |

| commit: one file (mean of 4 999) | 3 761 ms | 250 ms | **over** |

| status: clean working copy (stat crawl) | 2 977 ms | 2 000 ms | **over** |

| status: 10 files modified | 3 062 ms | 2 000 ms | **over** |

| commit: 10 files | 9 089 ms | 500 ms | **over** |

| log: whole bookmark | 408 ms | 2 000 ms | ok |

| blame: hot file (500 lines) | 2 920 ms | 2 000 ms | **over** |

| blame: ordinary file | 2 927 ms | 1 000 ms | **over** |

| checkpoint | 596 ms | 10 000 ms | ok |

| status after checkpoint | 2 873 ms | 2 000 ms | **over** |

| push: everything to an empty remote | 782 ms | 60 000 ms | ok |

| push: up to date | 4 ms | 1 000 ms | ok |

| clone: everything, with checkout | 3 378 ms | 60 000 ms | ok |

| fsck | 7 955 ms | 60 000 ms | ok |

| gc | 9 489 ms | 60 000 ms | ok |

| status after gc | 2 829 ms | 2 000 ms | **over** |

Peak resident memory over the whole run: 1 405 MiB. The run took 5 h 14 min,

almost all of it building the history, because each commit costs as much

as a status.

Smaller runs, same machine:

| Files, changes | Mean commit | Clean status | Blame (hot) | Peak memory |

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

| 1 000, 200 | 90 ms | 62 ms | 62 ms | 70 MiB |

| 1 000, 800 | 166 ms | 130 ms | 119 ms | 118 MiB |

| 4 000, 200 | 343 ms | 235 ms | 239 ms | 254 MiB |

| 10 000, 5 000 | 3 761 ms | 2 977 ms | 2 920 ms | 1 405 MiB |

### What it shows

Sync, log, checkpoints and repository maintenance are fine. Everything

that snapshots the working copy (status, commit, blame of the working

copy's base) grows with both the number of files and the length of the

history. Timing the phases of one snapshot at 4 000 files and 300 changes:

| Phase | Time |

|---|---:|

| load the base state (checkpoint plus the changes since) | 75–130 ms |

| materialize every file of the base state | 75 ms |

| walk the working copy against the manifest | 50 ms |

| build the working-copy change | 8 ms |

A clean status should be a stat walk and nothing else. The fix is backlog

item O10: skip loading and materializing when every file's stat matches a

manifest written for the same base, make the base state lazy for the

callers that need it, and cache materialized snapshots per state. The

thresholds above stay as they are until then, so the harness reports the

gap rather than hiding it.

- [ ] O10 Snapshot fast path (found by O4; do next on the oxy track): at 10 000 files and 5 000 changes a commit takes 3.8 s and a clean status 3.0 s, because every snapshot loads and materializes the whole base state (about 75 ms load, 75 ms materialize, 50 ms walk at 4 000 files). Skip load and materialize when every file's stat matches a manifest written for the same base; make the base state lazy for callers that need it; cache the materialized snapshot per state. Target the spec §25 numbers.