====== Esercitazione debugging ======

I {{:fisica:informatica:201516:primoanno:esempio_debugging.pdf|lucidi introduttivi}} per il debugging.
Eseguire con i debugger [[https://www.gnu.org/software/ddd/|ddd]] e/o [[http://www.gnu.org/software/gdb/|gdb]] e trovare il problema nei seguenti programmi.

===== Esercizio 1: Aggiornamenti =====
<code c>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#define N 5

/* globali */
int z[N+1];
int a[N-1];
int i;
 
void aggiorna (int k);

int main(void)
{
  srand(time(NULL));
  i=0;
  while (i<N)
    {
 
      aggiorna(i);
      
      printf("iterazione %d\n",i);
      i++;
    } 
  printf("exiting ...\n"); 
  return 0;
}

void aggiorna (int k) {
  a[k]=rand()%2;
  z[k+1]=a[k];
}
</code>
in pratica il codice, salvato in "file.c" compilato con 
<code bash>
gcc -Wall -pedantic -o ese file.c
</code>
ed eseguito con 
<code>
$ ./ese
</code>
va inspiegabilmente in ciclo all'interno del ciclo. Per eseguire in modalita' interattiva di debugging:
  * Compilare con opzione "-g", ad esempio <code bash>
gcc -Wall -pedantic -g -o ese file.c
</code>
  * lanciare l'eseguibile usando il debugger come in <code bash>
$ ddd ./ese
</code>
 * oppure  in <code bash>
$ gdb ./ese
</code>
 a questo punto e' possibile fermare il programma durante la sua esecuzione, ispezionare le variabili etc..

===== Esercizio 2: Debuggare codice altrui ... =====

//Per i solutori piu' che abili//. Trovare l'errore...

<code c>
#include<stdio.h>
#include<string.h>


void leggi( char *[]);
void stampa(char *[], int);

int main()
{
  char *a[3]={"alberello","rosea","roma"};
  char *b = NULL;
    
  leggi(a);
    
  return 0;
    
}

void stampa(char *arch[],int sizeA)
{
  int i;
  
  printf("i loro indirizzi sono:\n");

  for(i=0;i<sizeA;i++)
    printf("%p\n",(void*)&arch[i]);
      

}
    
void leggi(char *archivio[]){
  int i;
  int size=strlen(*archivio);
     
  for(i=0;i<size;i++)
    printf("%s\n",archivio[i]);
  
 stampa(archivio, size);
}
</code>

===== Esercizio 3: (avanzato) Verificare i memory leak con ''mtrace'' (solo per chi ha mcheck.h/mtrace già installato) =====
Con riferimento al main sviluppato per l'esercizio precedente verificare che tutta la memoria allocata venga deallocata prima dell'uscita dal main().

Per la verifica si utilizzi la funzione ''mtrace'' e l'utility ''mtrace'', questi strumenti tracciano le azioni di allocazione e deallocazione di memoria compiute dal programma per verificare la presenza di //memory leak// cioe' memoria non deallocata. 

Per fare questo procedere come segue:
  * leggere le informazioni in ''man 3 mtrace''
  * includere l'header ''mcheck.h''
  * inserire la chiamata alla funzione di libreria mtrace() all'inizio della parte del programma C che vogliamo verificare
  * inserire la chiamata alla funzione di libreria muntrace() alla fine della parte del programma C che vogliamo verificare
  * compilare il file da verificare con opzione ''-g'' per includere le informazioni di debugging. Ad esempio se il mio file si chiama ''main.c'' posso compilare con
<code bash>
bash$ gcc -Wall -pedantic -g -o prova main.c 
</code>
  * settare la variabile di ambiente ''MALLOC_TRACE'' al path del file in cui vogliamo che la ''mtrace()'' registri le informazioni sugli accessi di memoria. Ad esempio se voglio registrare le informazioni nel file ''./mtrace.out'' devo usare il comando
<code bash>
bash$ export MALLOC_TRACE=./mtrace.out
</code>
  * eseguire, nel nostro esempio con:
<code bash>
bash$ ./prova
</code>
  * dopo l'esecuzione nel file ''./mtrace.out'' sono registrati gli accessi in formato testuale non facilmente comprensibile. Interpretarlo con l'utility mtrace. Ad esempio sempre riferendosi al nostro esempio invocare
<code bash>
bash$ mtrace ./prova ./mtrace.out 
</code>
questo rispondera' ''No memory leaks'' se tutta la memoria e' stata deallocata o fornira' indicazioni su dove e' stata allocata la mamoria rimasta da deallocare.

===== Esercizio 4: (avanzato) verificare gli accessi in memoria: valgrind =====

Verificare la correttezza degli accessi ai puntatori dello heap compiuti dalle funzioni su liste sviluppate negli esercizi precedenti utilizzando ''valgrind''. 
Questo strumento permette fra l'altro di capire se tutte le variabili sono inizializzate prima del loro uso, se accediamo a memoria gia' deallocata o mai allocata e situazioni similari


Per fare questo procedere come segue:  
  * compilare il file da verificare con opzione ''-g'' per includere le informazioni di debugging. Ad esempio se il mio file si chiama ''main.c'' posso compilare con
<code bash>
bash$ gcc -Wall -pedantic -g -o prova main.c
</code>
  * eseguire
<code bash>
bash$ valgrind ./prova
</code>
in questo modo, a schermo verranno riportare le infrazioni rilevate. Ad esempio, //invalid read// o //invalid write// sono accessi in lettura o scrittura a memoria non allocata o gia' deallocata.

''valgrind'' contiene moltissime opzioni, invitiamo gli studenti interessati ad esplorarle partendo dal[[http://valgrind.org/|sito]].