Bonjour,
je constate un comportement de mon code que je n'arrive pas a expliquer. ^^
je travaille avec VS2013 sur windows 7.

Problème : mon code a une grosse fuite mémoire bien sale ^^
je monitore donc la mémoire de mon process pour essayer d'identifier la source du problème.
voici mon main :
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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
 
for (int i = 0; i < 1000; i++)
		{
			cout << "Debut Process image " << i << endl;
			GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
			SIZE_T virtualMemUsedByPRocess_before_constructor = pmc.PagefileUsage;
 
			WorkerBunny Worker(&Model, &params, source.c_str());
 
			GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
			SIZE_T virtualMemUsedByPRocess_after_constructor = pmc.PagefileUsage;
			long int diff = virtualMemUsedByPRocess_after_constructor - virtualMemUsedByPRocess_before_constructor;
			double ko = diff / 1024;
			cout << ko << "     Ko alloué par le constructeur" << endl;
 
			Worker.Matching();
 
			GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
			SIZE_T virtualMemUsedByPRocess_after_matching = pmc.PagefileUsage;
			long int diff2 = virtualMemUsedByPRocess_after_matching - virtualMemUsedByPRocess_after_constructor;
			double ko2 = diff2 / 1024;
			cout << ko2 << "     Ko alloué par le Matching" << endl;
 
			Worker.EstimateTransformation();
 
			GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
			SIZE_T virtualMemUsedByPRocess_after_EstimateTransformation = pmc.PagefileUsage;
			long int diff3 = virtualMemUsedByPRocess_after_EstimateTransformation - virtualMemUsedByPRocess_after_matching;
			double ko3 = diff3 / 1024;
			cout << ko3 << "     Ko alloué par le EstimateTransformation" << endl;
 
			Worker.ReleaseMemory();
 
			GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
			SIZE_T virtualMemUsedByPRocess_afterrelease = pmc.PagefileUsage;
			long int diff4 = virtualMemUsedByPRocess_after_EstimateTransformation - virtualMemUsedByPRocess_afterrelease;
			double ko4 = diff4 / 1024;
			cout << ko4 << "     Ko desalloué par le ReleaseMemory" << endl;
			long int diff5 = virtualMemUsedByPRocess_afterrelease - virtualMemUsedByPRocess_before_constructor;
			double ko5 = diff5 / 1024;
			cout << ko5 << "     ko Memoire non désaloué" << endl;
 
			string Result = Worker.GetResult();
 
			cout << Result << endl << endl;
		}
lorsque j'éxécute ce code, je constate des fuites mémoire provenant du constructeur et de la fonction Matching.

lorsque je mets en commentaire la méthode EstimateTransformation je n'ai plus de problème de mémoire dans les 2 fonction précédente...

je suis perdu ^^
j'ai testé mes fonctions une par une indépendamment des autres et dans ces cas je n'ai pas de fuite
avec la dernière (EstimateTransformation) par contre ça fuit mais le monitoring annonce que la fuite ne viens pas d'elle....


merci pour votre aide