TP 4 - Mesures de performances
Licence 3 Informatique - 2007-2008
PhilippeCollet,
NicolasNobelis
URL de cette page :
http://deptinfo.unice.fr/twiki/bin/view/Linfo/GLEnvtProg0708TP4
URL de l'enseignement :
http://deptinfo.unice.fr/twiki/bin/view/Linfo/GLEnvtProg0708
Avant propos
- Créez votre répertoire de séance pour le TP et placez-vous dedans. Vérifiez que votre variable PATH cite le répertoire courant avant les autres. Sinon, corrigez-le avec la commande
export PATH=.:$PATH
- Récupérez et décompressez l'archive Fourniture4.tar.bz2.
- Dans ce TP, le principal aspect de performance pris en considération est la vitesse d’exécution d’un programme.
1. Principes de la commande SED
La commande
sed
bien connue
¹ existe depuis les premières versions du système Unix et a fait l’objet, depuis 35 ans, de nombreuses implémentations.
La
FSF a, pour sa part, développé de nombreuses versions de
"Gnu sed" ou
"gsed". Nous utiliserons trois versions de
"Gnu sed" pour ce TP :
1.1.8
de 1993,
3.0.2
de 1998,
4.1.4
de 2005.
La syntaxe d’appel de
sed
, pour transformer un fichier
origine.txt en un fichier
transforme.txt avec un script
script.sed est la suivante :
~> sed -f script.sed origine.txt > transforme.txt
Le script peut contenir de quelques lignes de commandes
sed
à plusieurs centaines. La puissance des transformations dépend de l’utilisation de certaines commandes
sed
, en particulier des
expressions régulières pour sélectionner des parties de ligne et de l’utilisation de la mémoire auxiliaire (
hold space). Le fichier d’origine à traiter peut contenir de quelques lignes à plusieurs millions.
Le fonctionnement général de
sed
consiste :
- à analyser le script de commandes sed pour construire un automate d’analyse et de transformation des lignes du fichier d’origine,
- à exécuter l’automate sur chaque ligne du fichier d’origine.
Paramètres de performance (10mn)
On donne une liste de paramètres susceptibles d’influer sur la performance d’une exécution de
sed
. Attribuez une note pour chaque paramètre :
A (très influent),
B (influent),
C (peu influent). Trouvez les relations de dépendances évidentes entre certains critères (par exemple vitesse de lecture du fichier et taille du fichier).
- vitesse du processeur,
- taille de la mémoire centrale (RAM),
- vitesse de lecture du disque,
- taille du fichier d’origine,
- taille du fichier transformé,
- syntaxe du fichier d’origine,
- taille du script de transformations,
- nature des transformations,
- algorithme utilisé pour construire l’automate,
- performance de l’automate construit,
- qualité de programmation de
sed
,
- qualité du compilateur et de son optimiseur.
2. Vitesse du processeur et des E/S
Toutes les commandes time
sont à utiliser avec le shell ZSH. Pour vérifier votre shell, faîtes un
echo $SHELL
.
Sur l’ordinateur de votre salle de TP, effectuez l’expérience suivante :
~> time sed -f script1.sed origine1.txt >! res
Notez les temps et interprétez-les.
Recommencez encore une fois la même expérience, notez les temps et interprétez-les.
Effectuez l’expérience suivante :
~> cp script1.sed /tmp/script1-$USER.sed
~> cp origine1.txt /tmp/origine1-$USER.txt
~> time sed -f /tmp/script1-$USER.sed /tmp/origine1-$USER.txt >! /tmp/res-$USER
~> rm -f /tmp/*$USER*
Notez les temps et interprétez-les.
Ouvrez une fenêtre de terminal et connectez-vous via
ssh
sur
uranie.unice.fr (OSF/1) ou
thalie.unice.fr (Solaris) - vous conserverez cette fenêtre jusqu’à la partie 3.
Demandez au système ses caractéristiques (
uname -a
). Recommencez l’expérience précédente. Qu’en déduisez-vous ?
Faîtes de même avec une machine de la salle de TP «
villes ». Pour éviter que chaque étudiant se connecte sur la même machine, on numérotera les postes de travail de votre salle 1 à 14 et on se connectera sur la machine « ville » de même rang : 1 paris, 2 madrid, 3 rome, 4 londres, 5 berlin, 6 angkor, 7 oslo, 8 tamanrasset, 9 katmandou, 10 berne, 11 lima, 12 tombouctou, 13 hiroshima, 14 nagasaki.
2.1. Vitesse des processeurs
Sur chacune des trois machines utilisées précédemment, exécutez le script
benchmarkUTF8 (ou
benchmark) fourni. Ce script shell, proposé par Bill Joy, utilise la commande
bc
standard sous Unix, pour calculer racine de 2 avec 100 chiffres significatifs, puis effectue une conversion en octal du résultat. Le temps
CPU mis par un Vax 780 (la machine mythique des années 1980, qui avait une puissance de calcul de 1 MIPS, 1 million d’instructions Vax par seconde), était de 6.2 sec. En comparant avec le temps mis par votre ordinateur, le script en déduit la puissance de calcul de votre processeur, en nombre de MIPS Vax 780). Comme la vitesse des processeurs a beaucoup augmenté depuis les années 80, la mesure effectuée porte maintenant sur une itération de quelques centaines de calculs.
Sur les machines Linux, le fichier
/proc/cpuinfo
donne aussi des informations utiles sur le processeur, son type et la vitesse de l’horloge interne.
Les temps d’exécution mesurés pour les expériences précédentes avec
sed
sont-ils en accord avec les vitesses des processeurs ? Expliquez les différences éventuelles.
3. Qualité des compilations
Placez-vous dans le répertoire
sed-302 et exécutez le script
configure
. Ce script
² analyse les caractéristiques de votre ordinateur et produit un
Makefile à partir d’un
Makefile générique.
Le but de cette section est de montrer l’effet des optimisations du code produit par le compilateur
gcc
sur les temps de compilation et d’exécution. Cela montre que les optimisations sont bénéfiques mais lentes à produire. Il faut donc les réaliser en phase de finalisation, une fois les tests de mise au point réalisés.
Que déduisez-vous de l’effet des optimisations demandées sur le temps de construction, le temps d’exécution et la
taille du programme ?
4. Profilage avec gprof
- Recompilez
sed302
avec CFLAGS=-pg et LDFLAGS=-pg en supprimant les autres options de compilation (pas de reliure statique, pas d’optimisation spéciale).
- Exécutez le
sed
obtenu avec les mêmes données que précédemment :
~> time sed302 -f script1.sed origine1.txt >! res
Observez l’existence du fichier de mesures produit (gmon.out
).
- Observez le nombre de lignes et de caractères des fichiers de données et résultat, puis analysez le profilage obtenu avec la commande
gprof
en plaçant le résultat dans un fichier de texte :
~> gprof sed302 >! gprof302-1.txt
- Qu’en déduisez-vous sur la partie du code qui joue un rôle prépondérant sur les temps d’exécution (code critique pour la performance) ? Voyez-vous une correlation entre les nombres d’appels de certaines fonctions et le nombre de lignes ou de caractères du fichier de données ?
- Effectuez à présent une autre exécution de
sed302
instrumenté :
~> wc script2.sed origine2.txt
406 592 9936 script2.sed
2 5 46 origine2.txt
~> sed302 -f script2.sed origine2.txt >! res
~> gprof sed302 >! gprof302-2.txt
- Comment expliquez-vous les différences constatées ? Pour améliorer l’efficacité générale du programme
sed
, faut-il améliorer le code critique de l’expérience 1 ou 2 ?
5. Profilage avec kprof
kprof
est un visualisateur graphique fourni par
KDE qui exploite les données textuelles de plusieurs outils de profilage, dont
gprof
, mais avec des messages en anglais seulement, et sans les messages d’explications fournis par défaut par
gprof
(options
-b ou
-brief).
On va donc refaire les analyses de profilage de
gprof en anglais et sans explications, des deux fichiers de données
origine1.txt et
origine2.txt de tailles respectives 5740 et 2 lignes avec les deux scripts
script1.sed
et
script2.sed
de tailles respectives 207 et 406 lignes.
~> sed302 -f script1.sed origine1.txt >! res
~> LC_ALL=C gprof -b sed302 >! gprof302-1.txt
~> sed302 -f script2.sed origine2.txt >! res
~> LC_ALL=C gprof -b sed302 >! gprof302-2.txt
Lancez
kprof
. Dans le menu
<file>, ouvrez le fichier
gprof302-1.txt. Examinez les vues plate, hiérarchique et le graphe d’appel.
Modifiez l’ordre des lignes en cliquant sur un critère de tri. Utilisez le filtre sur les noms de méthode pour ne retenir que certaines d’entre-elles. Utilisez le clic-droit sur les noms de méthode pour naviguer vers les appelants ou appelés. Une fois familiarisé avec
kprof
, faites une analyse fine du comportement de sed302 avec le script
script1.sed et le fichier
origine1.txt.
Examinez ensuite avec
kprof
les analyses
gprof302-2.txt et
gprof302-3.txt et interprétez les résultats. Finalement, utilisez la comparaison de profiles dans le menu
<file>.
6. Pour les plus courageux ...
Recommencez les expériences menées précédemment mais avec les versions de
sed
de
1993 (118) et de
2005 (414). Qu’en déduisez-vous ? La version
sed-001
est la version historique de ATT des années 1970, mais est écrite en C traditionnel, sans aucune précaution de portabilité ou de typage. Si vous arrivez à la compiler, vous constaterez qu’elle est plus rapide, mais avec moins de possibilités que les versions des années 1990. Les dernières versions
4.x réconcilient rapidité pour traiter les cas simples et expressivité des transformations très étendues.
¹:
SED
est un outil très classique sous UNIX, qui permet de transformer automatiquement un ou plusieurs fichiers de texte selon les règles d’un script fourni en ligne ou dans un fichier. Les règles utilisent des expressions régulières de base ou étendues, selon les versions.
²: Il est fourni avec la distribution de
sed-302
. Bien qu’il ait le même objectif que le script configure utilisé en TPs de
Programmation Système et Réseau, celui-ci est beaucoup plus complexe et complet. Sur les versions récentes son exécution peut prendre plusieurs dizaines de secondes.
--
NicolasNobelis - 01 Mar 2008
to top