Comment obtenir le temps d'exécution d'un script efficacement?

Je voudrais afficher le temps d'achèvement d'un script.

Ce que je fais actuellement c'est -

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

Cela montre simplement l'heure du début et de la fin du script. Serait-il possible d'afficher une sortie à granularité fine telle que temps processeur / temps io, etc.?

Il suffit d'utiliser timelorsque vous appelez le script:

time yourscript.sh

Si ce timen'est pas une option,

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

runtime=$((end-start))

Appelez simplement timessans argument lorsque vous quittez votre script.

Avec kshou zsh, vous pouvez également utiliser à la timeplace. Avec zsh, vous timeobtiendrez également le temps de l'horloge murale en plus du temps de l' utilisateur et du temps système .

Pour conserver le statut de sortie de votre script, vous pouvez le faire:

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

Ou vous pouvez également ajouter un piège sur EXIT:

trap times EXIT

De cette façon, les heures seront appelées à chaque fois que le shell se fermera et le statut de sortie sera préservé.

$ 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

Notez également que tous bash, kshet zshune $SECONDSvariable spéciale qui obtient automatiquement incrémenté à chaque seconde. Dans les deux cas zshet ksh93, cette variable peut également être faite à virgule flottante (avec typeset -F SECONDS) pour obtenir plus de précision. Ce n'est que l'heure du mur, pas le temps du processeur.

Je suis un peu en retard, mais je voulais poster ma solution (pour une précision inférieure à la seconde) au cas où d’autres tomberaient sur ce fil en cherchant. La sortie est au format jours, heures, minutes et enfin secondes:

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

J'espère que quelqu'un trouve cela utile!

Ma méthode pour 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"

Oui, cela s'appelle Python, mais si vous pouvez vivre avec cela, alors c'est une solution plutôt agréable et laconique.

Cette question est assez ancienne, mais en essayant de trouver ma façon préférée de le faire, ce fil est arrivé très haut ... et je suis étonné que personne ne l'ait mentionné:

perf stat -r 10 -B sleep 1

'perf' est un outil d'analyse des performances inclus dans le noyau sous 'tools / perf' et souvent disponible pour l'installation en tant que paquet séparé ('perf' dans CentOS et 'linux-tools' dans Debian / Ubuntu). Le Linux Wiki perf Wiki contient beaucoup plus d’informations à ce sujet.

Lancer 'perf stat' donne pas mal de détails, y compris le temps d'exécution moyen à la fin:

1.002248382 seconds time elapsed                   ( +-  0.01% )

Une petite fonction shell qui peut être ajoutée avant les commandes pour mesurer leur temps:

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

Ensuite, utilisez-le dans votre script ou sur votre ligne de commande comme suit:

tm the_original_command with all its parameters

Voici une variante de la réponse d'Alex. Je ne me soucie que des minutes et des secondes, mais je voulais aussi que le formatage soit différent. Alors j'ai fait ça:

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 [email protected]
#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..."

Personnellement, j'aime bien insérer tout mon code de script dans une fonction "principale" comme ceci:

main () {
 echo running ...
}

# stuff ...

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

Notez à quel point il est facile d’utiliser la timecommande dans ce scénario. Évidemment, vous ne mesurez pas l'heure précise, y compris la durée d'analyse du script, mais je la trouve suffisamment précise dans la plupart des situations.

En utilisant uniquement bash, il est également possible de mesurer et de calculer la durée d'une partie du script shell (ou le temps écoulé pour l'ensemble du script):

start=$SECONDS

... # do time consuming stuff

end=$SECONDS

vous pouvez maintenant soit simplement imprimer la différence:

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

si vous n’avez besoin que d’une durée supplémentaire, faites:

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

Vous pouvez également stocker la durée dans une variable:

let diff=end-start

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

Script

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

La fonction de minutage basée sur SECONDS, limitée à la granularité de second niveau, n’utilise aucune commande externe:

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

Par exemple:

time_it sleep 5

donne

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