====== Esercitazione 1 ======
===== Esercizio 0: Getting started -- Preprocessing, compilazione e linking =====
0.1) Compilare ed eseguire il seguente programma:
#include
#include
int main (void) {
double x=3.0;
printf("Radice = %f\n",sqrt(x));
return 0;
}
salvato nel file //ff.c// con
gcc -Wall -pedantic ff.c
Chi segnala un errore? E' fallita la fase di preprocessing, la compilazione o il linking? Cosa contine il modulo oggetto se specifico l'opzione -c? Come si risolve il problema?
0.2) Cosa accade se eliminiamo la linea
#include
? A questo punto cosa va storto? Sapete interpretare i messaggi a video e stabilire chi li ha scritti e perche'? Viene generato l'eseguibile?
0.3) Generare il modulo oggetto. Utilizzare //objdump, nm, readelf// per capire cosa contengono la tabella di rilocazione, la tabella dei simboli esportati ed esterni, le sezioni data, BSS e codice.
0.4) Usare l'opzione //-E// e la //-S// del gcc: che cosa succede? Cosa accade specificando il flag -g assieme a -S? Che cosa e' accaduto?
===== Esercizio 1. Invasion Percolation =====
Invasion percolation e' una semplice forma frattale basata su un modello di diffusione di fluidi. In due dimensioni, l'invasion percolation si simula come segue.\\
**(Passo 1)** Dati N ed r, si genera una griglia quadrata NxN di numeri casuali nel range [1,r] . Ad esempio, una griglia 5x5 di numeri nel range [1,100] puo' essere:
||26 | 17 |72 |45 | 38 ||
||10 | 38 |39 |92 | 38 ||
||44 | 27 |12 |29 | 77 ||
||61 | 26 |90 |35 | 11 ||
||83 | 84 |18 |56 | 52 ||
**(Passo 2)** poi si marca il centro della griglia come `pieno' ad esempio (8-) indica la cella piena):
||26 | 17 |72 |45 | 38 ||
||10 | 38 |39 |92 | 38 ||
||44 | 27 |8-) |29 | 77 ||
||61 | 26 |90 |35 | 11 ||
||83 | 84 |18 |56 | 52 ||
**(Passo 3)** Si effettua un ciclo in cui ad ogni passo:
- si esaminano i vicini di tutte le celle gia' piene (gia' marcate con 8-)),
- si sceglie la cella **c** con il valore minore e
- si marca **c** con come 'piena'.
Finche' il 50% le celle dela griglia sono state marcate come piene.
Ad esempio, al primo passo i quattro vicini della cella (2,2) nella nostra griglia sono 39,29,90,29 indicati in grassetto:
||26 | 17 |72 |45 | 38 ||
||10 | 38 |**39** |92 | 38 ||
||44 | **27** |8-) |**29** | 77 ||
||61 | 26 |**90** |35 | 11 ||
||83 | 84 |18 |56 | 52 ||
Quindi scegliamo 27. L'evoluzione della forma frattale e' : (8-) indica la cella selezionata ad ogni nuovo passo, mentre i vicini sono indicati in grassetto)
||26 | 17 |72 |45 | 38 ||
||10 | **38** |**39** |92 | 38 ||
||**44** | 8-) |8-) |**29** | 77 ||
||61 | **26** |**90** |35 | 11 ||
||83 | 84 |18 |56 | 52 ||
||26 | 17 |72 |45 | 38 ||
||10 | **38** |**39** |92 | 38 ||
||**44** | 8-) |8-) |**29** | 77 ||
||**61** | 8-) |**90** |35 | 11 ||
||83 | **84** |18 |56 | 52 ||
||26 | 17 |72 |45 | 38 ||
||10 | **38** |**39** |**92** | 38 ||
||**44** | 8-) |8-) |8-) | **77** ||
||**61** | 8-) |**90** |**35** | 11 ||
||83 | **84** |18 |56 | 52 ||
Si richiede di implementare il comando
percolation N r
che simula //invasion percolation// su una griglia NxN con valori nel range [1..r].
Ogni iterazione viene visualizzata sullo schermo a intervalli di 1sec. La computazione si ferma quando il 50% delle celle e' stata marcata.
Le funzioni che compongono il programma devono essere opportunamente testate in modo automatico (con adeguati programmi di test).
//ATTENZIONE: Le matrici **devono** essere rappresentate come array di puntatori a righe. Per i numeri casuali e' sufficiente usare le funzioni della libreria standard. Per pulire lo schermo fra una stampa e l'altra si puo' usare ''system("clear")''.//
===== Esercizio 2: Compilazione separata e Makefile =====
Suddividere il programma C relativo all'esercizio 1 in piu' file in modo che:
* il ''main()'' sia contenuto in un file ''main.c''
* le altre funzioni siano suddivise in almeno altri due file ''.c''
Predisporre gli opportuni file ''.h'' e le inclusioni necessari per una corretta compilazione.
Sviluppare inoltre un ''makefile'' che contenga almeno i seguenti target:
* un target per ciascun modulo oggetto
* un target **percolation** che permette di ricreare l'eseguibile a partire dai moduli oggetto
* un target **test** che esegue i test automatici e ne comunica l'esito
* un target **cleanall** che elimina i file di core e gli oggetti della compilazione.