Skip to main content

grit_lib/diff/
tree_content.rs

1//! Parallel blob loads for tree-to-tree diffs (commit ranges, `grit diff A B`).
2
3use crate::config::ConfigSet;
4#[cfg(test)]
5use crate::diff_rename_parallel::parallel_map_indices;
6#[cfg(test)]
7use crate::error::Error;
8use crate::error::Result;
9use crate::merge_diff::{diff_attr_forces_text, diff_driver_forces_text, diff_textconv_active};
10use crate::objects::FileMode;
11use crate::objects::ObjectId;
12use crate::objects::ObjectKind;
13use crate::objects::OidHashSet;
14use crate::odb::Odb;
15use crate::pack_store::PackReadContextGuard;
16use crate::parallel::run_ordered_batches;
17use crate::parallel::{try_par_map_with_local, ParallelHashError};
18use crate::parallel::{ParallelOp, ParallelOptions, ThreadPolicy};
19use std::num::NonZeroUsize;
20use std::path::Path;
21use std::sync::Arc;
22
23use super::detail::{line_stat_for_options, LineStat};
24use super::structured::{structured_file_diff, SideBytes, StructuredFileDiff};
25use super::DiffEntry;
26use super::DiffOptions;
27
28fn note_blob_read() {
29    crate::test_probe_hooks::hooks::diff_blob_read();
30}
31
32fn collect_tree_diff_blob_oids(entries: &[DiffEntry]) -> Vec<ObjectId> {
33    let mut set = OidHashSet::default();
34    for entry in entries {
35        if entry.old_mode != FileMode::GITLINK
36            && entry.old_mode != FileMode::ABSENT
37            && !entry.old_oid.is_zero()
38        {
39            set.insert(entry.old_oid);
40        }
41        if entry.new_mode != FileMode::GITLINK
42            && entry.new_mode != FileMode::ABSENT
43            && !entry.new_oid.is_zero()
44        {
45            set.insert(entry.new_oid);
46        }
47    }
48    set.into_iter().collect()
49}
50
51pub(crate) fn prefetch_tree_diff_blobs(odb: &Odb, entries: &[DiffEntry]) -> Result<()> {
52    if entries.is_empty() {
53        return Ok(());
54    }
55    odb.prefetch_promisor_read_batch(collect_tree_diff_blob_oids(entries))
56}
57
58/// Fewest changed entries for which per-entry blob loads and line diffs use worker threads.
59///
60/// Starting workers (stacks, allocator arenas, per-thread pack inflaters) costs more than
61/// loading and diffing a small commit's blobs on the calling thread: showing git.git commits
62/// that touch up to 17 files ran faster serially, while from about 18 files the pool won.
63/// Fewer, larger files gain nothing either, since each entry is diffed by one thread.
64const PER_ENTRY_POOL_MIN_ITEMS: usize = 16;
65
66/// Pool options for per-entry content work, fanning out once there are enough entries.
67///
68/// Below [`PER_ENTRY_POOL_MIN_ITEMS`] entries (or the policy's
69/// [`ThreadPolicy::min_items_override`], never below two) the work runs on the calling
70/// thread and the policy, which probes the CPU count and cgroup quota, is not consulted.
71fn per_entry_parallel_options(
72    thread_policy: &ThreadPolicy,
73    config: &ConfigSet,
74    entry_count: usize,
75) -> ParallelOptions {
76    let min_items = thread_policy
77        .min_items_override
78        .unwrap_or(PER_ENTRY_POOL_MIN_ITEMS)
79        .max(2);
80    if entry_count < min_items {
81        return ParallelOptions {
82            threads: NonZeroUsize::MIN,
83            min_items: 0,
84            min_total_bytes: None,
85            signed_entry_threshold: None,
86        };
87    }
88    let mut par_opts = thread_policy.resolve(ParallelOp::DiffContent, config);
89    par_opts.min_items = 0;
90    par_opts.min_total_bytes = None;
91    par_opts
92}
93
94/// Tree diff entry with structured line hunks ready for CLI rendering.
95#[derive(Debug, Clone, PartialEq, Eq)]
96pub struct TreeDiffStructured {
97    /// Tree diff metadata (paths, modes, oids, status).
98    pub entry: DiffEntry,
99    /// Structured hunks and mode metadata.
100    pub structured: StructuredFileDiff,
101    /// `true` when either side looks like a binary blob (NUL in the first 8 KiB).
102    pub binary: bool,
103    /// Old-side byte length (for binary `--stat` rows).
104    pub old_size: u64,
105    /// New-side byte length (for binary `--stat` rows).
106    pub new_size: u64,
107    /// Worktree/index side bytes when content is not materialized in the ODB.
108    pub patch_bytes: Option<(SideBytes, SideBytes)>,
109}
110
111/// One tree diff entry with both sides loaded for line-level diffing.
112#[derive(Debug, Clone, PartialEq, Eq)]
113#[cfg(test)]
114pub(crate) struct TreeDiffContent {
115    /// Tree diff metadata (paths, modes, oids, status).
116    pub entry: DiffEntry,
117    /// Old-side bytes prepared for structured text diffing.
118    pub old_bytes: SideBytes,
119    /// New-side bytes prepared for structured diffing.
120    pub new_bytes: SideBytes,
121    /// `true` when either side looks like a binary blob (NUL in the first 8 KiB).
122    pub binary: bool,
123}
124
125/// Load old/new blob bytes for each entry, using a worker pool when thresholds allow.
126///
127/// Submodule gitlinks are synthesized as `Subproject commit <oid>` lines; missing sides
128/// are empty. Order matches `entries`.
129///
130/// # Errors
131///
132/// Propagates object database read failures.
133#[cfg(test)]
134pub(crate) fn tree_diff_contents_parallel(
135    odb: &Odb,
136    entries: Vec<DiffEntry>,
137    config: &ConfigSet,
138    thread_policy: &ThreadPolicy,
139) -> Result<Vec<TreeDiffContent>> {
140    if entries.is_empty() {
141        return Ok(Vec::new());
142    }
143    prefetch_tree_diff_blobs(odb, &entries)?;
144    let mut par_opts = thread_policy.resolve(ParallelOp::DiffContent, config);
145    par_opts.min_items = par_opts.min_items.min(8);
146    let est_bytes = entries.len().saturating_mul(8192);
147    let rows = parallel_map_indices(odb, entries.len(), par_opts, est_bytes, |i| {
148        let entry = &entries[i];
149        let (old_bytes, old_bin) = load_old_side(odb, entry)?;
150        let (new_bytes, new_bin) = load_new_side(odb, entry)?;
151        Ok::<TreeDiffContent, Error>(TreeDiffContent {
152            entry: entry.clone(),
153            old_bytes,
154            new_bytes,
155            binary: old_bin || new_bin,
156        })
157    })?;
158    Ok(rows)
159}
160
161/// One tree diff entry's stat row: metadata, binary flag, line counts, side byte lengths.
162pub(crate) type TreeDiffStatRow = (DiffEntry, bool, Option<LineStat>, u64, u64);
163
164/// Per-file line counts for stat modes (loads blobs, no hunk allocation).
165///
166/// Worker threads are used only for 16 or more entries (or the policy's
167/// [`ThreadPolicy::min_items_override`]); smaller diffs run on the calling thread.
168///
169/// # Errors
170///
171/// Propagates object database read failures.
172pub(crate) fn tree_diff_stat_parallel(
173    odb: &Odb,
174    entries: Vec<DiffEntry>,
175    config: &ConfigSet,
176    thread_policy: &ThreadPolicy,
177    diff_options: DiffOptions,
178) -> Result<Vec<TreeDiffStatRow>> {
179    if entries.is_empty() {
180        return Ok(Vec::new());
181    }
182    prefetch_tree_diff_blobs(odb, &entries)?;
183    let par_opts = per_entry_parallel_options(thread_policy, config, entries.len());
184    let line_diff_opts = diff_options;
185    let store = odb.pack_store_for(odb.objects_dir());
186    let rows = try_par_map_with_local(
187        &entries,
188        par_opts,
189        0,
190        || PackReadContextGuard::install(Arc::clone(&store)),
191        move |_ctx, entry| {
192            if !entry.old_oid.is_zero()
193                && entry.old_oid == entry.new_oid
194                && entry.old_mode == entry.new_mode
195            {
196                let (old_bytes, old_bin) = load_old_side(odb, entry)?;
197                let binary = old_bin;
198                let size = old_bytes.byte_len();
199                return Ok((
200                    entry.clone(),
201                    binary,
202                    if binary {
203                        None
204                    } else {
205                        Some(LineStat::default())
206                    },
207                    size,
208                    size,
209                ));
210            }
211            let (old_bytes, old_bin) = load_old_side(odb, entry)?;
212            let (new_bytes, new_bin) = load_new_side(odb, entry)?;
213            let binary = old_bin || new_bin;
214            let old_size = old_bytes.byte_len();
215            let new_size = new_bytes.byte_len();
216            let stat = if binary {
217                None
218            } else {
219                Some(line_stat_for_options(
220                    &String::from_utf8_lossy(&old_bytes.data),
221                    &String::from_utf8_lossy(&new_bytes.data),
222                    &line_diff_opts,
223                ))
224            };
225            Ok((entry.clone(), binary, stat, old_size, new_size))
226        },
227    );
228    match rows {
229        Ok(rows) => Ok(rows),
230        Err(ParallelHashError::Task(err)) => Err(err),
231    }
232}
233
234/// Load sides and compute a structured line diff for one tree diff entry.
235///
236/// # Errors
237///
238/// Propagates object database read failures.
239pub fn tree_diff_structured_entry(
240    odb: &Odb,
241    entry: &DiffEntry,
242    diff_options: &DiffOptions,
243) -> Result<TreeDiffStructured> {
244    if !entry.old_oid.is_zero()
245        && entry.old_oid == entry.new_oid
246        && entry.old_mode == entry.new_mode
247    {
248        let (old_bytes, old_bin) = load_old_side(odb, entry)?;
249        let size = old_bytes.byte_len();
250        return Ok(TreeDiffStructured {
251            entry: entry.clone(),
252            structured: StructuredFileDiff {
253                old_mode: entry.old_mode.octal_if_present(),
254                new_mode: entry.new_mode.octal_if_present(),
255                old_encoding_lossy: old_bytes.encoding_lossy,
256                new_encoding_lossy: old_bytes.encoding_lossy,
257                hunks: Vec::new(),
258            },
259            binary: old_bin,
260            old_size: size,
261            new_size: size,
262            patch_bytes: None,
263        });
264    }
265    let (old_bytes, old_bin) = load_old_side(odb, entry)?;
266    let (new_bytes, new_bin) = load_new_side(odb, entry)?;
267    let binary = old_bin || new_bin;
268    let old_size = old_bytes.byte_len();
269    let new_size = new_bytes.byte_len();
270    let structured = if binary {
271        StructuredFileDiff {
272            old_mode: entry.old_mode.octal_if_present(),
273            new_mode: entry.new_mode.octal_if_present(),
274            old_encoding_lossy: old_bytes.encoding_lossy,
275            new_encoding_lossy: new_bytes.encoding_lossy,
276            hunks: Vec::new(),
277        }
278    } else {
279        structured_file_diff(
280            entry.old_mode,
281            entry.new_mode,
282            &old_bytes,
283            &new_bytes,
284            diff_options.clone(),
285        )
286    };
287    Ok(TreeDiffStructured {
288        entry: entry.clone(),
289        structured,
290        binary,
291        old_size,
292        new_size,
293        patch_bytes: None,
294    })
295}
296
297/// Visit structured tree diffs in path order without retaining every file's hunks at once.
298///
299/// When thread policy allows, workers compute up to about `2 × threads` entries ahead while
300/// the callback consumes results strictly in order.
301///
302/// Worker threads are used only for 16 or more entries (or the policy's
303/// [`ThreadPolicy::min_items_override`]); smaller diffs run on the calling thread.
304///
305/// # Errors
306///
307/// Propagates object database read failures and callback errors.
308pub(crate) fn for_each_tree_diff_structured(
309    odb: &Odb,
310    entries: &[DiffEntry],
311    diff_options: DiffOptions,
312    config: &ConfigSet,
313    thread_policy: &ThreadPolicy,
314    mut visit: impl FnMut(TreeDiffStructured) -> Result<()>,
315) -> Result<()> {
316    if entries.is_empty() {
317        return Ok(());
318    }
319    prefetch_tree_diff_blobs(odb, entries)?;
320    let diff_options = diff_options.cap_word_level_inline_for_changed_files(entries.len());
321    let par_opts = per_entry_parallel_options(thread_policy, config, entries.len());
322    let n_workers = par_opts.threads.get();
323    if n_workers <= 1 || entries.len() < 2 {
324        for entry in entries {
325            visit(tree_diff_structured_entry(odb, entry, &diff_options)?)?;
326        }
327        return Ok(());
328    }
329    let line_diff_opts = diff_options;
330    let store = odb.pack_store_for(odb.objects_dir());
331    run_ordered_batches(
332        entries,
333        1,
334        n_workers,
335        || PackReadContextGuard::install(Arc::clone(&store)),
336        move |_ctx, entry| tree_diff_structured_entry(odb, entry, &line_diff_opts),
337        move |_batch, rows| {
338            for row in rows {
339                visit(row)?;
340            }
341            Ok(())
342        },
343    )
344}
345
346/// Load sides and compute structured line diffs for each entry in parallel.
347///
348/// Worker threads are used only for 16 or more entries (or the policy's
349/// [`ThreadPolicy::min_items_override`]); smaller diffs run on the calling thread.
350///
351/// # Errors
352///
353/// Propagates object database read failures.
354pub(crate) fn tree_diff_structured_parallel(
355    odb: &Odb,
356    entries: Vec<DiffEntry>,
357    config: &ConfigSet,
358    thread_policy: &ThreadPolicy,
359    diff_options: DiffOptions,
360) -> Result<Vec<TreeDiffStructured>> {
361    if entries.is_empty() {
362        return Ok(Vec::new());
363    }
364    prefetch_tree_diff_blobs(odb, &entries)?;
365    let diff_options = diff_options.cap_word_level_inline_for_changed_files(entries.len());
366    let par_opts = per_entry_parallel_options(thread_policy, config, entries.len());
367    let line_diff_opts = diff_options;
368    let store = odb.pack_store_for(odb.objects_dir());
369    let rows = try_par_map_with_local(
370        &entries,
371        par_opts,
372        0,
373        || PackReadContextGuard::install(Arc::clone(&store)),
374        move |_ctx, entry| tree_diff_structured_entry(odb, entry, &line_diff_opts),
375    );
376    match rows {
377        Ok(rows) => Ok(rows),
378        Err(ParallelHashError::Task(err)) => Err(err),
379    }
380}
381
382pub(crate) fn load_old_side(odb: &Odb, e: &DiffEntry) -> Result<(SideBytes, bool)> {
383    if e.old_mode == FileMode::GITLINK {
384        return Ok((
385            SideBytes::from_bytes(gitlink_line(&e.old_oid).into_bytes()),
386            false,
387        ));
388    }
389    if e.old_mode == FileMode::ABSENT {
390        return Ok((SideBytes::from_bytes(Vec::new()), false));
391    }
392    let path = e.old_path.as_deref().or(e.new_path.as_deref());
393    load_odb_blob_side_for_diff(odb, &e.old_oid, path, false)
394}
395
396pub(crate) fn load_new_side(odb: &Odb, e: &DiffEntry) -> Result<(SideBytes, bool)> {
397    if e.new_mode == FileMode::GITLINK {
398        return Ok((
399            SideBytes::from_bytes(gitlink_line(&e.new_oid).into_bytes()),
400            false,
401        ));
402    }
403    if e.new_mode == FileMode::ABSENT {
404        return Ok((SideBytes::from_bytes(Vec::new()), false));
405    }
406    let path = e.new_path.as_deref().or(e.old_path.as_deref());
407    load_odb_blob_side_for_diff(odb, &e.new_oid, path, false)
408}
409
410/// Text a gitlink side contributes to a patch: `Subproject commit <hex>\n`,
411/// or nothing for the zero id (an absent side).
412pub(crate) fn gitlink_line(oid: &ObjectId) -> String {
413    if *oid == ObjectId::zero() {
414        return String::new();
415    }
416    format!("Subproject commit {}\n", oid.to_hex())
417}
418
419fn git_dir_for_diff(odb: &Odb) -> Option<&Path> {
420    odb.config_git_dir().or_else(|| odb.objects_dir().parent())
421}
422
423/// True when a path's attributes or textconv require reading a blob above
424/// [`Odb::big_file_threshold`](crate::objects::odb::Odb::big_file_threshold).
425fn diff_side_must_read_large_blob(odb: &Odb, path: &str) -> Result<bool> {
426    let Some(git_dir) = git_dir_for_diff(odb) else {
427        return Ok(false);
428    };
429    if diff_attr_forces_text(git_dir, path) {
430        return Ok(true);
431    }
432    let config = crate::config::ConfigSet::load(
433        &crate::environment::Environment::empty(),
434        Some(git_dir),
435        &crate::config::LoadConfigOptions::standard(
436            &crate::environment::Environment::empty(),
437            Some(git_dir),
438        ),
439    )?;
440    if diff_textconv_active(git_dir, &config, path) {
441        return Ok(true);
442    }
443    Ok(diff_driver_forces_text(git_dir, &config, path))
444}
445
446/// Whether a blob/worktree side at `size` bytes should be treated as binary without reading
447/// content (Git `diff_populate_filespec`; strict `>` on `core.bigFileThreshold`).
448pub(crate) fn treat_side_as_binary_without_reading(
449    odb: &Odb,
450    size: u64,
451    path: Option<&str>,
452    force_read_content: bool,
453) -> Result<bool> {
454    if force_read_content || size == 0 {
455        return Ok(false);
456    }
457    let threshold = odb.big_file_threshold()?;
458    if size <= threshold {
459        return Ok(false);
460    }
461    if let Some(path) = path {
462        if diff_side_must_read_large_blob(odb, path)? {
463            return Ok(false);
464        }
465    }
466    Ok(true)
467}
468
469/// Classify blob bytes for diffing after inflation.
470///
471/// When `retain_binary_payload` is false, binary sides drop payload bytes (line diffs stay lean).
472/// When true (patch-text / `--binary` emission), payload is kept and `binary` is still set.
473pub(crate) fn side_bytes_after_blob_read(
474    data: Vec<u8>,
475    retain_binary_payload: bool,
476) -> (SideBytes, bool) {
477    let binary = crate::crlf::is_binary(&data);
478    let size = data.len() as u64;
479    if binary && !retain_binary_payload {
480        (SideBytes::unread(size), true)
481    } else {
482        (SideBytes::from_bytes(data), binary)
483    }
484}
485
486/// Load ODB blob bytes for diffing, skipping inflation when over `core.bigFileThreshold`.
487///
488/// Returns empty side bytes with `binary = true` when content is not read. When
489/// `force_read_content` is true, large blobs are inflated and binary payload bytes are retained
490/// (for `GIT binary patch` / `git apply`).
491///
492/// # Errors
493///
494/// Propagates object database and config errors.
495pub fn load_odb_blob_side_for_diff(
496    odb: &Odb,
497    oid: &ObjectId,
498    path: Option<&str>,
499    force_read_content: bool,
500) -> Result<(SideBytes, bool)> {
501    if *oid == ObjectId::zero() {
502        return Ok((SideBytes::unread(0), false));
503    }
504    if !force_read_content {
505        let info = odb.read_info(oid)?;
506        if info.kind == ObjectKind::Blob
507            && treat_side_as_binary_without_reading(odb, info.size, path, false)?
508        {
509            return Ok((SideBytes::unread(info.size), true));
510        }
511    }
512    note_blob_read();
513    #[cfg(test)]
514    odb.hot_path_metrics().record_blob_content_read();
515    let data = odb.read(oid)?.data;
516    Ok(side_bytes_after_blob_read(data, force_read_content))
517}
518
519/// Classify raw blob bytes for line diffs (NUL in the first 8 KiB ⇒ binary).
520#[must_use]
521pub fn bytes_for_diff(data: Vec<u8>) -> (SideBytes, bool) {
522    let size = data.len() as u64;
523    if crate::crlf::is_binary(&data) {
524        (SideBytes::unread(size), true)
525    } else {
526        (SideBytes::from_bytes(data), false)
527    }
528}
529
530#[cfg(test)]
531mod tests {
532    use super::*;
533    use crate::config::ConfigSet;
534    use crate::diff::{diff_trees, DiffOptions, DiffStatus};
535    use crate::objects::{serialize_tree, ObjectKind, TreeEntry};
536    use crate::parallel::ThreadPolicy;
537    use crate::repo::{InitOptions, Repository};
538
539    fn init_repo() -> (tempfile::TempDir, Repository) {
540        let dir = tempfile::tempdir().expect("tempdir");
541        let (repo, _) = Repository::init(dir.path(), &InitOptions::default()).expect("init");
542        (dir, repo)
543    }
544
545    fn init_repo_with_core_config(snippet: &str) -> (tempfile::TempDir, Repository) {
546        let dir = tempfile::tempdir().expect("tempdir");
547        let (repo, _) = Repository::init(dir.path(), &InitOptions::default()).expect("init");
548        std::fs::write(repo.git_dir().join("config"), snippet).expect("config");
549        (dir, repo)
550    }
551
552    #[test]
553    fn tree_diff_contents_parallel_matches_serial_load() {
554        let (_dir, repo) = init_repo();
555        let odb = repo.odb();
556        let a = odb.write(ObjectKind::Blob, b"alpha\n").expect("write a");
557        let b = odb.write(ObjectKind::Blob, b"beta\n").expect("write b");
558        let tree_a = odb
559            .write(
560                ObjectKind::Tree,
561                &serialize_tree(&[TreeEntry {
562                    mode: 0o100644,
563                    name: b"file-a".to_vec(),
564                    oid: a,
565                }]),
566            )
567            .expect("tree a");
568        let tree_b = odb
569            .write(
570                ObjectKind::Tree,
571                &serialize_tree(&[TreeEntry {
572                    mode: 0o100644,
573                    name: b"file-b".to_vec(),
574                    oid: b,
575                }]),
576            )
577            .expect("tree b");
578        let raw = diff_trees(odb, Some(&tree_a), Some(&tree_b), "").expect("diff");
579        assert_eq!(raw.len(), 2);
580        let config = repo.config().snapshot().expect("config");
581        let serial = tree_diff_contents_parallel(
582            odb,
583            raw.clone(),
584            &config,
585            &ThreadPolicy::with_threads_override(Some(1)),
586        )
587        .expect("serial load");
588        let parallel = tree_diff_contents_parallel(
589            odb,
590            raw,
591            &config,
592            &ThreadPolicy::with_threads_override(Some(4)),
593        )
594        .expect("parallel load");
595        assert_eq!(serial, parallel);
596        assert!(serial
597            .iter()
598            .any(|c| c.entry.status == DiffStatus::Added || c.entry.status == DiffStatus::Deleted));
599    }
600
601    #[test]
602    fn name_only_does_not_read_blobs_for_tree_to_tree() {
603        use crate::config::ConfigSet;
604        use crate::diff::{build_file_diffs, DiffDetail, DiffOptions};
605
606        let (_dir, repo) = init_repo();
607        let odb = repo.odb();
608        let a = odb.write(ObjectKind::Blob, b"alpha\n").expect("write a");
609        let b = odb.write(ObjectKind::Blob, b"beta\n").expect("write b");
610        let old = odb
611            .write(
612                ObjectKind::Tree,
613                &serialize_tree(&[TreeEntry {
614                    mode: 0o100644,
615                    name: b"f.txt".to_vec(),
616                    oid: a,
617                }]),
618            )
619            .expect("old tree");
620        let new = odb
621            .write(
622                ObjectKind::Tree,
623                &serialize_tree(&[TreeEntry {
624                    mode: 0o100644,
625                    name: b"f.txt".to_vec(),
626                    oid: b,
627                }]),
628            )
629            .expect("new tree");
630        let entries = diff_trees(odb, Some(&old), Some(&new), "").expect("entries");
631        let metrics = odb.hot_path_metrics();
632        metrics.set_blob_counting(true);
633        metrics.reset_blob_content_reads();
634        let config = ConfigSet::new();
635        let _ = build_file_diffs(
636            odb,
637            entries,
638            DiffDetail::NameOnly,
639            DiffOptions::default(),
640            &config,
641            &ThreadPolicy::default(),
642        )
643        .expect("name-only");
644        metrics.set_blob_counting(false);
645        assert_eq!(metrics.blob_content_reads(), 0);
646    }
647
648    #[test]
649    fn small_entry_counts_run_serially_without_consulting_the_policy() {
650        let config = ConfigSet::new();
651        let policy = ThreadPolicy::with_threads_override(Some(4));
652        for count in [0, 1, 2, PER_ENTRY_POOL_MIN_ITEMS - 1] {
653            let opts = per_entry_parallel_options(&policy, &config, count);
654            assert_eq!(opts.threads, NonZeroUsize::MIN, "{count} entries");
655        }
656        for count in [PER_ENTRY_POOL_MIN_ITEMS, PER_ENTRY_POOL_MIN_ITEMS * 4] {
657            let opts = per_entry_parallel_options(&policy, &config, count);
658            assert_eq!(opts.min_items, 0);
659            assert_eq!(opts.min_total_bytes, None);
660            assert_eq!(
661                opts.threads,
662                policy.resolve(ParallelOp::DiffContent, &config).threads
663            );
664        }
665    }
666
667    #[test]
668    fn min_items_override_moves_the_pool_threshold() {
669        let config = ConfigSet::new();
670        let threads = ThreadPolicy::with_threads_override(Some(4))
671            .resolve(ParallelOp::DiffContent, &config)
672            .threads;
673        let forced = ThreadPolicy::with_threads_override(Some(4)).min_items_override(Some(0));
674        assert_eq!(
675            per_entry_parallel_options(&forced, &config, 1).threads,
676            NonZeroUsize::MIN
677        );
678        assert_eq!(
679            per_entry_parallel_options(&forced, &config, 2).threads,
680            threads
681        );
682        let raised = ThreadPolicy::with_threads_override(Some(4)).min_items_override(Some(100));
683        assert_eq!(
684            per_entry_parallel_options(&raised, &config, 99).threads,
685            NonZeroUsize::MIN
686        );
687        assert_eq!(
688            per_entry_parallel_options(&raised, &config, 100).threads,
689            threads
690        );
691    }
692
693    #[test]
694    fn structured_diff_below_and_above_pool_threshold_matches_serial() {
695        let (_dir, repo) = init_repo();
696        let odb = repo.odb();
697        let tree_of = |version: &str, files: usize| {
698            let entries: Vec<TreeEntry> = (0..files)
699                .map(|i| TreeEntry {
700                    mode: 0o100644,
701                    name: format!("f{i:03}.txt").into_bytes(),
702                    oid: odb
703                        .write(
704                            ObjectKind::Blob,
705                            format!("file {i}\n{version}\nend\n").as_bytes(),
706                        )
707                        .expect("blob"),
708                })
709                .collect();
710            odb.write(ObjectKind::Tree, &serialize_tree(&entries))
711                .expect("tree")
712        };
713        let config = repo.config().snapshot().expect("config");
714        for files in [PER_ENTRY_POOL_MIN_ITEMS - 1, PER_ENTRY_POOL_MIN_ITEMS + 1] {
715            let (old, new) = (tree_of("old", files), tree_of("new", files));
716            let entries = diff_trees(odb, Some(&old), Some(&new), "").expect("entries");
717            assert_eq!(entries.len(), files);
718            let run = |threads| {
719                tree_diff_structured_parallel(
720                    odb,
721                    entries.clone(),
722                    &config,
723                    &ThreadPolicy::with_threads_override(Some(threads)),
724                    DiffOptions::default(),
725                )
726                .expect("structured diff")
727            };
728            let serial = run(1);
729            assert_eq!(serial, run(4), "{files} files");
730            assert!(serial.iter().all(|f| f.structured.hunks.len() == 1));
731        }
732    }
733
734    #[test]
735    fn big_file_threshold_honors_diff_driver_binary_false() -> Result<()> {
736        let (dir, repo) = init_repo_with_core_config(
737            "[core]\n\tbigFileThreshold = 4k\n\n[diff \"foo\"]\n\tbinary = false\n",
738        );
739        std::fs::write(dir.path().join(".gitattributes"), "*.bin diff=foo\n")?;
740        let odb = repo.odb();
741        let mut old_body = vec![b'a'; 100];
742        old_body.extend(std::iter::repeat_n(b'x', 4900));
743        assert_eq!(old_body.len(), 5000);
744        let mut new_body = old_body.clone();
745        new_body[0] = b'b';
746        let old_oid = odb.write(ObjectKind::Blob, &old_body)?;
747        let new_oid = odb.write(ObjectKind::Blob, &new_body)?;
748        let tree_old = odb.write(
749            ObjectKind::Tree,
750            &serialize_tree(&[TreeEntry {
751                mode: 0o100644,
752                name: b"a.bin".to_vec(),
753                oid: old_oid,
754            }]),
755        )?;
756        let tree_new = odb.write(
757            ObjectKind::Tree,
758            &serialize_tree(&[TreeEntry {
759                mode: 0o100644,
760                name: b"a.bin".to_vec(),
761                oid: new_oid,
762            }]),
763        )?;
764        let entries = diff_trees(odb, Some(&tree_old), Some(&tree_new), "")?;
765        assert_eq!(entries.len(), 1);
766        let metrics = odb.hot_path_metrics();
767        metrics.set_blob_counting(true);
768        metrics.reset_blob_content_reads();
769        let structured = tree_diff_structured_entry(odb, &entries[0], &DiffOptions::default())?;
770        metrics.set_blob_counting(false);
771        assert!(
772            !structured.binary,
773            "diff.foo.binary=false must force a textual diff"
774        );
775        assert!(
776            !structured.structured.hunks.is_empty(),
777            "expected unified hunks, not binary short-circuit"
778        );
779        assert!(
780            metrics.blob_content_reads() >= 2,
781            "both sides must be read for a line diff"
782        );
783        Ok(())
784    }
785
786    #[test]
787    fn tree_diff_skips_reading_blobs_over_big_file_threshold() {
788        let (_dir, repo) = init_repo_with_core_config("[core]\n\tbigFileThreshold = 4k\n");
789        let odb = repo.odb();
790
791        let big_a = odb
792            .write(ObjectKind::Blob, &vec![b'a'; 5000])
793            .expect("big blob a");
794        let big_b = odb
795            .write(ObjectKind::Blob, &vec![b'b'; 5001])
796            .expect("big blob b");
797        let tree_old = odb
798            .write(
799                ObjectKind::Tree,
800                &serialize_tree(&[TreeEntry {
801                    mode: 0o100644,
802                    name: b"f.bin".to_vec(),
803                    oid: big_a,
804                }]),
805            )
806            .expect("old tree");
807        let tree_new = odb
808            .write(
809                ObjectKind::Tree,
810                &serialize_tree(&[TreeEntry {
811                    mode: 0o100644,
812                    name: b"f.bin".to_vec(),
813                    oid: big_b,
814                }]),
815            )
816            .expect("new tree");
817        let entries = diff_trees(odb, Some(&tree_old), Some(&tree_new), "").expect("entries");
818        let metrics = odb.hot_path_metrics();
819        metrics.set_blob_counting(true);
820        metrics.reset_blob_content_reads();
821        let config = repo.config().snapshot().expect("config");
822        let _ = tree_diff_stat_parallel(
823            odb,
824            entries,
825            &config,
826            &ThreadPolicy::default(),
827            DiffOptions::default(),
828        )
829        .expect("stat");
830        metrics.set_blob_counting(false);
831        assert_eq!(metrics.blob_content_reads(), 0);
832    }
833
834    #[test]
835    fn blob_at_exactly_big_file_threshold_is_still_read() {
836        let (_dir, repo) = init_repo_with_core_config("[core]\n\tbigFileThreshold = 4k\n");
837        let odb = repo.odb();
838
839        let at_threshold = odb
840            .write(ObjectKind::Blob, &vec![b'b'; 4096])
841            .expect("at threshold");
842        let other = odb.write(ObjectKind::Blob, b"z\n").expect("other");
843        let tree_old = odb
844            .write(
845                ObjectKind::Tree,
846                &serialize_tree(&[TreeEntry {
847                    mode: 0o100644,
848                    name: b"g.bin".to_vec(),
849                    oid: other,
850                }]),
851            )
852            .expect("old tree");
853        let tree_new = odb
854            .write(
855                ObjectKind::Tree,
856                &serialize_tree(&[TreeEntry {
857                    mode: 0o100644,
858                    name: b"g.bin".to_vec(),
859                    oid: at_threshold,
860                }]),
861            )
862            .expect("new tree");
863        let entries = diff_trees(odb, Some(&tree_old), Some(&tree_new), "").expect("entries");
864        let metrics = odb.hot_path_metrics();
865        metrics.set_blob_counting(true);
866        metrics.reset_blob_content_reads();
867        let config = repo.config().snapshot().expect("config");
868        let _ = tree_diff_stat_parallel(
869            odb,
870            entries,
871            &config,
872            &ThreadPolicy::default(),
873            DiffOptions::default(),
874        )
875        .expect("stat");
876        metrics.set_blob_counting(false);
877        assert!(metrics.blob_content_reads() >= 1);
878    }
879
880    #[test]
881    fn blob_under_big_file_threshold_is_read_for_stat() {
882        let (_dir, repo) = init_repo_with_core_config("[core]\n\tbigFileThreshold = 4k\n");
883        let odb = repo.odb();
884
885        let under = odb
886            .write(ObjectKind::Blob, &vec![b'c'; 4000])
887            .expect("under");
888        let other = odb.write(ObjectKind::Blob, b"x\n").expect("other");
889        let tree_a = odb
890            .write(
891                ObjectKind::Tree,
892                &serialize_tree(&[TreeEntry {
893                    mode: 0o100644,
894                    name: b"h.bin".to_vec(),
895                    oid: other,
896                }]),
897            )
898            .expect("tree a");
899        let tree_b = odb
900            .write(
901                ObjectKind::Tree,
902                &serialize_tree(&[TreeEntry {
903                    mode: 0o100644,
904                    name: b"h.bin".to_vec(),
905                    oid: under,
906                }]),
907            )
908            .expect("tree b");
909        let entries = diff_trees(odb, Some(&tree_a), Some(&tree_b), "").expect("entries");
910        let metrics = odb.hot_path_metrics();
911        metrics.set_blob_counting(true);
912        metrics.reset_blob_content_reads();
913        let config = repo.config().snapshot().expect("config");
914        let _ = tree_diff_stat_parallel(
915            odb,
916            entries,
917            &config,
918            &ThreadPolicy::default(),
919            DiffOptions::default(),
920        )
921        .expect("stat");
922        metrics.set_blob_counting(false);
923        assert!(metrics.blob_content_reads() >= 2);
924    }
925
926    #[test]
927    fn single_entry_structured_diff_matches_threaded_policy() {
928        let (_dir, repo) = init_repo();
929        let odb = repo.odb();
930        let a = odb.write(ObjectKind::Blob, b"one\ntwo\n").expect("write a");
931        let b = odb
932            .write(ObjectKind::Blob, b"one\nthree\n")
933            .expect("write b");
934        let tree = |oid| {
935            odb.write(
936                ObjectKind::Tree,
937                &serialize_tree(&[TreeEntry {
938                    mode: 0o100644,
939                    name: b"f.txt".to_vec(),
940                    oid,
941                }]),
942            )
943            .expect("tree")
944        };
945        let (old, new) = (tree(a), tree(b));
946        let entries = diff_trees(odb, Some(&old), Some(&new), "").expect("entries");
947        assert_eq!(entries.len(), 1);
948        let config = repo.config().snapshot().expect("config");
949        let run = |threads| {
950            tree_diff_structured_parallel(
951                odb,
952                entries.clone(),
953                &config,
954                &ThreadPolicy::with_threads_override(Some(threads)),
955                DiffOptions::default(),
956            )
957            .expect("structured diff")
958        };
959        let serial = run(1);
960        assert_eq!(serial, run(4));
961        assert_eq!(serial[0].structured.hunks.len(), 1);
962    }
963}