Jak skutecznie uzyskać czas wykonania skryptu?

Chciałbym wyświetlić czas zakończenia skryptu.

Obecnie robię to -

#!/bin/bash
date  ## echo the date at start
# the script contents
date  ## echo the date at end

Ten program to czas rozpoczęcia i zakończenia skryptu. Czy byłoby możliwe wyświetlanie drobnoziarnistych danych wyjściowych, takich jak czas procesora / czas io itp.?

Po prostu użyj, timegdy wywołasz skrypt:

time yourscript.sh

Jeśli timenie ma takiej opcji,

start=`date +%s`
stuff
end=`date +%s`

runtime=$((end-start))

Wystarczy timeswyjść bez argumentów po wyjściu ze skryptu.

Za pomocą kshlub zshmożesz także użyć timezamiast tego. Za pomocą zsh, timeda Ci także zegar ścienny oprócz czasu użytkownika i procesora systemu .

Aby zachować status wyjścia skryptu, możesz go zrobić:

ret=$?; times; exit "$ret"

Możesz też dodać pułapkę na EXIT:

trap times EXIT

W ten sposób czasy będą wywoływane przy każdym wyjściu powłoki i zachowaniu statusu wyjścia.

$ bash -c 'trap times EXIT; : {1..1000000}'
0m0.932s 0m0.028s
0m0.000s 0m0.000s
$ zsh -c 'trap time EXIT; : {1..1000000}'
shell  0.67s user 0.01s system 100% cpu 0.677 total
children  0.00s user 0.00s system 0% cpu 0.677 total

Należy również pamiętać, że wszystko bash, kshi zshposiada $SECONDSspecjalną zmienną, która zostaje automatycznie zwiększana co drugi. W obu zshi ksh93, że zmienna może być również wykonane zmiennoprzecinkowej (Z typeset -F SECONDS), aby uzyskać większą precyzję. Jest to tylko zegar ścienny, a nie czas procesora.

Jestem trochę spóźniony na modę, ale chciałem opublikować moje rozwiązanie (dla precyzji poniżej sekundy) na wypadek, gdyby inni natknęli się na ten wątek podczas wyszukiwania. Dane wyjściowe mają format dni, godzin, minut, a na koniec sekund:

res1=$(date +%s.%N)

# do stuff in here

res2=$(date +%s.%N)
dt=$(echo "$res2 - $res1" | bc)
dd=$(echo "$dt/86400" | bc)
dt2=$(echo "$dt-86400*$dd" | bc)
dh=$(echo "$dt2/3600" | bc)
dt3=$(echo "$dt2-3600*$dh" | bc)
dm=$(echo "$dt3/60" | bc)
ds=$(echo "$dt3-60*$dm" | bc)

printf "Total runtime: %d:%02d:%02d:%02.4f\n" $dd $dh $dm $ds

Mam nadzieję, że ktoś tam uzna to za przydatne!

Moja metoda na bash:

# Reset BASH time counter
SECONDS=0
    # 
    # do stuff
    # 
ELAPSED="Elapsed: $(($SECONDS / 3600))hrs $((($SECONDS / 60) % 60))min $(($SECONDS % 60))sec"

#!/bin/bash
start=$(date +%s.%N)

# HERE BE CODE

end=$(date +%s.%N)    
runtime=$(python -c "print(${end} - ${start})")

echo "Runtime was $runtime"

Tak, to wywołuje Python, ale jeśli możesz z tym żyć, jest to całkiem fajne, zwięzłe rozwiązanie.

To pytanie jest dość stare, ale próbując znaleźć mój ulubiony sposób zrobienia tego, ten wątek pojawił się wysoko ... i jestem zaskoczony, że nikt o nim nie wspominał:

perf stat -r 10 -B sleep 1

„perf” to narzędzie do analizy wydajności zawarte w jądrze pod „tools / perf” i często dostępne do zainstalowania jako osobny pakiet („perf” w CentOS i „linux-tools” w Debian / Ubuntu). Wiki systemu Linux Kernal perf zawiera o wiele więcej informacji na ten temat.

Uruchamianie „perf stat” podaje sporo szczegółów, w tym średni czas wykonania na samym końcu:

1.002248382 seconds time elapsed                   ( +-  0.01% )

Mała funkcja powłoki, którą można dodać przed komendami, aby zmierzyć ich czas:

tm() {
  s=$(date +%s)
  $@
  rc=$?
  echo "took $[$(date +%s)-$s] seconds. return code $rc" >&2
  return $rc
}

Następnie użyj go w skrypcie lub w wierszu poleceń w następujący sposób:

tm the_original_command with all its parameters

Oto odmiana odpowiedzi Alexa. Zależy mi tylko na minutach i sekundach, ale chciałem też, żeby był inaczej sformatowany. Więc zrobiłem to:

start=$(date +%s)
end=$(date +%s)
runtime=$(python -c "print '%u:%02u' % ((${end} - ${start})/60, (${end} - ${start})%60)")

#!/bin/csh
#PBS -q glean
#PBS -l nodes=1:ppn=1
#PBS -l walltime=10:00:00
#PBS -o a.log
#PBS -e a.err
#PBS -V
#PBS -M shihcheng.guo@gmail.com
#PBS -m abe
#PBS -A k4zhang-group
START=$(date +%s)
for i in {1..1000000}
do
echo 1
done
END=$(date +%s)
DIFF=$(echo "$END - $START" | bc)
echo "It takes DIFF=$DIFF seconds to complete this task..."

Używając tylko basha można również zmierzyć i obliczyć czas trwania części skryptu powłoki (lub czas, jaki upłynął dla całego skryptu):

start=$SECONDS

... # do time consuming stuff

end=$SECONDS

teraz możesz po prostu wydrukować różnicę:

echo "duration: $((end-start)) seconds."

jeśli potrzebujesz tylko przyrostowego czasu trwania:

echo "duration: $((SECONDS-start)) seconds elapsed.."

Możesz także zapisać czas trwania w zmiennej:

let diff=end-start

Osobiście lubię zawijać cały mój kod skryptu w jakąś funkcję „główną”, taką jak:

main () {
 echo running ...
}

# stuff ...

# calling the function at the very end of the script
time main

Zauważ, jak łatwe jest użycie timepolecenia w tym scenariuszu. Oczywiście nie mierzysz dokładnego czasu, w tym czasu analizy skryptu, ale uważam, że jest on wystarczająco dokładny w większości sytuacji.

#!/bin/bash
begin=$(date +"%s")

Script

termin=$(date +"%s")
difftimelps=$(($termin-$begin))
echo "$(($difftimelps / 60)) minutes and $(($difftimelps % 60)) seconds elapsed for Script Execution."

Funkcja synchronizacji oparta na SECONDSograniczeniu do szczegółowości drugiego poziomu nie korzysta z żadnych zewnętrznych poleceń:

time_it() {
  local start=$SECONDS ts ec
  printf -v ts '%(%Y-%m-%d_%H:%M:%S)T' -1
  printf '%s\n' "$ts Starting $*"
  "$@"; ec=$?
  printf -v ts '%(%Y-%m-%d_%H:%M:%S)T' -1
  printf '%s\n' "$ts Finished $*; elapsed = $((SECONDS-start)) seconds"
  # make sure to return the exit code of the command so that the caller can use it
  return "$ec"
}

Na przykład:

time_it sleep 5

daje

2019-03-30_17:24:37 Starting sleep 5 2019-03-30_17:24:42 Finished
sleep 5; elapsed = 5 seconds