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

Introduction

Dans ce laboratoire (lab), vous allez explorer la commande time sous Linux, un outil puissant pour mesurer le temps d'exécution de commandes et de programmes. En tant que jeune développeur logiciel chez TechInnovate, vous avez été chargé d'optimiser un ensemble 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 de performance. Grâce à cette expérience pratique, vous apprendrez à utiliser time pour évaluer et améliorer l'efficacité de votre code.

Skills Graph

Mesure du temps d'exécution d'opérations sur des fichiers

La commande time est un outil polyvalent qui permet d'obtenir des informations sur les ressources consommées lors de l'exécution d'une commande. Commençons par mesurer le temps d'exécution de quelques opérations simples sur des fichiers.

Tout d'abord, créons un fichier avec un 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 écrit le texte spécifié dans ce fichier. Le symbole > est utilisé pour rediriger la sortie de la commande echo vers le fichier.

Maintenant, mesurons le temps d'exécution de l'opération de lecture de ce fichier :

time cat test_file.txt

Vous devriez voir le contenu du fichier, suivi des informations de mesure du temps. La sortie pourrait 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 ce que signifient 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 CPU.
• 0.003 total : Le temps total écoulé depuis que vous avez appuyé sur Entrée jusqu'à la fin de l'exécution de la commande.

Pour une opération aussi simple, ces temps sont très courts. Vous pourriez observer de légères variations à chaque exécution de la commande en raison de la charge du système et d'autres facteurs.

Mesure du temps d'exécution de commandes complexes

Votre chef d'équipe vous a fourni un script de traitement de fichiers de logs. Mesurons le temps d'exécution de ce script pour établir une référence de base pour l'optimisation.

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

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 opérations suivantes :

1. Crée une boucle qui génère 1000 entrées de log.
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, mesurons le temps d'exécution de ce script :

time./process_logs.sh

La sortie affichera le temps nécessaire à l'exécution de l'ensemble du script. Elle pourrait ressembler à ceci :

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

Ces chiffres varieront en fonction des performances de votre système, mais ils constituent une référence de base pour vos efforts d'optimisation. Remarquez que le temps total est supérieur à la somme des temps utilisateur et système. Cette différence indique souvent des opérations d'entrée/sortie (I/O), qui dans ce cas sont les opérations de lecture et d'écriture de fichiers.

Utilisation de la commande time avec différentes commandes

Explorons le comportement de la commande time avec différents types d'opérations. Cela vous aidera à mieux interpréter les résultats pour diverses tâches.

Tout d'abord, mesurons le temps d'exécution d'une opération intensive en termes de CPU :

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

Cette commande génère une séquence de nombres et les compte. Elle est principalement limitée par le CPU.

Ensuite, mesurons le temps d'exécution d'une opération intensive en termes d'entrée/sortie (I/O) :

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

Cette commande recherche tous les fichiers .txt à partir du répertoire racine. Elle est principalement limitée par les opérations d'I/O.

Enfin, mesurons le temps d'exécution d'une commande qui implique à la fois le CPU et les opérations d'I/O :

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

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

Comparez les sorties de ces commandes. Vous remarquerez que les tâches intensives en termes de CPU ont tendance à avoir des temps utilisateur plus élevés, tandis que les tâches intensives en termes d'I/O ont souvent des temps totaux plus élevés par rapport aux temps utilisateur et système.

Résumé

Dans ce laboratoire (lab), vous avez exploré la commande time sous Linux, un outil essentiel pour mesurer et optimiser l'exécution de commandes. Vous avez appris à :

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

Ces compétences seront inestimables lorsque vous continuerez à optimiser des scripts et à analyser les performances dans votre rôle chez TechInnovate.

N'oubliez pas que lors de l'optimisation de code :

• Recherchez les opérations dont le temps d'exécution est anormalement élevé.
• Tenez compte à la fois du temps CPU (utilisateur + système) et du temps total.
• Pour les opérations limitées par les entrées/sorties (I/O), 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 CPU, concentrez-vous sur la réduction du temps utilisateur.

En appliquant ces techniques dans votre travail, vous deviendrez plus compétent pour identifier et résoudre les goulots d'étranglement de performance dans votre code.