Discussion :

[keket123]

Salut!
Je débute en c++ et j'ai le problème suivant:
je veux exécuter un prog qui crée une matrice de "double" de dimension 20000 x 20000:

Code cpp :

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

1
2
3
4
5
6
7
8
#include <iostream>
using namespace std;
 
int main(){
  cout<<"size of double: "<< sizeof(double)<<endl;
  double** Matrix=new double*[20000];
  for (int i=0; i<20000; i++) Matrix[i]=new double[20000];
}

Quand je lance le prog, j'obtiens la sortie suivante:

Code :

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

1
2
3
4
size of double: 8
terminate called after throwing an instance of 'std::bad_alloc'
  what():  St9bad_alloc
Aborting

Si je tape la commande linux "free -s 0.01" pendant l'exécution du prog, je remarque que la mémoire physique diminue pratiquement jusque zéro puis que le prog s'arrête. Je ne comprends pas pourquoi il ne continue pas à tourner en utilisant les 18 GB de mon swap (oui, je sais, c'est beaucoup)...
Quelqu'un a une idée??

(je suis sous debian et je compile avec g++)


sortie de "free -s 0.01":

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
             total       used       free     shared    buffers     cached
Mem:        516692     437852      78840          0      40244     190016
-/+ buffers/cache:     207592     309100
Swap:     17757076        112   17756964
 
             total       used       free     shared    buffers     cached
Mem:        516692     445044      71648          0      40244     190016
-/+ buffers/cache:     214784     301908
Swap:     17757076        112   17756964
 
             total       used       free     shared    buffers     cached
Mem:        516692     455088      61604          0      40244     190016
-/+ buffers/cache:     224828     291864
Swap:     17757076        112   17756964
 
             total       used       free     shared    buffers     cached
Mem:        516692     467364      49328          0      40244     190016
-/+ buffers/cache:     237104     279588
Swap:     17757076        112   17756964
 
             total       used       free     shared    buffers     cached
Mem:        516692     476788      39904          0      40244     190016
-/+ buffers/cache:     246528     270164
Swap:     17757076        112   17756964
 
             total       used       free     shared    buffers     cached
Mem:        516692     489064      27628          0      40244     190016
-/+ buffers/cache:     258804     257888
Swap:     17757076        112   17756964
 
             total       used       free     shared    buffers     cached
Mem:        516692     499604      17088          0      40244     190016
-/+ buffers/cache:     269344     247348
Swap:     17757076        112   17756964
 
             total       used       free     shared    buffers     cached
Mem:        516692     510564       6128          0      40240     188996
-/+ buffers/cache:     281328     235364
Swap:     17757076        112   17756964
 
CRASH!

[Matthieu Brucher]

Attention, c'est un programme 32bits, non ? Donc son espace adressable est de 4Go maximum, et sous Linux c'est limité à 2Go par processus. Même si c'est juste juste au niveau de la mémoire, si tu as d'autres objets volumineux, ça plantera sans aucun doute.

[Ti-R]

Ce n'est pas possible d'allouer un peu moins de mémoire pour ton problème ?

D'allouer 20000 double, et de réutiliser cet espace 20000 fois ?

car 8*20000*20000 = 2.98 Go de mémoire.... c'est pas mal, un peu trop

[Médinoc]

J'ai bien peur que ce soit la seule solution:

20,000 * 20,000 : 400,000,000 de doubles.
Un double faisant 4 ou 8 octets, on se retrouve déjà avec 1.6 Go dans le premier cas, 3.2 Go dans le second cas (enfin, avec de "petits" Go) ---> Sur une machine 32bits, le second cas a déjà épuisé la mémoire disponible pour un processus.

[koala01]

Salut,

AMHA, une matrice carrée de 20.000 doubles, ca fait effectivement énrome… Est tu sur d'avoir besoin d'une matrice si grande?

D'un autre coté, n'oublie quand meme pas qu'une matrice, au niveau de la mémoire, ca garde toujours une seule dimention.

Rien ne t'empeche d'utiliser la formule classique

Code :

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

position[ligne][colone]=position[ligne*nombre_colone+colone]

ou ses dérivées, principalement, afin de t'éviter d'avoir à jouer systématiquement avec des pointeur de pointeurs...

Juste par aquit de conscience: quelle application pourrait nécessiter de disposer en permanence de 400.000.000 (car, il s'agit bien de cela) d'éléments, et en type double, qui plus est???

[mat.M]

for (int i=0; i<20000; i++) Matrix[i]=new double[20000];

Et la gestion d'exceptions elle est ou ?
Si c'était géré par un try..catch on serait plus fixés...
Pour des grosses allocations il faut passer par d'autres méthodes que new , utiliser des fonctions spécifiques à Linux pour la gestion de mémoire.