Problem Solving:
Formulazione del problema P, Descrizione di P mediante un modello matematico:M(P) approssimazione di M(P) mediante metodi numerici Mh(P), Sviluppo dell’algoritmo risolutivo Mh(P),Implementazione in uno specifico ambiente di calcolo

Da che cosa dipende il tempo di esecuzione di un software?

Un’ implementazione efficiente dipende oltre che dal numero di operazioni floating-point anche dagli accessi alla MEMORIA
T1 = Nmem x tmem + N flop x t flop    mem=tempo di accesso alla memoria, flop=tempo operazioni floating point
Nmem & Nflop: dipende dall’algoritmo; tmem & tflop: dipende dalla tecnologia.

Ridurre il numero di accessi alla memoria, ridurre il tempo di accesso alla memoria –> riuso dei dati nei registri
La complessità di tempo dell’algoritmo (Nflop) e la velocità del processore (tflop) sono fisse

Vantaggi e caratteristiche delle BLAS

Modularità: sw scritto in termini di building blocks; Chiarezza: codice più breve e più leggibile;
Efficienza: implementazioni ottimizzate da parte dei costruttori di computer; Portabilità: interfacce standard, dipendenza dall’architettura incapsulata in BLAS; Affidabilità, robustezza: gestione accurata di “dettagli” algoritmici e implementativi e di situazioni di errore (es: overflow)

Traffico parassita:
Parametro di valitazione del traffico parassita: q = #accessi alla memoria / #operazioni floating point
SAXPY: y=y+ax  –> preleva x (n accessi), preleva y (n accessi), preleva a (1 accesso), calcolo = (2n op. fl.p.), riponi y (n accessi)
q = m/f = (3n+1) / (2n)
DOT: a = x(trasposto) * y –> preleva x (n accessi), preleva y (n accessi), calcolo = (2n op. fl.p.), riponi in a (1 accesso)
q = m/f = (2n+1) / (2n)  –> quasi 1.
GAXPY: y=y+Mx  –> preleva y (n accessi), preleva M (n^2 accessi), preleva x (n accessi), calcolo y+Mx = (2n^2 op. fl.p.), riponi y (n accessi)
q = m/f = (3n+n^2) / (2n^2)
Strategia: Suddivisione della matrice in blocchi di dimensione pari alla cache

Tecnica di LOOP UNROLLING

Lo “srotolamento” del ciclo consistente nel modificare il controllo del ciclo e nel replicare opportunamente le istruzioni all’interno del ciclo viene detto Tecnica di LOOP UNROLLING
Vantaggi del loop unrolling: Utilizzo ottimale dei processori con architettura pipelined, riduzione dell’overhead del ciclo di iterazione riduzione del numero di trasferimenti fra i vari livelli memoria, aumento delle operazioni concorrenti;L’overhead del programma e il numero di trasferimenti di dati dai livelli più bassi di memoria ai registri, si riducono di un fattore proporzionale alla nuova lunghezza del ciclo (profondità dell’unrolling); Svantaggi del loop unrolling: unrolling;Aumento della memoria destinata al programma; Perdita della generalità del codice

Una matrice si dice simmetrica quando A[i][j] = A[j][i]

Cholesky e matrici simmetriche:
Applicando l’algoritmo di Gauss senza pivoting ad una matrice simmetrica, abbiamo che le sottomatrici attive sono anch’esse simmetriche. Questo è vero in generale e si dimostra.
Si può sfruttare la simmetria considerando solo un triangolo della matrice.
Se si usa il pivoting parziale si perde la simmetria della matrice.
Quindi, in generale, l’utilizzo di una tecnica di pivoting nell’algoritmo di Gauss NON CONSENTE di sfruttare, in termini di efficienza computazionale la simmetria della matrice
In quali condizioni si può evitare il pivoting?
- Matrici a diagonale dominante (al generico passo K, le sottomatrici attive sono a diagonale dominante – il pivot starebbe sempre sulla diagonale)
- Matrici simmetriche e definite positive (una matrice è def positiva se det(A)>0) (criterio di Sylvester)
Se una matrice è simmetrica, la fattorizzazione A=LU (senza pivoting) si specializza in A=LDL^T (A=LU, D^-U=LT quindi U=DL^T, A=LDL^T) L=matrice triangolare inferiore(moltiplicatori), D=matrice diagonale(elementi diagonali di U))
Come si specializza la fattorizzazione LDL^T di una matrice simmetrica e definita positiva?
Esiste un’unica matrice L triangolare inferiore tale che: A=LL^T
A=LLT –> Algoritmo di Cholesky    T(chol)=O((n^3)/6))=Tgauss(n)/2
L’Algoritmo di Cholesky ha una complessità di TEMPO che è la metà di quella dell’Algoritmo di Gauss!!
A è simmetrica allora si memorizza solo una metà degli elementi; L è triangolare allora si memorizzano solo gli elementi non nulli
L’Algoritmo di Cholesky ha una complessità di SPAZIO che è la metà di quella dell’Algoritmo di Gauss!!
Quando è possibile applicare la fattorizzazione LL^T ad una matrice simmetrica e a diagonale dominante? ovvero quando una matrice simmetrica a diagonale dominante è anche definita positiva?
- non singolare (det(A)>0)
- simmetrica
- a diagonale dominante
- ha gli elementi sulla diag non negativi

Matrici TOEPLITZ ottenute l’una da una rotazione dell’altra.

Matrice bidiagonale:
- bidiagonale inferiore se: a(i,j)=0 per j>i e per i>j+1
- bidiagonale superiore se: a(i,j)=0 per i>j e per j>i+1

Matrice tridiagonale: se a(i,j)=0 per |i-j|>1
In una matrice tridiagonale di dim nxn gli elementi che bisogna effettivamente conservare sono quelli delle tre diagonali cioè sono 3n-2.

Matrice a banda: ampiezza di banda inferiore=p, ampiezza di banda superiore=q  se a(i,j)=0 per i>j+p e per j>i+q

Si consideri la seguente matrice a banda 6×6 con p=1 e q=2

a(1,1) a(1,2) a(1,3)
a(2,1) a(2,2) a(2,3) a(2,4)
a(3,2) a(3,3) a(3,4) a(3,5)
a(4,3) a(4,4) a(4,5) a(4,6)
a(5,4)  a(5,5) a(5,6)
a(6,5) a(6,6)

questa matrice viene memorizzata nel seguente modo:

*            *     a(1,3) a(2,4) a(3,5) a(4,6)
*         a(1,2) a(2,3) a(3,4) a(4,5) a(5,6)
a(1,1) a(2,2) a(3,3) a(4,4) a(5,5) a(6,6)
a(2,1) a(3,2) a(4,3) a(5,4) a(6,5)    *
ossia l’elemento a(i,j) è memorizzato nella colonna di posto j e nella riga di posto 3+i-j=q+1+i-j

Fattorizzazione LU senza pivoting di una matrice tridiagonale e risoluzione dei sistemi lineari associati:
si ha che i fattori L ed U di una matrice tridiagonale (che ammette fattorizzazione LU) sono matrici bidiagonali

Fattorizzazione LU di una matrice partizionata a blocchi:
se abbiamo una matrice tridiagonale (w=p+q+1), conduce alle matrici bidiagonali dove
L-> w=p+1=1+1=2; U-> w=q+1=1+1=2
Gli elementi di U e di A appartenenti alla banda superiore coincidono; gli elementi di L da determinare sono L2 e L3; gli elementi di U da determinare sono le matrici diagonali U1, U2, U3

Come si specializzano gli algoritmi di Forward e Back Substitution per matrici a blocchi?
Si risolve Lz=y O(n^2) operazioni poi Ux=z (z è stato ricavato precedentemente)

ALGORITMO FORWARD:

for i=1 to n do
y[i]=b[i]-L[i]y[i-1]
endfor
(L[1]y[0]=0)

ALGORITMO DI BACK

for i=N to 1 do
U[i]x[i]=y[i]-F[i]y[i+1]
endfor
(F[n]x[n+1]=0)

FATTORIZZAZIONE LU DI UNA MATRICE A BLOCCHI

Supponiamo di avere una matrice partizionata in 9=3×3 blocchi
(A11, A12, A13, A21, A22, A23, A31, A32, A33).
Sappiamo che A=LU.
Effettuando il prodotto:
A11=L11 U11     A12=L11 U12                  A13=L11 U13
A21=L21 U11     A22=L21 U12+L22 U22    A23=L21 U13+L22 U23
A31=L31 U11     A32=L31 U12+L32 U22    A33=L31 U13+L32 U23+L33 U33
Da queste uguaglianze si ricavano le espressioni per il calcolo dei blocchi di L e di U
Ricordando l’algoritmo di fattorizzazione LU abbiamo che fissiamo la colonna e la riga e sotto abbiamo la matrice attiva.
PASSO1:
- fattorizzazione LU del “pannello verticale”
- calcolo un pannello orizzontale di U
- aggiorna la matrice attiva
alla fine del passo 1 abbiamo:
- il primo pannello verticale di L
- il primo pannello orizzontale di U

Nel PASSO 2 scendiamo di un livello quindi alla fine avremo:
- il secondo pannello verticale di L
- il secondo pannello orizzontale di U

ALGORITMO LU BLOCK PARTITIONED

A dcomposta in nxn blocchi di dim nbxnb

For k=1, n step nb do
- applica la fatt LU al pannello A(k:n,k:k+nb-1)
- calcola il pannello U(k:k+nb-1, k+nb:n)
- aggiorna la matrice attiva

Sistema sparso:

Un sistema di equazioni lineari si dice “sparso” se ha molti coefficienti nulli; il grado di sparsità è SP=numero di coefficienti nulli / numero totale di coefficienti. In generale in un sistema dove A=nxm e p è il numero di coefficienti non nulli: SP=(n x m) – p / n x m. Dunque 0=<SP>=1, e più SP è prossimo a 1 maggiore è il grado si sparsità della matrice.

I metodi iterativi:

Per sistemi con elevato grado di sparsità l’algoritmo di Gauss non è molto efficiente in quanto non solo effettua operazioni su coefficienti nulli ma può anche portarli a essere non nulli. Per tale motivo c’è bisogno di metodi alternativi detti iterativi, che lavorano sui coefficienti non nulli. Per tale motivo è anche possibile implementare opportune tecniche di memorizzazione di matrici sparse per migliorare la complessità di spazio. Una di queste tecniche è quella dei tre vettori – CSR -  R contenente gli elementi non nulli per riga della matrice A, IC contente l’indice di colonna in A degli elementi presenti in R, J contente la posizione in R del primo elemento non nullo per ciascuna riga di A.

Metodi iterativi: Jacobi

Procedimento iterativo:a partire da arbitrari valori iniziali delle incognite x1(^0), x2(^0), x3(^0) , esegue una sequenza di iterazioni in ognuna delle quali si calcolano nuovi valori per le incognite utilizzando i valori calcolati nella iterazione precedente. Dunque dato un sistema Ax=b:
ad ogni passo i=1…n   ->   xi(^k+1)=1/aii (bi – sum per j=1 to n con j!=i di (aij  xj(^k) )).
La complessità di tale metodo per il calcolo delle n componenti ad ciascuna iterazione è
Tjac(n)=n(2n-1) operazioni=n^2 operazioni, ma siccome le operazioni vengono effettuate solo sui p coefficienti non nulli (SP=1- p/n^2) allora Tjac(n)= p operazioni= n^2 (1-SP) operazioni

Metodi iterativi: Gauss-Seidel

Il procedimento è simile a quella di Jacobi, la differenza sostanziale è che mentre in Jacobi ad ogni iterazione k il nuovo valore delle incognite è calcolato utilizzando unicamente i valori x1(^k-1), x2(^k-1), x3(^k-1) calcolati all’iterata precedente, in Gauss Seidel invece ad ogni passo k nel calcolare una xi(^k) possono essere utilizzati i valori xj(^k), per j<i e xj(^k-1) per j>=i (ossia i valori delle soluzioni del passo precedente k-1). Ad esempio nel calcolare x2(^k) viene utilizzato x1(^k) e x2(^k-1), x3(^k-1). . Dunque dato un sistema Ax=b:
ad ogni passo i=1…n   ->   xi(^k+1)=1/aii (bi – [sum per j=1 to i-1 di (aij  xj(^k+1))] – [sum per j=i+1 to n di (aij  xj(^k))]). Analogamente a quanto accade per jacobi, Tgs(n)= p operazioni= n^2 (1-SP) operazioni.

Convergenza e consistenza dei metodi iterativi:

In generale Gauss-Seidel converge più velocemente alla soluzione rispetto a Jacobi. Tuttavia i metodi iterativi non sempre convergono alla soluzione del sistema.
Un metodo iterativo si dice convergente se la successione generata dal metodo è convergente, qualunque siano i valori iniziali, cioè se lim (k->inf) di xi(^k)= xi(^*) per ogni i=1…n e per ogni xi(^0) approssimazione iniziale. Se il metodo converge allora esso convergerà alla soluzione; per tale caratteristica i metodi si dicono consistenti, ossia che quando converge esso converge alla soluzione. Un metodo iterativo si dive convergente se ||C||<1, dove ||C|| indica la norma della matrice C nxn dei coefficienti cij del sistema. Inoltre Jacobi converge con certezza anche quando la matrice è a diagonale strettamente dominante. Tali condizioni tuttavia sono solo sufficienti non necessarie in quanto il metodo può convergere anche se queste condizioni non sono soddisfatte.

Efficienza di un metodo iterativo:

La complessità totale di un metodo iterativo è: Ttot(n)= k Tit(n); dove k indica il numero di iterazioni eseguite (parametro dipendente dalla velocità di convergenza) e Tit(n) indica la complessità di tempo di 1 iterazione (parametro dipendente dal costo di ciascuna iterazione). Sia per Jacobi che per Gauss Seidel il numero di operazioni effettuate è relativo solo ai coefficienti p non nulli dunque T(n)= p operazioni= n^2 (1-SP) operazioni.

Velocità di convergenza:

||C|| oltre a garantire la convergenza serve a determinare la velocità di convergenza dato che  quanto più piccolo è questo valore tanto più velocemente si convergerà alla soluzione ottima.
Indicando con eps(^k)=x(^k)- x(^*) l’errore di troncamento ammissibile alla k-esima iterazione (differenza all’iterata k tra l’approssimazione e la soluzione), dove || eps(^k)||<=||C^k || ||eps(^0)||, è possibili trovare il numero minimo di iterazioni per avere || eps(^k)||<tol (tol=tolleranza desiderata): k=[ ln (tol) – ln (||eps(^0)||) ]/ ln (||C||).
La convergenza del metodo equivale alla convergenza a 0 dell’errore di troncamento alla k-esima iterazione, cioè di di eps(^k).

Criteri di arresto:

Il metodo iterativo può essere arrestato o agendo sull’errore assoluto e in tal caso il criterio d’arresto sarà: ||x(^k) – x*||<=tol, dove in generale tol=10(^-m) è l’approssimazione corretta a m cifre decimali; oppure sull’errore relativo ||x(^k) – x*|| / ||x*||<=tol, dove in generale tol=10(^-m) è l’approssimazione corretta a m-1 cifre significative; tuttavia utilizzando questi criteri si presuppone la conoscenza della soluzione x* ottima e quindi la necessità di determinare stime calcolabili dell’errore ad ogni iterazione. Mentre criteri d’arresto effettivamente utilizzabili sono quelli basate su quantità già calcolate e quindi basati o sulla stima dell’errore assoluto ||x(^k+1) – x(^k)||<=tol; o sull’errore relativo ||x(^k) – x(^k-1)|| / ||x(^k-1)||<=tol.
Altro criterio di arresto, aggiuntivo e/o sostitutivo, è quello basato sull’impostazione di un numero massimo Maxit di iterazioni che permette l’arresto anche nel caso in cui il metodo non converge e limita il costo computazionale del procedimento iterativo.

L’ heapsort per eseguire l’ordinamento, utilizza una struttura chiamata heap (mucchio); un heap è rappresentabile con un albero binario in cui tutti i nodi seguono una data proprietà, detta priorità. Esso è completo almeno fino al penultimo livello dell’albero e ad ogni nodo corrisponde uno ed un solo elemento.

In uno heap decrescente (utilizzato per ordinare ad esempio un array in senso crescente) ogni nodo padre contiene un valore maggiore o uguale a quello dei suoi due figli diretti, di conseguenza risulterà maggiore anche di tutti i nodi che si trovano nel sottoalbero di cui esso è la radice; questo non implica affatto che nodi a profondità maggiore contengano valori minori di quelli a profondità minore.

Quindi in ogni istante, in un heap decrescente, la radice contiene il valore maggiore.

Questa struttura è molto usata, in particolare, per l’ordinamento di array.

In questo caso si considera come radice l’elemento iniziale di indice 1; inoltre i figli di un nodo con indice j, avranno indice rispettivamente 2j, quello sinistro, 2j+1 quello destro.

Per comprendere meglio il funzionamento dell’algoritmo è bene capire che gli elementi che si trovano nella seconda metà dell’array rappresenteranno foglie dello heap e quindi esse saranno già al loro posto giusto; non vi è infatti alcun elemento dopo di esse.

…tratto da wikipedia

Implementazione Iterativa di Heap Sort

L’algoritmo che ordina in senso crescente inizia creando uno heap decrescente. Per ogni iterazione si copia la radice (primo elemento dell’array) in fondo all’array stesso, eseguendo uno scambio di elementi. L’algoritmo poi ricostruisce uno heap di n – 1 elementi spostando verso il basso la nuova radice, e ricomincia con un altro scambio (tra il primo elemento dell’array e quello in posizione n – 1), eseguendo un ciclo che considera array di dimensione progressivamente decrescente.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

#include <stdio.h>
#define MAX 20
 
int sinistro(int i)
{
 return 2*i+1;
}
 
int destro(int i)
{
 return 2*i+2;
}
 
int padre(int i)
{
 return (int)(i-1/2);
}
 
stampavettore(int *vettore,int n)
{
 int i;
 
 for(i=0 ; i<=n ; printf("%d ",vettore[i++]));
}
 
int riempivettore(int *vettore)
{
 int i;
 
 i=0;
 do {
 printf("inserire l'elemento %d dell'array('-1' per terminare): ",i+1);
 scanf("%d",vettore+i);
 } while (vettore[i++] != -1);
 return i-2;
}
 
void scambia(int *n1,int *n2)
{
 int temp;
 
 temp = *n1;
 *n1 = *n2;
 *n2 = temp;
}
 
void heapify(int *vettore, int i,int heapsize)
{
 int l,r,maggiore,violazione=1;
 
 while (violazione)
 {
 l = sinistro(i);
 r = destro(i);
 
 if ((l <= heapsize) && (vettore[l] > vettore[i]))
 {
 maggiore = l;
 }
 else 
 {
 maggiore = i;
 }
 
 if ((r <= heapsize) && (vettore[r]>vettore[maggiore]))
 {
 maggiore = r;
 }
 if (maggiore != i)
 {
 scambia(&vettore[i],&vettore[maggiore]);
 i=maggiore;
 }
 else
 {
 violazione = 0;
 }
 }
}
 
void buildheap(int *vettore,int heapsize,int n)
{
 int i;
 
 for (i=(int)(n/2) ; i>=0 ; i--)
 {
 heapify(vettore,i,heapsize);
 }
}
 
heapsort(int *vettore,int n)
{
 int i,heapsize;
 
 heapsize=n;
 buildheap(vettore,heapsize,n);
 for (i=n ; i>0 ; i--)
 {
 scambia(&vettore[0],&vettore[i]);
 heapsize--;
 heapify(vettore,0,heapsize);
 }
}
 
main()
{
 int vettore[MAX];
 int n; /*numero di elementi*/
 
 n=riempivettore(vettore);
 
 heapsort(vettore,n);
 
 stampavettore(vettore,n);
}

Si può dimostrare che la complessità asintotica massima dell’heap sort è O(nlogn). Tuttavia, in generale (e soprattutto per array quasi ordinati) altri algoritmi con la medesima complessità asintotica, per esempio quick sort o merge sort, ottengono migliori prestazioni. Per array di piccole dimensioni è addirittura più veloce l’insertion sort nonostante abbia una complessità di O(n^2))

Implementazione Ricorsiva di Heap Sort

Qui vi è l’implementazione ricorsiva in linguaggio C di Heap Sort

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

#include <stdio.h>
#define MAX 20
 
int sinistro(int i)
{
 return 2*i+1;
}
 
int destro(int i)
{
 return 2*i+2;
}
 
int padre(int i)
{
 return (int)(i-1/2);
}
 
stampavettore(int *vettore,int n)
{
 int i;
 
 for(i=0 ; i<=n ; printf("%d ",vettore[i++]));
}
 
int riempivettore(int *vettore)
{
 int i;
 
 i=0;
 do {
 printf("inserire l'elemento %d dell'array('-1' per terminare): ",i+1);
 scanf("%d",vettore+i);
 } while (vettore[i++] != -1);
 return i-2;
}
 
void scambia(int *n1,int *n2)
{
 int temp;
 
 temp = *n1;
 *n1 = *n2;
 *n2 = temp;
}
 
void heapify(int *vettore, int i,int heapsize)
{
 int l,r,maggiore;
 
 l = sinistro(i);
 r = destro(i);
 
 if ((l <= heapsize) && (vettore[l] > vettore[i]))
 {
 maggiore = l;
 }
 else
 {
 maggiore = i;
 }
 
 if ((r <= heapsize) && (vettore[r]>vettore[maggiore]))
 {
 maggiore = r;
 }
 if (maggiore != i)
 {
 scambia(&vettore[i],&vettore[maggiore]);
 heapify(vettore,maggiore,heapsize);
 }
}
 
void buildheap(int *vettore,int heapsize,int n)
{
 int i;
 
 for (i=(int)(n/2) ; i>=0 ; i--)
 {
 heapify(vettore,i,heapsize);
 }
}
 
heapsort(int *vettore,int n)
{
 int i,heapsize;
 
 heapsize=n;
 buildheap(vettore,heapsize,n);
 for (i=n ; i>0 ; i--)
 {
 scambia(&vettore[0],&vettore[i]);
 heapsize--;
 heapify(vettore,0,heapsize);
 }
}
 
main()
{
 int vettore[MAX];
 int n; /*numero di elementi*/
 
 n=riempivettore(vettore);
 
 heapsort(vettore,n);
 
 stampavettore(vettore,n);
}

Il Quicksort, termine che tradotto letteralmente in italiano indica ordinamento rapido, è l’algoritmo di ordinamento che ha, in generale, prestazioni migliori tra quelli basati su confronto; è stato sottoposto a un’analisi matematica approfondita ed estremamente precisa, tanto che le sue prestazioni sono state comprese a fondo e il suo comportamento è stato descritto in modo molto accurato.

I risultati ottenuti in fase di analisi sono stati verificati sperimentalmente in modo esteso e l’algoritmo di base è stato migliorato al punto da diventare il metodo ideale per un gran numero di applicazioni pratiche.

tratto da wikipedia

Per la sua estrema facilità è stato scelto in molte librerie di linguaggi, come il C, di implementare di base una funzione che effettui l’ordinamento del Quicksort… però il nostro professore di programmazione vuole vedere il codice sorgente

Codice C Quicksort

Eccolo qua:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#include <stdio.h>
#define MAX 20
 
stampavettore(int *vettore,int n)
{
 int i;
 
 for(i=0 ; i<=n ; printf("%d ",vettore[i++]));
}
 
int riempivettore(int *vettore)
{
 int i;
 
 i=0;
 do {
 printf("inserire l'elemento %d dell'array('-1' per terminare): ",i+1);
 scanf("%d",vettore+i);
 } while (vettore[i++] != -1);
 return i-2;
}
 
void scambia(int *n1,int *n2)
{
 int temp;
 
 temp = *n1;
 *n1 = *n2;
 *n2 = temp;
}
 
int partiziona(int *vettore, int p, int r)
{
 int x = vettore[p];
 int i = p-1;
 int j = r+1;
 int itera = 1;
 
 do {
 for(; vettore[--j] > x ;);
 for(; vettore[++i] < x ;);
 
 if (i < j)
 {
 scambia(&vettore[i],&vettore[j]);
 }
 else
 {
 itera = 0;
 }
 } while (itera);
 
return j;
}
 
void quicksort(int *vettore, int p, int r)
{
 int q;
 
 if (p < r)
 {
 q = partiziona(vettore,p,r);
 quicksort(vettore,p,q);
 quicksort(vettore,q+1,r);
 }
}
 
main()
{
 int vettore[MAX];
 int n; /*numero di elementi*/
 
 n=riempivettore(vettore);
 
 quicksort(vettore,0,n);
 
 stampavettore(vettore,n);
}

Caratteristiche del Quicksort

Allocazione di memoria del vettore

Sappiamo che nel linguaggio c dichiariamo un vettore con l’istruzione

int vett[n];

in questo modo creiamo un vettore chiamato vett di n elementi:

vett[0] , vett[1] , … , vett[n-1]

Supponiamo, con n=5, di riempire il vettore in questo modo:

Risulterà che:

0
1
2
3
4

 vett[0] = 10 = *vett
 vett[1] = 11 = *vett+1
 vett[2] = 12 = *vett+2
 vett[3] = 13 = *vett+3
 vett[4] = 14 = *vett+4

Inoltre supponiamo di aver fatto girare al computer il programma,
avremo alcuni indirizzi se stampiamo:

804400008 = vett
804400012 = vett+1
804400016 = vett+2
804400020 = vett+3
804400024 = vett+4

Passare il vettore ad una funzione

Ora che sappiamo come viene creato un vettore in memoria affrontiamo
il problema di passare il vettore nelle funzioni. Supponiamo la funzione:

0
1
2
3
4
5
6

void funzione(int *vettore)
 {
 int i;
 
for (i=0 ; i<n ; i++)
 vettore[i] += 20;
 }

che aggiunge 20 ad ogni elemento del vettore. Quale sarà la chiamata giusta
da fare nel programma chiamante?

0
1
2
3
4
5
6
7
8
9

main()
 {
 .
 .
 .
 funzione(vett);
 .
 .
 .
 }

Perchè passiamo “vett” e non “&vett”?
Il contenuto di “vett” non è altro che un indirizzo… il primo elemento del
vettore è “*vett” oppure “vett[0]“.
Quindi con questa chiamata non facciamo altro che passare per valore alla
funzione un indirizzo che è proprio l’indirizzo del nostro vettore

Praticamente nella funzione viene dichiarato un puntatore ad intero chiamato
“vettore”. La dichiarazione è

0

int *vettore

Quindi in vettore mettiamo l’indirizzo che nell’esempio è 804400008.
All’intrno della funzione risulterà che:

vettore   = 804400008          <– indirizzo
*vettore   = 10                 <– contenuto di vett[0]
*vettore+1 = 11                 <– contenuto di vett[1]

Questo è il motivo che nel linguaggio C non è obbligatorio definire la
dimensione del vettore!

STAMPA SU VIDEO DI UN VETTORE v DI n ELEMENTI

0
1
2
3
4
5
6
7
8
9

void StampaVettore(int n, float *v)
 {
 int i;
 
printf("\n Vettore = ( ");
 for ( i=0 ; i<n-1 ; i++ )
 printf("%.2f %s",v[i],", ");
 
printf("%.2f %s \n",v[n-1]," );");
 }

STAMPA SU VIDEO DI UNA MATRICE M DI n RIGHE ED m COLONNE

0
1
2
3
4
5
6
7
8
9
10

void StampaMatrice(int n, int m, float **M)
 {
 int i,j;
 
for (i=0;i<n;i++)
 {
 printf("\n");
 for (j=0;j<m;j++) printf("%.2f %s",M[i][j],"   ");
 }
 printf("\n");
 }

Iniziamo la lezione dicendo subito che per INPUT/OUTPUT si intende l’ insieme delle operazioni di
ingresso ed uscita, ossia lo scambio di informazioni tra il programma e le unita’ periferiche del
calcolatore.
Nel linguaggio C l’ I/O e’ interamente implementato mediante funzioni della libreria standard.
Il linguaggio C vede i file come un flusso (stream) sequenziale di byte. Uno stream dal punto di vista
tecnico e’ una implementazione software in grado di gestire le informazioni relative all’interazione a
basso livello con la periferica associata, in modo che il programma possa trascurare di che periferica si
tratti.
Ogni file termina con un marcatore di fine file detto
EOF( end-of-file) definito in <stdio.h> come una costante simbolica uguale a -1.

I file e gli stream

Un file e’ una sequenza di lunghezza non prefissata di valori dello stesso tipo.
Quando un file viene aperto sara’ associato uno stream . Tre file e i loro rispettivi stream, lo standard di
input, lo standard di output, lo standard error (stdin, stdout, stderr) , sono aperti automaticamente
quando inizia l’esecuzione di un programma.
Lo stream dello standard di input consente ad un programma di ricevere input dalla tastiera. (puo’
essere rediretto su altre periferiche).
Lo stream dello standard di output consente ad un programma di di scrivere sul video della
macchina.(puo’ essere rediretto su altre periferiche)
Lo stream dello standard di errore consente ad un programma di scrivere sul video della macchina.
(non puo’ essere rediretto su altre periferiche).
Un programma C puo’ servirsi degli stream standard ; basta che vi compaia la direttiva
#include<stdio.h>
Gli stream forniscono un canale di comunicazione tra i file ed i programmi.
L’apertura di un file restituisce un puntatore ad una struttura FILE (definita in <stdio.h>) che contiene
le informazioni utilizzate per elaborare il file. La struttura FILE ha un file descriptor (descrittore di
file), cioe’ l’indice di un vettore del S.O. chiamata open file table (tabella dei file aperti). Ogni
elemento del vettore contiene un file control block o FCB (blocco di controllo del file) il quale viene
utilizzato dal S.O. per amministrare un particolare file.
Consideriamo due tipi di file i file di testo ed i file binari; i primi utilizzati quando l’informazione da
memorizzarvi e’ di tipo testo cioe’ sequenze di caratteri; i secondi quando si vuole memorizzare nel file
dati di un generico tipo (interi,strutture ecc…).

Il puntatore al file

Attraverso la definizione
FILE *fp;
viene permessa l’associazione di un identificatore del programma ad un file, che si trova in memoria
secondaria.
Con la sola definizione, fp e’ soltanto una “variabile di tipo FILE”; l’effettiva associazione avviene in
fase di apertura del file.
Il puntatore fp punta ad informazioni che descrivono alcune caratteristiche dei file come il nome, lo
stato e la posizione corrente.
Scopo del puntatore al file e’ quello di identificare uno specifico file su disco e viene usato dal flusso
associato per svolgere in modo corretto le operazioni di input/output.

Apertura di un file

Avendo la definizione FILE *fp;
Per aprire il file di avente nome “dati.in” ed associarlo ad fp si esegue la seguente operazione di
apertura:
fp = fopen(“dati.in”, “r”);
Vediamo che l’access mode “r” implica l’apertura del file dati.in, presente in memoria secondaria, in
modalita’ di sola lettura.
Il prototipo della fopen() e’:
FILE *fopen(const char *nome_del_file, const char *modo);
nome_del_file deve essere un puntatore ad una stringa di caratteri che costituisce un nome valido
secondo quanto definito dal S.O. e puo’ includere un percorso (path); la stringa a cui punta il modo
definisce la modalita’ con cui sara’ aperto il file.
La fopen() restituisce un puntatore al file di tipo FILE oppure un puntatore nullo nel caso si verifichi un
errore.
Si puo’ pensare che quando il file viene aperto, vi sia un cursore che segna il punto di accesso
all’interno del file (viene letto un dato in corrispondenza della posizione del cursore). Cosi all’apertura
del file il cursore si posiziona all’inizio del file; quando viene letto un dato, il cursore va alla posizione
successiva; alla prossima lettura viene letto il dato successivo eccetera.
Un file puo’ essere aperto per operazioni di sola scrittura e sono necessarie le istruzioni:
FILE *fp;
fp = fopen(“dati.in”, “w”);
e’ possibile aprire sia file di testo che file binari.
Notare che conviene sempre nei programmi verificare che il file sia stato aperto correttamente (cioe’
che la funzione fopen() abbia avuto successo).
Per fare cio’ si deve usare, nel caso il file in uso fosse dati.in, un frammento di codice come il seguente:

0
1
2
3
4
5
6
7
8
9
10
11

FILE *fp;
 char nome_del_file [] = “dati_in”
 fp = fopen(nome_del_file, “r”);
 if(fp!=NULL)
 {
 /* istruzioni di utilizzo del file*/
 }
 else
 {
 printf(“\n impossibile aprire il file”);
 exit(1);
 }

La istruzione di uscita exit(1) viene utilizzata soltanto se si e’ nel main() altrimenti se si e’ all’interno di
una altra funzione, al suo posto si utilizza la return.

Chiusura di un file

Per chiudere un file precedentemente aperto con la fopen() si utilizza la funzione fclose().
E’ molto importante chiudere tutti i file aperti in un programma prima che questi termini la sua
esecuzione. Infatti l’operazione di chiusura scrive nel file fisico corrispondente possibili dati che siano
rimasti nel buffer di scrittura.
Il prototipo della fclose e’:
int fclose(FILE *fp);
in cui fp e’ il puntatore che restituisce la fopen().
La fclose() tenta di chiudere il file puntato da fp e restituisce il valore 0 nel caso in cui la chiusura sia
terminata con successo (altrimenti un valore diverso da 0 nel caso di chiusura fallita). Comunque di
solito la fclose() da errore soltanto se un disco e’ stato tolto dall’unita’ di lettura prematuramente
oppure quando non vi e’ piu’ spazio libero.

Le modalita’ di accesso dei file

La modalita’ di accesso (access mode) indica come si dovra’ collegare un file ad un identificatore del
programma e come si potra’ usare quel file.
Come visto sopra la modalita’ “r” implica che il file venga aperto soltanto in lettura (solo per leggerne i
dati), se il file esiste naturalmente.
Mentre con “w” si indica (ad esempio nella fopen(“dati.in”, “w”);) di aprire il file dati.in in modalita’
di scrittura. Se il file esiste, nella memoria secondaria, i dati in esso contenuti saranno persi e sostituiti
con i nuovi dati che vi scriveremo; se il file non esiste viene creato.
Vediamo una lista con i valori previsti per l’argomento modo nella fopen(.. , ..)

• “r”                          Apre un file testuale esistente per sola lettura, posizionando il cursore all’inizio del file;
• “w”                          Apre un file testuale per sola scrittura: se il file gia’ esiste i dati in esso contenuti vengono perduti; se il file non esiste ne viene creato uno nuovo;
• “a”                          Apre un file di testuale esistente per scrittura, in modalita’ append; il cursore viene posizionato alla fine del file e si puo’ scrivere nel file solo in coda ai dati gia’ presenti; i dati gia presenti non vengono cancellati;
• “r+”                         Apre un file testuale esistente in lettura e scrittura; il cursore viene posto all’inizio;
• “w+”                         Apre un file testuale per lettura e scrittura; se il file gia’ esiste i dati in esso contenuti vengono perduti; se il file non esiste, ne viene creato uno nuovo;
• “a+”                         Apre un file testuale in modalita’ append; se il file non esiste, ne viene creato uno nuovo; si possono leggere tutti i dati del file; si possono scrivere dati solo in fondo al file.
• “rb”                         Apre un file binario esistente per sola lettura, posizionando il cursore all’inizio;
• “wb”                         Apre un file binario per sola scrittura; se il file gia’ esiste i dati in esso contenuti vengono persi; se il file non esiste , ne viene creato uno nuovo;
• “ab”                         Apre o crea un file binario per scrittura in modalita’ append; il cursore viene posizionato alla fine del file e si puo’ scrivere nel file solo in coda ai dati gia’ presenti;
• “rb+”                        Apre un file binario esistente in lettura e scrittura
• “wb+”                        Apre o crea un file binario in lettura e scrittura
• “ab+”                        Apre o crea in modalita’ append un file binario.

Creazione di un file sequenziale

Vediamo un esempio di programma in cui utilizzeremo le funzioni fopen() ed fclose():

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/* creare un file sequenziale*/
 #include<stdio.h>
 int main ()
 {
 int numero_di_conto;
 char nome[31];
 float saldo;
 FILE *fpunt; /* puntatore al file clienti.dat*/
 if ((fpunt = fopen(“clienti.dat”, “w”)) = = NULL)
 printf(“Il file non puo’ essere aperto\n”);
 else {
 printf(“Inserite il numero di conto, il nome, ed il saldo.\n”);
 printf(“inserite EOF per finire gli inserimenti\n”);
 printf(“?”);
 scanf(“%d%s%f”,&numero_di_conto, nome, &saldo);
 while(!feof(stdin)) {
 fprintf(fpunt,”%d%s%.2f\n”, numero_di_conto, nome, saldo);
 printf(“?”);
 scanf(“%d%s%f”,&numero_di_conto, nome, &saldo);
 }
 fclose(fpunt);
 }
 return 0;
 }

Questo programma creera’ un semplice file ad accesso sequenziale di nome clienti.dat
Nella schermata di input dovremo inserire ad esempio
? 10 roberta 10,5
? 11 roberto 22
? 12 jennifer 30
?
ed EOF per terminare l’immissione di nuovi dati.
Come anticipato FILE *fpunt stabilisce che fpunt e’ un puntatore ad una struttura FILE.
La fprintf e’ analoga alla funzione printf soltanto che la fprintf scrive nel file invece che sul video.
Il programma richiedera’ all’utente di immettere per ogni record i vari campi; quando viene conclusa
l’immissione dei dati richiedera’ un end-of-file.
L’end-of-file per i diversi sistemi di computer e’ segnalato in lista (Sistema,Combinazione di tasti):
Sistemi UNIX: <return><ctrl>d
PC IBM e compatibili: <ctrl>z
Macintosh: <ctrl>d
VAX(VMS): <ctrl>z

La riga di codice
while (!feof(stdin))
Usa la funzione feof per determinare se sia stato impostato EOF per il file al quale punta stdin.
EOF indichera’ al programma che non ci sono piu’ dati da elaborare.
Il nostro programma non mostra come i dati dei record appaiono realmente all’interno del file. Per fare
cio’ e verificare quindi la correttezza dei dati creati necessita un programma che leggera’ il file e ne
visualizza il contenuto.
Funzioni di lettura e scrittura
Si distinguono in due categorie lettura e scrittura per carattere e lettura e scrittura per linee (stringhe).
Fra le prime consideriamo la funzione fputc e la funzione fgetc.
La funzione fputc ha il seguente prototipo:
int fputc (int c , FILE *fpunt);
questa funzione preleva un carattere c e lo stampa(scrive) nel file fpunt,(file puntato da fpunt) nella
posizione del cursore; naturalmente il file deve essere stato precedentemente aperto con la funzione
fopen( ), ed fpunt e’ il puntatore restituito da quest’ultima funzione.
Il carattere c viene convertito in un unsigned char nella fputc.
Restituisce il carattere letto (il codice) oppure EOF (se la stampa e’ andata male)
La funzione fgetc ha il seguente prototipo:
int fgetc(FILE *fpunt);
la funzione restituisce (convertito in intero) il carattere letto dal file fpunt “file precedentemente aperto
con la fopen()”;
il cursore avanza di un dato (il prossimo da leggere); in caso vi sia errore viene restituito EOF.
Nella lettura e scrittura per linee consideriamo la funzione fgets ed fputs ; con la fgets si legge al piu’
una intera linea da un file passato per argomento “file precedentemente aperto tramite la funzione
fopen()”.
Il prototipo della funzione e’:
char *fgets (char *strin, int n, FILE *fpunt);
con questa funzione viene letto, dal file fpunt, una sequenza di caratteri, fermandosi al newline (oppure
fermandosi ad n caratteri letti od all’EOF) e memorizza i caratteri letti nell’array strin; la fgets
restituisce l’array letto oppure NULL se ha incontrato EOF.
L’eventuale EOL (‘\n’) letto verra’ incluso nella stringa risultante.
Con il parametro n si specifica il numero massimo di caratteri da leggere; se la linea del file contiene
un numero di caratteri maggiore di n i caratteri in eccesso non verranno letti.
La funzione fputs ha il seguente prototipo:
int fputs(const char *strin, FILE *fpunt);
e stampa nel file fpunt(precedentemente aperto tramite la fopen(..) ) i caratteri contenuti nella stringa
strin; se la stampa e’ andata a buon fine restituisce il valore 0 , altrimenti un numero diverso da zero.
Esempio
Nel seguente programma la funzione fputs() scrive nel file prova delle stringhe lette dalla tastiera,
tramite la funzione gets(), e passategli come parametro.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include "stdio.h"
 #include "stdlib.h"
 #include "string.h"
 int main()
 {char strin[81];
 FILE *fpunt;
 if((fpunt=fopen("prova", "w"))==NULL)
 {
 printf("Errore nella lettura del file\n");
 exit(1);
 }
 do
 {
 printf("inserite una stringa e premere INVIO per uscire:\n");
 gets(strin);
 strcat(strin,"\n"); /*aggiunta di un newline*/
 fputs(strin,fpunt);
 }while(*strin !='\n');
 return 0;
 }

Per uscire dal programma introducete una stringa vuota.
Notare che la funzione gets non memorizza il carattere di newline, per cui ne aggiungiamo uno alla
stringa letta da input, attraverso la funzione strcat, prima che tale stringa venga scritta nel file fpunt.
La funzione rewind()
La rewind() ripristina l’indicatore di posizione del file specificato ‘cursore’. Ossia il file e’ come se
venisse ravvolto con la rewind().
Il prototipo di tale funzione e’:
void rewind (FILE *fpunt);
fpunt e’ un puntatore ad un file.
Le funzioni di lettura e scrittura formattata
Sono la fprintf() e la fscanf() analoghe alla printf e scanf, soltanto che accettano un argomento in piu’,
cioe’ il file dove scrivere o da cui leggere.
I prototipi sono rispettivamente:
int fprintf(FILE *fpunt, const char *stringa_formato, <argomenti>);
la quale stampa nel file fpunt secondo le specifiche della stringa formato;
e la
int fscanf (FILE *fpunt, const char * stringa_formato, <argomenti>);
la fscanf legge dal file fpunt i dati specificati nella stringa_formato.
Cenni sui file ad accesso casuale
I record di un file creati con l’output formattato della funzione fprintf non avranno necessariamente la
stessa lunghezza. Ogni record di un file ad accesso casuale puo’ essere acceduto direttamente avendo di
norma la stessa lunghezza. Dal momento che in un file ad accesso casuale ogni record ha lunghezza
fissa, la sua posizione all’interno del file puo’ essere calcolata con una funzione della chiave del record.
Le funzioni di lettura e scrittura per blocchi
Attraverso le funzioni fread() ed fwrite() si possono leggere e scrivere rispettivamente interi blocchi di
byte da un file.
I loro prototipi sono:

size_t fread(void *buffer, size_t num_byte, size_t contatore, FILE *fpunt);
size_t fwrite(void *buffer, size_t num_byte, size_t contatore, FILE *fpunt);

nella fread buffer e’ l’indirizzo di una locazione di memoria destinata a ricevere i dati letti dal file
fpunt. Con essa si leggono dal file fpunt un blocco di contatore dati con ciascun dato avente dimensione
num_byte. La fread restituisce il numero di elementi letti con successo.
Le funzioni fread ed fwrite sono in grado di leggere e scrivere su disco interi vettori di dati.
Il terzo argomento delle funzioni e’ il numero degli elementi del vettore che dovranno essere letti/scritti
dal/sul disco.
Vediamo adesso un programma che se il file viene aperto in modo binario scrive un double un int e un
long in un file di nome fle_test e li rilegge:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <stdio.h>
 #include<stdlib.h>
 int main ()
 {
 FILE *fpunt;
 double d=11.23;
 int i=101;
 long l=113023L;
 if((fpunt=fopen("file_test","wb+"))==NULL)
 {
 printf("errore di apertura del file\n");
 exit(1);
 }
 fwrite(&d,sizeof(double), 1,fpunt);
 fwrite(&i,sizeof(int), 1,fpunt);
 fwrite(&l, sizeof(long),1,fpunt);
 rewind(fpunt) ; /*riposiziona il puntatore all'inizio del file*/
 fread(&d, sizeof(double),1,fpunt);
 fread(&i, sizeof(int),1,fpunt);
 fread(&l,sizeof(long),1,fpunt);
 printf("%f %d %ld",d,i,l);
 fclose(fpunt);
 return 0;
 }

Il linguaggio C consente le operazioni di lettura e scrittura ad accesso casuale usando la funzione
fseek(), che ha il compito di posizionare il cursore del file.
Il prototipo della fseek() e’:
int fseek(FILE *fpunt, long num_byte, int origine);
fpunt e’ il puntatore al file come viene restituito dalla funzione fopen();
num_byte e’ il numero di byte di distanza tra l’origine e la nuova posizione (detto offset o
scostamento); notare che in questo caso occorre usare l’operatore sizeof per accedere all’elemento
desiderato; mentre origine e’ una delle seguenti macro definite da stdio.h :

• SEEK_SET: Inizio del file
• SEEK_CUR: Posizione corrente
• SEEK_END: Fine del file

Per leggere l’ennesimo elemento del file fp, che supponiamo contenga elementi di tipo tipo_elementi,
useremo:

fseek(fp,(n-1)*sizeof(tipo_elementi),SEEK_SET);
fread(&buffer,sizeof(tipo_elementi),1,fp);

Esempio di programma per file binari

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#include<stdio.h>
 #define N 15
 char nome_file[] ="file_int.dat";
 int vector[N];
 void inserisci_in_array();
 void crea_file();
 void apri_file();
 int main()
 {
 char car;
 inserisci_in_array();
 crea_file();
 apri_file();
 scanf("\n%c",&car);
 return 0;
 }
 void inserisci_in_array()
 {
 int i;
 printf("\ninserite gli %d elementi interi dell'array\n",N);
 for(i=0; i<N;i++)
 {printf("%d) ",i+1);
 scanf("%d",&vector[i]);
 }
 }
 void crea_file()
 {
 FILE *fp;
 int i=0;
 if((fp=fopen(nome_file,"wb"))!=NULL){
 fwrite(vector,sizeof(int),N,fp);
 fclose(fp);
 }
 else
 printf("errore nell'apertura in scrittara del file %s ",nome_file);
 }
 void apri_file()
 {
 FILE *fp;
 int i;
 if((fp=fopen(nome_file,"rb"))!=NULL)
 {
 while(fread(vector,N*sizeof(int),1,fp)==1)
 {for(i=0;i<N;i++)
 printf(" %d) %d ",i+1,vector[i]);
 }
 fclose(fp);
 }
 else printf("errore nell'apertura del file %s in lettura",nome_file);
 }

GDB (ovvero GNU DeBugger) è molto più di un semplice debugger: è un vero e proprio program execution path analysis tool.
Invocando il comando “gdb –help” avremo:

This is the GNU debugger.  Usage:

    gdb [options] [executable-file [core-file or process-id]]
    gdb [options] --args executable-file [inferior-arguments ...]

Options:

  --args             Arguments after executable-file are passed to inferior
  --[no]async        Enable (disable) asynchronous version of CLI
  -b BAUDRATE        Set serial port baud rate used for remote debugging.
  --batch            Exit after processing options.
  --cd=DIR           Change current directory to DIR.
  --command=FILE     Execute GDB commands from FILE.
  --core=COREFILE    Analyze the core dump COREFILE.
  --pid=PID          Attach to running process PID.
  --dbx              DBX compatibility mode.
  --directory=DIR    Search for source files in DIR.
  --epoch            Output information used by epoch emacs-GDB interface.
  --exec=EXECFILE    Use EXECFILE as the executable.
  --fullname         Output information used by emacs-GDB interface.
  --help             Print this message.
  --interpreter=INTERP
                     Select a specific interpreter / user interface
  --mapped           Use mapped symbol files if supported on this system.
  --nw               Do not use a window interface.
  --nx               Do not read .gdbinit file.
  --quiet            Do not print version number on startup.
  --readnow          Fully read symbol files on first access.
  --se=FILE          Use FILE as symbol file and executable file.
  --symbols=SYMFILE  Read symbols from SYMFILE.
  --tty=TTY          Use TTY for input/output by the program being debugged.
  --version          Print version information and then exit.
  -w                 Use a window interface.
  --write            Set writing into executable and core files.
  --xdb              XDB compatibility mode.

Bhè… ci sono molte opzione, come la maggior parte dei programmi . in questa guida ci limiteremo a chiamare gdb passandoci semplicente il nome dell’eseguibile da analizzare.
Facciamo subito il solito primo esempio: hello.c.

0
1
2
3
4
5
6

#include 
 
int main()
{
        printf("Hello World\n");
        exit(0);
}

Se vogliamo analizzare questo programma dobbiamo compilarlo con l’opzione “-g” del compilatore gcc; in questo modo l’eseguibile conterrà delle informazioni utili al debugger per analizzare il programma. Compiliamo…

emac:~/temp ferrara$ gcc -g -o helloworld hello.c
emac:~/temp ferrara$ ls -l
total 32
-rw-r--r--  1 ferrara  ferrara     72 19 Nov 22:41 hello.c
-rwxr-xr-x  1 ferrara  ferrara  11764 19 Nov 22:45 helloworld

Adesso abbiamo il nostro eseguibile chiamato “helloword” compilato per essere esaminato con gdb. Non ci resta che lanciare il comando:

emac:~/temp ferrara$ gdb helloworld
GNU gdb 5.3-20030128 (Apple version gdb-309) (Thu Dec  4 15:41:30 GMT 2003)
Copyright 2003 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.  Type "show warranty" for details.
This GDB was configured as "powerpc-apple-darwin".
Reading symbols for shared libraries .. done
(gdb) <-- Prompt di gdb

Gdb ha caricato il nostro eseguibile e ci ha presentato il suo prompt (gdb). Adesso abbiamo svariati comandi a nostra disposizione! Esaminiamo il più semplice: list. Esso, seguito dal nome della funzione o del numero di linea, ci presenta a video il sorgente:

(gdb) list main < -- Comando dato al prompt di gdb
1       #include
2
3       int main()
4       {
5               printf("Hello World\n");
6               exit(0);
7       }
8

Per maggiori informazioni basta digitare il comando “help list” al prompt di gdb per avere maggiori informazioni su questo comando. Ma come fa gdb a sapere il codice del programma helloworld se noi abbiamo fassato come argomento solo l’eseguibile? Questa informazione è stata registrata nell’eseguibile grazie all’opzione –g del compilatore .
Ora con il comando run facciamo girare il programma all’interno di gdb:

(gdb) run &tab; < -- Comando dato al prompt di gdb
Starting program: /Users/ferrara/temp/helloworld
Reading symbols for shared libraries . done
Hello World &tab; <-- Output del pogramma

Program exited normally.

Come si poteva immaginare non ci sono errori. Alla fine dell’esecuzione gdb ci ripresenta il suo prompt e possiamo continuare a dargli altri comandi.
Adesso proveremo a disassemblare il codice di helloworld con il comando disass:

(gdb) disass main < -- Comando dato al prompt di gdb
Dump of assembler code for function main:
0x00001da4 :    mflr    r0
0x00001da8 :    stmw    r30,-8(r1)
0x00001dac :    stw     r0,8(r1)
0x00001db0 :   stwu    r1,-80(r1)
0x00001db4 :   mr      r30,r1
0x00001db8 :   bcl-    20,4*cr7+so,0x1dbc
0x00001dbc :   mflr    r31
0x00001dc0 :   addis   r3,r31,0
0x00001dc4 :   addi    r3,r3,564
0x00001dc8 :   bl      0x1f34
0x00001dcc :   li      r3,0
0x00001dd0 :   bl      0x1dd4
End of assembler dump.

Questa funzione di gdb delizierà gli smanettoni, ma non approfondiremo questo argomento.
Per uscire dal gdb e quindi tornare al prompt della nostra shell bastera digitare il comando quit o semplicemente q.

Primo esempio di debugging

Esaminiamo il seguente programma (segmentation_fault.c):

0
1
2
3
4
5
6
7
8
9
10
11
12

#include
#include 
 
int main()
{
        char *buf;
 
        strcpy(buf,"HelloWorld");
 
        printf("%s\n", buf);
 
        exit(0);
}

Questo programma stampa a video “HelloWorld”. Ma eseguendolo abbiamo un errore:

emac:~/temp ferrara$ gcc -g -o sfault segmentation_fault.c
emac:~/temp ferrara$ ./sfault
Bus error

Dove abbiamo sbagliato? Lanciamo gdb e diamo il comando run per avviare il programma:

emac:~/temp ferrara$ gdb sfault < -- Comando dato alla shell per avviare gdb
GNU gdb 5.3-20030128 (Apple version gdb-309) (Thu Dec  4 15:41:30 GMT 2003)
Copyright 2003 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.  Type "show warranty" for details.
This GDB was configured as "powerpc-apple-darwin".
Reading symbols for shared libraries .. done
(gdb) run &tab; <-- Comando dato al prompt di gdb
Starting program: /Users/ferrara/temp/sfault
Reading symbols for shared libraries . done

Program received signal EXC_BAD_ACCESS, Could not access memory. <-- Trovato un errore
0x90007680 in strcpy () <-- La funzione dove si blocca il programma è strcpy
(gdb) <-- Prompt di gdb per eventuali altri comandi

Questa è un informazione utilissima, ma si può avere di più. Siccome è difficile pensare che ci sia un bug nelle glibc (cioè dove è implementata la funzione strcpy()) proviamo a pensare che abbiamo passato alla funzione i parametri sbagliati, quindi inseriremo un breakpoint alla riga 8 e mentre il programma rimane bloccato aspettando il comando step per superare il breakpoint gli faremo stampare la variabile buf e il suo contenuto per verificarlo:

(gdb) list <-- Chiedo il listato del sorgente
1       #include
2       #include
3
4       int main()
5       {
6               char *buf;
7               long i;
8
9               strcpy(buf,"HelloWorld");
10
(gdb) b 8 <-- Inserisco un breakpoint alla riga 8
Breakpoint 1 at 0x1d8c: file segmentatio_fault.c, line 8.
(gdb) run <-- Avvio il programma
The program being debugged has been started already.
Start it from the beginning? (y or n) y <-- Chiedo di ricominciare da capo
Starting program: /Users/ferrara/temp/sfault 

Breakpoint 1, main () at segmentatio_fault.c:9
9               strcpy(buf,"HelloWorld"); <-- Si è fermato prima di eseguire la riga 9
(gdb) p buf <-- Stampo la variabile buf
$1 = 0x0
(gdb) p *buf <-- Stampo il contenuto di buf
Cannot access memory at address 0x0 <-- Questo è il notro errore
(gdb) bt <-- Stampo lo stack del programma alla riga 8
#0  main () at segmentatio_fault.c:9
(gdb) step  <-- Continuiamo l’esecuzione del programma

Program received signal EXC_BAD_ACCESS, Could not access memory.
0x90007680 in strcpy ()
(gdb) bt <-- Stampo lo stack dopo il blocco del programma
#0  0x90007680 in strcpy () <-- Il programma si è bloccato in questa punto
#1  0x00001d9c in main () at segmentatio_fault.c:9
(gdb) clear 8 <-- Cancello il breakpoint alla riga 8
Deleted breakpoint 1
(gdb) q <-- Esco da gdb perché ho tutte le informazioni che mi servono
The program is running.  Exit anyway? (y or n) y <-- Confermo
emac:~/temp ferrara$ <-- Prompt di shell

Il codice di questo programma era molto semplice, e il bug si poteva trovare anche solo leggendo il codice sorgente. Intanto abbiamo imparato l’utilizzo base dei seguenti comandi:

Programmi che richiedono parametri

Per analizzare dei programmi che richiedono parametri come questo:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include 
 
int main(int argc, char *argv[])
{
	int i,a;
	char *car;
	int ALLOCATO,SCRITTI;
 
	if (argc != 3)
		printf("usa: %s  \n",argv[0]), exit(1);
 
	ALLOCATO = atoi(argv[1]);
	SCRITTI = atoi(argv[2]);
 
	car = (char *) malloc(ALLOCATO*sizeof(char));
 
	for(i=0,a='a' ; i < SCRITTI ; i++,a++)
		car[i]=a;
 
	printf("%s\n",car);
 
	exit(0);
}

Basta chiamare gdb come abbiamo fatto finora e passare gli argomenti assieme al comando run:

(gdb) run 5 5
Starting program: /Users/ferrara/temp/serio 5 5
Reading symbols for shared libraries . done
abcde

Program exited normally.
(gdb)

Passando come secondo argomento un numero molto grande rispetto al primo si ha un vero e proprio segmentation fault:

(gdb) run 5 99999999
Starting program: /Users/ferrara/temp/serio 5 99999999

Program received signal EXC_BAD_ACCESS, Could not access memory.
0x00001d40 in main (argc=3, argv=0xbffffce8) at serio.c:18
18                      car[i]=a;
(gdb)

Come mai accade questo? Adesso avete gli strumenti necessari per procedere da soli… buon divertimento con gdb!

Conclusioni

Questo documento è da considerarsi una semplicissima introduzione, giusto quel che basta per cominciare ad usare il manuale di gdb senza perdersi tra le tantissime opzioni.
Per ulteriori informazioni digitare il comando “man gdb” dal prompt di shell oppure “help ” dal prompt di gdb.

Per ci si scoccia di usare un debugger a linea di comando può trovare delle front end per gdb come xxgdb.

Finite queste quattro chiacchiere, presenterò nel tutorial 2 files, un file conterrà tutte le funzioni, l’altro invece sarà un programmino di esempio che ne illustrerà l’uso. Cominciamo con il primo file, lo chiameremo split.h, qui ci vanno le nostre funzioni, #define vari, includes…

file split.h

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
 
#define KB 1024
 
// funzioni sulla memoria delle stringhe
 
int getAllocatedElements(char **array)
{ return _msize(array) / sizeof(char*); }
 
int freeArray(char **array, int prompt)
{
if(!array) return 0;
 
// altrimenti riazzero tutto gia messo
int dim=getAllocatedElements(array);
int i=0;
int bytesFree=dim*sizeof(char*);
 
if(prompt) printf("\n\n");
 
for(i; i<dim; i++)
{
       if(prompt) printf("Libero la stringa allocata: %s(%d bytes allocati)\n",array[i],_msize(array[i]));
 
       bytesFree+=_msize(array[i]);
       free(array[i]);
}
 
if(prompt) printf("%d Indirizzi da liberare(%d bytes)\n",dim,dim*sizeof(char*));
free(array); 
 
return bytesFree;
}
 
// Funzioni di stringhe
 
char* Reverse(char* str, char* ptrstr)
{
int l=strlen(str);
int i=0, j=l-1;
 
for(i,j; i<l, j>=0; i++,j--) ptrstr[i]=str[j];
ptrstr[i]='\0';
 
return &ptrstr[0];
}
 
char* Replace(char src, char newc, char* str)
{
int l=strlen(str);
int i=0;
 
for(i; i<l; i++)
    if(str[i]==src) str[i]=newc;
 
return &str[0];
}
 
char* ReplaceFirst(char src, char newc, char* str)
{
int l=strlen(str);
int i=0;
 
for(i; i<l; i++)
    if(str[i]==src){ str[i]=newc; break; }
 
return &str[0];
}
 
int Count(char c, char *str)
{
int n=0;
int i=0;
 
for(i; i< strlen(str); i++)
       if(str[i]==c) n++;
 
return n;
}
 
int CountStrings(char **array)
{
int dim=getAllocatedElements(array);
int i=0;
int n=0;
 
for(i ; i<dim; i++)
      if(strlen(array[i])>0) n++;
return n;
}
 
void print(char **array, unsigned int max)
{
int i=0;
 
for(i; i<max; i++)
       printf("%s\n",array[i]);
}
 
void printAll(char **array)
{ print(array, getAllocatedElements(array) ); }
 
// -----------------------------------------------------------------------------
 
// SPLIT 2.0
char** Split(char *str, char c, char **array)
{
if(!array) return NULL;
 
// altrimenti riazzero tutto gia messo
int dim=getAllocatedElements(array);
 
int memtoalloc=Count(c,str)-dim;
 
if(memtoalloc)
{
array=realloc(array, _msize(array) + ( (memtoalloc+1)*sizeof(char*) ) );
if(!array) return NULL;
}
 
int z=0;
for(z; z<dim; z++)
       free(array[z]);
 
       char buffer[KB];
       int i=0,j=0;
       int n=0; // conto tokens
 
       while(i < strlen(str) )
       {
               if(str[i]!=c)
               {
               buffer[j]=str[i];
               j++;
               } else {
               buffer[j]='\0';
 
               array[n]=calloc( strlen(buffer)+1, sizeof(char) ); // alloco un nuovo indirizzo per contenere la stringa stessa
               if(!array[n]) return NULL;
 
               strcpy(array[n],buffer);
               j=0;  
 
               n++; // incremento il n di tokens
               }
       i++;
       }
 
       if(strlen(buffer)>0)
       {
       buffer[j]='\0';
               array[n]=calloc( strlen(buffer)+1, sizeof(char) ); // alloco un nuovo indirizzo per contenere la stringa stessa
               if(!array[n]) return NULL;
 
               strcpy(array[n],buffer);
               j=0;
 
               n++; // incremento il n di tokens
       }
 
return array;
}

E’ ora di utilizzare le funzioni create, passiamo al main:

file main.c

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#include "strings.h"
// Usare split 2.0
 
int main(void)
{
int toks=0; // numero di pezzi
 
char **array=calloc(2,sizeof(char*) );
// allocazione di una memoria di base, successivamente verrà adattata
 
if(!array){ printf("Memoria insufficiente"); exit(0); }
// un computer degli anni 30 non potra allocare tanta memoria, se non esiste il puntatore termina subito
 
char *str1="Il mio cane e molto cattivo e bambino";
char *str2="uno due#tre quattro#cinque sei#sette otto#nove dieci";
// le stringhe di esempio
 
printf("Prima del primo split, gli indirizzi allocati occupano %d bytes",_msize(array));
printf("\n\nSplit(separatore: spazio) della stringa:\n'%s'\n\n",str1);
 
printf("Puntatore all'array: %p\n",array);
array=Split(str1,' ',array);
printf("Nuovo puntatore all'array: %p\n\n",array);
 
printf("Numero di stringhe estratte: %d\n\n",CountStrings(array));
printAll(array);
printf("\n\nDopo il primo split, gli indirizzi allocati occupano %d bytes",_msize(array));
 
// Un altro split, riutilizzando la memoria precedente, e rimodellandola dinamicamente
 
printf("\n\nSplit(separatore: #) della stringa:\n'%s'\n\n",str2);
 
printf("Puntatore attuale all'array: %p\n",array);
array=Split(str2,'#',array);
printf("Puntatore dopo l'ultima modifica: %p\n\n",array);
 
printf("Numero di stringhe estratte: %d\n\n",CountStrings(array));
printAll(array);
printf("\n\nDopo il secondo split, gli indirizzi allocati occupano %d bytes",_msize(array));
 
printf("\n\nMemoria liberata: %d bytes\n\n", freeArray(array,1));
/*
 necessaria, non usare free(liberera solo gli indirizzi),
 ricorda di non liberare mai la memoria 2 volte,
 liberala solo quando non ti serve piu
*/
 
system("pause"); // in modalità windows, dove lavoreremo noi, serve ad una pausa
return 1;
}

Il tutorial è finito, spero di aver fatto contento qualcuno, segnalatemi errori o suggerimenti, grazie per la lettura al prossimo tutorial!