gix-blame: prefilter blame walk with changed-path bloom cache

Use the new changed-path bloom filters from the commit graph to greatly
speed up blame our implementation. Whenever we find a rejection on the
bloom filter for the current path, we skip it altogether and pass the
blame without diffing the trees.

Author: vmg

gix-blame/src/file/function.rs

@@ -173,6 +173,20 @@ pub fn incremental(
             continue;
         }
 
+        let first_parent_bloom_result =
+            maybe_changed_path_in_bloom_filter(cache, suspect, current_file_path.as_ref(), &mut stats);
+
+        if first_parent_bloom_result == Some(false) {
+            let (first_parent_id, first_parent_commit_time) = parent_ids[0];
+            pass_blame_from_to(suspect, first_parent_id, &mut hunks_to_blame);
+            queue.insert(first_parent_commit_time, first_parent_id);
+            previous_entry = previous_entry
+                .take()
+                .filter(|(id, _)| *id == suspect)
+                .map(|(_, entry)| (first_parent_id, entry));
+            continue 'outer;
+        }
+
         let mut entry = previous_entry
             .take()
             .filter(|(id, _)| *id == suspect)
@@ -269,6 +283,9 @@ pub fn incremental(
                 options.rewrites,
             )?;
             let Some(modification) = changes_for_file_path else {
+                if index == 0 && first_parent_bloom_result == Some(true) {
+                    stats.bloom_false_positive += 1;
+                }
                 if more_than_one_parent {
                     // None of the changes affected the file we’re currently blaming.
                     // Copy blame to parent.
@@ -910,6 +927,33 @@ fn collect_parents(
     Ok(parent_ids)
 }
 
+fn maybe_changed_path_in_bloom_filter(
+    cache: Option<&gix_commitgraph::Graph>,
+    commit_id: ObjectId,
+    path: &BStr,
+    stats: &mut Statistics,
+) -> Option<bool> {
+    if let Some(cache) = cache {
+        let result = cache.maybe_contains_path_by_id(commit_id, path);
+        match result {
+            Some(false) => {
+                stats.bloom_queries += 1;
+                stats.bloom_definitely_not += 1;
+            }
+            Some(true) => {
+                stats.bloom_queries += 1;
+                stats.bloom_maybe += 1;
+            }
+            None => {
+                stats.bloom_filter_not_present += 1;
+            }
+        }
+        result
+    } else {
+        None
+    }
+}
+
 /// Return an iterator over tokens for use in diffing. These are usually lines, but it's important
 /// to unify them so the later access shows the right thing.
 pub(crate) fn tokens_for_diffing(data: &[u8]) -> impl TokenSource<Token = &[u8]> {

gix-blame/src/types.rs

@@ -250,6 +250,16 @@ pub struct Statistics {
     /// The amount of blobs there were compared to each other to learn what changed between commits.
     /// Note that in order to diff a blob, one needs to load both versions from the database.
     pub blobs_diffed: usize,
+    /// Number of times changed-path Bloom filters were queried successfully.
+    pub bloom_queries: usize,
+    /// Number of queries where Bloom filters were unavailable for the commit.
+    pub bloom_filter_not_present: usize,
+    /// Number of Bloom answers that were `maybe`.
+    pub bloom_maybe: usize,
+    /// Number of Bloom answers that were `definitely not`.
+    pub bloom_definitely_not: usize,
+    /// Number of `maybe` Bloom answers that turned out not to affect the path.
+    pub bloom_false_positive: usize,
 }
 
 impl Outcome {

gix-blame/tests/blame.rs

@@ -1,4 +1,8 @@
-use std::{collections::BTreeMap, path::PathBuf};
+use std::{
+    collections::BTreeMap,
+    path::{Path, PathBuf},
+    process::Command,
+};
 
 use gix_blame::BlameRanges;
 use gix_hash::ObjectId;
@@ -351,6 +355,56 @@ fn diff_algorithm_parity() {
     }
 }
 
+#[test]
+fn changed_path_bloom_prefilter_keeps_blame_output_identical() -> gix_testtools::Result {
+    let worktree_path = fixture_path()?;
+    write_changed_path_commit_graph(&worktree_path)?;
+
+    let source_file_name: gix_object::bstr::BString = "simple.txt".into();
+    let 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,
+    };
+
+    let Fixture {
+        odb,
+        mut resource_cache,
+        suspect,
+    } = Fixture::for_worktree_path(worktree_path.clone())?;
+    let without_bloom = gix_blame::file(
+        &odb,
+        suspect,
+        None,
+        &mut resource_cache,
+        source_file_name.as_ref(),
+        options.clone(),
+    )?;
+
+    let Fixture {
+        odb,
+        mut resource_cache,
+        suspect,
+    } = Fixture::for_worktree_path(worktree_path.clone())?;
+    let cache = gix_commitgraph::at(worktree_path.join(".git/objects/info"))
+        .map_err(|err| std::io::Error::other(format!("loading commit-graph failed: {err}")))?;
+    let with_bloom = gix_blame::file(
+        &odb,
+        suspect,
+        Some(cache),
+        &mut resource_cache,
+        source_file_name.as_ref(),
+        options,
+    )?;
+
+    pretty_assertions::assert_eq!(with_bloom.entries, without_bloom.entries);
+    assert!(with_bloom.statistics.bloom_queries > 0);
+    assert!(with_bloom.statistics.trees_diffed <= without_bloom.statistics.trees_diffed);
+    Ok(())
+}
+
 #[test]
 fn file_that_was_added_in_two_branches() -> gix_testtools::Result {
     let worktree_path = gix_testtools::scripted_fixture_read_only("make_blame_two_roots_repo.sh")?;
@@ -754,6 +808,32 @@ mod incremental {
     }
 }
 
+fn write_changed_path_commit_graph(worktree_path: &Path) -> gix_testtools::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(())
+}
 fn fixture_path() -> gix_testtools::Result<PathBuf> {
     gix_testtools::scripted_fixture_read_only("make_blame_repo.sh")
 }