Suture Performance Baseline

Date: 2026-05-12 Platform: Linux x86_64, release profile (optimized) Toolchain: Rust stable, Criterion.rs 0.5

1. DAG Operations

Thresholds

2. Semantic Merge (JSON)

Thresholds

3. CAS Operations

Thresholds

4. Patch Serialization

Thresholds

5. Hub Operations

Thresholds

6. Historical Benchmark Results (from existing suite)

These results are from the pre-existing benchmark suite in benchmarks.rs:

Top 3 Bottlenecks

1. Log walk at scale FIXED in v3.2.1

The repo_log timeout at 10,000 commits was caused by commit() calling snapshot_uncached() after every commit, which replayed the entire patch chain from root to tip (O(n) per commit → O(n²) total). Fixed by computing the file tree incrementally: load the parent's cached tree from SQLite (O(1)) and apply only the new patch's changes (O(k) where k = files in the batch).

Before: 10,000 commits → >600s (timeout). After: 10,000 commits → 8.5s (70x faster).

2. Commit 1000 files — 652 ms (repo_add_commit vs dag_perf_commit)

The full repo add + commit path for 1000 files takes 652 ms (~0.65 ms/file), while the DAG-level commit benchmark takes 97.8 ms. The ~6.7x overhead comes from per-file filesystem I/O: reading files, hashing, writing blobs to CAS, and updating the staging index.

Recommendation: Batch filesystem reads with parallel hashing (rayon). Defer CAS writes until commit time. Use mtime/size stat cache to skip unchanged files.

3. Patience diff on large files — 30 ms for 1K lines

The patience diff algorithm takes 30 ms for a 1000-line file with 10% changes. This scales poorly — a 10K-line file would take ~300 ms, which is perceptible.

Recommendation: Profile to determine if the bottleneck is LCS computation or unique-line fingerprinting. Consider the imara-diff crate for large-file diffing, or switch to Myers' algorithm for files above a threshold.

Quick-Win Optimizations Applied

1. #[inline] on hot-path methods — Added to TouchSet::intersects,

TouchSet::len, TouchSet::iter, TouchSet::insert, TouchSet::contains, DagNode::id, PatchDag::patch_count, and hash_bytes (was already inlined).

1. Removed redundant from_utf8 in hash_with_context — The function

already takes &str, so from_utf8(context.as_bytes()) was a no-op conversion that could fail unnecessarily.

1. Eliminated duplicate method definitions — Removed accidental duplicate

len, iter, insert on TouchSet and has_patch on PatchDag that were causing code bloat.

Binary Size

Optimizations Applied

• LTO (Link-Time Optimization): lto = true — enables cross-crate inlining and dead code elimination
• Single codegen unit: codegen-units = 1 — better optimization at the cost of slower compilation
• Panic = abort: panic = "abort" — removes unwinding machinery, saves ~50-100 KB
• Strip: strip = true — removes debug info and symbol tables

Build Times

Benchmark Files

7. Comprehensive Merge Benchmarks (v5.1.0)

Date: 2026-05-01 Platform: Linux x86_64, release profile, Criterion.rs 0.5 Method: Median of 50 iterations

JSON

YAML

TOML

CSV

XML

Key Takeaways

• JSON is the fastest format — <1ms for typical files (up to 1,000 keys)
• All formats merge in <5ms for typical config files (<100 keys)
• CSV is slowest at scale due to row-based parsing — O(rows × cols)
• Conflict detection is fast (<100µs for most formats) because it only needs to find the first mismatch
• JSON scales sub-linearly past 1K keys (likely due to serde_json's optimized parser)

7. Recent Optimizations (v5.4.0)

7.1 Merge Engine (2026-05-12)

7.2 Stash Operations (2026-05-12)