Wie kann man effektiv die Ausführungszeit eines Skripts ermitteln?

Ich möchte die Fertigstellungszeit eines Skripts anzeigen.

Was ich derzeit mache, ist -

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

Dies zeigt nur den Zeitpunkt des Beginns und Endes des Skripts. Wäre es möglich, eine feinkörnige Ausgabe wie Prozessorzeit / Io-Zeit usw. anzuzeigen?

Verwenden timeSie einfach, wenn Sie das Skript aufrufen:

time yourscript.sh

Wenn timekeine Option ist,

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

runtime=$((end-start))

Rufen Sie einfach timesbeim Beenden Ihres Skripts ohne Argumente auf.

Mit kshoder zshkönnen Sie auch timestattdessen verwenden. Mit zsh, timegeben Sie neben der Benutzer- und System- CPU-Zeit auch die Uhrzeit der Wanduhr an .

Um den Beendigungsstatus Ihres Skripts beizubehalten, können Sie Folgendes festlegen:

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

Oder Sie können auch eine Falle hinzufügen EXIT:

trap times EXIT

Auf diese Weise werden Zeiten aufgerufen, wenn die Shell beendet wird und der Beendigungsstatus beibehalten wird.

$ 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

Beachten Sie auch , dass alle bash, kshund zshhat eine $SECONDSspezielle Variable , die automatisch jede Sekunde erhöht werden. In beide zshund ksh93kann diese Variable auch Floating - Point vorgenommen werden (mit typeset -F SECONDS) mehr Präzision zu erhalten. Dies ist nur die Wanduhrzeit, nicht die CPU-Zeit.

Ich bin ein bisschen spät dran am Zug, wollte aber meine Lösung posten (für eine Genauigkeit von weniger als einer Sekunde), falls andere durch die Suche auf diesen Thread stoßen. Die Ausgabe erfolgt im Format Tage, Stunden, Minuten und zuletzt Sekunden:

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

Hoffe, jemand da draußen findet das nützlich!

Meine Methode für 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"

Ja, das nennt sich Python, aber wenn Sie damit leben können, dann ist dies eine nette, knappe Lösung.

Diese Frage ist ziemlich alt, aber als ich versuchte, meine Lieblingsmethode zu finden, kam dieser Thread hoch ... und ich bin überrascht, dass niemand darauf eingegangen ist:

perf stat -r 10 -B sleep 1

'perf' ist ein Tool zur Leistungsanalyse, das im Kernel unter 'tools / perf' enthalten ist und oft als separates Paket installiert werden kann ('perf' in CentOS und 'linux-tools' unter Debian / Ubuntu). Das Linux Kernal Perf Wiki enthält viel mehr Informationen dazu.

Das Ausführen von 'perf stat' enthält eine ganze Reihe von Details, einschließlich der durchschnittlichen Ausführungszeit am Ende:

1.002248382 seconds time elapsed                   ( +-  0.01% )

Eine kleine Shell-Funktion, die vor Befehlen hinzugefügt werden kann, um ihre Zeit zu messen:

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

Verwenden Sie es dann in Ihrem Skript oder in Ihrer Befehlszeile wie folgt:

tm the_original_command with all its parameters

Hier ist eine Variation von Alex 'Antwort. Ich kümmere mich nur um Minuten und Sekunden, aber ich wollte es auch anders formatieren. Also habe ich das gemacht:

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..."

Mit nur bash ist es auch möglich, die Zeitdauer für einen Teil des Shell-Skripts (oder die verstrichene Zeit für das gesamte Skript) zu messen und zu berechnen :

start=$SECONDS

... # do time consuming stuff

end=$SECONDS

Sie können jetzt entweder nur den Unterschied drucken:

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

Wenn Sie nur eine inkrementelle Dauer benötigen, gehen Sie wie folgt vor:

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

Sie können die Dauer auch in einer Variablen speichern:

let diff=end-start

Persönlich möchte ich meinen gesamten Skriptcode in eine "Haupt" -Funktion einbetten:

main () {
 echo running ...
}

# stuff ...

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

Beachten Sie, wie einfach die Verwendung des timeBefehls in diesem Szenario ist. Natürlich messen Sie nicht die genaue Zeit einschließlich der Skriptanalysezeit, aber ich finde sie in den meisten Situationen genau genug.

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

Script

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

Die Timing-Funktion SECONDS, die auf der Second-Level-Granularität basiert , verwendet keine externen Befehle:

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"
}

Zum Beispiel:

time_it sleep 5

gibt

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