La idea es depurar la asignacion de momeria.

Tengo un programa algo grande que necestito depurar. El programa usa memoria dinamica todo el tiempo y en general el programa funciona bien.

Sin embargo segun mis calculos el programa esa usando mas memoria de la que necesita. Algunos megas de mas 

Reemplace las llamadas a free, malloc y calloc por unas funciones para ir depurando cada que se reserva o libera memoria.

¿Alguno de ustedes ha hecho algo parecido?

¿Alguna sugerencia algun cambio?

Tengo el siguiente codigo:

 
char **punteros;
size_t *contador_size;
size_t offset_contador = 0;
size_t contador_memoria = 0;
 
void _free_( char *ptr)	{
	remove_contador(ptr);
	free(ptr);
}
 
char *_calloc_(size_t nmemb, size_t size)	{
	char *ptr;
	ptr = calloc(nmemb,size);
	add_contador(ptr,nmemb*size);
	return ptr;
}
void add_contador(char *ptr,size_t size)	{
	printf("add_contador: %u [0x%x] %u + %u bytes\n",offset_contador,ptr,contador_memoria,size);
	punteros = realloc(punteros,(offset_contador+1)*sizeof(char*));
	contador_size = realloc(contador_size,(offset_contador+1)*sizeof(size_t));
	punteros[offset_contador] = ptr;
	contador_size[offset_contador] = size;
	contador_memoria+=size;
	offset_contador++;
}
 
void remove_contador(char *ptr)	{
	size_t i = 0;
	while(punteros[i] != ptr && i < offset_contador)	{
		i++;
	}
	printf("remove_contador: %u [0x%x]\n",i,ptr);
	contador_memoria-=contador_size[i];
	while(i < offset_contador-1)	{
			punteros[i] = punteros[i+1];
			contador_size[i] = contador_size[i+1];
		i++;
	}
	punteros[i] = NULL;
	contador_size[i] = 0;
	offset_contador--;
}

Al final solo tenemos que validar la variable contador_memoria para saber cuantos bytes quedan y offset_contador para saber cuantos apuntadore quedan.

Saludos