Non so se questo tipo di problema può essere catalogato come memory leak, ad ogni modo gli assomiglia molto: una mia funzione alloca con calloc un vettore di puntatori (a struct). Faccio quello che devo fare, alla fine della funzione libero tutto con una free.

codice:
        DATA * mat[MAX];
	
	if (cond) {

	
		// ...


	} else {


		mat[0] = (DATA *)calloc(1,sizeof(DATA));
		mat[0]->wp = src;
		
		for (j=1,i=next; i<n; i++,j++)
		{
			mat[j] = (DATA*) calloc(1,sizeof(DATA));
			mat[j]->wp = w[i];
		}

		n_mat = n;
		
		if ( F (n_mat,mat) ) {
			_err(ERR_F);
		}
		
		for (i=0; i<n_mat; i++)
		{
			
			if (!i)  continue;
				
			cons += mat[i]->cons;
					
		
		}

		*cdst = cons ;
		*cwp = mat[1]->cons ;

		for (j=0,i=next; i<n; i++,j++) free(mat[j]);
		

	}
Praticamente (lo vedo anche da task manager) la memoria che viene allocata da questa funzione non viene rilasciata nella stessa quantità con cui è allocata; ovvero vedo un aumento costante di memoria.

Devo usare l'allocazione dinamica perchè la funzione F vuole un array di puntatori..altrimenti dichiarerei un vettore statico e tanti cari saluti.

Ho fatto varie ricerche e la questione sembra essere imputabile al fatto che il sistema operativo (WIN32 in questo caso) rilascia la memoria per utilizzi futuri del programma che l'ha allocata, e non la rende di nuovo disponibile a se stesso, con lo scopo di ottimizzare le operazioni di allocazione/deallocazione. Bene.

Il problema è che la mia funzione viene invocata continuamente, ogni due secondi, da un applicazione esterna. Finchè l'utente non si stanca e stacca tutto, potenzialmente per un tempo pari a infinito. Dato che le macchine non hanno risorse infinite ( nel nostro caso, anzi, sono piuttosto limitate ), prima o poi il sistema si inchioda perchè non ha piu memoria disponibile.

Ora, supponendo che il codice che ho scritto non contenga errori grossolani, cosa mi dovrei inventare per stabilizzare la memoria richiesta?

Grazie dell'attenzione