Commande Linux time : Mesure du temps d'exécution

Introduction

Dans cet atelier, vous allez explorer la commande time sous Linux, un utilitaire indispensable pour mesurer le temps d'exécution des commandes et des programmes. En tant que développeur logiciel junior chez TechInnovate, vous avez été chargé d'optimiser une série de scripts de traitement de données. Votre chef d'équipe vous a suggéré d'utiliser la commande time pour identifier les goulots d'étranglement en termes de performances. Grâce à cette expérience pratique, vous apprendrez à utiliser time pour évaluer et améliorer l'efficacité de votre code.

Chronométrage des opérations sur les fichiers

La commande time est un outil polyvalent qui donne un aperçu des ressources consommées lors de l'exécution d'une commande. Commençons par chronométrer quelques opérations simples sur les fichiers.

Tout d'abord, créons un fichier avec du contenu :

echo "This is a test file for TechInnovate's performance analysis." > test_file.txt

Cette commande crée un nouveau fichier nommé test_file.txt dans votre répertoire actuel et y écrit le texte spécifié. Le symbole > est utilisé pour rediriger la sortie de echo vers le fichier.

Maintenant, chronométrons l'opération de lecture de ce fichier :

time cat test_file.txt

Vous devriez voir le contenu du fichier, suivi des informations de chronométrage. Le résultat devrait ressembler à ceci :

This is a test file for TechInnovate's performance analysis.
cat test_file.txt  0.00s user 0.00s system 85% cpu 0.003 total

Voici la signification de ces mesures :

• 0.00s user : La quantité de temps CPU passée dans le code en mode utilisateur (en dehors du noyau) au sein du processus.
• 0.00s system : La quantité de temps CPU passée dans le noyau au sein du processus.
• 85% cpu : Le pourcentage d'utilisation du processeur.
• 0.003 total : Le temps total écoulé entre le moment où vous appuyez sur Entrée et la fin de la commande.

Pour une opération aussi simple, ces durées sont infimes. Vous pourriez constater de légères variations à chaque exécution de la commande en raison de la charge du système et d'autres facteurs externes.

Chronométrage de commandes complexes

Votre chef d'équipe vous a fourni un script qui traite des fichiers journaux (logs). Chronométrons son exécution pour obtenir une base de référence en vue d'une optimisation.

Tout d'abord, créons un script de traitement simple :

cat << EOF > process_logs.sh
#!/bin/zsh
for i in {1..1000}; do
    echo "Processing log entry $i" >> output.log
done
sort output.log > sorted_output.log
uniq -c sorted_output.log > final_output.log
rm output.log sorted_output.log
EOF

chmod +x process_logs.sh

Ce script effectue les actions suivantes :

1. Crée une boucle qui génère 1000 entrées de journal.
2. Trie ces entrées.
3. Compte les entrées uniques.
4. Supprime les fichiers intermédiaires.

La commande chmod +x rend le script exécutable.

Maintenant, chronométrons l'exécution de ce script :

time ./process_logs.sh

Le résultat affichera le temps nécessaire à l'exécution de l'ensemble du script. Cela pourrait ressembler à ceci :

./process_logs.sh  0.03s user 0.01s system 92% cpu 0.045 total

Ces chiffres varieront selon les performances de votre système, mais ils constituent une base de comparaison pour vos efforts d'optimisation. Notez que le temps total (total) est supérieur à la somme des temps utilisateur (user) et système (system). Cette différence indique souvent des opérations d'entrée/sortie (I/O), qui correspondent ici aux opérations de lecture et d'écriture de fichiers.

Utilisation de time avec différentes commandes

Explorons comment la commande time se comporte avec différents types d'opérations. Cela vous permettra de mieux interpréter les résultats selon la nature des tâches.

Tout d'abord, chronométrons une opération intensive pour le processeur (CPU-bound) :

time echo {1..10000} | wc -w

Cette commande génère une séquence de nombres et les compte. Elle sollicite principalement le processeur.

Ensuite, chronométrons une opération intensive en entrées/sorties (I/O-bound) :

time find / -name "*.txt" 2> /dev/null

Cette commande recherche tous les fichiers .txt à partir de la racine. Elle sollicite principalement le disque.

Enfin, chronométrons une commande qui combine CPU et I/O :

time sort -R /etc/passwd | head -n 5

Cette commande trie de manière aléatoire le contenu du fichier /etc/passwd et affiche les 5 premières lignes.

Comparez les résultats de ces commandes. Vous remarquerez que les tâches intensives en CPU ont tendance à avoir des temps user plus élevés, tandis que les tâches intensives en I/O ont souvent des temps total nettement supérieurs aux temps user et system.

Résumé

Dans cet atelier, vous avez exploré la commande time sous Linux, un outil crucial pour mesurer et optimiser l'exécution des commandes. Vous avez appris à :

1. Chronométrer des opérations sur les fichiers pour évaluer leurs performances.
2. Mesurer le temps d'exécution de scripts complexes.
3. Comparer le comportement de time avec différents types d'opérations (intensives en CPU, intensives en I/O et mixtes).

Ces compétences seront précieuses pour continuer à optimiser vos scripts et analyser les performances dans votre rôle chez TechInnovate.

N'oubliez pas, lors de l'optimisation du code :

• Recherchez les opérations ayant des temps d'exécution anormalement élevés.
• Prenez en compte à la fois le temps CPU (user + system) et le temps total (total).
• Pour les opérations limitées par les entrées/sorties (I/O-bound), concentrez-vous sur la réduction de l'écart entre le temps total et le temps CPU.
• Pour les opérations limitées par le processeur (CPU-bound), concentrez-vous sur la réduction du temps utilisateur (user).

En appliquant ces techniques dans votre travail, vous deviendrez plus expert dans l'identification et la résolution des goulots d'étranglement de performance dans votre code.