Discussion :

[yann458]

Bonjour,
Je constate un phénomène bizarre

J'ai écrit un code qui alloue 500000 pointers et un pointers de 700Mb, bref.

Les 700Mb sont allouer avec succés si je n'ai pas allouer les 500Ko de pointers.
L'allocation des 700Mb echoue si j'ai allouer les 500Ko Pointers car il n'y à plus de place pour l'adressage
Le plus étonnant c'est que l'allocation des 700Mb échoue même si j'ai liberer les 500Ko pointers.

Je ne sais pas ce qu'il se passe pourtant je libére bien les pointers.

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
void *pu[1024*500];
void CmemoryleakDlg::OnBnClickedButton1()
{
 
	int cu=1024*500;
 
	for (int i = 0 ; i < cu;i++)
	{
		__try 
		{
		//BYTE *p=new BYTE[1*1024];
		BYTE *p=(BYTE*)malloc(1024);
		memset(p,0,1024);
		pu[i]=p;
		if (p==NULL)
			p=p;
		}
		__except(MainFilterFunction(GetExceptionInformation()))
		{
		}
	}
	for (int i = 0 ; i < cu;i++)
	{
		free(pu[i]);
		//BYTE *p=(BYTE*)pu[i];
		//delete p;
	}
	BYTE *ii=new BYTE[700*1024*1024]; //CRASH EXCEPTION OUT OF MEMORY
	if (ii==NULL)
			ii=ii;
 
}

Comment faire sinon pour résoudre ce phénoméne ?
car j'ai un projet à moi qui utilise beaucoup de pointers.

Merci.

[Ehonn]

Bonjour

En lisant juste la description, tu devrais avoir quelque chose qui devrait ressembler à ceci :

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
// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++11 -pedantic -fopenmp main.cpp -o main && ./main
// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++98 -pedantic -fopenmp main.cpp -o main && ./main
 
#include <iostream>
#include <vector>
#include <thread>
#include <chrono>
 
 
int main()
{
	std::vector<void *> ps(500000, nullptr);
 
	std::vector<int> tab((700 * 1000 * 1000) / sizeof(int));
 
	std::this_thread::sleep_for(std::chrono::seconds(30)); // Le temps de regarder la consommation mémoire
 
	return 0;
}

Ce programme fonctionne bien et prend environ 700 Mo de mémoire vive.

---

un pointers de 700Mb

C'est pas très bien dit, un pointeur fait toujours sizeof(void *).

Au passage : en C++ (moderne) on n'utilise pas les pointeurs nus (voir memory).

[the Hound]

Bonjour,
Je constate un phénomène bizarre

J'ai écrit un code qui alloue 500000 pointeurs et un pointeurs de 700MB, bref.

Les 700MB sont alloués avec succès si je n'ai pas alloué les 500ko de pointeurs.
L'allocation des 700MB échoue si j'ai alloué les 500ko pointeurs car il n'y a plus de place pour l'adressage
Le plus étonnant c'est que l'allocation des 700MB échoue même si j'ai liberé les 500ko pointeurs.

Je ne sais pas ce qu'il se passe pourtant je libère bien les pointeurs. (Ça ne veut rien dire au passage.)

[...]

Comment faire sinon pour résoudre ce phénomène ?
car j'ai un projet à moi qui utilise beaucoup de pointeurs.

Merci.

C'est cadeau.

[skeud]

(Je vais peut-etre dire une grosse bétise, mais je pense que c'est une idée)

Si je me gourre pas, un pointeur est codé sur 4 octet.
Tu créer deux giga tableau (un de 1024*500 et l'autre de 1024*1024*700).
Donc d'après mes calcul:
1024*500+1024*1024*700 = 734 515 200.
donc 734 515 200 pointeur au total.
multiplié par la taille d'un pointeur (4 octet): 734515200 * 4 = 2 938 060 800. soit presque 3 Giga juste pour les pointeur (sans compter les malloc que tu fais).

Si tu as un PC avec 2Go de ram ou 4Go, je pense que c'est normal que ça plante .

PS: Je tiens à précisé que je ne suis absolument pas sur de mon explication, je cherche d'ou peu provenir le problème et n'étant pas complètement sur de la taille d'un pointeur, mon explication est à prendre comme une indication et non pas comme vérité constante.

[fenkys]

Je confirme. Tu dis une grosse bétise.

Un pointeur dépend de l'architecture et du compilateur. J'ai connu des pointeurs sur 8, 16, 32 et 64 bits.

Par ailleurs 500 000 pointeurs vont représenter plusieurs Mo par eux même mais on est loin du Go. En tenant compte de la mémoire allouée on arrive a environ 500 Mo. C'est beaucoup mais c'est inférieur au Go.

[pepito3364]

ça peut venir d'un problème de répartition de la mémoire.
Tu peux allouer 700 Mo en 700 bloc de 1 Mo par exemple mais pas d'un seul bloc. Si c'est ça, ça vient du fait que tu n'as pas 700 Mo contigu de libre.

Tu es sur quel os et tu compil avec quoi?

[the Hound]

Code :

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

1
2
3
 
if (p==NULL)
    p=p;

Juste comme ça ... pourquoi ?

1024*500+1024*1024*700 = 734 515 200.
donc 734 515 200 pointeur au total.

Sauf qu'il alloue "seulement" 1024*500 pointeurs, les 700MB ne sont pas alloués pour être utilisés sous forme de pointeurs (c'est des BYTE).

ça peut venir d'un problème de répartition de la mémoire.
Tu peux allouer 700 Mo en 700 bloc de 1 Mo par exemple mais pas d'un seul bloc. Si c'est ça, ça vient du fait que tu n'as pas 700 Mo contigu de libre.

Physiquement les blocs mémoire sont rarement contigus ... et le système peut allouer virtuellement des ressources qu'il n'a pas.
Je ne sais pas comment la gestion de mémoire fonctionne sur son OS, mais avec une machine 4Go de RAM de nos jours + le swap du système, c'est étonnant qu'il n'arrive pas à allouer seulement 700Mo (contigus).

Tu es sur quel os et tu compil avec quoi?

Windows je pense, en tout cas le bloc __try/__except le suggère.

[yann458]

ça peut venir d'un problème de répartition de la mémoire.
Tu peux allouer 700 Mo en 700 bloc de 1 Mo par exemple mais pas d'un seul bloc. Si c'est ça, ça vient du fait que tu n'as pas 700 Mo contigu de libre.

Tu es sur quel os et tu compil avec quoi?

Je travaille sur visual studio 2008 avec windows XP 4 GB de mémoires.
Ce que je ne comprend pas ,c'est quand je libere mes 500ko pointers avant d'allouer les 700 Mb, et l'allocation des 700 MB echoue.

Quand mes x pointer sont libérer ,la mémoire est contigu ???