1041 lines
36 KiB
Bash
Executable File
1041 lines
36 KiB
Bash
Executable File
#!/bin/bash
|
|
. driglibash-base
|
|
|
|
REPO_NAME=git_update_testing
|
|
REPO_PATH=./remote
|
|
WITH_SUBMODULE="true"
|
|
SUB_NAME="submodule_for_performance_testing"
|
|
FILES_TO_KEEP='sample0'
|
|
REMOTE="./remote/performance_testing"
|
|
|
|
if [ "$WITH_SUBMODULE" = "true" ]; then
|
|
bash creation_repo.sh -s &> /dev/null
|
|
else
|
|
bash creation_repo.sh &> /dev/null
|
|
fi
|
|
|
|
Help()
|
|
{
|
|
echo "
|
|
NAME
|
|
performance_tests.sh
|
|
SYNOPSIS
|
|
performance_tests.sh [-a] [-h] [-n number]
|
|
OPTIONS
|
|
-a excutes all the tests.
|
|
-n number executes test number
|
|
-h prints the help.
|
|
DESCRIPTION
|
|
This script is in writing. It allows you to measure memory and bandwidth usage. The first four test different cloning methods. Te following apply changes to the local remote before testing fetching and merging commands.
|
|
TEST0: classic cloning
|
|
TEST1: --single-branch cloning
|
|
TEST2: --depth=1 --no-single-branch cloning
|
|
TEST3: --depth=1 cloning
|
|
TEST4: --depth=1 with reflog and gc cloning
|
|
TEST5: sparse-checking 1M sample0 cloning
|
|
_________________
|
|
TEST6: classic fetching+checking out after addition of a 1M file
|
|
TEST7: classic fetching+checking out after removal of a 1M file
|
|
TEST8: classic fetching+checking out after addition then removal of a 1M file
|
|
|
|
TEST9: --depth=1 fetching+checking out after addition of a 1M file
|
|
TEST10: --depth=1 fetching+checking out after removal of a 1M file
|
|
TEST11: --depth=1 fetching+checking out after addition then removal of 1M a file
|
|
|
|
TEST12: --depth=1 fetching+checking out with reflog annd gc after addition of a 1M file
|
|
TEST13: --depth=1 fetching+checking out with reflog annd gc after removal of a 1M file
|
|
TEST14: --depth=1 fetching+checking out with reflog annd gc after addition then removal of a 1M file
|
|
|
|
TEST15: --depth=1 fetching+ --reset=hard after addition of a 1M file
|
|
TEST16: --depth=1 fetching+ --reset=hard after removal of a 1M file
|
|
TEST17: --depth=1 fetching+ --reset=hard after addition then removal of a 1M file
|
|
|
|
TEST18: --depth=1 fetching+ --reset=hard and reflog and gc after addition of a 1M file
|
|
TEST19: --depth=1 fetching+ --reset=hard and reflog and gc after removal of a 1M file
|
|
TEST20: --depth=1 fetching+ --reset=hard and reflog and gc after addition then removal of a 1M file
|
|
|
|
TEST21: --depth=1 fetching+checking out after addition of a 1M file in submodule
|
|
TEST22: --depth=1 fetching+checking out after removal of a 1M file in submodule
|
|
TEST23: --depth=1 fetching+checking out after addition then removal of a 1M file in submodule
|
|
|
|
TEST24: --depth=1 fetching+merging -X theirs with reflog and gc after addition of a 1M file
|
|
TEST25: --depth=1 fetching+merging -X theirs with reflog and gc after removal of a 1M file
|
|
TEST26: --depth=1 fetching+merging -X theirs with reflog and gc after addition then removal of a 1M file
|
|
|
|
TEST27: --depth=1 fetching+merging -s ours with reflog and gc after addition of a 1M file
|
|
TEST28: --depth=1 fetching+merging -s ours with reflog and gc after removal of a 1M file
|
|
TEST29: --depth=1 fetching+merging -s ours with reflog and gc after addition then removal of a 1M file"
|
|
}
|
|
|
|
#USEFUL FUNCTIONS FOR THE TESTS
|
|
create_random_file(){
|
|
run dd if=/dev/urandom of=$1 bs=$2 count=1 &> /dev/null
|
|
}
|
|
|
|
get_storage_used(){
|
|
mem=$(du $1 | tail -n1 | tr -cd [:digit:])
|
|
}
|
|
|
|
get_bandwidth(){
|
|
bw="unknown"
|
|
bw=$(grep -e "Receiving objects:" $1 | grep -o "Receiving objects: [[:alnum:]%/(),. ]*" | tail -n1)
|
|
bw=${bw#*,}
|
|
}
|
|
|
|
#TESTS ON THE INITIAL POPULATING OF THE REPO
|
|
section "Tests on the initial populating of the repository"
|
|
test0(){
|
|
section TEST0
|
|
echo "TEST 0: classic cloning."
|
|
run git clone --recurse-submodules --remote-submodules --progress --no-local $1 &> cloning_text
|
|
run cd $REPO_NAME
|
|
run git submodule update --init --recursive --force --remote --progress &> /dev/null
|
|
run cd ..
|
|
get_storage_used "./$REPO_NAME"
|
|
get_bandwidth cloning_text
|
|
echo "memory usage: $mem"
|
|
echo "bandwidth usage (submodule excluded): $bw"
|
|
run rm cloning_text
|
|
run rm -rf $REPO_NAME
|
|
}
|
|
|
|
test1(){
|
|
section TEST1
|
|
echo "TEST 1: --single-branch cloning."
|
|
run git clone --recurse-submodules --remote-submodules --progress --single-branch --no-local $1 &> cloning_text
|
|
run cd $REPO_NAME
|
|
run git submodule update --init --recursive --force --remote --progress &> /dev/null
|
|
run cd ..
|
|
get_storage_used ./$REPO_NAME
|
|
get_bandwidth cloning_text
|
|
echo "memory usage: $mem"
|
|
echo "bandwidth usage (submodule excluded): $bw"
|
|
run rm cloning_text
|
|
run rm -rf $REPO_NAME
|
|
}
|
|
|
|
test2(){
|
|
section TEST2
|
|
echo "TEST 2: --depth=1 --no-single-branch"
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local --no-single-branch $1 &> cloning_text
|
|
run cd $REPO_NAME
|
|
run git submodule update --init --recursive --force --remote --progress --depth=1 --no-single-branch &> /dev/null
|
|
run cd ..
|
|
get_storage_used ./$REPO_NAME
|
|
get_bandwidth cloning_text
|
|
echo "memory usage: $mem"
|
|
echo "bandwidth usage (submodule excluded): $bw"
|
|
run rm cloning_text
|
|
run rm -rf $REPO_NAME
|
|
}
|
|
|
|
test3(){
|
|
section TEST3
|
|
echo "TEST 3: --depth=1 with single-branch (default))"
|
|
run git clone --recurse-submodules --remote-submodules --progress --single-branch --no-local --depth=1 $1 &> cloning_text
|
|
run cd $REPO_NAME
|
|
run git submodule update --init --recursive --force --remote --progress --depth=1 &> /dev/null
|
|
run cd ..
|
|
get_storage_used ./$REPO_NAME
|
|
get_bandwidth cloning_text
|
|
echo "memory usage: $mem"
|
|
echo "bandwidth usage (submodule excluded): $bw"
|
|
run rm cloning_text
|
|
run rm -rf $REPO_NAME
|
|
}
|
|
|
|
test4(){
|
|
section TEST4
|
|
echo "TEST 4: --depth=1 with single-branch (default) and reflog and gc"
|
|
run git clone --recurse-submodules --remote-submodules --progress --single-branch --no-local --depth=1 $1 &> cloning_text
|
|
run cd $REPO_NAME
|
|
run git submodule update --init --recursive --force --remote --progress --depth=1 &> /dev/null
|
|
run git reset --hard
|
|
run cd ..
|
|
get_storage_used ./$REPO_NAME
|
|
get_bandwidth cloning_text
|
|
echo "memory usage: $mem"
|
|
echo "bandwidth usage (submodule excluded): $bw"
|
|
run rm cloning_text
|
|
run rm -rf $REPO_NAME
|
|
}
|
|
|
|
test5(){
|
|
section TEST5
|
|
run mkdir $REPO_NAME
|
|
run echo "TEST 5 : sparse-checking only $FILES_TO_KEEP with depth=1"
|
|
#creating a git repo with sparse-checking settings
|
|
run cd $REPO_NAME
|
|
run git init -q
|
|
run git config core.sparsecheckout true
|
|
run echo $FILES_TO_KEEP >> .git/info/sparse-checkout
|
|
#pulling from the remote with sparse-checking enabled
|
|
run git remote add -f origin ../$1 &> /dev/null
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git checkout -f origin/main &> /dev/null
|
|
get_storage_used .
|
|
echo "memory usage: $mem"
|
|
echo "bandwidth usage (submodule excluded): unknown"
|
|
run cd ..
|
|
run rm -rf $REPO_NAME
|
|
}
|
|
|
|
#Tests on the updating of the repository
|
|
#classic fetching
|
|
test6(){
|
|
section TEST6
|
|
run echo 'TEST 6: after addition of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --remote &> /dev/null
|
|
run git fetch --progress --tags --prune --prune-tags origin &> /dev/null
|
|
run git checkout -f origin/main &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: +$mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test7(){
|
|
section TEST7
|
|
run echo 'TEST 7: after removal of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
run rm sample0
|
|
run git add sample0
|
|
run git commit --quiet -m"1M sample0 deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --remote &> /dev/null
|
|
run git fetch --progress --tags --prune --prune-tags origin &> /dev/null
|
|
run git checkout -f origin/main &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~1
|
|
run git clean -df
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test8(){
|
|
section TEST8
|
|
run echo 'TEST 8: after addition then removal of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run rm sample5
|
|
run git add sample5
|
|
run git commit --quiet -m"1M "sample5" deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --remote &> /dev/null
|
|
run git fetch --progress --tags --prune --prune-tags origin &> /dev/null
|
|
run git checkout -f origin/main &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~2
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
|
|
#fetching with --depth=1
|
|
test9(){
|
|
section TEST9
|
|
run echo 'TEST 9: after addition of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run cd ../../$REPO_NAME
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git checkout -f origin/main &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: +$mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test10(){
|
|
section TEST10
|
|
run echo 'TEST 10: after removal of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
run rm sample0
|
|
run git add sample0
|
|
run git commit --quiet -m"1M sample0 deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git checkout -f origin/main &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test11(){
|
|
section TEST11
|
|
run echo 'TEST 11: after addition then removal of a 1M file'
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run rm sample5
|
|
run git add sample5
|
|
run git commit --quiet -m"1M "sample5" deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git checkout -f origin/main &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~2
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
|
|
# --depth=1 fetching with reflog and gc
|
|
test12(){
|
|
section TEST12
|
|
run echo 'TEST 12: after addition of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run cd ../../$REPO_NAME
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git checkout -f origin/main &> /dev/null
|
|
run git reflog expire --expire=now --all &> /dev/null
|
|
run git gc --aggressive --prune=now &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: +$mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test13(){
|
|
section TEST13
|
|
run echo 'TEST 13: after removal of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
run rm sample0
|
|
run git add sample0
|
|
run git commit --quiet -m"1M sample0 deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git checkout -f origin/main &> /dev/null
|
|
run git reflog expire --expire=now --all &> /dev/null
|
|
run git gc --aggressive --prune=now &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test14(){
|
|
section TEST14
|
|
run echo 'TEST 14: after addition then removal of a 1M file'
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run rm sample5
|
|
run git add sample5
|
|
run git commit --quiet -m"1M "sample5" deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git checkout -f origin/main &> /dev/null
|
|
run git reflog expire --expire=now --all &> /dev/null
|
|
run git gc --aggressive --prune=now &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~2
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
|
|
#--depth=1 fetching with reset --hard
|
|
test15(){
|
|
section TEST15
|
|
run echo 'TEST 15: after addition of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run cd ../../$REPO_NAME
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git reset --hard origin/main &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: +$mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test16(){
|
|
section TEST16
|
|
run echo 'TEST 16: after removal of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
run rm sample0
|
|
run git add sample0
|
|
run git commit --quiet -m"1M sample0 deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git reset --hard origin/main &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test17(){
|
|
section TEST17
|
|
run echo 'TEST 17: after addition then removal of a 1M file'
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run rm sample5
|
|
run git add sample5
|
|
run git commit --quiet -m"1M "sample5" deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git reset --hard origin/main &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~2
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
#--depth=1 fetching with reset --hard and reflog and gc
|
|
test18(){
|
|
section TEST18
|
|
run echo 'TEST 18: after addition of a 1M file'
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git reset --hard origin/main &> /dev/null
|
|
run git reflog expire --expire=now --all &> /dev/null
|
|
run git gc --aggressive --prune=now &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test19(){
|
|
section TEST19
|
|
run echo 'TEST 19: after removal of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
run rm sample0
|
|
run git add sample0
|
|
run git commit --quiet -m"1M sample0 deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git reset --hard origin/main &> /dev/null
|
|
run git reflog expire --expire=now --all &> /dev/null
|
|
run git gc --aggressive --prune=now &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test20(){
|
|
section TEST20
|
|
run echo 'TEST 20: after addition then removal of a 1M file'
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run rm sample5
|
|
run git add sample5
|
|
run git commit --quiet -m"1M "sample5" deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git reset --hard origin/main &> /dev/null
|
|
run git reflog expire --expire=now --all &> /dev/null
|
|
run git gc --aggressive --prune=now &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~2
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
#--depth=1 fetching after modification applied in submodule
|
|
test21(){
|
|
section TEST21
|
|
run echo 'TEST 21: after addition of a 1M file'
|
|
if [ "$WITH_SUBMODULE" = "true" ]; then
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote submodule
|
|
run cd ..
|
|
run cd $REPO_PATH/$SUB_NAME
|
|
create_random_file 'sub_sample1' '1M'
|
|
run git add sub_sample1
|
|
run git commit --quiet -m"second 1M sample created"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git checkout -f origin/main &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REPO_PATH/$SUB_NAME
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
else
|
|
echo "This test will not be performed because we are in no-submodule mode. Change boolean \$WITH_SUBMODULE to switch."
|
|
fi
|
|
}
|
|
|
|
test22(){
|
|
section TEST22
|
|
run echo 'TEST 22: after removal of a 1M file'
|
|
if [ "$WITH_SUBMODULE" = "true" ]; then
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote submodule
|
|
run cd ..
|
|
run cd $REPO_PATH/$SUB_NAME
|
|
rm sub_sample0
|
|
run git add sub_sample0
|
|
run git commit --quiet -m"1M 'sub_sample0' deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
git checkout -f origin/main &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REPO_PATH/$SUB_NAME
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
else
|
|
echo "This test will not be performed because we are in no-submodule mode. Change boolean \$WITH_SUBMODULE to switch."
|
|
fi
|
|
}
|
|
|
|
test23(){
|
|
section TEST23
|
|
run echo 'TEST 23: after addition then removal of a 1M file'
|
|
if [ "$WITH_SUBMODULE" = "true" ]; then
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote submodule
|
|
run cd ..
|
|
run cd $REPO_PATH/$SUB_NAME
|
|
create_random_file 'sub_sample1' '1M'
|
|
run git add sub_sample1
|
|
run git commit --quiet -m"second 1M sample created"
|
|
rm sub_sample1
|
|
run git add sub_sample1
|
|
run git commit --quiet -m"1M 'sub_sample1' deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git checkout -f origin/main &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REPO_PATH/$SUB_NAME
|
|
run git reset --hard -q HEAD~2
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
else
|
|
echo "This test will not be performed because we are in no-submodule mode. Change boolean \$WITH_SUBMODULE to switch."
|
|
fi
|
|
}
|
|
|
|
# --depth=1 fetching+merging -X theirs with reflog and gc
|
|
test24(){
|
|
section TEST24
|
|
run echo 'TEST 24: after addition of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run cd ../../$REPO_NAME
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git merge -X theirs --allow-unrelated-histories &> /dev/null
|
|
run git reflog expire --expire=now --all &> /dev/null
|
|
run git gc --aggressive --prune=now &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: +$mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test25(){
|
|
section TEST25
|
|
run echo 'TEST 25: after removal of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
run rm sample0
|
|
run git add sample0
|
|
run git commit --quiet -m"1M sample0 deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git merge -X theirs --allow-unrelated-histories &> /dev/null
|
|
run git reflog expire --expire=now --all &> /dev/null
|
|
run git gc --aggressive --prune=now &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test26(){
|
|
section TEST26
|
|
run echo 'TEST 26: after addition then removal of a 1M file'
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run rm sample5
|
|
run git add sample5
|
|
run git commit --quiet -m"1M "sample5" deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git merge -X theirs --allow-unrelated-histories &> /dev/null
|
|
run git reflog expire --expire=now --all &> /dev/null
|
|
run git gc --aggressive --prune=now &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~2
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
|
|
# --depth=1 fetching+merging -s ours with reflog and gc
|
|
test27(){
|
|
section TEST27
|
|
run echo 'TEST 27: after addition of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run cd ../../$REPO_NAME
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git switch -c temp origin/main &> /dev/null #creating a temporary branch identical to origin/main
|
|
run git merge -s ours --allow-unrelated-histories main &> /dev/null
|
|
run git checkout main &> /dev/null
|
|
run git merge --allow-unrelated-histories temp &> /dev/null
|
|
run git branch -D temp &> /dev/null
|
|
run git reflog expire --expire=now --all &> /dev/null
|
|
run git gc --aggressive --prune=now &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: +$mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test28(){
|
|
section TEST28
|
|
run echo 'TEST 28: after removal of a 1M file'
|
|
#initialization
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
run rm sample0
|
|
run git add sample0
|
|
run git commit --quiet -m"1M sample0 deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git switch -c temp origin/main &> /dev/null #creating a temporary branch identical to origin/main
|
|
run git merge -s ours --allow-unrelated-histories main &> /dev/null
|
|
run git checkout main &> /dev/null
|
|
run git merge --allow-unrelated-histories temp &> /dev/null
|
|
run git branch -D temp &> /dev/null
|
|
run git reflog expire --expire=now --all &> /dev/null
|
|
run git gc --aggressive --prune=now &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~1
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
test29(){
|
|
section TEST29
|
|
run echo 'TEST 29: after addition then removal of a 1M file'
|
|
run git clone --recurse-submodules --remote-submodules --progress --depth=1 --no-local $1 &> /dev/null
|
|
run cd $REPO_NAME
|
|
get_storage_used .
|
|
mem_before=$mem
|
|
#modification of the remote repo
|
|
run cd ../$REMOTE
|
|
create_random_file 'sample5' '1M' #adding a 1M file
|
|
run git add sample5
|
|
run git commit --quiet -m"fourth 1M sample created"
|
|
run rm sample5
|
|
run git add sample5
|
|
run git commit --quiet -m"1M "sample5" deleted"
|
|
run cd ../../$REPO_NAME
|
|
#fetching
|
|
run git submodule update --init --recursive --force --depth=1 --remote &> /dev/null
|
|
run git fetch --progress --tags --depth=1 --prune --prune-tags origin &> /dev/null
|
|
run git switch -c temp origin/main &> /dev/null #creating a temporary branch identical to origin/main
|
|
run git merge -s ours --allow-unrelated-histories main &> /dev/null
|
|
run git checkout main &> /dev/null
|
|
#run git merge --allow-unrelated-histories temp &> /dev/null
|
|
run git branch -D temp &> /dev/null
|
|
run git reflog expire --expire=now --all &> /dev/null
|
|
run git gc --aggressive --prune=now &> /dev/null
|
|
get_storage_used .
|
|
mem_after=$mem
|
|
mem=$(($mem_after-$mem_before))
|
|
echo "memory usage: $mem"
|
|
run cd ../$REMOTE
|
|
run git reset --hard -q HEAD~2
|
|
run cd ../..
|
|
run rm -rf performance_testing
|
|
}
|
|
|
|
|
|
while getopts ":hn:a" option; do
|
|
case $option in
|
|
h) # display Help
|
|
Help
|
|
exit;;
|
|
n)
|
|
TEST_NUM=$OPTARG;;
|
|
a)
|
|
ALL_TESTS=true;;
|
|
\?) # Invalid option
|
|
echo "Error: Invalid option here"
|
|
exit;;
|
|
esac
|
|
done
|
|
|
|
if [ "$ALL_TESTS" = "true" ]; then
|
|
test0 $REMOTE
|
|
test1 $REMOTE
|
|
test2 $REMOTE
|
|
test3 $REMOTE
|
|
test4 $REMOTE
|
|
test5 $REMOTE
|
|
echo $(section "Tests on the updating of the repository")
|
|
section "classic fetching+checking out"
|
|
test6 $REMOTE
|
|
test7 $REMOTE
|
|
test8 $REMOTE
|
|
echo $(section "fetching+checking out with --depth=1")
|
|
test9 $REMOTE
|
|
test10 $REMOTE
|
|
test11 $REMOTE
|
|
echo $(section "--depth=1 fetching+checking out reflog and gc")
|
|
test12 $REMOTE
|
|
test13 $REMOTE
|
|
test14 $REMOTE
|
|
echo $(section "--depth=1 fetching+ reset --hard")
|
|
test15 $REMOTE
|
|
test16 $REMOTE
|
|
test17 $REMOTE
|
|
echo $(section "--depth=1 fetching+ reset --hard and reflog and gc")
|
|
test18 $REMOTE
|
|
test19 $REMOTE
|
|
test20 $REMOTE
|
|
echo $(section "--depth=1 fetching+checking out after modification applied in submodule")
|
|
test21 $REMOTE
|
|
test22 $REMOTE
|
|
test23 $REMOTE
|
|
echo $(section "--depth=1 fetching+merging -X theirs with reflog and gc")
|
|
test24 $REMOTE
|
|
test25 $REMOTE
|
|
test26 $REMOTE
|
|
echo $(section "--depth=1 fetching+merging -s ours with reflog and gc")
|
|
test27 $REMOTE
|
|
test28 $REMOTE
|
|
test29 $REMOTE
|
|
|
|
|
|
elif [ -n "$TEST_NUM" ]; then
|
|
case $TEST_NUM in
|
|
0)
|
|
test0 $REMOTE;;
|
|
1)
|
|
test1 $REMOTE;;
|
|
2)
|
|
test2 $REMOTE;;
|
|
3)
|
|
test3 $REMOTE;;
|
|
4)
|
|
test4 $REMOTE;;
|
|
5)
|
|
test5 $REMOTE;;
|
|
6)
|
|
test6 $REMOTE;;
|
|
7)
|
|
test7 $REMOTE;;
|
|
8)
|
|
test8 $REMOTE;;
|
|
9)
|
|
test9 $REMOTE;;
|
|
10)
|
|
test10 $REMOTE;;
|
|
11)
|
|
test11 $REMOTE;;
|
|
12)
|
|
test12 $REMOTE;;
|
|
13)
|
|
test13 $REMOTE;;
|
|
14)
|
|
test14 $REMOTE;;
|
|
15)
|
|
test15 $REMOTE;;
|
|
16)
|
|
test16 $REMOTE;;
|
|
17)
|
|
test17 $REMOTE;;
|
|
18)
|
|
test18 $REMOTE;;
|
|
19)
|
|
test19 $REMOTE;;
|
|
20)
|
|
test20 $REMOTE;;
|
|
21)
|
|
test21 $REMOTE;;
|
|
22)
|
|
test22 $REMOTE;;
|
|
23)
|
|
test23 $REMOTE;;
|
|
24)
|
|
test24 $REMOTE;;
|
|
25)
|
|
test25 $REMOTE;;
|
|
26)
|
|
test26 $REMOTE;;
|
|
26)
|
|
test26 $REMOTE;;
|
|
27)
|
|
test27 $REMOTE;;
|
|
28)
|
|
test28 $REMOTE;;
|
|
29)
|
|
test29 $REMOTE;;
|
|
*)
|
|
echo "Error: Invalid test number"
|
|
die;;
|
|
esac
|
|
else
|
|
Help
|
|
fi
|
|
|
|
#add the submodules management to the cloning
|
|
#add run |