Benchmarks: closing summary against Git and tuned Git (refs #41) 87828a0b1f36

| commit, 1 000 files | 0.99 s | 0.79 to 0.86 s | 0.26 to 0.27 s |

(The Git figure for 1 000 files was first taken while OxygenFlow was

building on Earth, as 1.1 to 1.2 s; quiet, Git takes 0.26 s.)

### Closing summary of backlog 4 (2026-10-02 04:30, Z1)

`~/bench/z1.sh` on a quiet Earth (load 0.5 to 1.0, no jobs), the build of

3d6b6fdd: `vs-git-tuned.sh`, `commit-vs-git.sh`, `commit1000.sh`,

`checkout-vs-git.sh`, fsck twice each, and `p1.sh` (fresh copies of the

tip). Git is 2.53; "tuned" is feature.manyFiles, core.untrackedCache and a

commit-graph.

| Operation | oxy, 2026-09-30 | oxy now | Git | Git, tuned |

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

| init and first commit | 38.5 s, 4.4 GB | **17.4 s**, 2.6 GB | 31.9 s, 41 MB | |

| status, clean | 0.41 to 0.43 s | 0.10 to 0.12 s | 0.19 to 0.21 s | 0.09 to 0.10 s |

| status, one file edited | 1.26 to 1.39 s | 0.10 s | 0.19 to 0.20 s | 0.09 to 0.10 s |

| diff, one file | 1.19 to 1.45 s | 0.15 to 0.16 s | 0.08 to 0.09 s | 0.08 s |

| commit, one file | about 3.1 s | 0.39 to 0.56 s; 0.29 to 0.35 s after a status | 0.14 to 0.15 s | |

| commit, 1 000 files | 4.9 s | 0.81 to 0.84 s | 0.26 to 0.27 s | |

| log -n 100 | 1.39 s | 0.03 s | 0.00 s | 0.00 s |

| blame MAINTAINERS | 1.18 s | 0.08 s | 0.07 s | 0.07 s |

| checkout to the first state and back | 2.2 to 2.8 s | 0.74 to 0.78 s | 0.22 to 0.43 s | 0.23 to 0.39 s |

| fsck | 22.1 s | **7.6 to 10.1 s** | 11.9 to 13.4 s | |

| gc of a fresh store | 39.7 s | **22.4 s** | 63.3 s | |

| store after gc | 324 MB | **278 MB** | 296 MB | |

The first commit's time varies with the page cache: 12.4 s when the tree

was read just before, 17.4 s here.

Where oxy is ahead of Git: the first commit, fsck, gc and the store.

Level with tuned Git (and twice as fast as Git as it comes): status, clean

and with an edit, by a stat check per directory against the manifest.

Close: blame (0.08 against 0.07 s), log (0.03 s, under the 0.05 s target,

against Git's 0.00 s).

Behind, and why:

- **Diff** (twice Git): the status check costs what Git's whole diff does

  (70 ms), and loading the state index adds 40 ms (its tree view 20 ms),

  plus about 25 ms of process and manifest reading. A lazily read

  (memory-mapped) state index is the next step.

- **Commit** (two to three times Git): about 120 ms of a one-file commit

  is the operation's fsync, which Git's default commit does not make; on

  ext4 it is the journal commit, not the data (starting writeback early

  changed nothing). The rest is the stat check (80 ms), the index load

  (40 ms) and the manifest written whole (30 to 60 ms). For 1 000 files,

  one read of the Linux import's root change for the inline texts of

  about 90 of them (110 ms) and rendering (97 ms) add to it.

- **Checkout** (three times Git): the fsync again (110 to 145 ms), every

  text read verified and decompressed (130 ms), the status check before

  it (115 ms), planning (67 ms) and the manifest (72 ms).

- **First commit memory**: 2.6 GB resident (2.07 GiB allocated) against

  the 2 GB target, because the walk holds every file's text until the

  change is stored. Storing texts as the walk reads them, the change

  holding references, is the remaining design.

Not re-measured tonight: status and diff with 1 000 files edited, a local

clone.