Simple implémentation C pour suivre la mémoire malloc / gratuit?

Vous pourrait allouer quelques octets supplémentaires dans votre enveloppe et de mettre un id (si vous voulez être en mesure de couple malloc() et free()) ou tout simplement de la taille. Juste malloc() que beaucoup plus de mémoire, de stocker des informations au début de votre bloc de mémoire et déplacez le pointeur de vous renvoyer à ce nombre d'octets à transférer.

Cela peut, d'ailleurs, aussi être facilement utilisé pour la clôture des pointeurs/empreintes digitales, et un tel.

Vous pouvez toujours utiliser valgrind au lieu de rouler votre propre mise en œuvre. Si vous n'avez pas de soins sur la quantité de mémoire que vous allouez vous pouvez utiliser un moyen encore plus simple de mise en œuvre: (je l'ai fait très rapidement, il pourrait donc y avoir des erreurs et je me rends compte que c'est pas le plus efficace de mise en œuvre. Le pAllocedStorage devrait être donnée d'une taille initiale et d'augmenter par un facteur de redimensionnement etc. mais vous obtenez l'idée.)

EDIT: j'ai manqué que c'était pour les BRAS, à ma connaissance, valgrind est pas disponible sur le BRAS de façon à ce que pourrait ne pas être une option.

static size_t indexAllocedStorage = 0;
static size_t *pAllocedStorage = NULL;
static unsigned int free_calls = 0; 
static unsigned long long int total_mem_alloced = 0; 
void * 
my_malloc(size_t size){
size_t *temp;
void *p = malloc(size);
if(p == NULL){
fprintf(stderr,"my_malloc malloc failed, %s", strerror(errno));
exit(EXIT_FAILURE);
}
total_mem_alloced += size;
temp = (size_t *)realloc(pAllocedStorage, (indexAllocedStorage+1) * sizeof(size_t));
if(temp == NULL){
fprintf(stderr,"my_malloc realloc failed, %s", strerror(errno));
exit(EXIT_FAILURE);
}
pAllocedStorage = temp; 
pAllocedStorage[indexAllocedStorage++] = (size_t)p;
return p;
}
void 
my_free(void *p){
size_t i;
int found = 0;
for(i = 0; i < indexAllocedStorage; i++){
if(pAllocedStorage[i] == (size_t)p){
pAllocedStorage[i] = (size_t)NULL;
found = 1;
break;
}
}
if(!found){
printf("Free Called on unknown\n");
}
free_calls++;
free(p);
}
void 
free_check(void) {
size_t i;
printf("checking freed memeory\n");
for(i = 0; i < indexAllocedStorage; i++){   
if(pAllocedStorage[i] != (size_t)NULL){
printf( "Memory leak %X\n", (unsigned int)pAllocedStorage[i]);
free((void *)pAllocedStorage[i]);
}
}
free(pAllocedStorage);
pAllocedStorage = NULL;
}

Votre programme peut également besoin d'intercepter le realloc(), calloc(), getcwd() (comme il peut allouer de la mémoire lorsque la mémoire tampon est NUL dans certaines implémentations) et peut-être strdup() ou une fonction similaire, si elle est prise en charge par votre compilateur

J'ai essayé quelques-uns des mêmes techniques mentionnées sur cette page et liquidation ici à partir d'une recherche sur google. Je sais que cette question est ancienne, mais je voulais ajouter pour l'enregistrement...

1) est-ce que votre système d'exploitation fournissent pas les outils pour voir combien de segment de mémoire est utilisée dans un processus en cours d'exécution? Je vois que vous parlez de BRAS, de sorte que ce pourrait bien être le cas. Dans la plus complète de Systèmes d'exploitation, c'est juste une question de l'utilisation d'un cmd-outil en ligne pour voir la taille du tas.

2) Si elle est disponible dans votre libc, sbrk(0) sur la plupart des plateformes de vous raconter la fin de l'adresse de votre segment de données. Si vous l'avez, tout ce que vous devez faire est de copier l'adresse au début de votre programme (par exemple, startBrk=sbrk(0)), alors, à tout moment, à votre taille allouée est sbrk(0) - startBrk.

3) Si elle est partagée, les objets peuvent être utilisés, vous êtes dynamiquement des liens vers votre libc, et vos OS runtime chargeur a quelque chose comme une variable d'environnement LD_PRELOAD, vous trouverez peut-être plus utile de construire votre propre objet partagé qui définit le réel de la libc fonctions avec les mêmes symboles (malloc(), pas MemAlloc()), alors le chargeur charge votre lib premier et "interposer" les fonctions de la libc. Vous pouvez en outre obtenir l'adresse de l'effectif des fonctions de la libc avec dlsym() et le RTLD_NEXT drapeau de sorte que vous pouvez faire ce que vous faites ci-dessus, sans avoir à recompiler tout votre code pour utiliser votre malloc/free wrappers. Il est alors tout à l'exécution de la décision lorsque vous démarrez votre programme (ou tout autre programme qui correspond à la description dans la première phrase) lorsque vous définissez une variable d'environnement comme LD_PRELOAD=mymemdebug.et puis l'exécuter. (google pour objet partagé interposition.. c'est une grande technique et utilisé par de nombreux débogueurs/profileurs)