1 pièce(s) jointe(s)
Problème de libération de la mémoire virtuelle
Bonjour à tous,
Mon problème est le suivant.
J'ai réalisé une application en C++ sous Visual Studio 10 sous windows XP 32bit.
Cette application doit créer une quantité très importante d'objets en mémoire de petite taille (environ 20 Ko).
J'ai donc ajouté à mon code un bloc try/catch pour intercepter les dépassements mémoires.
Lorsque l'occupation mémoire atteint 2Go, les allocations échouent. Une exception est générée. L'application la capture et libère la mémoire.
L'objectif est de pouvoir gérer ces situations et garder la stabilité de l'appli.
Or il semble qu'après avoir libérer toutes les ressources allouées par l'application, la mémoire virtuelle n'est pas libérée.
En utilisant la fonction GlobalMemoryEx(), on s'apperçoit que la mémoire disponible n'est que de quelques méga.
Il est ensuite impossible de réallouer un espace mémoire de plus d'une dizaine de méga.
Pour mieux comprendre voici un code d'exemple reproduisant le problème :
Code:
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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
| // AllocationErr.cpp : définit le point d'entrée pour l'application console.
//
#include "stdafx.h"
//#include <iostream.h>
#include <vector>
#include "AllocationErr.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
using namespace std;
void ReportMemory()
{
MEMORYSTATUSEX statex;
statex.dwLength = sizeof (statex);
GlobalMemoryStatusEx (&statex);
HANDLE heap = GetProcessHeap();
SIZE_T size = HeapCompact(heap, 0);
BOOL validated = HeapValidate(heap, 0, NULL);
TRACE("GlobalMemoryStatusEx:\n");
TRACE(" + TotalVirtual : %0.1lf Mo\n", statex.ullTotalVirtual / (1024.0 * 1024.0));
TRACE(" + AvailVirtual : %0.1lf Mo\n", statex.ullAvailVirtual / (1024.0 * 1024.0));
TRACE(" + Process mem load : %0.1lf %%\n", (1.0 - (double) statex.ullAvailVirtual / (double) statex.ullTotalVirtual) * 100.0);
TRACE(" + TotalPageFile : %0.1lf Mo\n", statex.ullTotalPageFile / (1024.0 * 1024.0));
TRACE(" + AvailPageFile : %0.1lf Mo\n", statex.ullAvailPageFile / (1024.0 * 1024.0));
}
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
TRACE("Before allocation\n");
ReportMemory();
const unsigned int taille_bloc = 10* 1024, nb_blocs_max = (3U * 1024U * 1024U * 1024U / taille_bloc);
int i = 0;
char ** p = NULL;
try
{
p = new char *[nb_blocs_max];
memset(p, 0, nb_blocs_max * sizeof(char *));
for(i = 0; i < nb_blocs_max; i++)
{
p[i] = new char[taille_bloc];
}
}
catch (CMemoryException* e)
{
e->Delete();
TRACE("After the program ran out of memory\n");
ReportMemory();
for(i = 0; i < nb_blocs_max; i++)
{
if(p[i])
{
delete [] p[i];
}
}
delete [] p;
}
TRACE("After freeing memory\n");
ReportMemory();
char * t = NULL;
try
{
const unsigned int taille_max = 30 * 1024 * 1024;
t = new char[taille_max];
}
catch (CMemoryException* e)
{
TRACE("Memory allocation failed\n");
e->Delete();
if(t)
{
delete [] t;
}
}
return 0;
} |
Le résultat afficher est le suivant :
Before allocation
GlobalMemoryStatusEx:
+ TotalVirtual : 2047.9 Mo
+ AvailVirtual : 2016.8 Mo:ccool:
+ Process mem load : 1.5 %
+ TotalPageFile : 5198.6 Mo
+ AvailPageFile : 3172.9 Mo
After the program ran out of memory
GlobalMemoryStatusEx:
+ TotalVirtual : 2047.9 Mo
+ AvailVirtual : 4.5 Mo:cry:
+ Process mem load : 99.8 %
+ TotalPageFile : 5198.6 Mo
+ AvailPageFile : 1155.2 Mo
After freeing memory
GlobalMemoryStatusEx:
+ TotalVirtual : 2047.9 Mo
+ AvailVirtual : 5.7 Mo8O
+ Process mem load : 99.7 %
+ TotalPageFile : 5198.6 Mo
+ AvailPageFile : 3170.8 Mo
Avez vous une idée ?
Vous trouverez également en pièce jointe le projet Visual 10 ...
