Vous voulez analyser combien de temps d'horloge murale, de noyau, etc., un programme Linux prend pour s'exécuter ? Que ce soit pour les tests de performances, l'optimisation du code ou simplement pour la curiosité générale, ce guide rapide vous aidera à démarrer !
Timing des programmes Linux
Chronométrer un programme Linux aide à comprendre combien de temps a été passé. La commande de temps Linux polyvalente peut être utilisée pour cela. La commande time mesure l'heure réelle (c'est-à-dire l'heure de l'horloge murale), l'heure utilisateur et l'heure système. Le temps utilisateur est le temps pendant lequel le programme s'exécute en mode utilisateur, ou en d'autres termes, en dehors du noyau. Le temps sys est le temps pendant lequel le programme s'exécute dans le noyau.
Il est important de noter que le temps utilisateur et le temps sys sont le temps CPU réel passé en mode utilisateur et dans le noyau, respectivement. En d'autres termes, lorsqu'un programme est bloqué pendant un certain temps et n'utilise pas le processeur, ce temps ne comptera pas pour l'utilisateurou sys fois. Sachant cela, nous pouvons mesurer avec précision combien de temps CPU effectif a été utilisé (en les combinant).
L'outil Linux time
Étant donné que les heures user et sys rapportent uniquement le temps CPU, alors que le temps réel rapporte l'heure réelle de l'horloge murale, il est (ainsi) très courant de voir l'outil de temps renvoie la sortie où une combinaison de utilisateur + sys n'égale pas le temps réel. Un exemple peut être vu lors de la synchronisation du sommeil :
time sleep 1
Ici, nous avons chronométré la commande sleep à l'aide de l'outil time. Comme nous pouvons le voir, notre temps réel (1,001 seconde) correspond très bien à l'heure de notre horloge murale et à l'heure demandée (le sommeil 1 demande un sommeil d'une seconde). Nous voyons également qu'il a fallu consacrer très peu de temps CPU à la commande dans son ensemble : en combinant le temps user + sys, nous voyons que seulement 0,001 seconde a été dépensée.
Publicité
On peut aussi, probablement à tort, en déduire que le noyau n'a pas été impliqué dans cette commande, car le temps sys est effectivement 0. Cependant, comme l'indique le manuel de temps : une commande est très proche de zéro, certaines valeurs (par exemple, le pourcentage de CPU utilisé) peuvent être signalées comme zéro (ce qui est faux) ou un point d'interrogation.”
Utilisation du temps pour la mesure des performances
Nous pouvons utiliser le temps pour évaluer combien de temps prendront des actions données (c'est-à-dire l'heure de l'horloge murale) et combien de temps CPU elles ont consommé en le faisant. À titre d'exemple simple, nous pourrions évaluer si un cache du système de fichiers fonctionne sur notre système. Pour ce faire, nous pourrions sauter dans le répertoire /usr, qui pourrait facilement contenir 200 000 à 500 000 fichiers sur une installation Linux courante.
Une fois là, nous pouvons utiliser l'outil de recherche, chronométré par le temps pour évaluer comment le temps nécessaire pour parcourir tous les dossiers et répertorier tous les fichiers du répertoire /usr :
cd /usr time find . >/dev/null 2>&1
Comme nous pouvons le voir, il faut 12 484 secondes pour répertorier tous les fichiers du répertoire /usr (et en dessous). Nous avons redirigé la sortie stdout (sortie standard) de la commande vers >/dev/null et redirigé également toutes les erreurs stderr (erreur standard) vers /dev/null en utilisant une redirection de stderr vers stdout, c'est-à-dire 2>&1.
Nous constatons également que notre temps CPU est de 1,043 seconde (utilisateur) + 2,908 secondes (sys) pour un total de 3,951 secondes de temps CPU.
Testons-le une autre fois en effaçant nos inodes (et autres) cache(s) :
sync ; écho 3 | sudo tee /proc/sys/vm/drop_caches cd /usr time find . >/dev/null 2>&1
Publicité
La première commande supprimera les inodes cache, dentries (entrées de répertoire) et pagecache. Cette fois, le résultat est revenu un peu plus vite, avec 1,255 seconde de gain sur la commande. Probablement un cache sur disque physique a aidé ici.
Pour démontrer le bon fonctionnement de la mise en cache Linux en général, réexécutons la commande mais cette fois sans supprimer les caches Linux :
Toute une différence ! Nous constatons une grande réduction du temps requis dans les trois zones chronométrées et notre commande s'exécute en moins d'une demi-seconde !
En utilisant time Pour l'optimisation du code
Une fois que nous nous sentons à l'aise avec la commande time sur la ligne de commande, nous pouvons étendre son utilisation pour optimiser nos scripts et notre code Bash. Par exemple, une approche couramment utilisée par certains professionnels consiste à exécuter une commande donnée plusieurs fois, par exemple 1 000 exécutions, et à calculer le temps total (ou moyen) de ces exécutions.
Ensuite, une commande alternative peut être utilisée. Cette commande alternative (ou solution/implémentation – c'est-à-dire plusieurs commandes prises ensemble comme un seul morceau de code à chronométrer) peut ensuite être chronométrée à nouveau. Sous Linux (ou plus précisément dans le codage Bash, etc.), il existe souvent de nombreuses façons d'aborder un problème donné ; il existe généralement plusieurs outils disponibles pour obtenir/atteindre le même résultat.
Tester celui qui fonctionne le mieux optimise le temps d'exécution du programme et potentiellement d'autres facteurs tels que les E/S disque (réduction de l'usure du disque) ou l'utilisation de la mémoire (permettant à plus de programmes de s'exécuter sur la même instance). Pour optimiser l'heure de l'horloge murale, un certain outil utilise, en moyenne, ainsi que le temps CPU consommé par l'outil (un autre facteur/considération d'optimisation important) peut être mesuré par l'outil de temps.
Publicité
< p>Explorons un exemple pratique d'utilisation de la ligne de commande pour exécuter une commande que nous souhaitons utiliser dans l'un de nos scripts. La commande obtiendra une liste de processus et affichera la deuxième colonne. Pour ce faire, nous utilisons à la fois awk et sed, et exécutons chaque commande 1000 fois pour voir la différence de performance globale.
temps pour ((i=1;i<=1000;i++)); faire ps -ef | awk '{print $2}' >/dev/null 2>&1; temps terminé pour ((i=1;i<=1000;i++)); faire ps -ef | sed 's|^[^ ]+[ t]+||;s|[ t].*||' >/dev/null 2>&1; done
Tout en paraissant plus complexe (il utilise une double expression régulière pour analyser la deuxième colonne), notre deuxième commande est un peu plus rapide que notre première commande en ce qui concerne l'heure de l'horloge murale.
En utilisant une configuration très similaire (c'est-à-dire time for ((i=1;i<=1000;i++)); do command_to_be_timed >/dev/null 2>&1; done où command_to_be_timed est la commande à tester pour l'horloge murale ou temps CPU), on peut tester n'importe quelle commande, ou ensemble de commandes (comme c'est le cas ici ; nous avons utilisé à la fois les commandes ps et awk/sed).
En suivant ces étapes plusieurs fois- les commandes consommatrices (dans n'importe quel script Linux) nous aideront à réduire le temps d'exécution global et/ou (si vous optimisez le temps CPU) la charge système de nos scripts.
Si vous voulez en savoir plus sur expressions régulières, Comment modifier du texte à l'aide d'expressions régulières avec l'éditeur de flux sed est susceptible d'intéresser.
Résumé
Dans ce article, nous avons exploré la commande Linux time. Nous avons clarifié ce qu'indiquent les temps réels, utilisateur et sys et comment ces deux derniers sont liés à l'utilisation du processeur. Nous avons également examiné plusieurs exemples d'utilisation pratique du temps.
Publicité
Si vous avez aimé lire cet article, jetez un œil à Asserts, erreurs et plantages : Quelle est la différence ? et Qu'est-ce que Stack Smashing ? Peut-il être corrigé ?.