gix-blame: implement benchmarks for incremental blame

Compare the performance of the implementation with and without the
commit graph cache.

gix-blame::incremental/without-commit-graph
                        time:   [14.852 s 14.895 s 14.944 s]
                        change: [+0.2968% +0.7623% +1.2529%] (p = 0.00 < 0.05)
                        Change within noise threshold.
gix-blame::incremental/with-commit-graph
                        time:   [287.55 ms 290.30 ms 292.85 ms]
                        change: [−3.1181% −1.6720% −0.4502%] (p = 0.11 > 0.05)
                        No change in performance detected.

Signed-off-by: Vicent Marti <vmg@strn.cat>

Author: vmg

Cargo.lock

@@ -10,6 +10,11 @@ authors = ["Christoph Rüßler <christoph.ruessler@mailbox.org>", "Sebastian Thi
 edition = "2021"
 rust-version = "1.82"
 
+[[bench]]
+name = "incremental-blame"
+harness = false
+path = "./benches/incremental_blame.rs"
+
 [features]
 ## Enable support for the SHA-1 hash by forwarding the feature to dependencies.
 sha1 = [
@@ -38,6 +43,8 @@ smallvec = "1.15.1"
 thiserror = "2.0.18"
 
 [dev-dependencies]
+criterion = "0.8.0"
+gix = { path = "../gix", default-features = false, features = ["basic", "sha1"] }
 gix-ref = { path = "../gix-ref" }
 gix-filter = { path = "../gix-filter" }
 gix-fs = { path = "../gix-fs" }

gix-blame/Cargo.toml

@@ -0,0 +1,130 @@
+use std::{
+    env,
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use gix_blame::{BlameEntry, BlameRanges, BlameSink};
+use gix_object::bstr::BString;
+
+const DEFAULT_BENCH_PATH: &str = "gix-blame/src/file/function.rs";
+
+struct DiscardSink;
+
+impl BlameSink for DiscardSink {
+    fn push(&mut self, _entry: BlameEntry) {}
+}
+
+fn incremental_options() -> gix_blame::Options {
+    gix_blame::Options {
+        diff_algorithm: gix_diff::blob::Algorithm::Histogram,
+        ranges: BlameRanges::default(),
+        since: None,
+        rewrites: Some(gix_diff::Rewrites::default()),
+        debug_track_path: false,
+    }
+}
+
+fn benchmark_incremental_blame(c: &mut Criterion) {
+    let repo_path = env::var_os("GIX_BLAME_BENCH_REPO")
+        .map(PathBuf::from)
+        .unwrap_or_else(|| {
+            PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                .parent()
+                .expect("gix-blame crate has a parent directory")
+                .to_path_buf()
+        });
+    let source_file_path: BString = env::var("GIX_BLAME_BENCH_PATH")
+        .unwrap_or_else(|_| DEFAULT_BENCH_PATH.into())
+        .into_bytes()
+        .into();
+    let commit_spec = env::var("GIX_BLAME_BENCH_COMMIT").unwrap_or_else(|_| "HEAD".into());
+    let git_dir = repo_path.join(".git");
+
+    if !has_commit_graph_cache(&git_dir) {
+        write_changed_path_commit_graph(&repo_path).expect("commit-graph should be writable for benchmark repository");
+    }
+
+    let repo = gix::open(&repo_path).expect("repository can be opened");
+    let suspect = repo
+        .rev_parse_single(commit_spec.as_str())
+        .expect("commit spec resolves to one object")
+        .detach();
+
+    let mut group = c.benchmark_group("gix-blame::incremental");
+    group.bench_function("without-commit-graph", |b| {
+        let mut resource_cache = repo
+            .diff_resource_cache_for_tree_diff()
+            .expect("tree-diff resource cache can be created");
+
+        b.iter(|| {
+            let mut sink = DiscardSink;
+            gix_blame::incremental(
+                &repo,
+                suspect,
+                None,
+                &mut resource_cache,
+                source_file_path.as_ref(),
+                &mut sink,
+                incremental_options(),
+            )
+            .expect("incremental blame should succeed");
+        });
+    });
+    group.bench_function("with-commit-graph", |b| {
+        let mut resource_cache = repo
+            .diff_resource_cache_for_tree_diff()
+            .expect("tree-diff resource cache can be created");
+        let cache = repo.commit_graph().expect("commit-graph can be loaded from repository");
+        b.iter(|| {
+            let mut sink = DiscardSink;
+            gix_blame::incremental(
+                &repo,
+                suspect,
+                Some(&cache),
+                &mut resource_cache,
+                source_file_path.as_ref(),
+                &mut sink,
+                incremental_options(),
+            )
+            .expect("incremental blame should succeed");
+        });
+    });
+    group.finish();
+}
+
+fn has_commit_graph_cache(git_dir: &Path) -> bool {
+    let info_dir = git_dir.join("objects/info");
+    info_dir.join("commit-graph").is_file() || info_dir.join("commit-graphs").is_dir()
+}
+
+fn write_changed_path_commit_graph(worktree_path: &Path) -> std::io::Result<()> {
+    let config_status = Command::new("git")
+        .args(["config", "commitGraph.changedPathsVersion", "2"])
+        .current_dir(worktree_path)
+        .status()?;
+    assert!(
+        config_status.success(),
+        "setting commitGraph.changedPathsVersion should succeed"
+    );
+
+    let write_status = Command::new("git")
+        .args([
+            "commit-graph",
+            "write",
+            "--no-progress",
+            "--reachable",
+            "--changed-paths",
+        ])
+        .current_dir(worktree_path)
+        .status()?;
+    assert!(
+        write_status.success(),
+        "writing changed-path commit-graph should succeed"
+    );
+    Ok(())
+}
+
+criterion_group!(benches, benchmark_incremental_blame);
+criterion_main!(benches);