Newsgroup: it.comp.lang.c
Titolo: si può fare?

Innanzitutto scusate la domanda da ignorante... spero possiate
aiutarmi... allora, il problema è questo: sto cercando di implementare
un piccolo algoritmo iterativo ed ad un certo punto dovrei fare una
roba del genere:
int *new_vecta;
int *new_vectb;
int *old_vecta = (int *)malloc(dim*sizeof(int));
int *old_vectb = (int *)malloc(dim*3*sizeof(int));
int old_dima = dim;
ind old_dimb = dim;
for(i=1; i<=N; i++) {
		new_dima = pow(3,i)*dim;
		new_dimb = pow(4,i)*dim;
		new_vecta = (int *)malloc(new_dima*sizeof(int));
		new_vectb = (int *)malloc(new_dimb*3*sizeof(int));
		//funzione che fa dei conti con array vecchi ed aggiorna i nuovi
		//richiede che siano passati gli array e le dimensioni
		old_vecta = new_vecta;
		old_vectb = new_vectb;
		old_dima = new_dima;
		old_dimb = new_dimb;
}
cioè ad ogni giro dovrei "sostituire" i vecchi vettori con dei vettori
più grandi che contengono dei refinements di ciò che sta nei vettori
vecchi, il problema è che al terzo giro in new_vectb ottengo dei
valori errati, nonostante la funzione che lavora sugli array sia
corretta... sono tipo dei valori sparati a caso molto elevati che
"sporcano" la prima parte del new_vectb (i primi 50 valori sono
rovinati, poi i rimanenti sono esatti)... ho il sospetto che sia colpa
di quelle copie selvagge di puntatori che faccio ad ogni ciclo senza
nemmeno pulire lo spazio "old" che rimane tagliato fuori cambiando il
puntatore... però non saprei come altro fare... volevo quindi sapere
se la procedura è corretta nonostante i mie dubbi oppure se potete
suggerirmi un altro modo per fare il lavoro...
Grazie mille per le eventuali risposte.
F.

 suggerirmi un altro modo per fare il lavoro...
Controlla che new non ritorni NULL.
E.

 Controlla che new non ritorni NULL.
volevo dire malloc, non new.
E.

 vecchi, 
Naturalmente bisognerebbe vedere il codice per capire cosa succede.
Oltre ad un problema di mancanza di memoria (come ti hanno già 
consigliato verifica che malloc() non restituisca NULL) puoi darsi che 
tu vada a scrivere oltre i limiti di uno dei blocchi allocati 
"invadendo" l'altro.
 > ho il sospetto che sia colpa
 > di quelle copie selvagge di puntatori che faccio ad ogni ciclo senza
 > nemmeno pulire lo spazio "old" che rimane tagliato fuori cambiando il
 > puntatore... però non saprei come altro fare...
A quanto ho capito non rilasci la memoria prima di riassegnare old_vecta 
e old_vectb. Se è cosi' basta mettere un paio di free() subito prima 
dell'assegnazione:
       free(old_vecta);
       free(old_vectb);
Anche cosi', comunque, la memoria ti finirà abbasta presto. Se ho fatto 
bene i conti, assumendo sizeof(int)=4 e dim =1, per N=5 ti servono piu o 
meno 16Kb, per N=10 ti servono 16Mb, per N=13 ti servono 4Gb. (Se dim 
non è 1 moltiplica per dim).
Anche ipotizzando che non ci siano problemi di frammentazione della 
memoria, potresti avere problemi con il limite massimo di memoria 
assegnabile ad un processo (che SO/architettura stai usando?).
Quindi, a meno che N non sia molto piccolo, ti consiglio di cercare una 
strategia alternativa all'allocazione in memoria di tutti i dati.
Tutto dipende dal tipo di calcolo che devi fare, ovviamente.
Remo.D


grazie per la risposta, ho modificato il codice per verificare se
malloc ritorna NULL ma non viene mai ritornato (quindi l'allocazione
pare che vada a buon fine), riporto un dump del vettore vectb ai vari
passi, nel caso possa servire per capire la situazione (i numeri <200
sono calcolati correttamente, gli altri sono la "sporcizia"
incriminata, come si può vedere l'errore si presenta a i=3 ossia al
secondo ciclo -- non al terzo come ho scritto erroneamente nel mio
primo post):
per i=1 --> 1 4 6 4 5 2 6 5 0 6 4 5 1 6 8 6 7 0 8 7 3 8 6 7 2 4 9 4 8
1 9 8 3 9 4 8 0 5 7 5 9 2 7 9 3 7 5 9
per i=2 --> 1 10 12 10 11 4 12 11 6 12 10 11 4 13 15 13 14 5 15 14 2
15 13 14 6 16 18 16 17 5 18 17 0 18 16 17 6 11 16 11 13 4 16 13 5 16
11 13 1 12 20 12 19 6 20 19 8 20 12 19 6 21 18 21 22 7 18 22 0 18 21
22 8 23 25 23 24 7 25 24 3 25 23 24 8 19 23 19 21 6 23 21 7 23 19 21 2
15 27 15 26 4 27 26 9 27 15 26 4 28 10 28 20 8 10 20 1 10 28 20 9 29
30 29 25 8 30 25 3 30 29 25 9 26 29 26 28 4 29 28 8 29 26 28 0 17 22
17 31 5 22 31 7 22 17 31 5 32 14 32 27 9 14 27 2 14 32 27 7 33 24 33
30 9 24 30 3 24 33 30 7 31 33 31 32 5 33 32 9 33 31 32
per i=3 --> 1067314053 -1109544403 -1096810496 1057446953 0
-1094713344 1052015329 1037939245 -1096810496 1057446953 -1109544403
1060110336 1043626721 -1101155795 1056964608 1043626721 -1096399454
1050673152 1043626721 -1109544403 1058013184 1052015329 -1109544403
1054867456 1057446953 -1092767187 1040187392 1043626721 -1089826980
-1115684864 1043626721 -1089826980 -1103101952 1052015329 -1092767187
-1107296256 1057446953 -1088010846 -1098907648 1043626721 -1109544403
1050673152 1060403937 -1109544403 1044381696 1063360922 -1101155795 0
1063360922 -1096399454 -1115684864 1060403937 -1109544403 1031798784
1065835561 -1101155795 1048576000 1057446953 -1096399454 1044381696
1052015329 -1096399454 1031798784 1057446953 47 14 48 47 5 48 46 47 15
49 51 49 50 14 51 50 2 51 49 50 15 44 49 44 46 13 49 46 14 49 44 46 6
52 54 52 53 16 54 53 18 54 52 53 16 55 57 55 56 17 57 56 5 57 55 56 18
58 60 58 59 17 60 59 0 60 58 59 18 53 58 53 55 16 58 55 17 58 53 55 6
41 52 41 61 11 52 61 16 52 41 61 11 62 38 62 43 13 38 43 4 38 62 43 16
63 57 63 48 13 57 48 5 57 63 48 16 61 63 61 62 11 63 62 13 63 61 62 1
36 65 36 64 12 65 64 20 65 36 64 12 66 42 66 67 19 42 67 6 42 66 67 20
68 70 68 69 19 70 69 8 70 68 69 20 64 68 64 66 12 68 66 19 68 64 66 6
71 54 71 72 21 54 72 18 54 71 72 21 73 75 73 74 22 75 74 7 75 73 74 18
76 60 76 77 22 60 77 0 60 76 77 18 72 76 72 73 21 76 73 22 76 72 73 8
78 80 78 79 23 80 79 25 80 78 79 23 81 83 81 82 24 83 82 7 83 81 82 25
84 86 84 85 24 86 85 3 86 84 85 25 79 84 79 81 23 84 81 24 84 79 81 8
69 78 69 87 19 78 87 23 78 69 87 19 88 67 88 71 21 67 71 6 67 88 71 23
89 83 89 75 21 83 75 7 83 89 75 23 87 89 87 88 19 89 88 21 89 87 88 2
51 91 51 90 15 91 90 27 91 51 90 15 92 45 92 93 26 45 93 4 45 92 93 27
94 96 94 95 26 96 95 9 96 94 95 27 90 94 90 92 15 94 92 26 94 90 92 4
97 39 97 98 28 39 98 10 39 97 98 28 99 100 99 70 20 100 70 8 100 99 70
10 101 34 101 65 20 34 65 1 34 101 65 10 98 101 98 99 28 101 99 20 101
98 99 9 102 104 102 103 29 104 103 30 104 102 103 29 105 106 105 80 25
106 80 8 106 105 80 30 107 108 107 86 25 108 86 3 108 107 86 30 103
107 103 105 29 107 105 25 107 103 105 9 95 102 95 109 26 102 109 29
102 95 109 26 110 93 110 97 28 93 97 4 93 110 97 29 111 106 111 100 28
106 100 8 106 111 100 29 109 111 109 110 26 111 110 28 111 109 110 0
59 77 59 112 17 77 112 22 77 59 112 17 113 56 113 114 31 56 114 5 56
113 114 22 115 74 115 116 31 74 116 7 74 115 116 22 112 115 112 113 17
115 113 31 115 112 113 5 117 47 117 118 32 47 118 14 47 117 118 32 119
120 119 96 27 120 96 9 120 119 96 14 121 50 121 91 27 50 91 2 50 121
91 14 118 121 118 119 32 121 119 27 121 118 119 7 122 82 122 123 33 82
123 24 82 122 123 33 124 125 124 104 30 125 104 9 125 124 104 24 126
85 126 108 30 85 108 3 85 126 108 24 123 126 123 124 33 126 124 30 126
123 124 7 116 122 116 127 31 122 127 33 122 116 127 31 128 114 128 117
32 114 117 5 114 128 117 33 129 125 129 120 32 125 120 9 125 129 120
33 127 129 127 128 31 129 128 32 129 127 128

grazie Remo D. ho visto ora il tuo post... è vero che la quantità di
dati cresce esponenzialmente, in particolare il vectb cresce come 4^N
però è giusto così, fa parte dell'algoritmo... non vorrei però tenere
in ram tutti i vettori contemporaneamente, vale a dire il vettore
lungo 4^1, quello lungo 4^2... ma solo gli ultimi due (che mi servono
per i calcoli), cioè quello 4^(N-1) e 4^N... ho provato come da te
suggerito ad inserire le free(v) subito dopo la chiamata a funzione,
ma ottengo un segmentation fault, appena prima del return del main...
comincio a disperare... ah la mia architetture è un Centrino 2 Due con
2 GB ram, uso Debian Linux come SO.... grazie ancora...


preciso che il segmentation fault avviene per i=3, per i=1 e i=2 tutto
è ok.


preciso anche che N "a regime" sarà tipicamente = 4, eccezionalmente
5. Mai di più.

 5. Mai di più.
Quanto vale dim?
Comunque se i valori sono bassi non puo' essere un problema di memoria 
disponibile (finchè sei parecchio sotto i 2Gb puoi stare "abbastanza" 
tranquillo).
Resta la prima ipotesi: vai a scrivere oltre il limite della memoria 
allocata da malloc().
Un buon debbuger potrebbe aiutarti a capire cosa succede (se trovi gdb 
troppo ostico, mi ricordo di essermi trovato bene con Insight come gui 
di gdb).
Altrimenti usa il vecchio metodo delle printf() per tracciare l'esecuzione.
Senza vedere il codice non ci sono molti altri consigli da dare.
Buona caccia.
Remo.D


ok, proverò con il KDbg di kde... nel frattempo ho fatto una stampa di
alcuni parametri ed ho un dubbio:
I:1   old:804b040, new:804b0f8, diff_mem:46,  diff_dim:144
I:2   old:804b0f8, new:804b360, diff_mem:154,  diff_dim:576
I:3   old:804b360, new:804bb68, diff_mem:514,  diff_dim:2304
dove:
I indica il numero di iterazione (o meglio il valore di i nel ciclo
for, i parte da 1)
old e new indicano gli indirizzi in ram rispettivamente di old_vectb e
new_vectb a quella iterazione
diff_mem è la differenza tra gli indirizzi di old_vectb e new_vectb --
che dovrebbe essere equivalente almeno alla differenza della loro
dimensione in byte per non avere sovrapposizioni, giusto?... E'
proprio su questo fatto che gradirei avere un tuo commento: da quello
che vedo io direi che in I=3 ho il vettore old che va sopra quello new
perché la differenza di dimensione tra i due è di 576 ma la distanza
in ram è di solo 514, quindi sovrappongono di 62... è corretto questo
ragionamento? Grazie ancora.
F.

 dimensione in byte per non avere sovrapposizioni, giusto?... 
Semmai sarà maggiore della dimensione del vecchio vettore.
E.


ehm scusami, non ho capito... :P

 ehm scusami, non ho capito... :P
Sei fai
	char *p, *q;
	p = malloc(size_p);
         q = malloc(size_q);
puoi assumere che valga
	(q >= p+size_p) || (p >= q+size_q)
E.

>> 5. Mai di più.
Visto che puoi determinare la massima occupazione di memoria prima del 
ciclo, perche' non fai una sola malloc e poi ad ogni iterazione sistemi 
i puntatori in modo da avere abbastanza spazio per ciascun vettore?
Non ti risolve il problema della sovrascrittura delle aree di memoria 
(devi ancora trovare dov'e' il problema) ma almeno ti toglie di torno la 
complicazione delle malloc/free ad ogni ciclo.
Per darti un idea, parti con:
+----------------+
| Vecchi vettori |
+----------------+
| spazio         |
| inutilizzato   |
|                |
+----------------+
| Nuovi vettori  |
+----------------+
ed il ciclo successivo hai:
+----------------+
| Nuovi vettori  |
|                |
+----------------+
| spazio         |
| inutilizzato   |
+----------------+
| Vecchi vettori |
+----------------+
Remo.D

 ha scritto nel messaggio
news:AUFkj.57164$8j3....@tornado.fastwebnet.it...

Questa cosa non si può assumere in generale.
Infatti hai comportamento indefinito.
Gli oggetti in questione sono totalmente scorrelati.
Sui alcuni sistemi embedded è possibile fare una
cosa del genere in quanto si ha un indirizzamento "lineare"
dove tutti i confronti sono validi.
Ma in generale ciò non è possibile.
--
Giorgio Silvestri
DSP/Embedded/Real Time OS   Software Engineer

 Gli oggetti in questione sono totalmente scorrelati.
Sto assumendo che la "malloc" restituisca puntatori a intervalli di 
memoria che non si sovrappongono... se non posso assumere questo, a cosa 
può servire la "malloc"?
E.

?manu* ha scritto:

Credo che Giorgio si riferisse all'assunzione che i puntatori 
appartengano ad uno stesso spazio di indirizzi e possano essere 
confrontati con <=. In genere non è detto (pensa a modelli di memoria 
con segmenti).
Se pero' si puo' rinunciare alla portabilità (e questo puo' saperlo solo 
l'OP) dovrebbe funzionare con GCC sotto Linux e probabilmente anche 
sotto Windows (bisognerebbe approfondire).
Remo.D.

 con segmenti).
Infatti è quello che volevo dire.
Le malloc servono ad allocare spazio per un nuovi oggetti
ma i puntatori ritornati non possono essere confrontati tra loro con >= (o
<=).


 <=).
Ok, ho capito il punto. Comunque Fab sta facendo del debugging, se gli è 
utile il confronto lo può fare, visto che sta cercando di capire come 
vengono allocati gli oggetti nello heap. Anche se non è garantito in 
generale, immagino che nel suo caso quell'operazione abbia senso.
E.

Grazie dei vari suggerimenti, purtroppo non ne sto venendo a capo...
sperando che non mi malediate vi posto il codice su cui sto lavorando
(la prima parte dell'algoritmo - che non funziona) così magari il
vostro occhio allenato riesce a scovare il baco... praticamente in
questa fase il programma prende un array di vertici e un array di
facce (come nei file obj, per chi usa blender o simili) ed ha il
compito di splittare tutti i lati della mesh per generare una mesh più
rifinita, ossia per ogni triangolo della mesh genera 4 triangoli
unendo i punti mediani calcolati per ogni lato, la seconda parte
dell'algoritmo poi adatterà in un certo modo la posizione dei
vertici... Questo è il codice (solo lo split):
typedef struct {
	float x,y,z;
} vertice;
typedef enum { false, true } bool;
//segue la definizione delle varie funzioni...
#include <stdlib.h>
#include <math.h>
#include "algo.h"
int main() {
	//dati dal file obj
	float obj_verts[]={0,1,0, 0.866,-0.5,0, -0.866,-0.5,0, 0,0,1.41};
	int obj_faces[]={2,3,1, 2,1,4, 3,2,4, 1,3,4};
	int numverts = 4, numfaces = 4;
	int i,j;
	vertice *verts0 = (vertice *)malloc(numverts*sizeof(vertice));
	int *faces0 = (int *)malloc(numfaces*3*sizeof(int));
	//LOADING strutture - TODO: direttamente da file obj
	for(i=0, j=0; i<numverts; i++, j+=3) {
		verts0[i].x = obj_verts[j];
		verts0[i].y = obj_verts[j+1];
		verts0[i].z = obj_verts[j+2];
	}
	for(i=0; i<numfaces*3; i++) {
		faces0[i] = obj_faces[i]-1;
	}
	//allocazione "manuale" per 3 cicli dell'algoritmo
	vertice *verts1 = (vertice *)malloc(numverts*3*sizeof(vertice));
	int *faces1 = (int *)malloc(numfaces*4*3*sizeof(int));
	vertice *verts2 = (vertice *)malloc(numverts*3*3*sizeof(vertice));
	int *faces2 = (int *)malloc(numfaces*4*4*3*sizeof(int));
	vertice *verts3 = (vertice *)malloc(numverts*3*3*3*sizeof(vertice));
	int *faces3 = (int *)malloc(numfaces*4*4*4*3*sizeof(int));
	split(verts0, faces0, verts1, faces1, numverts, numfaces);
	free(verts0); free(faces0);
	for(j=0; j<numfaces*3*4; j++) printf("%d ",faces1[j]);
	printf("\n\n");
	split(verts1, faces1, verts2, faces2, numverts*3, numfaces*4);
	free(verts1); free(faces1);
	for(j=0; j<numfaces*3*4*4; j++) printf("%d ",faces2[j]);
	printf("\n\n");
	split(verts2, faces2, verts3, faces3, numverts*3*3, numfaces*4*4);
	free(verts2);
	//free(faces2);
	for(j=0; j<numfaces*3*4*4*4; j++) printf("%d ",faces3[j]);
	printf("\n\n");
	return 0;
}
void split(vertice *verts, int *faces, vertice *nverts, int *nfaces,
int numverts, int numfaces) {
	int i,j,k,indexmab,indexmbc,indexmca,last;
	vertice a,b,c, mab,mbc,mca;
	bool thereismab, thereismbc, thereismca;
	for(i=0; i<numverts; i++) nverts[i]=verts[i]; //copio i vecchi
vertici nel nuovo array
	last = numverts;
	for(i=0,k=0; i<numfaces*3; i+=3,k+=12) {
		a = verts[faces[i]];
		b = verts[faces[i+1]];
		c = verts[faces[i+2]];
		mab = mediano(a,b);
		mbc = mediano(b,c);
		mca = mediano(c,a);
		thereismab=false; thereismbc=false; thereismca=false;
		for(j=numverts; j<=last; j++) {
			//se lo hai trovato esci, altrimenti continua a cercare
			if(vequal(nverts[j],mab) && thereismab==false) { thereismab=true;
indexmab=j; /*printf("hit\n");*/ }
			if(vequal(nverts[j],mbc) && thereismbc==false) { thereismbc=true;
indexmbc=j; /*printf("hit\n");*/ }
			if(vequal(nverts[j],mca) && thereismca==false) { thereismca=true;
indexmca=j; /*printf("hit\n");*/ }
		}
		//se sei arrivato a last e non l'hai trovato, lo inserisci
		if(thereismab==false) { nverts[last]=mab; indexmab=last; last++; }
		if(thereismbc==false) { nverts[last]=mbc; indexmbc=last; last++; }
		if(thereismca==false) { nverts[last]=mca; indexmca=last; last++; }
		//riarrangio i vertici e inserisco in nfaces
		nfaces[k] = faces[i];
		nfaces[k+1] = indexmab;
		nfaces[k+2] = indexmca;
		nfaces[k+3] = indexmab;
		nfaces[k+4] = indexmbc;
		nfaces[k+5] = faces[i+1];
		nfaces[k+6] = indexmca;
		nfaces[k+7] = indexmbc;
		nfaces[k+8] = faces[i+2];
		nfaces[k+9] = indexmca;
		nfaces[k+10] = indexmab;
		nfaces[k+11] = indexmbc;
		//printf("ind: %d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d
\n",nfaces[k],nfaces[k+1],nfaces[k+2],nfaces[k+3],nfaces[k+4],nfaces[k
+5],nfaces[k+6],nfaces[k+7],nfaces[k+8],nfaces[k+9],nfaces[k
+10],nfaces[k+11]);
		//NOTA BENE: questa stampa è OK
	}
	//qui impazzisce e sovrascrive le prime 60 circa posizioni dell'array
}
int vequal(vertice a, vertice b) {
	if((a.x==b.x) && (a.y==b.y) && (a.z==b.z)) return 1;
	return 0;
}
vertice mediano(vertice v1, vertice v2) {
	vertice v;
	v.x = (v1.x + v2.x)/2;
	v.y = (v1.y + v2.y)/2;
	v.z = (v1.z + v2.z)/2;
	return v;
}

notare che la stampa di nfaces in fondo al ciclo for nello split
funziona perfettamente! Se eseguo la stampa dello stesso vettore DOPO
la parentesi graffa, ossia fuori dal ciclo ho i primi valori errati!
pazzesco....


Qui c'è qualcosa di grave.. se faccio questa modifica:
...
int *faces2 = (int *)malloc(numfaces*4*4*3*sizeof(int));
vertice *verts3 = (vertice *)malloc(numverts*3*3*3*sizeof(vertice));
int *faces3 = (int *)malloc(numfaces*4*4*4*3*sizeof(int)); //INUTILE
int *faces3_bkup = (int *)malloc(numfaces*4*4*4*3*sizeof(int)); //
AGGIUNGO QUESTA....
e poi chiamo la funzione con il nuovo vettore:
split(verts2, faces2, verts3, faces3_bkup, numverts*3*3,
numfaces*4*4);
tutto funziona bene.... ci sono dei problemi con le allocazioni... è
come se malloc mi allocasse due spazi sovrapposti... mah... continuo
con le esplorazioni... :(

ok, scambiando l'ordine delle allocazioni di verts3 e faces3 il codice
funziona... ma questa è una non-soluzione...

Io metterei dei controlli per essere sicuro che non stai scrivendo fuori 
dai vettori... In particolare in
		for(j=numverts; j<=last; j++) {
sei sicuro che non ci voglia la disuguaglianza stretta?
E.


ottima osservazione, ora faccio delle verifiche... cmq con quello
scambio di allocazioni sembra andare, il risultato dopo 3 suddivisioni
è questo:
http://www.fotothing.com/photos/241/241e566d95d9603c08cda8ef14e0a050.jpg?ts=1200850865
Grazie!
F.

se dovesse interessare, questo codice funziona, lo ho provato fino ad
N=6 e non ci sono problemi. Però, se aggiungo dopo le assegnazioni
old=new le istruzioni free(newv) e free(newf) ottengo segmentation
fault, se inverto l'ordine e metto free(newf); free(newv); all'uscita
dal ciclo il vettore oldv contiene tutti valori 0 (e la seconda fase
dell'algoritmo crasha), infine c'è stato un caso in cui mi è uscito
l'errore che riporto sotto... forse avevo duplicato una free ma non
ricordo esattamente... perché non posso fare le free? c'è qualcosa che
non va con il mio sistema secondo voi?
int N = 4;
vertice *newv;
int *newf;
int verts_size;
verts_size = numverts;
for(i=1; i<=N; i++) {
	newf = (int *)malloc(numfaces*3*pow(4,i)*sizeof(int));
	newv = (vertice *)malloc(verts_size*pow(3,i)*sizeof(vertice));
	split(oldv, oldf, newv, newf, verts_size, numfaces*pow(4,(i-1)),
&verts_size);
	oldv=newv;
	oldf=newf;
	//free(newf);
	//free(newv);
}
*** glibc detected *** ./a.out: double free or corruption (top):
0x0804a140 ***
======= Backtrace: =========
/lib/i686/cmov/libc.so.6[0xb7e62735]
/lib/i686/cmov/libc.so.6(cfree+0x90)[0xb7e661a0]
./a.out[0x80487e3]
/lib/i686/cmov/libc.so.6(__libc_start_main+0xe0)[0xb7e0d450]
./a.out[0x8048401]
======= Memory map: ========
08048000-08049000 r-xp 00000000 08:04 7651334    /home/fabrizio/
Documents/Uni/work/new/a.out
08049000-0804a000 rw-p 00000000 08:04 7651334    /home/fabrizio/
Documents/Uni/work/new/a.out
0804a000-0806b000 rw-p 0804a000 00:00 0          [heap]
b7c00000-b7c21000 rw-p b7c00000 00:00 0
b7c21000-b7d00000 ---p b7c21000 00:00 0
b7deb000-b7df5000 r-xp 00000000 08:04 9437228    /lib/libgcc_s.so.1
b7df5000-b7df6000 rw-p 00009000 08:04 9437228    /lib/libgcc_s.so.1
b7df6000-b7df7000 rw-p b7df6000 00:00 0
b7df7000-b7f3e000 r-xp 00000000 08:04 9437190    /lib/i686/cmov/
libc-2.7.so
b7f3e000-b7f3f000 r--p 00147000 08:04 9437190    /lib/i686/cmov/
libc-2.7.so
b7f3f000-b7f41000 rw-p 00148000 08:04 9437190    /lib/i686/cmov/
libc-2.7.so
b7f41000-b7f44000 rw-p b7f41000 00:00 0
b7f44000-b7f67000 r-xp 00000000 08:04 9437194    /lib/i686/cmov/
libm-2.7.so
b7f67000-b7f69000 rw-p 00023000 08:04 9437194    /lib/i686/cmov/
libm-2.7.so
b7f78000-b7f7a000 rw-p b7f78000 00:00 0
b7f7a000-b7f96000 r-xp 00000000 08:04 9437246    /lib/
ld-2.7.so
b7f96000-b7f98000 rw-p 0001b000 08:04 9437246    /lib/
ld-2.7.so
bf9fb000-bfa10000 rw-p bf9fb000 00:00 0          [stack]
ffffe000-fffff000 r-xp 00000000 00:00 0          [vdso]
Abortito

Il risultato finale (4 iterazioni):
http://www.fotothing.com/photos/0ca/0ca19c08812fa67b3336515111175f98.jpg?ts=1200908696
carino!! YO!
Ciao e grazie.