Newsgroup: it.comp.lang.c
Titolo: memory leak

memory leak
Salve, sono di nuovo qui a chiedere il vostro prezioso aiuto... come
dice il proverbio... prima o poi tutti i nodi vengono al pettine...  E
così è capitato...
Vi espongo il problema: si tratta di un algoritmo iterativo di
refinement di mesh. E' costituito essenzialmente da due funzioni
chiamate "split" ed "update" che richiedono due vettori e che, a
partire
da questi, calcolano due vettori più estesi (update ne calcola uno
solo in realtà), una roba tipo:
Xk+1, Yk+1 = qualcosa(Xk,Yk) dove dimensione(Xk+1) > dimensione(Xk) e
lo stesso vale per
Yk+1. Ora, l'algoritmo funziona bene, cioè fa quello che deve fare
però, come si può vedere
dall'estratto che ho riportato sotto genera dei memory leak tremendi,
in particolare, data una mesh
con circa 50000 vertici (dopo 3 iterazioni) si ha:
==8462== LEAK SUMMARY:
==8462==    definitely lost: 2,183,488 bytes in 60,715 blocks.
==8462==      possibly lost: 0 bytes in 0 blocks.
==8462==    still reachable: 0 bytes in 0 blocks.
==8462==         suppressed: 0 bytes in 0 blocks.
il problema è che ad ogni iterazione non riesco a fare le free() sui
vettori del ciclo precedente, ho provato ad inserirle dopo
l'assegnazione "oldf=newf", eliminando newf, newv ed updv (che ora
sono diventati oldf ed oldv) ma facendo questo ottengo un Segmentation
Fault... penso sia perchè la free tenta di pulire l'area di newv,
newf, updv che in realtà non va pulita in quanto è utilizzata come
oldv ed oldf... interpreto bene? Ma allora non c'è modo di eliminare i
memory leak? Forse sbaglio la posizione delle free?
Vi ringrazio anticipatamente.
F.
Riporto l'estratto di codice incriminato:
vertice *oldv = (vertice *)malloc(numverts*sizeof(vertice));
int *oldf = (int *)malloc(numfaces*3*sizeof(int));
//caricamento strutture - TODO direttamente da file obj
for(i=0, j=0; i<numverts; i++, j+=3) {
	oldv[i].x = obj_verts[j];
	oldv[i].y = obj_verts[j+1];
	oldv[i].z = obj_verts[j+2];
}
for(i=0; i<numfaces*3; i++) {
	oldf[i] = obj_faces[i]-1; //faces indicizza direttamente verts
}
int N = 3;
vertice *newv, *updv;
int *newf;
int verts_size;
verts_size = numverts;
for(i=1; i<=N; i++) {
	if((newv = (vertice
*)malloc(numfaces*3*pow(4,i)*sizeof(vertice)))==NULL) { printf("Mem
allocation error\n"); exit(1); }
	if((newf = (int *)malloc(numfaces*3*pow(4,i)*sizeof(int)))==NULL)
{ printf("Mem allocation error\n"); exit(1); }
	if((updv = (vertice
*)malloc(numfaces*3*pow(4,i)*sizeof(vertice)))==NULL) { printf("Mem
allocation error\n"); exit(1); }
	split(oldv, oldf, newv, newf, verts_size, numfaces*pow(4,(i-1)),
&verts_size);
	update(newv, newf, verts_size, numfaces*3*pow(4,i), updv);
	oldv=updv;
	oldf=newf;
	//se qui inserisco: free(newv); free(updv); free(newf); ottengo segm.
fault
	//credo sia perché le aree di updv,newf sono ora puntate da oldv ed
oldf e quindi
	//se vengono eliminate i puntatori non hanno più nulla a cui
puntare...
	//ma allora come elimino i memory leak?
}
stampa(oldv,oldf,numfaces*3*pow(4,N));
return 0;

 stampa(oldv,oldf,numfaces*3*pow(4,N));
Perchè stampi i vettori vecchi? Se hai seguito il mio consiglio questa 
riga va tolta.
E.

 E.

==28807== All heap blocks were freed -- no leaks are possible.
Olè!

 Olč!
magari dicessi cosa tu abbia variato... :D

 magari dicessi cosa tu abbia variato... :D
ho fatto la cosa consigliata da ?manu* poi ho messo le due free in
uscita (vedi mio post precedente) poi mi sono accorto che in una
funzione in cui usavo una lista linkata dimenticavo di liberarla,
quindi ho inserito un ciclo con le free sugli elementi della lista.
That's all.
Ciao.


che programma e' che usi per vedere i memory leak?
Ciao Jack

 Ciao Jack
Il programma si chiama valgrind e fa un sacco di cose, compresa
l'analisi dei memory leak... è geniale ed utilissimo imho...
se hai Debian o derivate ti basta fare apt-get install valgrind, per
gli altri sistemi vedi il sito: 
http://valgrind.org/
Ciao.


ok grazie.
Ciao Jack