1use 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
58const PER_ENTRY_POOL_MIN_ITEMS: usize = 16;
65
66fn 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#[derive(Debug, Clone, PartialEq, Eq)]
96pub struct TreeDiffStructured {
97 pub entry: DiffEntry,
99 pub structured: StructuredFileDiff,
101 pub binary: bool,
103 pub old_size: u64,
105 pub new_size: u64,
107 pub patch_bytes: Option<(SideBytes, SideBytes)>,
109}
110
111#[derive(Debug, Clone, PartialEq, Eq)]
113#[cfg(test)]
114pub(crate) struct TreeDiffContent {
115 pub entry: DiffEntry,
117 pub old_bytes: SideBytes,
119 pub new_bytes: SideBytes,
121 pub binary: bool,
123}
124
125#[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
161pub(crate) type TreeDiffStatRow = (DiffEntry, bool, Option<LineStat>, u64, u64);
163
164pub(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
234pub 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
297pub(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
346pub(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
410pub(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
423fn 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
446pub(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
469pub(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
486pub 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#[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}