Semaine 9 : débogage, tests, projet#

Vous trouverez ici le matériel pédagogique pour la Semaine 9, dont l’objectif premier est de lancer votre travail sur le projet. Jusqu’ici, vous avez écrit des programmes de quelques lignes; avec le projet, vous allez progressivement aborder des programmes de une à plusieurs centaines de lignes. Aussi, pour vous y préparer, nous verrons en amphi des éléments de méthodologie et des outils de débogage.

Consignes#

Vous n’aurez pas de trop des quelques semaines à venir pour le projet; lancez vous à fond dès maintenant. Pour être fier de vos réalisations à venir. Pour de belles soutenances la semaine du 11 décembre. Et aussi parce que le projet est le moment où vous allez consolider et donner du sens à tout ce que nous avons vu depuis le début du semestre. Incidemment, c’est la meilleure préparation à l’examen du 18 décembre, dans moins d’un mois.

Les TPs seront des moments privilégiés des semaines à venir où vous pourrez bénéficier de toute l’aide d’un enseignant. Pour en tirer le meilleur parti, il est essentiel de l’avoir bien préparé, notamment en ayant travaillé sur le projet bien en amont; pour cette semaine:

  • Choix d’un binôme

  • Téléchargement et consultation du sujet (voir instructions sur la page web ci-dessus)

  • Début du travail en autonomie % (quelques heures!)

  • Préparation des questions à l’attention de votre enseignant: quels sont les points à clarifier? les problèmes bloquants?

Cours : débogage et tests#

TD#

Note

Vous n’aurez pas de TD cette semaine; c’est autant de temps de libéré pour vous consacrer au projet.

Attention

Il y aura un dernier TD la semaine prochaine!

TP : déboguage, projet#

Attention

Le cœur de ce TP est le projet. Ne passez pas plus de 25 minutes sur les exercices de cette feuille (entraînement, débogage).

Exercice 0: entraînement (5 minutes)#

À partir de maintenant, nous vous fournirons chaque semaine une collection de petits exercices d’entraînement et de révisions. Aujourd’hui, trois premiers pour tester l’outil.

Exécutez la cellule suivante, suivez les consignes qui s’affichent et cliquez sur Valider pour vérifier votre réponse. Utilisez les différents bouttons pour parcourir les exercices et leurs variantes.

import glob
from exercizer.jupyter_exercizer import Exercizer
Exercizer(glob.glob("exercizer/*.md"))

Exercice : analyse d’erreur à l’exécution#

Il est possible de compiler un programme de sorte que les erreurs d’accès à la mémoire soient mieux détectées et que la pile d’appel soit affichée directement en cas de plantage (comme avec Python) sans avoir à utiliser le débogueur. Le programme consomme cependant un peu plus de ressources. En savoir plus.

  1. Compilez le programme calcul.cpp, exécutez le et observez l’affichage.

  2. L’exécution s’est terminée avec une erreur. Ouvrez le fichier calcul.cpp; constatez que l’instruction du programme ligne 21 n’a pas été exécutée. On sait donc que l’erreur s’est produite avant cette ligne, mais on ne sait pas où exactement elle s’est produite, ni dans quelles circonstances. Dans cet exercice et le suivant, nous allons maintenant mettre en application deux techniques vues en cours pour analyser l’état du programme au moment de l’erreur.

  3. Recompilez le programme calcul.cpp en ajoutant les options -g et -fsanitize=address :

    g++ -g -fsanitize=address calcul.cpp -o calcul

    Attention

    Notez que nous avons dû utiliser g++ comme compilateur. La version de clang++ que nous utilisons – un peu ancienne pour des questions de compatibilité avec l’interpréteur cling – ne gère en effet pas correctement l’option -fsanitize=address.

  4. Exécutez le programme, et lisez le message d’erreur détaillé. Où a eu lieu l’erreur? Ne cherchez pas à corriger le programme!

Exercice : analyse post-mortem d’erreurs à l’exécution au débogueur#

Le but de cet exercice est de commencer à prendre en main l’utilisation du débogueur, afin de pouvoir l’utiliser seul par la suite lorsque vous rencontrerez des problèmes avec vos programmes du projet. Nous allons pour le moment nous consacrer sur l”analyse post-mortem d’erreurs à l’exécution, comme ferait un médecin légiste sur le corps d’une victime d’un crime.

Notez que, lorsque vous avez lancé le programme calcul précédemment, le message core dumped était affiché. Comme vu en cours, cela signifiait que, en cas d’erreur grave d’un programme, le système d’exploitation enregistre (dump) tout ou partie de l’état de la mémoire dans un fichier appelé core pour analyse ultérieure. Dans cet exercice, nous allons utiliser le déboggeur pour réaliser une telle analyse.

  1. Recompilez le programme avec l’option -g :

    clang++ -g calcul.cpp -o calcul

  2. Configurez votre terminal pour que, en cas d’erreur grave d’un programme, un fichier core soit enregistré, avec une taille maximale de 1M:

    ulimit -c 1000000

  3. Relancez le programme.

  4. Selon la configuration du système, le lieu où est enregistré le fichier core varie. Nous allons maintenant rechercher ce fichier et lancer le déboggeur.

    Instructions en local sur les salle de TP

    La commande suivante lance automatiquement le déboggueur sur le dernier fichier core produit par l’utilisateur :

    coredumpctl debug

    Instructions sur JupyterHub

    Sur JupyterHub, le fichier core produit est enregistré dans le dossier courant, sous un nom comme core.12431. Utilisez la commande ls pour trouver ce fichier. Si vous avez plusieurs fichiers core et que vous avez un doute, supprimez les tous avec

    rm core.*

    puis relancez le programme calcul.

    Lancez le débogueur :

    gdb --tui --silent calcul

    Lancez l’analyse du fichier core avec la commande ci-dessous, en remplaçant core.12431 par le nom complet du nouveau fichier core produit :

    (gdb) core core.12431

  5. À quelle ligne a eu lieu l’erreur?

  6. Afficher la pile d’appel avec la commande suivante :

    where full

  7. Affichez le code avec :

    list

  8. Déduisez-en la cause de l’erreur. Ne la corrigez pas!

  9. Quittez le débogueur avec la commande :

```
quit
```

Exercice : exécution pas-à-pas avec le débogueur#

Nous allons maintenant analyser le même programme en l’exécutant pas à pas.

Attention

Rappel

L’exécution pas-à-pas avec gdb n’est actuellement pas disponible sur JupyterHub. Vous ne pouvez donc faire cet exercice que en salle de TP ou si vous avez installé les logiciels chez vous.

Attention

Rappel

Ne passez pas plus de 20 minutes sur le débogage. Si vous n’avez pas fini, vous reprendrez plus tard. Passez au projet.

  1. Retrouvez le mode d’emploi de gdb dans les notes du cours. Une fois le débogueur lancé, consultez les questions suivantes du TP pour savoir quelles commandes du débogueur utiliser. Il est recommandé d’avoir sous les yeux à la fois l’énoncé de TP (pour savoir quelles commandes on vous demande d’utiliser) et le mode d’emploi (qui indique à quoi correspondent ces commandes).

  2. Utilisez les commandes start, puis step pour exécuter successivement quelques instructions jusqu’à rentrer dans la boucle for.

  3. Essayez la commande print i, puis avancez de quelques instructions. Essayez la commande display i, puis avancez de quelques instructions.

  4. Continuez l’exécution pas à pas jusqu’à rentrer dans la fonction max. Utilisez la commande where full pour visualiser la pile d’appel.

  5. Utilisez la commande continue pour continuer l’exécution jusqu’à la fin.

  6. L’exécution se termine avec une erreur. Cette fois la ligne au moment de l’erreur est affichée. Utilisez les commandes vues plus haut pour consulter les valeurs des variables et retrouver ce qui a déclenché l’erreur.

Travail sur le projet#