Vous voulez savoir combien de temps dure un processus et bien plus encore? La commande de temps Linux renvoie des statistiques de temps, vous donnant des informations intéressantes sur les ressources utilisées par vos programmes.
Table des matières
le temps a beaucoup de parents
Il existe de nombreuses distributions Linux et différents systèmes d’exploitation de type Unix. Chacun d’eux a un shell de commande par défaut. Le shell par défaut le plus courant dans les distributions Linux modernes est le shell bash. Mais il y en a beaucoup d’autres, comme le shell Z (zsh) et le shell Korn (ksh).
Tous ces shells intègrent leur propre commande de temps, soit en tant que intégré commande ou en tant que mot reservé. Lorsque vous tapez time dans une fenêtre de terminal, le shell exécutera sa commande interne au lieu d’utiliser le binaire de temps GNU qui est fourni dans le cadre de votre distribution Linux.
Nous voulons utiliser la version GNU de time car elle a plus options et est plus flexible.
Quelle heure va courir?
Vous pouvez vérifier quelle version fonctionnera à l’aide de la commande type. type vous fera savoir si le shell gérera lui-même votre instruction, avec ses routines internes, ou la transmettra au binaire GNU.
dans une fenêtre de terminal, tapez le type de mot, un espace, puis le mot temps et appuyez sur Entrée.
type time
Nous pouvons voir que dans le shell bash, le temps est un mot réservé. Cela signifie que Bash utilisera ses routines de temps internes par défaut.
type time
Dans le shell Z (zsh), l’heure est un mot réservé, donc les routines internes du shell seront utilisées par défaut.
type time
Dans le shell Korn, le temps est un mot clé. Une routine interne sera utilisée à la place de la commande de temps GNU.
Exécution de la commande GNU time
Si le shell de votre système Linux a une routine de temps interne, vous devrez être explicite si vous souhaitez utiliser le binaire de temps GNU. Vous devez soit:
Fournissez le chemin complet vers le binaire, tel que / usr / bin / time. Exécutez la commande quelle heure pour trouver ce chemin.
Utilisez le temps de commande.
Utilisez une barre oblique inverse comme le temps.
La commande which time nous donne le chemin vers le binaire.
Nous pouvons tester cela en utilisant / usr / bin / time comme commande pour lancer le binaire GNU. Ça marche. Nous obtenons une réponse de la commande time nous disant que nous n’avons fourni aucun paramètre de ligne de commande pour que cela fonctionne.
La saisie de l’heure de la commande fonctionne également et nous obtenons les mêmes informations d’utilisation de temps. La commande command demande au shell d’ignorer la commande suivante afin qu’elle soit traitée en dehors du shell.
Utiliser un caractère avant le nom de la commande équivaut à utiliser la commande avant le nom de la commande.
Le moyen le plus simple de vous assurer que vous utilisez le binaire de temps GNU est d’utiliser l’option anti-slash.
time
time
time invoque la version shell de time. time utilise le temps binaire.
Utilisation de la commande time
Chronométrons certains programmes. Nous utilisons deux programmes appelés loop1 et loop2. Ils ont été créés à partir de loop1.c et loop2.c. Ils ne font rien d’utile à part démontrer les effets d’un type d’inefficacité du codage.
C’est loop1.c. La longueur d’une chaîne est requise dans les deux boucles imbriquées. La longueur est obtenue à l’avance, en dehors des deux boucles imbriquées.
#include "stdio.h"
#include "string.h"
#include "stdlib.h"
int main (int argc, char* argv[])
{
int i, j, len, count=0;
char szString[]="how-to-geek-how-to-geek-how-to-geek-how-to-geek-how-to-geek-how-to-geek";
// get length of string once, outside of loops
len = strlen( szString );
for (j=0; j
This is loop2.c. The length of the string is obtained time after time for every cycle of the outer loop. This inefficiency ought to show up in the timings.
#include "stdio.h"
#include "string.h"
#include "stdlib.h"
int main (int argc, char* argv[])
{
int i, j, count=0;
char szString[]="how-to-geek-how-to-geek-how-to-geek-how-to-geek-how-to-geek-how-to-geek";
for (j=0; j
Let’s fire up the loop1 program and use time to measure its performance.
time ./loop1
Maintenant, faisons de même pour loop2.
time ./loop2
Cela nous a donné deux ensembles de résultats, mais ils sont dans un format vraiment moche. Nous pouvons faire quelque chose à ce sujet plus tard, mais choisissons quelques informations parmi les résultats.
Lorsque les programmes s'exécutent, il existe deux modes d'exécution entre lesquels ils sont commutés. Celles-ci sont appelées mode utilisateur et mode noyau.
En bref, un processus en mode utilisateur ne peut pas accéder directement au matériel ou à la mémoire de référence en dehors de sa propre allocation. Afin d'accéder à ces ressources, le processus doit faire des requêtes au noyau. Si le noyau approuve la demande, le processus entre en exécution en mode noyau jusqu'à ce que l'exigence soit satisfaite. Le processus est ensuite repassé en mode exécution utilisateur.
Les résultats pour loop1 nous indiquent que loop1 a passé 0,09 seconde en mode utilisateur. Il n'a passé aucun temps en mode noyau ou le temps en mode noyau est une valeur trop faible pour être enregistrée une fois qu'elle a été arrondie. Le temps total écoulé était de 0,1 seconde. loop1 a obtenu une moyenne de 89% du temps CPU sur la durée de son temps total écoulé.
Le programme inefficace loop2 a pris trois fois plus de temps à s'exécuter. Son temps total écoulé est de 0,3 seconde. La durée du temps de traitement en mode utilisateur est de 0,29 seconde. Rien ne s'inscrit en mode noyau. loop2 a obtenu une moyenne de 96% du temps CPU pour la durée de son exécution.
Formatage de la sortie
Vous pouvez personnaliser la sortie de temps en utilisant une chaîne de format. La chaîne de format peut contenir du texte et des spécificateurs de format. La liste des spécificateurs de format peut être trouvé sur la page de manuel pour le temps. Chacun des spécificateurs de format représente une information.
Lorsque la chaîne est imprimée, les spécificateurs de format sont remplacés par les valeurs réelles qu'ils représentent. Par exemple, le spécificateur de format pour le pourcentage de CPU est la lettre P. Pour indiquer à l'heure qu'un spécificateur de format n'est pas simplement une lettre ordinaire, ajoutez-lui un signe de pourcentage, comme% P. Utilisons-le dans un exemple.
L'option -f (chaîne de format) est utilisée pour indiquer à l'heure que ce qui suit est une chaîne de format.
Notre chaîne de format va imprimer les caractères «Programme:» et le nom du programme (et tous les paramètres de ligne de commande que vous passez au programme). Le spécificateur de format% C signifie «Nom et arguments de ligne de commande de la commande chronométrée». Le n fait passer la sortie à la ligne suivante.
Il existe de nombreux spécificateurs de formats et ils sont sensibles à la casse, alors assurez-vous de les saisir correctement lorsque vous faites cela pour vous-même.
Ensuite, nous allons imprimer les caractères «Temps total:» suivi de la valeur du temps total écoulé pour cette exécution du programme (représenté par% E).
Nous utilisons n pour donner une autre nouvelle ligne. Nous imprimerons ensuite les caractères «Mode (s) utilisateur», suivis de la valeur du temps CPU passé en mode utilisateur, signifiée par le% U.
Nous utilisons n pour donner une autre nouvelle ligne. Cette fois, nous nous préparons à la valeur temporelle du noyau. Nous imprimons les caractères "Kernel Mode (s)", suivis du spécificateur de format pour le temps CPU passé en mode noyau, qui est% S.
Enfin, nous allons imprimer les caractères «nCPU:» pour nous donner une nouvelle ligne et le titre de cette valeur de données. Le spécificateur de format% P donnera le pourcentage moyen de temps CPU utilisé par le processus chronométré.
La chaîne de format entière est placée entre guillemets. Nous aurions pu inclure des caractères t pour placer des tabulations dans la sortie si nous étions pointilleux sur l'alignement des valeurs.
time -f "Program: %CnTotal time: %EnUser Mode (s) %UnKernel Mode (s) %SnCPU: %P" ./loop1
Envoi de la sortie vers un fichier
Pour conserver un enregistrement des horaires des tests que vous avez effectués, vous pouvez envoyer la sortie de temps à un fichier. Pour ce faire, utilisez l'option -o (sortie). La sortie de votre programme sera toujours affichée dans la fenêtre du terminal. Seule la sortie du temps est redirigée vers le fichier.
Nous pouvons réexécuter le test et enregistrer la sortie dans le fichier test_results.txt comme suit:
time -o test_results.txt -f "Program: %CnTotal time: %EnUser Mode (s) %UnKernel Mode (s) %SnCPU: %P" ./loop1
cat test_results.txt
La sortie du programme loop1 est affichée dans la fenêtre du terminal et les résultats du temps vont dans le fichier test_results.txt.
Si vous souhaitez capturer l'ensemble suivant de résultats dans le même fichier, vous devez utiliser l'option -a (append) comme suit:
time -o test_results.txt -a -f "Program: %CnTotal time: %EnUser Mode (s) %UnKernel Mode (s) %SnCPU: %P" ./loop2
cat test_results.txt
Il devrait maintenant être évident pourquoi nous avons utilisé le spécificateur de format% C pour inclure le nom du programme dans la sortie de la chaîne de format.
Et nous n'avons plus de temps
Probablement la plus utile aux programmeurs et aux développeurs pour affiner leur code, la commande time est également utile pour tous ceux qui souhaitent en savoir un peu plus sur ce qui se passe sous le capot à chaque fois que vous lancez un programme.