Analyseur de mémoire consommé par un soft

**chris_wafer_2001** · 21/10/2005, 21h12

Bonjour j'ai développé un logiciel avec Visual C++; et j'aimerais avoir des statistiques sur la mémoire utilisée, consommé, perdue.

Existe-t-il des logiciels permettant de voir la mémoire perdue par le logiciel?
Style des new sans faire de delete, ...

Ces logiciels permettent-ils de retrouver où on a pas libérer la mémoire?

Merci d'avance pour votre aide...

Chris.

**Crisanar** · 22/10/2005, 11h56

Dans la liste des outils de ce site il y avait un petit programme qui a l'air de bien fonctionner : MemProof, dispo ICI

**chris_wafer_2001** · 22/10/2005, 17h52

Envoyé par Crisanar

Dans la liste des outils de ce site il y avait un petit programme qui a l'air de bien fonctionner : MemProof, dispo ICI

J'ai fait le programme suivant pour tester MemProof :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
void fuite_memoire()
{
	int *c = new int;
}
 
 
int main (int argc, char *arv[])
{
 
	for(int i = 0; i < 100; i++)
	{
		fuite_memoire();
	}
 
	return 1;
}

Je ne vois pas dans MemProof où il faut que je cliques pour qu'il me dise que la mémoire utilisée par la variable c de type int dans la fonction fuite_memoire n'est jamais libérée.

Quelqu'un peut m'aider?

Merci d'avance...

Chris.

**moldavi** · 22/10/2005, 19h26

Il existe plusieurs façons de gérer les fuites de mémoire, et il existe aussi des outils (parfois payants).

- Surcharge de l'opérateur new. Ici un exemple: http://loulou.developpez.com/tutorie...eur3d/partie1/
(attention il y a un bug si on utilise des variables globales).

- Utiliser une classe personnalisée qui compte le nombre d'allocation et de désallocation. Si à la fin la différence des deux != 0 alors fuite).

-Les outils: si tu utilies VC++, tu peux te servir de "DumpMemoryLeaks". Pour les payants j'ai pas encore testé.
Ici: http://www.developpez.com/c/memoire/

PS: toujours penser à regarder dans les FAQ de ce site.

**chris_wafer_2001** · 22/10/2005, 20h19

DumpMemoryLeaks ???

Où je trouve ça?

Comment je m'en sers?

**moldavi** · 22/10/2005, 21h08

Les mots clés ci-dessous:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
 
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
 
_CrtDumpMemoryLeaks();

Les explications ici:

http://msdn.microsoft.com/library/de...emoryleaks.asp

**chris_wafer_2001** · 23/10/2005, 17h22

J'ai fait ce que tu as dit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
 
void fuite_memoire()
{
	int *c = new int;
	*c = 0x89ABCDEF;
}
 
 
int main (int argc, char *arv[])
{
 
	for(int i = 0; i < 5; i++)
	{
		fuite_memoire();
	}
 
	_CrtDumpMemoryLeaks();
 
	return 1;
}

Le résultat de l'exécution donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
d:\softs\microsoft visual studio\vc98\include\crtdbg.h(552) : {45} normal block at 0x00431DA0, 4 bytes long.
 Data: <    > EF CD AB 89 
d:\softs\microsoft visual studio\vc98\include\crtdbg.h(552) : {44} normal block at 0x00431DD0, 4 bytes long.
 Data: <    > EF CD AB 89 
d:\softs\microsoft visual studio\vc98\include\crtdbg.h(552) : {43} normal block at 0x00431E00, 4 bytes long.
 Data: <    > EF CD AB 89 
d:\softs\microsoft visual studio\vc98\include\crtdbg.h(552) : {42} normal block at 0x00430030, 4 bytes long.
 Data: <    > EF CD AB 89 
d:\softs\microsoft visual studio\vc98\include\crtdbg.h(552) : {41} normal block at 0x00430060, 4 bytes long.
 Data: <    > EF CD AB 89

Ainsi, je vois bien qu'il y a 5 blocks non libérés, mais comment savoir exactement d'où ça vient???
J'aimerais bien qu'il me dise que ça vient de l'objet c qui se trouve dans la fonction fuite_memoire!!!
Vous savez comment faire?

Merci d'avance...

Chris.

**moldavi** · 23/10/2005, 18h40

Le problème c'est que "_CrtDumpMemoryLeaks();" ne te donnera l'emplacement concerné que pour le cas d'une allocation avec "malloc" et encore pour un projet qui ne contient qu'un fichier unique. Si tu utilises plusieurs sources, alors tu dois inclure ceci au tout début:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

Pour les allocations avec l'opérateur new, si tu doubles-click sur la ligne concerné tu es renvoyé dans le fichier "crtdbg.h". Tu as une solution ici:

http://www.codeproject.com/debug/consoleleak.asp.

Personnellement j'utilise cette fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
_CrtSetBreakAlloc(41);
_CrtSetBreakAlloc(42);
_CrtSetBreakAlloc(43);
_CrtSetBreakAlloc(44);
_CrtSetBreakAlloc(45);

Comme tu peux le voir, les nombres 41, 42, 43, 44, 45, correspondent au résultat de _CrtDumpMemoryLeaks(); que tu as obtenu. Tu places ce code en tout début de programme avant toute allocation et le débuggeur s'arrêtera à chaque allocation. En regardant la pile d'appel, tu trouves assez facilement de quel allocation il s'agit. Attention, il ne faut pas modifier le code source entre temps car les nombres pourraient ne plus correspondre.

Il y a d'autres méthodes, par exemple en faisant une différences des états d'allocations dans une portion de code. Je te renvoie à la documentation. pour tout ça.

**chris_wafer_2001** · 23/10/2005, 19h01

Et MemProof peut faire des trucs comme ça?

**moldavi** · 23/10/2005, 19h25

Oui, mais ça à plutôt l'air dédié à delphi et borland.

**chris_wafer_2001** · 23/10/2005, 19h30

Et tu connais pas un soft qui le fait, sans devoir toucher au code?

**Zenol** · 23/10/2005, 19h43

Je cherche aussi un programme qui puisse surveiller toute les alocation/désalocations mémoir d'un processuse, de préférence sans avoir a modifier le code, sans avoir besoin de rajouter quelque chose a la compilation. Je suis donc aussi intérèsser par la réponsse, a la diférence que je n'utilise pas VisualC++.

**moldavi** · 23/10/2005, 21h32

J'ai téléchargé AQTime. Il y a une version d'évaluation de quelques jours.

J'ai pas encore eu le temps de tester. Mais apparemment, il permet de faire ce genre de test sans modifier grand chose dans le code.

Je préfère une gestion manuelle pour ce genre de vérification, mais si je trouve des softs performants alors pourquoi pas.

Il en existe d'autres (confère le lien que j'ai donné plus haut qui se trouve sur ce site).

**moldavi** · 23/10/2005, 21h47

Envoyé par chris_wafer_2001

Et tu connais pas un soft qui le fait, sans devoir toucher au code?

En fait sans toucher au code juste en surveillant l'exe, je pense qu'il ne faut pas trop rêver.

La seule chose que tu peux surveiller, je pense, c'est l'évolution de la mémoire utilisée (confère le gestionnaire de tâche sous win).

Tu lances ton soft: mémoire utilisée = 6300ko par exemple.

Au bout de deux jours: mémoire utilisée = 85500ko par exemple, ben là y a problème.

**Crisanar** · 23/10/2005, 23h25

Un hook de certaines d'APIs bien spécifiques (VirtualAlloc, HeapAlloc,...) ne peut pas faire ce travail 'proprement'?

**moldavi** · 24/10/2005, 02h24

Envoyé par Crisanar

Un hook de certaines d'APIs bien spécifiques (VirtualAlloc, HeapAlloc,...) ne peut pas faire ce travail 'proprement'?

Oui effectivement. D'ailleurs peut-être que certains softs utilisent ce procédé.

**Aurelien.Regat-Barrel** · 24/10/2005, 10h17

Envoyé par Crisanar

Un hook de certaines d'APIs bien spécifiques (VirtualAlloc, HeapAlloc,...) ne peut pas faire ce travail 'proprement'?

Non, parce qu'à priori ces fonctions ne sont pas utilisées directement dans son soft, mais indirectement par new/malloc. Ainsi, pour un seul HeapAlloc, il y a peut être 20 new d'effectués (le new rajoute sa gestion de la mémoire par dessus celle de Windows).
La CRT de VC++ permet de détecter les fuites (_CrtDumpMemoryLeaks...), ainsi que de poser un breakpoint sur un numéro d'allocation. Ainsi, après avoir appris que l'allocation numéro 41 n'est pas libérée, réexécute ton logiciel exactement de la même manière en donnant le numéro 41 à _CrtSetBreakAlloc. Lorsque cette allocation aura lieu, hop le debugger arrêtera le process et tu pourras localiser l'allocation.
Par le code c'est pénible à faire car faut recompiler. Tu peux le faire depuis le débogueur:
http://support.microsoft.com/kb/151585/en-us
et apparement y'a eu un super travail de fait ici:
http://www.codeproject.com/tools/visualleakdetector.asp
apparement, car quand j'ai voulu testé le téléchargement depuis le site ne fonctionnait pas, du coup je me suis fait ma petite lib.

**chris_wafer_2001** · 25/10/2005, 19h00

J'ai découvert le logiciel :
BoundsChecker

Il s'intègre notamment à Visual C++; et permet de recompiler en instrumentatnt le code.
Les fuites de mémoire sont détectés, et on a juste à cliquer pour atterir sur le code provoquant la fuite mémoire!!!

GENIAL et ENORME!!!

Malheureusement, le logiciel est payant, mais ça vaut le coup car les résultats sont impressionnants.

Plus d'infos sur le lien suivant : http://www.compuware.com/products/devpartner/bounds.htm

Chris.

**Aurelien.Regat-Barrel** · 25/10/2005, 23h30

Je ne l'ai jamais utilisé, mais il est souvent cité comme référence, avec purify (payant lui aussi).
Sous Linux en gratuit il y a valgrind.

Analyseur de mémoire consommé par un soft

C++

Discussions similaires

Partager

Partager