Outils - mémoire

Pierre Maurette

14/04/2004 à 16:26

Winceslacz Fredo typa:

Bonjour,
y a t'il un outil permettant de facilement savoir si de la mémoire n'a
pas été désallouée, mise à part forcer les liste à n^y elements et
prier? un parseur, ou un traceur système...

je m'amuse avec des listes, et je ne vois pas trop
comment vérifier que mes free() ont bien tout "libéré"...
merci
Vous voulez vérifier que la mémoire n'a pas été désallouée, ou qu'elle

a bien été libérée ?
Dans les deux cas, adoptez déjà la technique d'initialiser tout
pointeur à NULL, et à lui affecter cette valeur après chaque free().
Sinon, je ne connais personellement que Codeguard chez Borland pour
tracer les fuites de mémoire.
Je n'ai jamais testé, mais vous devez pouvoir encapsuler vos malloc()
et free() dans une fonction et y entretenir une variable statique
représentatnt la mémoire allouée. Un truc genre (non testé, non
complet, ajouter test de réussite des allocations):

void* GestionMemoire(void** pptr, const size_t taille)
{
static int alloue = 0;

if(*pptr != NUL)
{
free(*pptr);
*pptr = NULL;
alloue -= taille;
}
else
{
if((*pptr = alloc(taille)) == NULL)
{
/* gérer l'erreur, retourner NULL*/
}
else
{
alloue += taille;
}
}
}

A vous de gérer l'association *pptr/taille.
Vous pouvez essayer les prototypes :

int GestionMemoire(void** pptr, const size_t taille);
(renvoie un code d'erreur)
Ou alors:
void* GestionMemoire(void* ptr, const size_t taille);
utilisation possible (pour allouer):

if((ptr = GestionMemoire(ptr, taille)) == NULL)
{
/* etc */

Pierre

Pierre Maurette

14/04/2004 à 16:27

Pierre Maurette typa:

[...]

if((*pptr = alloc(taille)) == NULL)
if((*pptr = malloc(taille)) == NULL)

Pierre

Régis Troadec

14/04/2004 à 18:09

"Winceslacz Fredo" a écrit dans le message de
news:

Bonjour,
y a t'il un outil permettant de facilement savoir si de la mémoire n'a
pas été désallouée, mise à part forcer les liste à n^y elements et
prier? un parseur, ou un traceur système...

Tu trouveras ce qu'il te faut au point 4.6 de la FAQ :
http://www.isty-info.uvsq.fr/~rumeau/fclc/fclc004.html#q6

Regis

je m'amuse avec des listes, et je ne vois pas trop
comment vérifier que mes free() ont bien tout "libéré"...
merci

Winceslacz Fredo

14/04/2004 à 18:47

Le Wed, 14 Apr 2004 16:26:14 +0200, Pierre Maurette a écrit :

Winceslacz Fredo typa:
Bonjour,
(...)

Vous voulez vérifier que la mémoire n'a pas été désallouée, ou qu'elle
a bien été libérée ?

Qu'elle a bien été libérée

Dans les deux cas, adoptez déjà la technique d'initialiser tout
pointeur à NULL, et à lui affecter cette valeur après chaque free().

Ah, j'avais pensé à l'allocation à NULL, mais pas à remettre à NULL.
Je viens de trouver ça dans la faq aussi.

Sinon, je ne connais personellement que Codeguard chez Borland pour
tracer les fuites de mémoire.

Merci

Je n'ai jamais testé, mais vous devez pouvoir encapsuler vos malloc()
et free() dans une fonction et y entretenir une variable statique
représentatnt la mémoire allouée. Un truc genre (non testé, non
complet, ajouter test de réussite des allocations):
(..)

Ah pas bête ça! le problème étant malheureusement à la
désallocation : on est obligé de rajouter une valeur forfaitaire en
fonction de la valeur passée à free(), vu que le nombre de bytes
désalloué est caché par le système... -> risque d'erreur

Je m'en vais explorer tout ça, ainsi que Lint et associés... merci pour
votre aide!

Emmanuel Delahaye

14/04/2004 à 18:52

In 'fr.comp.lang.c', Winceslacz Fredo wrote:

Bonjour,
y a t'il un outil permettant de facilement savoir si de la mémoire n'a
pas été désallouée, mise à part forcer les liste à n^y elements et
prier? un parseur, ou un traceur système...

je m'amuse avec des listes, et je ne vois pas trop
comment vérifier que mes free() ont bien tout "libéré"...
merci

J'utilise un traceur d'allocation maison (SYSALLOC). Il est dispo sur mon
site en chantier:

mapage.noos.fr/emdel/clib.htm

Pour l'activer il faut définir globalement DBG_SYSALLOC et démarrer le code
comme ça:

#include "ed/inc/sysalloc.h"

/* l'ancien main() devient :*/
int main_(void)
{
<... application ...>
}

int main (void)
{
/* a ajuster selon les besoins */
char Trace [1 << 10];
SYS_INIT (Trace, OFF);

main_ ();

sys_mem_trace();

return 0;
}

Partout où il y a du malloc()/free(), il faut inclure :

#include "ed/inc/sysalloc.h"

après tout le reste.

--
-ed- [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/

Laurent Deniau

14/04/2004 à 19:15

Winceslacz Fredo wrote:

Winceslacz Fredo typa:

Bonjour,

(...)

Vous voulez vérifier que la mémoire n'a pas été désallouée, ou qu'elle
a bien été libérée ?

Qu'elle a bien été libérée

Dans les deux cas, adoptez déjà la technique d'initialiser tout
pointeur à NULL, et à lui affecter cette valeur après chaque free().

Ah, j'avais pensé à l'allocation à NULL, mais pas à remettre à NULL.
Je viens de trouver ça dans la faq aussi.

Sinon, je ne connais personellement que Codeguard chez Borland pour
tracer les fuites de mémoire.

Merci

Je n'ai jamais testé, mais vous devez pouvoir encapsuler vos malloc()
et free() dans une fonction et y entretenir une variable statique
représentatnt la mémoire allouée. Un truc genre (non testé, non
complet, ajouter test de réussite des allocations):

(..)

Ah pas bête ça! le problème étant malheureusement à la
désallocation : on est obligé de rajouter une valeur forfaitaire en
fonction de la valeur passée à free(), vu que le nombre de bytes
désalloué est caché par le système... -> risque d'erreur

Ce n'est pas oblige. Compter les paires alloc/free suffit pour
"detecter" le manque de d'appels a free etant donne que si les tailles
fournies ne correspondent pas un segfault devrait tomber rapidement.

Sur Linux/Unix, si tu utilises la glibc, elle possede deja quelques
fonctionnalites interessantes:

http://www.gnu.org/software/libc/manual/html_mono/libc.html#Allocation%20Debugging

a+, ld.

Winceslacz Fredo

14/04/2004 à 19:20

Le Wed, 14 Apr 2004 16:52:08 +0000, Emmanuel Delahaye a écrit :

Bonjour!

J'utilise un traceur d'allocation maison (SYSALLOC). Il est dispo sur mon
site en chantier:
mapage.noos.fr/emdel/clib.htm

Ouah la mine!
MERCI de mettre tout ça à disposition, excellent pour l'apprentissage!

Pierre Maurette

14/04/2004 à 22:58

Winceslacz Fredo typa:
[...]

Je n'ai jamais testé, mais vous devez pouvoir encapsuler vos malloc()
et free() dans une fonction et y entretenir une variable statique
représentatnt la mémoire allouée. Un truc genre (non testé, non
complet, ajouter test de réussite des allocations):
(..)

Ah pas bête ça! le problème étant malheureusement à la
désallocation : on est obligé de rajouter une valeur forfaitaire en
fonction de la valeur passée à free()
Tout d'abord, je pense que mon idée de compter la somme des unités

allouées (un size_t) est justement assez bête. Et même compter les
malloc() et les "balancer" avec les free() ne donne qu'une illusion de
sécurité, en ce sens que ça ne détecterait pas une allocation qui
écraserait un pointeur. Appliquez déjà les règles suivantes (ce ne
sont que des blocs, pas un programme!):

int* ptr1 = NULL;
int* ptr2 = NULL;

if(ptr1 == NULL)
{
if((ptr1 = (int*)malloc(taille)) == NULL)
{
/* traiter l'erreur */
}
else
{
/* suite */
}
}

if(ptr1 != NULL)
{
free(ptr1);
ptr1 = NULL
}

if(ptr2 == NULL) /* && ptr1 != NULL) peut-être */
{
ptr2 = ptr1;
ptr1 = NULL;
}

nota: le cast (int*) n'est pas nécessaire en C (je crois bien, en tous
cas), mais je l'utilise. En effet, je vis dans le péché et fait
parfois du C en C++. Shame on me...

vu que le nombre de bytes
désalloué est caché par le système... -> risque d'erreur
Un rappel, des fois que ce ne serait pas totalement clair:

malloc() renvoie en cas de succès un pointeur void*. La VALEUR de ce
pointeur est la SEULE clé qui permettra de désallouer. On peut
imaginer que le programme, ou certainement plus souvent le système
d'exploitation, entretien une correspondance entre ces valeurs et une
quantité de mémoire. Des erreurs classiques sont donc :
- Ne pas rapatrier la valeur du pointeur depuis une fonction où se
passe l'allocation (mais là, les problèmes surgissent avant la
désallocation).
- Ecraser la valeur contenue dans le pointeur :
ptr = malloc(taille1);
/* code qui ne sauve pas la valeur de ptr */
ptr = malloc(taille2);
A partir de là, l'erreur est consommée, fuite mémoire de taille1.

Pierre

Winceslacz Fredo <mth.5.fresch@spamgourmet.com> typa:
[...]

Je n'ai jamais testé, mais vous devez pouvoir encapsuler vos malloc()
et free() dans une fonction et y entretenir une variable statique
représentatnt la mémoire allouée. Un truc genre (non testé, non
complet, ajouter test de réussite des allocations):
(..)

Ah pas bête ça! le problème étant malheureusement à la
désallocation : on est obligé de rajouter une valeur forfaitaire en
fonction de la valeur passée à free()
Tout d'abord, je pense que mon idée de compter la somme des unités

allouées (un size_t) est justement assez bête. Et même compter les
malloc() et les "balancer" avec les free() ne donne qu'une illusion de
sécurité, en ce sens que ça ne détecterait pas une allocation qui
écraserait un pointeur. Appliquez déjà les règles suivantes (ce ne
sont que des blocs, pas un programme!):

int* ptr1 = NULL;
int* ptr2 = NULL;

if(ptr1 == NULL)
{
if((ptr1 = (int*)malloc(taille)) == NULL)
{
/* traiter l'erreur */
}
else
{
/* suite */
}
}

if(ptr1 != NULL)
{
free(ptr1);
ptr1 = NULL
}

if(ptr2 == NULL) /* && ptr1 != NULL) peut-être */
{
ptr2 = ptr1;
ptr1 = NULL;
}

nota: le cast (int*) n'est pas nécessaire en C (je crois bien, en tous
cas), mais je l'utilise. En effet, je vis dans le péché et fait
parfois du C en C++. Shame on me...

vu que le nombre de bytes
désalloué est caché par le système... -> risque d'erreur
Un rappel, des fois que ce ne serait pas totalement clair:

malloc() renvoie en cas de succès un pointeur void*. La VALEUR de ce
pointeur est la SEULE clé qui permettra de désallouer. On peut
imaginer que le programme, ou certainement plus souvent le système
d'exploitation, entretien une correspondance entre ces valeurs et une
quantité de mémoire. Des erreurs classiques sont donc :
- Ne pas rapatrier la valeur du pointeur depuis une fonction où se
passe l'allocation (mais là, les problèmes surgissent avant la
désallocation).
- Ecraser la valeur contenue dans le pointeur :
ptr = malloc(taille1);
/* code qui ne sauve pas la valeur de ptr */
ptr = malloc(taille2);
A partir de là, l'erreur est consommée, fuite mémoire de taille1.

Pierre

Vous avez filtré cet utilisateur ! Consultez son message

Winceslacz Fredo typa:
[...]

Je n'ai jamais testé, mais vous devez pouvoir encapsuler vos malloc()
et free() dans une fonction et y entretenir une variable statique
représentatnt la mémoire allouée. Un truc genre (non testé, non
complet, ajouter test de réussite des allocations):
(..)

Ah pas bête ça! le problème étant malheureusement à la
désallocation : on est obligé de rajouter une valeur forfaitaire en
fonction de la valeur passée à free()
Tout d'abord, je pense que mon idée de compter la somme des unités

allouées (un size_t) est justement assez bête. Et même compter les
malloc() et les "balancer" avec les free() ne donne qu'une illusion de
sécurité, en ce sens que ça ne détecterait pas une allocation qui
écraserait un pointeur. Appliquez déjà les règles suivantes (ce ne
sont que des blocs, pas un programme!):

int* ptr1 = NULL;
int* ptr2 = NULL;

if(ptr1 == NULL)
{
if((ptr1 = (int*)malloc(taille)) == NULL)
{
/* traiter l'erreur */
}
else
{
/* suite */
}
}

if(ptr1 != NULL)
{
free(ptr1);
ptr1 = NULL
}

if(ptr2 == NULL) /* && ptr1 != NULL) peut-être */
{
ptr2 = ptr1;
ptr1 = NULL;
}

nota: le cast (int*) n'est pas nécessaire en C (je crois bien, en tous
cas), mais je l'utilise. En effet, je vis dans le péché et fait
parfois du C en C++. Shame on me...

vu que le nombre de bytes
désalloué est caché par le système... -> risque d'erreur
Un rappel, des fois que ce ne serait pas totalement clair:

malloc() renvoie en cas de succès un pointeur void*. La VALEUR de ce
pointeur est la SEULE clé qui permettra de désallouer. On peut
imaginer que le programme, ou certainement plus souvent le système
d'exploitation, entretien une correspondance entre ces valeurs et une
quantité de mémoire. Des erreurs classiques sont donc :
- Ne pas rapatrier la valeur du pointeur depuis une fonction où se
passe l'allocation (mais là, les problèmes surgissent avant la
désallocation).
- Ecraser la valeur contenue dans le pointeur :
ptr = malloc(taille1);
/* code qui ne sauve pas la valeur de ptr */
ptr = malloc(taille2);
A partir de là, l'erreur est consommée, fuite mémoire de taille1.

Pierre

Marc Boyer

15/04/2004 à 10:39

Winceslacz Fredo wrote:

Bonjour,
y a t'il un outil permettant de facilement savoir si de la mémoire n'a
pas été désallouée, mise à part forcer les liste à n^y elements et
prier? un parseur, ou un traceur système...

je m'amuse avec des listes, et je ne vois pas trop
comment vérifier que mes free() ont bien tout "libéré"...

Je connaissais "purify", mais je viens de trouver une
page qui en recense toutes une liste
http://www.cs.colorado.edu/homes/zorn/public_html/MallocDebug.html

Marc Boyer
--
La contractualisation de la recherche, c'est me donner de l'argent pour
faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce
que je sais faire, je le fais sans moyens...

Arnaud Giersch

15/04/2004 à 11:25

Jeudi le 15 avril 2004, vers 10:39:17 (CEST), Marc Boyer a écrit:

Winceslacz Fredo wrote:
comment vérifier que mes free() ont bien tout "libéré"...

Je connaissais "purify", mais je viens de trouver une
page qui en recense toutes une liste
http://www.cs.colorado.edu/homes/zorn/public_html/MallocDebug.html

On peut ajouter valgrind (http://valgrind.kde.org/) qui fonctionne
sous linux/x86.

--
Arnaud

Outils - mémoire

10 réponses

Veuillez sélectionner un problème