git-commit-vandalism/t/t6421-merge-partial-clone.sh

441 lines
16 KiB
Bash
Raw Normal View History

#!/bin/sh
test_description="limiting blob downloads when merging with partial clones"
# Uses a methodology similar to
# t6042: corner cases with renames but not criss-cross merges
# t6036: corner cases with both renames and criss-cross merges
# t6423: directory rename detection
#
# The setup for all of them, pictorially, is:
#
# A
# o
# / \
# O o ?
# \ /
# o
# B
#
# To help make it easier to follow the flow of tests, they have been
# divided into sections and each test will start with a quick explanation
# of what commits O, A, and B contain.
#
# Notation:
# z/{b,c} means files z/b and z/c both exist
# x/d_1 means file x/d exists with content d1. (Purpose of the
# underscore notation is to differentiate different
# files that might be renamed into each other's paths.)
. ./test-lib.sh
. "$TEST_DIRECTORY"/lib-merge.sh
test_setup_repo () {
test -d server && return
git init server &&
(
cd server &&
git config uploadpack.allowfilter 1 &&
git config uploadpack.allowanysha1inwant 1 &&
mkdir -p general &&
test_seq 2 9 >general/leap1 &&
cp general/leap1 general/leap2 &&
echo leap2 >>general/leap2 &&
mkdir -p basename &&
cp general/leap1 basename/numbers &&
cp general/leap1 basename/sequence &&
cp general/leap1 basename/values &&
echo numbers >>basename/numbers &&
echo sequence >>basename/sequence &&
echo values >>basename/values &&
mkdir -p dir/unchanged &&
mkdir -p dir/subdir/tweaked &&
echo a >dir/subdir/a &&
echo b >dir/subdir/b &&
echo c >dir/subdir/c &&
echo d >dir/subdir/d &&
echo e >dir/subdir/e &&
cp general/leap1 dir/subdir/Makefile &&
echo toplevel makefile >>dir/subdir/Makefile &&
echo f >dir/subdir/tweaked/f &&
echo g >dir/subdir/tweaked/g &&
echo h >dir/subdir/tweaked/h &&
echo subdirectory makefile >dir/subdir/tweaked/Makefile &&
for i in $(test_seq 1 88)
do
echo content $i >dir/unchanged/file_$i
done &&
git add . &&
git commit -m "O" &&
git branch O &&
git branch A &&
git branch B-single &&
git branch B-dir &&
git branch B-many &&
git switch A &&
git rm general/leap* &&
mkdir general/ &&
test_seq 1 9 >general/jump1 &&
cp general/jump1 general/jump2 &&
echo leap2 >>general/jump2 &&
rm basename/numbers basename/sequence basename/values &&
mkdir -p basename/subdir/
cp general/jump1 basename/subdir/numbers &&
cp general/jump1 basename/subdir/sequence &&
cp general/jump1 basename/subdir/values &&
echo numbers >>basename/subdir/numbers &&
echo sequence >>basename/subdir/sequence &&
echo values >>basename/subdir/values &&
git rm dir/subdir/tweaked/f &&
echo more >>dir/subdir/e &&
echo more >>dir/subdir/Makefile &&
echo more >>dir/subdir/tweaked/Makefile &&
mkdir dir/subdir/newsubdir &&
echo rust code >dir/subdir/newsubdir/newfile.rs &&
git mv dir/subdir/e dir/subdir/newsubdir/ &&
git mv dir folder &&
git add . &&
git commit -m "A" &&
git switch B-single &&
echo new first line >dir/subdir/Makefile &&
cat general/leap1 >>dir/subdir/Makefile &&
echo toplevel makefile >>dir/subdir/Makefile &&
echo perl code >general/newfile.pl &&
git add . &&
git commit -m "B-single" &&
git switch B-dir &&
echo java code >dir/subdir/newfile.java &&
echo scala code >dir/subdir/newfile.scala &&
echo groovy code >dir/subdir/newfile.groovy &&
git add . &&
git commit -m "B-dir" &&
git switch B-many &&
test_seq 2 10 >general/leap1 &&
rm general/leap2 &&
cp general/leap1 general/leap2 &&
echo leap2 >>general/leap2 &&
rm basename/numbers basename/sequence basename/values &&
mkdir -p basename/subdir/
cp general/leap1 basename/subdir/numbers &&
cp general/leap1 basename/subdir/sequence &&
cp general/leap1 basename/subdir/values &&
echo numbers >>basename/subdir/numbers &&
echo sequence >>basename/subdir/sequence &&
echo values >>basename/subdir/values &&
mkdir dir/subdir/newsubdir/ &&
echo c code >dir/subdir/newfile.c &&
echo python code >dir/subdir/newsubdir/newfile.py &&
git add . &&
git commit -m "B-many" &&
git switch A
)
}
# Testcase: Objects downloaded for single relevant rename
# Commit O:
# general/{leap1_O, leap2_O}
# basename/{numbers_O, sequence_O, values_O}
# dir/subdir/{a,b,c,d,e_O,Makefile_TOP_O}
# dir/subdir/tweaked/{f,g,h,Makefile_SUB_O}
# dir/unchanged/<LOTS OF FILES>
# Commit A:
# (Rename leap->jump, rename basename/ -> basename/subdir/, rename dir/
# -> folder/, move e into newsubdir, add newfile.rs, remove f, modify
# both both Makefiles and jumps)
# general/{jump1_A, jump2_A}
# basename/subdir/{numbers_A, sequence_A, values_A}
# folder/subdir/{a,b,c,d,Makefile_TOP_A}
# folder/subdir/newsubdir/{e_A,newfile.rs}
# folder/subdir/tweaked/{g,h,Makefile_SUB_A}
# folder/unchanged/<LOTS OF FILES>
# Commit B(-single):
# (add newfile.pl, tweak Makefile_TOP)
# general/{leap1_O, leap2_O,newfile.pl}
# basename/{numbers_O, sequence_O, values_O}
# dir/{a,b,c,d,e_O,Makefile_TOP_B}
# dir/tweaked/{f,g,h,Makefile_SUB_O}
# dir/unchanged/<LOTS OF FILES>
# Expected:
# general/{jump1_A, jump2_A,newfile.pl}
# basename/subdir/{numbers_A, sequence_A, values_A}
# folder/subdir/{a,b,c,d,Makefile_TOP_Merged}
# folder/subdir/newsubdir/{e_A,newfile.rs}
# folder/subdir/tweaked/{g,h,Makefile_SUB_A}
# folder/unchanged/<LOTS OF FILES>
#
# Objects that need to be fetched:
# Rename detection:
# Side1 (O->A):
# Basename-matches rename detection only needs to fetch these objects:
# Makefile_TOP_O, Makefile_TOP_A
# (Despite many renames, all others are content irrelevant. They
# are also location irrelevant because newfile.rs was added on
# the side doing the directory rename, and newfile.pl was added to
# a directory that was not renamed on either side.)
# General rename detection only needs to fetch these objects:
# <None>
# (Even though newfile.rs, jump[12], basename/subdir/*, and e
# could all be used as destinations in rename detection, the
# basename detection for Makefile matches up all relevant
# sources, so these other files never end up needing to be
# used)
# Side2 (O->B):
# Basename-matches rename detection only needs to fetch these objects:
# <None>
# (there are no deleted files, so no possible sources)
# General rename detection only needs to fetch these objects:
# <None>
# (there are no deleted files, so no possible sources)
# Merge:
# 3-way content merge needs to grab these objects:
# Makefile_TOP_B
# Nothing else needs to fetch objects
#
# Summary: 2 fetches (1 for 2 objects, 1 for 1 object)
#
diffcore-rename: use a different prefetch for basename comparisons merge-ort was designed to minimize the amount of data needed and used, and several changes were made to diffcore-rename to take advantage of extra metadata to enable this data minimization (particularly the relevant_sources variable for skipping "irrelevant" renames). This effort obviously succeeded in drastically reducing computation times, but should also theoretically allow partial clones to download much less information. Previously, though, the "prefetch" command used in diffcore-rename had never been modified and downloaded many blobs that were unnecessary for merge-ort. This commit corrects that. When doing basename comparisons, we want to fetch only the objects that will be used for basename comparisons. If after basename fetching this leaves us with no more relevant sources (or no more destinations), then we won't need to do the full inexact rename detection and can skip downloading additional source and destination files. Even if we have to do that later full inexact rename detection, irrelevant sources are culled after basename matching and before the full inexact rename detection, so we can still avoid downloading the blobs for irrelevant sources. Rename prefetch() to inexact_prefetch(), and introduce a new basename_prefetch() to take advantage of this. If we modify the testcase from commit 557ac0350d ("merge-ort: begin performance work; instrument with trace2_region_* calls", 2021-01-23) to pass --sparse --filter=blob:none to the clone command, and use the new trace2 "fetch_count" output from a few commits ago to track both the number of fetch subcommands invoked and the number of objects fetched across all those fetches, then for the mega-renames testcase we observe the following: BEFORE this commit, rebasing 35 patches: strategy # of fetches total # of objects fetched --------- ------------ -------------------------- recursive 62 11423 ort 30 11391 AFTER this commit, rebasing the same 35 patches: ort 32 63 This means that the new code only needs to download less than 2 blobs per patch being rebased. That is especially interesting given that the repository at the start only had approximately half a dozen TOTAL blobs downloaded to start with (because the default sparse-checkout of just the toplevel directory was in use). So, for this particular linux kernel testcase that involved ~26,000 renames on the upstream side (drivers/ -> pilots/) across which 35 patches were being rebased, this change reduces the number of blobs that need to be downloaded by a factor of ~180. Signed-off-by: Elijah Newren <newren@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-06-22 10:04:40 +02:00
test_expect_merge_algorithm failure success 'Objects downloaded for single relevant rename' '
test_setup_repo &&
git clone --sparse --filter=blob:none "file://$(pwd)/server" objects-single &&
(
cd objects-single &&
git rev-list --objects --all --missing=print |
grep "^?" | sort >missing-objects-before &&
git checkout -q origin/A &&
GIT_TRACE2_PERF="$(pwd)/trace.output" git \
-c merge.directoryRenames=true merge --no-stat \
--no-progress origin/B-single &&
# Check the number of objects we reported we would fetch
cat >expect <<-EOF &&
fetch_count:2
fetch_count:1
EOF
grep fetch_count trace.output | cut -d "|" -f 9 | tr -d " ." >actual &&
test_cmp expect actual &&
# Check the number of fetch commands exec-ed
grep d0.*fetch.negotiationAlgorithm trace.output >fetches &&
test_line_count = 2 fetches &&
git rev-list --objects --all --missing=print |
grep "^?" | sort >missing-objects-after &&
comm -2 -3 missing-objects-before missing-objects-after >old &&
comm -1 -3 missing-objects-before missing-objects-after >new &&
# No new missing objects
test_must_be_empty new &&
# Fetched 2 + 1 = 3 objects
test_line_count = 3 old
)
'
# Testcase: Objects downloaded for directory rename
# Commit O:
# general/{leap1_O, leap2_O}
# basename/{numbers_O, sequence_O, values_O}
# dir/subdir/{a,b,c,d,e_O,Makefile_TOP_O}
# dir/subdir/tweaked/{f,g,h,Makefile_SUB_O}
# dir/unchanged/<LOTS OF FILES>
# Commit A:
# (Rename leap->jump, rename basename/ -> basename/subdir/, rename dir/ ->
# folder/, move e into newsubdir, add newfile.rs, remove f, modify
# both Makefiles and jumps)
# general/{jump1_A, jump2_A}
# basename/subdir/{numbers_A, sequence_A, values_A}
# folder/subdir/{a,b,c,d,Makefile_TOP_A}
# folder/subdir/newsubdir/{e_A,newfile.rs}
# folder/subdir/tweaked/{g,h,Makefile_SUB_A}
# folder/unchanged/<LOTS OF FILES>
# Commit B(-dir):
# (add dir/subdir/newfile.{java,scala,groovy}
# general/{leap1_O, leap2_O}
# basename/{numbers_O, sequence_O, values_O}
# dir/subdir/{a,b,c,d,e_O,Makefile_TOP_O,
# newfile.java,newfile.scala,newfile.groovy}
# dir/subdir/tweaked/{f,g,h,Makefile_SUB_O}
# dir/unchanged/<LOTS OF FILES>
# Expected:
# general/{jump1_A, jump2_A}
# basename/subdir/{numbers_A, sequence_A, values_A}
# folder/subdir/{a,b,c,d,Makefile_TOP_A,
# newfile.java,newfile.scala,newfile.groovy}
# folder/subdir/newsubdir/{e_A,newfile.rs}
# folder/subdir/tweaked/{g,h,Makefile_SUB_A}
# folder/unchanged/<LOTS OF FILES>
#
# Objects that need to be fetched:
# Makefile_TOP_O, Makefile_TOP_A
# Makefile_SUB_O, Makefile_SUB_A
# e_O, e_A
# * Despite A's rename of jump->leap, those renames are irrelevant.
# * Despite A's rename of basename/ -> basename/subdir/, those renames are
# irrelevant.
# * Because of A's rename of dir/ -> folder/ and B-dir's addition of
# newfile.* into dir/subdir/, we need to determine directory renames.
# (Technically, there are enough exact renames to determine directory
# rename detection, but the current implementation always does
# basename searching before directory rename detection. Running it
# also before basename searching would mean doing directory rename
# detection twice, but it's a bit expensive to do that and cases like
# this are not all that common.)
# Summary: 1 fetches for 6 objects
#
diffcore-rename: use a different prefetch for basename comparisons merge-ort was designed to minimize the amount of data needed and used, and several changes were made to diffcore-rename to take advantage of extra metadata to enable this data minimization (particularly the relevant_sources variable for skipping "irrelevant" renames). This effort obviously succeeded in drastically reducing computation times, but should also theoretically allow partial clones to download much less information. Previously, though, the "prefetch" command used in diffcore-rename had never been modified and downloaded many blobs that were unnecessary for merge-ort. This commit corrects that. When doing basename comparisons, we want to fetch only the objects that will be used for basename comparisons. If after basename fetching this leaves us with no more relevant sources (or no more destinations), then we won't need to do the full inexact rename detection and can skip downloading additional source and destination files. Even if we have to do that later full inexact rename detection, irrelevant sources are culled after basename matching and before the full inexact rename detection, so we can still avoid downloading the blobs for irrelevant sources. Rename prefetch() to inexact_prefetch(), and introduce a new basename_prefetch() to take advantage of this. If we modify the testcase from commit 557ac0350d ("merge-ort: begin performance work; instrument with trace2_region_* calls", 2021-01-23) to pass --sparse --filter=blob:none to the clone command, and use the new trace2 "fetch_count" output from a few commits ago to track both the number of fetch subcommands invoked and the number of objects fetched across all those fetches, then for the mega-renames testcase we observe the following: BEFORE this commit, rebasing 35 patches: strategy # of fetches total # of objects fetched --------- ------------ -------------------------- recursive 62 11423 ort 30 11391 AFTER this commit, rebasing the same 35 patches: ort 32 63 This means that the new code only needs to download less than 2 blobs per patch being rebased. That is especially interesting given that the repository at the start only had approximately half a dozen TOTAL blobs downloaded to start with (because the default sparse-checkout of just the toplevel directory was in use). So, for this particular linux kernel testcase that involved ~26,000 renames on the upstream side (drivers/ -> pilots/) across which 35 patches were being rebased, this change reduces the number of blobs that need to be downloaded by a factor of ~180. Signed-off-by: Elijah Newren <newren@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-06-22 10:04:40 +02:00
test_expect_merge_algorithm failure success 'Objects downloaded when a directory rename triggered' '
test_setup_repo &&
git clone --sparse --filter=blob:none "file://$(pwd)/server" objects-dir &&
(
cd objects-dir &&
git rev-list --objects --all --missing=print |
grep "^?" | sort >missing-objects-before &&
git checkout -q origin/A &&
GIT_TRACE2_PERF="$(pwd)/trace.output" git \
-c merge.directoryRenames=true merge --no-stat \
--no-progress origin/B-dir &&
# Check the number of objects we reported we would fetch
cat >expect <<-EOF &&
fetch_count:6
EOF
grep fetch_count trace.output | cut -d "|" -f 9 | tr -d " ." >actual &&
test_cmp expect actual &&
# Check the number of fetch commands exec-ed
grep d0.*fetch.negotiationAlgorithm trace.output >fetches &&
test_line_count = 1 fetches &&
git rev-list --objects --all --missing=print |
grep "^?" | sort >missing-objects-after &&
comm -2 -3 missing-objects-before missing-objects-after >old &&
comm -1 -3 missing-objects-before missing-objects-after >new &&
# No new missing objects
test_must_be_empty new &&
# Fetched 6 objects
test_line_count = 6 old
)
'
# Testcase: Objects downloaded with lots of renames and modifications
# Commit O:
# general/{leap1_O, leap2_O}
# basename/{numbers_O, sequence_O, values_O}
# dir/subdir/{a,b,c,d,e_O,Makefile_TOP_O}
# dir/subdir/tweaked/{f,g,h,Makefile_SUB_O}
# dir/unchanged/<LOTS OF FILES>
# Commit A:
# (Rename leap->jump, rename basename/ -> basename/subdir/, rename dir/
# -> folder/, move e into newsubdir, add newfile.rs, remove f, modify
# both both Makefiles and jumps)
# general/{jump1_A, jump2_A}
# basename/subdir/{numbers_A, sequence_A, values_A}
# folder/subdir/{a,b,c,d,Makefile_TOP_A}
# folder/subdir/newsubdir/{e_A,newfile.rs}
# folder/subdir/tweaked/{g,h,Makefile_SUB_A}
# folder/unchanged/<LOTS OF FILES>
# Commit B(-minimal):
# (modify both leaps, rename basename/ -> basename/subdir/, add
# newfile.{c,py})
# general/{leap1_B, leap2_B}
# basename/subdir/{numbers_B, sequence_B, values_B}
# dir/{a,b,c,d,e_O,Makefile_TOP_O,newfile.c}
# dir/tweaked/{f,g,h,Makefile_SUB_O,newfile.py}
# dir/unchanged/<LOTS OF FILES>
# Expected:
# general/{jump1_Merged, jump2_Merged}
# basename/subdir/{numbers_Merged, sequence_Merged, values_Merged}
# folder/subdir/{a,b,c,d,Makefile_TOP_A,newfile.c}
# folder/subdir/newsubdir/e_A
# folder/subdir/tweaked/{g,h,Makefile_SUB_A,newfile.py}
# folder/unchanged/<LOTS OF FILES>
#
# Objects that need to be fetched:
# Rename detection:
# Side1 (O->A):
# Basename-matches rename detection only needs to fetch these objects:
# numbers_O, numbers_A
# sequence_O, sequence_A
# values_O, values_A
# Makefile_TOP_O, Makefile_TOP_A
# Makefile_SUB_O, Makefile_SUB_A
# e_O, e_A
# General rename detection only needs to fetch these objects:
# leap1_O, leap2_O
# jump1_A, jump2_A, newfile.rs
# (only need remaining relevant sources, but any relevant sources need
# to be matched against all possible unpaired destinations)
# Side2 (O->B):
# Basename-matches rename detection only needs to fetch these objects:
# numbers_B
# sequence_B
# values_B
# (because numbers_O, sequence_O, and values_O already fetched above)
# General rename detection only needs to fetch these objects:
# <None>
# Merge:
# 3-way content merge needs to grab these objects:
# leap1_B
# leap2_B
# Nothing else needs to fetch objects
#
# Summary: 4 fetches (1 for 6 objects, 1 for 8, 1 for 3, 1 for 2)
#
merge-ort: add prefetching for content merges Commit 7fbbcb21b1 ("diff: batch fetching of missing blobs", 2019-04-05) introduced batching of fetching missing blobs, so that the diff machinery would have one fetch subprocess grab N blobs instead of N processes each grabbing 1. However, the diff machinery is not the only thing in a merge that needs to work on blobs. The 3-way content merges need them as well. Rather than download all the blobs 1 at a time, prefetch all the blobs needed for regular content merges. This does not cover all possible paths in merge-ort that might need to download blobs. Others include: - The blob_unchanged() calls to avoid modify/delete conflicts (when blob renormalization results in an "unchanged" file) - Preliminary content merges needed for rename/add and rename/rename(2to1) style conflicts. (Both of these types of conflicts can result in nested conflict markers from the need to do two levels of content merging; the first happens before our new prefetch_for_content_merges() function.) The first of these wouldn't be an extreme amount of work to support, and even the second could be theoretically supported in batching, but all of these cases seem unusual to me, and this is a minor performance optimization anyway; in the worst case we only get some of the fetches batched and have a few additional one-off fetches. So for now, just handle the regular 3-way content merges in our prefetching. For the testcase from the previous commit, the number of downloaded objects remains at 63, but this drops the number of fetches needed from 32 down to 20, a sizeable reduction. Signed-off-by: Elijah Newren <newren@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-06-22 10:04:41 +02:00
test_expect_merge_algorithm failure success 'Objects downloaded with lots of renames and modifications' '
test_setup_repo &&
git clone --sparse --filter=blob:none "file://$(pwd)/server" objects-many &&
(
cd objects-many &&
git rev-list --objects --all --missing=print |
grep "^?" | sort >missing-objects-before &&
git checkout -q origin/A &&
GIT_TRACE2_PERF="$(pwd)/trace.output" git \
-c merge.directoryRenames=true merge --no-stat \
--no-progress origin/B-many &&
# Check the number of objects we reported we would fetch
cat >expect <<-EOF &&
fetch_count:12
fetch_count:5
fetch_count:3
fetch_count:2
EOF
grep fetch_count trace.output | cut -d "|" -f 9 | tr -d " ." >actual &&
test_cmp expect actual &&
# Check the number of fetch commands exec-ed
grep d0.*fetch.negotiationAlgorithm trace.output >fetches &&
test_line_count = 4 fetches &&
git rev-list --objects --all --missing=print |
grep "^?" | sort >missing-objects-after &&
comm -2 -3 missing-objects-before missing-objects-after >old &&
comm -1 -3 missing-objects-before missing-objects-after >new &&
# No new missing objects
test_must_be_empty new &&
# Fetched 12 + 5 + 3 + 2 = 22 objects
test_line_count = 22 old
)
'
test_done