L'impression de temps d'exécution d'une commande shell

Est possible d'imprimer le temps d'exécution d'une commande shell avec la combinaison suivante?

root@hostname:~# "command to execute" && echo "execution time"

InformationsquelleAutor jack | 2009-11-01

command-line shell

65

N'oubliez pas qu'il existe une différence entre bash est builtin time (qui doit être appelé par défaut lorsque vous ne time command) et /usr/bin/time (ce qui devrait vous obliger à l'appeler par son chemin d'accès complet).

La builtin time toujours imprime sur la sortie stderr, mais /usr/bin/time vous permettra d'envoyer la sortie vers un fichier spécifique, afin de ne pas interférer avec la commande en cours d'exécution du flux stderr. Aussi, /usr/bin/time's format est configurable sur la ligne de commande ou par la variable d'environnement TIME, alors que bash est builtin time format est seulement configuré par l' TIMEFORMAT variable d'environnement.
```
$ time factor 1234567889234567891 # builtin
1234567889234567891: 142662263 8653780357

real    0m3.194s
user    0m1.596s
sys 0m0.004s
$ /usr/bin/time factor 1234567889234567891
1234567889234567891: 142662263 8653780357
1.54user 0.00system 0:02.69elapsed 57%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+215minor)pagefaults 0swaps
$ /usr/bin/time -o timed factor 1234567889234567891 # log to file `timed`
1234567889234567891: 142662263 8653780357
$ cat timed
1.56user 0.02system 0:02.49elapsed 63%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+217minor)pagefaults 0swaps
```
- De man bash: "La TIMEFORMAT variable peut être définie à un format de chaîne de caractères qui spécifie la façon dont le calendrier doit être affichée"
- Oops - I pensée il y avait un moyen de le formater, mais je l'ai raté dans help time parce que j'ai seulement jeté un coup d'oeil sur elle et j'ai pensé que c'était un argument de ligne de commande. Je vais mettre à jour la réponse.
- Ici, nous sommes 9 ans plus tard et la commande n'a pris 0m0.018s. J'ai juste pensé que je voudrais signaler.
InformationsquelleAutor Mark Rushakoff
104

time est une commande intégrée dans la plupart des shells qui écrit de temps d'exécution d'information à l'ats.

Vous pouvez également essayer quelque chose comme
```
start_time=`date +%s`
<command-to-execute>
end_time=`date +%s`
echo execution time was `expr $end_time - $start_time` s.
```
Ou dans bash:
```
start_time=`date +%s`
<command-to-execute> && echo run time is $(expr `date +%s` - $start_time) s
```
- d'accord avec Maaza, cette souplesse m'a permis de mesurer le temps de toute une série de commandes.
- Est-il possible d'appliquer linux aspects en fonction de ce que commande linux pour calculer l'exécution
- Un inconvénient de cette approche est qu'il mesure en secondes, alors que time utilise milisecondes. Et si vous souhaitez qu'une poignée de commandes sans avoir à utiliser des variables et des calculs, vous pouvez utiliser des parenthèses: time ( command1 ; command2 ; command3 ) vous pouvez même temps individuellement avec un temps total, comme suit: time ( time command1 ; time command2 ; time command3 ) bien sûr, si vous voulez une vingtaine de commandes, peut-être mieux de se servir de cette réponse de la solution. Mais alors, vous devriez commencer à penser à mettre vos commandes dans un script...
InformationsquelleAutor mob
24
```
root@hostname:~# time [command]
```
Il distingue entre le temps réel utilisé et l'heure du système utilisé.
- C'est certainement la base de réponse mais il y a quelques complications si vous voulez voir la sortie d'erreur de la commande et encore envoyer les informations de synchronisation de la sortie standard, comme la question de fait. Le temps de commande écrit sur la sortie stderr. Ce que vous suggérez est probablement assez précis - d'où mon +1.
- time écrit à l'ats, pas stderr. Qui, j'imagine, rend les choses pires.
InformationsquelleAutor Jason
12

Pour une ligne-par-ligne delta de mesure, essayez gnonom.

C'est un utilitaire en ligne de commande, un peu comme moreutils ts, pour ajouter des informations d'horodatage à la sortie standard d'une autre commande. Utile pour les processus long où vous souhaitez un record historique de ce qui est si long.

Tuyauterie rien à gnomon ajoute un horodatage pour chaque ligne, indiquer le temps que la ligne était la dernière ligne droite dans la mémoire tampon--c'est, combien de temps il a fallu à la ligne suivante apparaît. Par défaut, gnomon affiche le nombre de secondes écoulées entre chaque ligne, mais c'est configurable.

InformationsquelleAutor Janus Troelsen
8

L'ajout de @foule réponse:

Ajoutant %N à date +%s nous donne l'ordre de la nanoseconde précision:
```
start=`date +%s%N`;<command>;end=`date +%s%N`;echo `expr $end - $start`
```
InformationsquelleAutor nav
5

Si je commence un long processus en cours d'exécution comme une copie ou un hachage et je veux savoir la suite comment ça a été long, je viens de le faire:
```
$ date; sha1sum reallybigfile.txt; date
```
Qui aura pour conséquence la sortie suivante:
```
Tue Jun  2 21:16:03 PDT 2015
5089a8e475cc41b2672982f690e5221469390bc0  reallybigfile.txt
Tue Jun  2 21:33:54 PDT 2015
```
Accordé, tel que mis en œuvre ici, il n'est pas très précis et ne parvient pas à calculer le temps écoulé. Mais c'est de la saleté simple et parfois, tout ce dont vous avez besoin.

InformationsquelleAutor Ethan
3

Dans zsh vous pouvez utiliser
```
=time ...
```
En bash ou zsh, vous pouvez utiliser
```
command time ...
```
Ces (par des mécanismes différents) force une commande externe pour être utilisé.

InformationsquelleAutor überRegenbogen
0

Juste ps -o etime= -p "<your_process_pid>"

InformationsquelleAutor mulg0r

Vous devez vous connecter pour publier un commentaire.