Utilisation de la mémoire vive par un programme

Version imprimable

22/09/2006, 17h23
Pixcoder

Utilisation de la mémoire vive par un programme
Salut!

J'utilise Dev C++ 4.9 et je voulais savoir si le compilateur limitait la quantité de mémoire vive utilisée par le programme, et dans pareil cas, si l'on pouvait la modifier cette quantité.

Si DevC++ ne le pemet pas, est ce qu'un autre compilateur le permet?

Je demande tout ceci parce que j'ai de sérieux problèmes d'allocation de mémoire , allocation que je provoque grâce à des appels à "new". J'attrape les erreurs avec des try{} et des catch{} associés.
Les allocations ressemblent à la suivante :
Code:

1 2 3 4 5 6 7 8 try { visible_cubes = new CList<int>* [n*p*h]; } catch(exception &exc) { Erreur( exc.what() ); }
D'autre part, le programme quitte à cette erreur sans bien m'exécuter ma fonction nommée "Erreur()". Il est vrai que mes allocations sont importantes et c'est pour cela que je me suis demandé si le compilateur ne limitait pas la mémoire pouvant être utilisée.

J'espère que vous avez compris mon problème!

PiX

:tagcode:
22/09/2006, 17h30
loufoque

Il semblerait que tu n'aies pas trop compris comment s'utilise CList.

Citation:

je voulais savoir si le compilateur limitait la quantité de mémoire vive

Non.
C'est le système qui s'occupe de cette gestion et ceci à l'execution.
22/09/2006, 17h43
Pixcoder

Ah, peutêtre que CList existe déjà; en réalité ici, j'ai créé CList donc j'en connais logiquement son utilisation.
22/09/2006, 20h23
rigobert
Citation:

Envoyé par Pixcoder

Ah, peutêtre que CList existe déjà; en réalité ici, j'ai créé CList donc j'en connais logiquement son utilisation.

Dans ce cas si le code suivant :
Code:

1 2 3 4 5 try { visible_cubes = new CList<int>* [n*p*h]; } catch(exception &exc)
lève une exception, c'est qu'il y a un bug ... dans l'implémentation de ta classe :aie: !

Et sans savoir comment elle est implémentée, on ne pourra pas faire grand chose pour t'aider...
22/09/2006, 22h07
loufoque

Citation:

c'est qu'il y a un bug ...

Ou alors qu'il y a eu une erreur lors de l'allocation mémoire.
23/09/2006, 01h02
Luc Hermitte

Tu es sûr de ne pas planter après le new ?
Je ne vois pas pourquoi une allocation d'un tableau de pointeurs de Toto devrait échouer autrement qu'en levant une std::exception (std::bad_alloc pour être plus précis). (a part avec un vieux GCC qui ne lève pas d'exceptions par défaut, une inclusion de <new>, ce genre de choses)

Ca sent plutôt le plantage dans le code qui suit qui tenterait de remplir les Toto pointés non alloués. Rajoutes donc une trace juste après ton allocation. Et vois la FAQ au sujet des tableaux à plusieurs dimensions.

J'imagine que tu réinventes la roue parce qu'il s'agit d'un exercice ?
24/09/2006, 14h50
NewbiZ

On pourrait avoir une idée de l'ordre de grandeur de n, p et h ?
Ainsi qu'un sizeof(CList<int>) ?
24/09/2006, 22h05
Pixcoder

n = 12
p = 12
h = 11
et sizeof(CList<int>) = 40

J'ai même tenté de remplacer l'allocation de mémoire grâce à 'new' par un 'allocator<CList<int> *>' et lors de l'allocation de mémoire, il me quitte le programme de la même manière!

Regardez la 3ème image sur ce site
http://rom3fr.free.fr
Elle présente le bug que j'ai eu pendant un moment tout à fait dans les mêmes conditions que précédemment, c'est-à-dire lors de cette allocation de mémoire.

Luc Hermitte : Non, il ne s'agit pas d'un exercice... Que me conseilles tu d'utiliser comme "structure" de mémorisation de classes prédéfinies, ici CList<int> * ?

PiX
24/09/2006, 22h12
Pixcoder

Luc Hermitte : lorsque que je faisun "system("pause");" juste avant cette allocation et que j'en place un autre juste après, lors de l'éxécution, il me fait la première pause et dès que j'appuis sur une touche pour continuer, le programme quitte prématurément sans aucun message d'erreur, sans rien...

Je ne comprends pas la cohérence de ce comportement, parfois il me sort l'erreur de la 3eme image et parfois il quitte le programme comme ca...

PiX
24/09/2006, 22h42
Luc Hermitte

Ton truc est hyper louche. Montre nous un exemple mininal mais complet !
Ca sent vraiment un problème de corruption. Il a peut-être lieu avant ton allocation de pointeurs de tableaux.

Une structure à utiliser ? Ben il y a plein de choses qui marchent très bien dans la SL. Si tu veux de la double dimension, il faut soit de l'huile de coude, soit utiliser des bibliothèques déjà existantes (qui ont l'avantage d'avoir déjà été validées).
Jettes un coup d'oeil à la FAQ.

Voici la méthode à l'origine de l'erreur. Elle fait parti d'un lot de fonctions qui charge chacune une partie du fichier. Quand je l'enlève et que je fais les modifs nécessaires pour ne plus avoir à utiliser ce qu'elle était censée charger, le programme se lance correctement.

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
96
97
98
99
100
101
 
void CMap::LoadListsOfVisibleCubes(FILE *filepointer)
{     
 
 
 
    fscanf(filepointer, "Visible cubes filename\n");
 
    //let us read the number of characters of the file to load
    unsigned int nbchar;
    fscanf(filepointer, "%d\n", &nbchar);     
 
 
 
 
    char *path;
    try
    {
      path = new char[nbchar];
    }
    catch(exception &exc)
    {
      Erreur(  "Allocation error, map.cpp"  );
    }    
 
 
 
    fscanf(filepointer, "%s\n\n", path);
 
 
 
 
    //now let us load the file
    FILE *filepointer2;
 
    if ((filepointer2=fopen(path, "r"))==NULL)
       Erreur("Error loading the visible cubes file, map.cpp");
 
    //displaying what is happening
    printf("\n\nLoading the visible cubes list ...\n");    
 
    printf("  allocating memory for 'visible_cubes'\n");
 
 
  system("pause");
 
  visible_cubes = new(std::nothrow) CList<int>* [n*p*h];
  if (visible_cubes == NULL)
    Erreur("Error allocating memory, 'visible_cubes', map.cpp");
 
  system("pause");    
 
 
    for (int i=0; i<n*p*h; i++)
    {
 
 
          try
          {
            visible_cubes[i] = new CList<int>;
          }
          catch(exception &exc)
          {
            Erreur(  "Allocation error, map.cpp"  );
          }    
 
          //reading the coordinates of the current position
          int id;
          fscanf(filepointer2, "id cube : %d, ", &id);
          unsigned int coordx, coordy, coordz;
          fscanf(filepointer2, "coordinates : %d %d %d\n", &coordx, &coordy, &coordz);          
          fscanf(filepointer2, "Visible cubes' indices : ");
 
 
 
          //reading the indices of the visible cubes;          
          int visible_cubes_index;
          fscanf(filepointer2, "%d ", &visible_cubes_index);
 
 
          while(visible_cubes_index != -1)
          {                
 
                 visible_cubes[i]->AjouterDebut(visible_cubes_index);
                 fscanf(filepointer2, "%d ", &visible_cubes_index);                                                 
          } //end while
 
          fscanf(filepointer2, "\n\n");
 
    }  //end (int i=0; i<n*p*h; i++)
 
    fclose(filepointer2);
    if (path != NULL)
      delete[] path;
 
    printf("\nVisible cubes lists loaded.\n\n");
 
 
 
 
}

Les commentaires sont en anglais, excusez moi.

Pour info, voici le code de CList :

List.h

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
 
#ifndef LIST_H
#define LIST_H
 
template <class T>
struct CMaillon
{
	//Champs contenu par un maillon (Modifiable, mais attention de bien modifier aussi le code des methodes suivantes : CMaillon(), operator =(CMaillon m)
	T Contenu;
 
	//Champs qui réalisent le chainage dans la liste
	CMaillon<T>* Suivant;
	CMaillon<T>* Precedent;
 
	//Methodes
	CMaillon();//Contructeur : initialise le maillon
	void operator =(CMaillon<T> m);//Affectation d'un maillon à un autre maillon
};
 
 
template <class T>
class CList
{
private:
	CMaillon<T>* Premier;//Pointeur sur le premier élément de la liste
	CMaillon<T>* Dernier;//Pointeur sur le dernier élément de la liste
public:
	CList();//Initialisation de la liste à la liste vide
	CMaillon<T>* AjouterDebut(T o);//Ajoute un maillon au début de la liste et renvoie un pointeur vers ce maillon	
	CMaillon<T>* GetPremier();//Renvoie le premier élément de la liste
	CMaillon<T>* Suivant(CMaillon<T>* m);//Renvoie l'élément qui est le suivant du maillon m dans la liste
	void Supprimer(CMaillon<T>* MaillonASupprimer);//Supprime le maillon pointé par MaillonASupprimer de la liste
	bool ListeVide();//Indique si la liste est vide ou non
	void DetruireListe();// Vide la liste de tout ses éléments en les effaçant
};
 
#endif

List.cpp

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
96
97
98
99
100
101
102
103
104
105
 
#include "List.h"
 
/*******************************************************************************************************************************\
|                                     DEFINITION DES METHODES DE CMaillon                                                       |
\*******************************************************************************************************************************/
 
template <class T>
CMaillon<T>::CMaillon()
{
	//Contenu=NULL;
	Suivant=NULL;
	Precedent=NULL;
}
 
template <class T>
void CMaillon<T>::operator =(CMaillon<T> m)
{
	Contenu=m.Contenu;
}
 
/*******************************************************************************************************************************\
|                                     DEFINITION DES METHODES DE CList                                                          |
\*******************************************************************************************************************************/
template <class T>
CList<T>::CList()
{
	Premier=NULL;
	Dernier=NULL;
}
 
template <class T>
CMaillon<T>* CList<T>::AjouterDebut(T o)
{
	CMaillon<T>* Nouveau=new CMaillon<T>;
	Nouveau->Contenu=o;
	Nouveau->Suivant=Premier;
	Nouveau->Precedent=NULL;
	if(Dernier==NULL)Dernier=Nouveau;
	else Premier->Precedent=Nouveau;
	Premier=Nouveau;
	return Nouveau;
}
 
 
 
 
 
template <class T>
CMaillon<T>* CList<T>::GetPremier()
{
	return Premier;
}
 
template <class T>
CMaillon<T>* CList<T>::Suivant(CMaillon<T>* m)
{
	return m->Suivant;
}
 
template <class T>
void CList<T>::Supprimer(CMaillon<T>* MaillonASupprimer)
{
	if((MaillonASupprimer!=NULL)&&(Premier!=NULL))
	{
		if(MaillonASupprimer==Premier)
		{
			Premier=Premier->Suivant;
			if(Premier!=NULL)Premier->Precedent=NULL;
			else Dernier=NULL;
			delete MaillonASupprimer;
		}
		else if(MaillonASupprimer==Dernier)
		{
			Dernier=Dernier->Precedent;
			Dernier->Suivant=NULL;
			delete MaillonASupprimer;
		}
		else
		{
			MaillonASupprimer->Precedent->Suivant=MaillonASupprimer->Suivant;
			MaillonASupprimer->Suivant->Precedent=MaillonASupprimer->Precedent;
			delete MaillonASupprimer;
		}
	}
}
 
 
 
 
template <class T>
bool CList<T>::ListeVide()
{
	return (Premier==NULL);
}
 
 
 
 
 
template <class T>
void CList<T>::DetruireListe()
{
	while(Premier!=NULL)Supprimer(GetPremier());
}

24/09/2006, 23h15
Pixcoder

Il faut noter que la méthode présentée void CMap::LoadListsOfVisibleCubes(FILE *filepointer) charge un nom de fichier (variable 'path') qui se trouve dans le fichier chargé par le "lot de méthodes", puis après avoir chargé ce nom de fichier, elle charge le fichier en question.

PiX
25/09/2006, 12h05
Rafy

Tu devrai utiliser la STL, ça serai beaucoup plus simple pour toi....
Elle est la pour ça....
25/09/2006, 12h36
NewbiZ

On pourrait avoir le type de visible_cubes ?

Ca m'a tout l'air d'être un CList<int>*
Ne faudrait il pas remplacer

Code:

new CList<int>* [n*p*h]

par

Code:

new CList<int> [n*p*h]