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 :

1. à analyser le script de commandes sed pour construire un automate d’analyse et de transformation des lignes du fichier d’origine,
2. à 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).

1. vitesse du processeur,
2. taille de la mémoire centrale (RAM),
3. vitesse de lecture du disque,
4. taille du fichier d’origine,
5. taille du fichier transformé,
6. syntaxe du fichier d’origine,
7. taille du script de transformations,
8. nature des transformations,
9. algorithme utilisé pour construire l’automate,
10. performance de l’automate construit,
11. qualité de programmation de sed,
12. 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.

• Construisez trois versions de sed nommées sed0 , sed2 et sed3 en utilisant les options respectives de compilation -O0 , -O2 et -O3 et une reliure statique ("-static -static-libgcc"). Pour obtenir l’optimisation et la reliure voulue, positionnez les variables CFLAGS et LDFLAGS, comme vous l’avez appris lors du TP précédent. Affichez les temps de construction et les tailles des exécutables.
  
• Chaque exécutable sed302 est produit dans le répertoire courant. Sauvegardez les différentes versions sous des noms adéquats (sed0, sed2, sed3). Supprimez la table des symboles des exécutables obtenus avec la commande strip et observez l’effet sur la taille des exécutables.
• Si nécessaire, placez des liens symboliques dans votre répertoire sur les fichiers ../origine1.txt et ../script1.sed utilisés pour les expériences. Mesurez les temps d’exécution des trois versions sed0, sed2, sed3 , en effectuant les expériences :

       ~> time sed0 -f script1.sed origine1.txt >! res
       ~> time sed2 -f script1.sed origine1.txt >! res
       ~> time sed3 -f script1.sed origine1.txt >! res
  

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