Mesure du temps d'exécution des commandes Linux

Introduction

Dans ce laboratoire, vous apprendrez à mesurer le temps d'exécution des commandes sous Linux. La capacité de suivre le temps nécessaire à l'exécution des commandes est une compétence précieuse pour l'analyse des performances, l'optimisation et le dépannage.

La commande time est un outil simple mais puissant qui vous permet de mesurer le temps nécessaire à l'exécution d'un programme ou d'une commande. Cela peut être particulièrement utile lorsque vous souhaitez optimiser vos scripts ou comparer l'efficacité de différentes approches pour résoudre un problème.

À la fin de ce laboratoire, vous serez en mesure d'utiliser la commande time pour mesurer les temps d'exécution et d'interpréter les résultats afin de prendre des décisions éclairées concernant l'efficacité des commandes.

Introduction à la commande Time

La commande time est un utilitaire qui mesure le temps d'exécution d'une commande ou d'un programme donné. Cet outil vous aide à comprendre combien de temps il faut pour qu'une commande se termine, ce qui est utile pour la surveillance des performances et l'optimisation.

Commençons par créer un script simple que nous pouvons utiliser pour démontrer la commande time.

Tout d'abord, accédez au répertoire du projet si vous n'y êtes pas déjà :

cd ~/project

Maintenant, créons un script simple appelé simple_echo.sh qui affiche simplement un message :

echo '#!/bin/bash' > ~/project/simple_echo.sh
echo 'echo "Hello, this is a simple script!"' >> ~/project/simple_echo.sh

Nous devons rendre le script exécutable avant de pouvoir l'exécuter :

chmod +x ~/project/simple_echo.sh

Maintenant, utilisons la commande time pour mesurer le temps nécessaire à l'exécution de ce script :

time ~/project/simple_echo.sh

Vous devriez voir une sortie similaire à celle-ci :

Hello, this is a simple script!
~/project/simple_echo.sh  0.00s user 0.00s system 90% cpu 0.001 total

Dans cette sortie :

La première ligne est la sortie de votre script.
La deuxième ligne affiche les informations de temps :
- user : La quantité de temps CPU passée en mode utilisateur (0.00s dans ce cas).
- system : La quantité de temps CPU passée en mode noyau (kernel mode) (0.00s dans ce cas).
- cpu : Le pourcentage d'utilisation du CPU (90% dans ce cas).
- total : Le temps total écoulé (temps réel, wall-clock time) du début à la fin (0.001 secondes dans ce cas).

Cet exemple simple montre que notre script s'exécute très rapidement, comme prévu.

Comprendre la sortie de la commande Time

Maintenant que nous avons vu l'utilisation de base de la commande time, examinons de plus près la sortie qu'elle fournit. Comprendre ces métriques est crucial pour une analyse correcte des performances.

Lorsque vous avez exécuté la commande time à l'étape précédente, vous avez vu plusieurs mesures de temps présentées sur une seule ligne :

user - Il s'agit de la quantité de temps CPU passée dans le code en mode utilisateur (en dehors du noyau). Il ne compte que le temps pendant lequel le CPU a travaillé activement sur le code de votre programme.
system - Il s'agit de la quantité de temps CPU passée dans le noyau (kernel). Cela inclut le temps consacré aux appels système (system calls) tels que la lecture ou l'écriture de fichiers.
cpu - Cela indique le pourcentage d'utilisation du CPU pendant l'exécution.
total - Il s'agit du temps total écoulé (temps réel, wall-clock time) entre le moment où la commande a démarré et le moment où elle s'est terminée. C'est ce que vous mesureriez avec un chronomètre.

Pour notre script simple, tous ces temps étaient très courts car le script effectue très peu de travail.

Créons un script plus gourmand en CPU pour voir ces valeurs plus clairement :

echo '#!/bin/bash' > ~/project/cpu_intensive.sh
echo 'for i in {1..1000000}; do' >> ~/project/cpu_intensive.sh
echo '  let "sum = $i + $i"' >> ~/project/cpu_intensive.sh
echo 'done' >> ~/project/cpu_intensive.sh
echo 'echo "Calculation complete"' >> ~/project/cpu_intensive.sh

Rendez le script exécutable :

chmod +x ~/project/cpu_intensive.sh

Maintenant, chronométrons ce script :

time ~/project/cpu_intensive.sh

Vous devriez voir une sortie similaire à celle-ci (les temps réels varieront en fonction de votre système) :

Calculation complete
~/project/cpu_intensive.sh  2.10s user 0.09s system 93% cpu 2.335 total

Notez que cette fois, les valeurs sont significativement plus élevées car notre script effectue plus de travail. Le temps user est beaucoup plus élevé (2.10s) car notre script passe la plupart de son temps à effectuer des calculs en mode utilisateur. Le temps system est également plus élevé (0.09s) mais reste relativement faible car notre script n'effectue pas beaucoup d'appels système. Le temps total écoulé est de 2.335 secondes et l'utilisation du CPU est de 93%.

Vous pouvez utiliser ces métriques pour identifier où un programme passe son temps :

Un temps user élevé signifie que le programme est gourmand en CPU dans l'espace utilisateur.
Un temps system élevé signifie que le programme effectue de nombreux appels système ou attend des E/S (I/O).
Si total est beaucoup plus élevé que la somme de user et system, cela peut indiquer que le programme attend des ressources ou s'exécute en parallèle.
Le pourcentage de CPU vous indique l'efficacité avec laquelle le CPU a été utilisé pendant l'exécution.

Comparer les temps d'exécution de différentes commandes

Maintenant que nous comprenons comment utiliser la commande time et interpréter sa sortie, comparons les temps d'exécution de différentes commandes pour comprendre leurs caractéristiques de performance.

Tout d'abord, créons un script gourmand en E/S (I/O) qui lit et écrit des données :

echo '#!/bin/bash' > ~/project/io_intensive.sh
echo 'for i in {1..10}; do' >> ~/project/io_intensive.sh
echo '  cat /etc/passwd > ~/project/temp_file_$i.txt' >> ~/project/io_intensive.sh
echo '  cat ~/project/temp_file_$i.txt > /dev/null' >> ~/project/io_intensive.sh
echo 'done' >> ~/project/io_intensive.sh
echo 'rm ~/project/temp_file_*.txt' >> ~/project/io_intensive.sh
echo 'echo "I/O operations complete"' >> ~/project/io_intensive.sh

Rendez le script exécutable :

chmod +x ~/project/io_intensive.sh

Maintenant, chronométrons ce script gourmand en E/S :

time ~/project/io_intensive.sh

Vous devriez voir une sortie similaire à celle-ci :

I/O operations complete
~/project/io_intensive.sh  0.01s user 0.00s system 96% cpu 0.014 total

Notez que le temps system est maintenant plus élevé par rapport au temps user par rapport à notre script gourmand en CPU. En effet, les opérations d'E/S de fichiers nécessitent des appels système (system calls), qui s'exécutent en mode noyau (kernel mode). Le pourcentage élevé de CPU (96%) indique que le système a travaillé activement la plupart du temps pendant l'exécution.

Chronométrons également une commande Linux courante qui recherche des modèles de texte :

time grep -r "root" /etc

Cette commande recherche récursivement le mot "root" dans tous les fichiers du répertoire /etc. La sortie pourrait ressembler à ceci :

[many matches shown here]
grep -r "root" /etc  0.18s user 0.08s system 99% cpu 0.259 total

Comparons maintenant les trois commandes que nous avons chronométrées :

simple_echo.sh : Exécution très rapide (0.001s total), temps CPU et système minimal.
cpu_intensive.sh : Exécution plus longue (2.335s total), principalement temps CPU utilisateur (2.10s).
io_intensive.sh : Temps d'exécution modéré (0.014s total), équilibré entre le temps utilisateur et le temps système en raison des opérations d'E/S.
grep -r "root" /etc : Temps d'exécution modéré (0.259s total), équilibré entre le temps utilisateur et le temps système en raison du traitement de texte et des E/S de fichiers.

Cette comparaison montre comment différents types d'opérations affectent le temps d'exécution et l'utilisation des ressources. Comprendre ces modèles peut vous aider à identifier les goulots d'étranglement (bottlenecks) dans vos scripts et commandes, ce qui conduit à un code plus efficace.

Résumé

Dans ce labo, vous avez appris à utiliser la commande time sous Linux pour mesurer et analyser le temps d'exécution des commandes et des scripts. Vous avez acquis une expérience pratique avec :

L'utilisation de la syntaxe de base de la commande time pour mesurer la durée d'exécution
La compréhension des métriques clés : utilisateur (user), système (system), pourcentage d'utilisation du CPU (CPU percentage) et temps total (total time)
La création et le chronométrage de scripts avec différentes caractéristiques de performance
La comparaison des temps d'exécution pour identifier les modèles de performance
L'utilisation d'outils de chronométrage pour une analyse détaillée des performances

La capacité de mesurer le temps d'exécution des commandes est une compétence essentielle pour les administrateurs système, les développeurs et les utilisateurs avancés. Elle vous permet d'identifier les goulots d'étranglement (bottlenecks) en matière de performances, d'optimiser votre code et de prendre des décisions éclairées concernant l'allocation des ressources.

Au fur et à mesure que vous continuez à travailler avec Linux, vous constaterez que la commande time est un outil précieux dans votre boîte à outils d'analyse des performances, vous aidant à créer des scripts et des commandes plus efficaces.