Semaine 9: débogage, tests, projet

Contenu

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 5 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 12 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 #

Cours: Debogage et tests

TD#

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

Il y aura un dernier TD la semaine prochaine!

TP : déboguage, projet#

Le cœur du TP est le projet. Ne passez pas plus de 20 minutes sur les exercices de débogage.

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.

Compilez le programme calcul.cpp, exécutez le et observez l’affichage.
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.
Recompilez le programme calcul.cpp en ajoutant l’option -fsanitize=address :
```
g++ -g -fsanitize=address calcul.cpp -o calcul
```
Exécutez le programme, et lisez le message d’erreur détaillé. Où a eu lieu l’erreur? Inutile de corriger le programme (on vous demande juste d’avoir trouvé où elle a eu lieu).

Dans ce TP, nous vous donnons les commandes de compilation directement avec g++ pour bien montrer le rôle de chacune des options. Vous pouvez aussi utiliser info-111 g++ qui ajoute plusieurs options, dont l’option -g (revoir les explications de la Semaine7). Il sera recommandé de le faire pour le travail sur le projet et les TPs suivants.

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

Rappel: la configuration système des salles de TP ne permet pas d’y utiliser l’analyse post-mortem proposée ci-dessous. Cet exercice est donc à réaliser depuis chez vous, en utilisant le service JupyterHub@Paris-Saclay.

Le but de cet exercice est de 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.

Comme dans l’exercice précédent, compilez le programme calcul.cpp, exécutez le et observez l’affichage.
Notez qu’un fichier nommé core a été produit. Selon la configuration du système, ce fichier aura éventuellement un nom de la forme core.24234, ou ne sera pas créé.
Recompilez le programme en ajoutant l’option -g :
```
g++ -g calcul.cpp -o calcul
```
Relancez le programme.
Lancez le débogueur :
```
gdb --tui --silent calcul
```
Analyser le fichier core avec la commande ci-dessous (en remplaçant si besoin le 2e core par le nom complet du nouveau fichier core produit) :
```
core core
```
À quelle ligne a eu lieu l’erreur?
Afficher la pile d’appel avec la commande suivante :
```
where full
```
Affichez le code avec :
```
list
```
Déduisez-en la cause de l’erreur. Inutile de corriger le programme (on vous demande juste d’avoir trouvé l’erreur grâce au débogueur).
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.

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.

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).
Utilisez les commandes start, puis step pour exécuter successivement quelques instructions jusqu’à rentrer dans la boucle for.
Essayez la commande print i, puis avancez de quelques instructions. Essayez la commande display i, puis avancez de quelques instructions.
Continuez l’exécution pas à pas jusqu’à rentrer dans la fonction max. Utilisez la commande where full pour visualiser la pile d’appel.
Utilisez la commande continue pour continuer l’exécution jusqu’à la fin.
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.