Discussion :

[YohDono]

Bonjour,

Je cherche à déterminer les points qui compose une sphère voici ma fonction :

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
std::vector<char> MaClasse::generateSphere(float diametre, float orgX, float orgY, float orgZ)
{
    std::vector<char> liste;
    char inSphere;
    int y, z;
	/*		y
	 * 		|_x
	 * 	       /
	 * 	     z
	 * */
 
    for(int x = orgX; x < diametre; x = x + 2)
    {
        for(y = orgY; y < diametre; y = y + 2)
        {
            for(z = orgZ; z < diametre; z = z + 2)
            {
		inSphere = isInSphere(diametre, abs(orgX - x), abs(orgY - y), abs(orgZ - z));
		liste.push_back(inSphere); // 0 ou 1
            }
        }
    }
 
    return liste;
}
 
char MaClasse::isInSphere(float diametre, float x, float y, float z)
{
    return square(x) + square(y) + square(z) <= square(diametre);
}

Lorsque je lance l’exécution avec un diamètre de 10 000 000 (pas de restriction sur le temps de calcul), j'obtiens l'exception std::bad_alloc...

Comment puis je faire pour obtenir tous mes points ?

Merci

Ps : J'ai essayé d'obtenir que le quart de ma sphère et ensuite effectué une symétrie,mais j'ai la même exception qui se lève...

[Bousk]

Bonjour,

pour 10 000 000 tu auras jusque 5 000 000 * 5 000 000 * 5 000 000 de push_back...
Ta liste finale devrait faire jusque 5 000 000 * 5 000 000 * 5 000 000 de char, ce qui est une taille déjà extraordinaire.
Mais en plus, le push_back doit réallouer une mémoire plus grande quand le push_back arrive au bout de l'allocation déjà faite.
Potentiellement à un moment on se retrouve avec une liste de bcp trop de millions + encore plus de millions char.
Inutile d'être un grand mathématicien pour supposer que c'est bcp trop de mémoires demandée.

Btw, une bonne pratique avec vector (que l'on retrouve dans un bon millier de posts sur ce forum, surement en faq etc...) c'est re faire un reserve avant les push_back.

Une autre bonne idée serait d'oublier l'idée saugrenue de vouloir une sphère de 10 000 000 de diamètre.
Ou tout simplement ne pas créer (Diamètre/2)^3 char. A quoi peut bien servir cette liste ?!

La réponse est simple : tu ne pourras jamais avoir autant de "points".

[koala01]

Salut,

L'exception std:: bad_alloc t'indique que "désolé mon p'tit gars, mais le système ne dispose pas d'assez de mémoire pour te fournir un espace contigu suffisamment grand pour te permettre de représenter en mémoire ce que tu demande".

Autrement dit, tu atteints les limites de ce que le système est susceptible de supporter.

Il peut y avoir plusieurs raisons à cela:

L'architecture cible de ton programme limite la taille de mémoire disponible (par exemple, tu ne peux pas utiliser 2Go de mémoire avec une applications 32 bits sous windows)

Le mode de fonctionnement de la collection que tu utilises fait qu'il y a un moment où le système a (temporairement) besoin d'un surplus d'espace libre.

Tu essayes de manipuler un nombre décidément trop important de données.

Vu que tu utilises un vecteur de char, je dirais que les deux raisons les plus vraisemblables sont la première et la deuxième

En effet, si tu compiles ton application en mode 32 bits, tu subira "de plein fouet" la limite imposée de ne pas dépasser les 2Gb d'espace mémoire alloués à une seule et même application.

Le fait de veiller à compiler ton application en 64 bits (si tant est que tu puisses le faire et utiliser une application 32 bits) pourrait te permettre de résoudre "temporairement" le problème.

Si je parle de le résoudre "temporairement", c'est, tout simplement, parce qu'il peut parfaitement arriver un moment où les restrictions imposées aux applications 64 bits risquent de te rattraper

Ce sera peut etre à 100 millions, peut etre à 30 milliards (ou à 300), mais, tôt ou tard, le système risque de te dire qu'il ne dispose pas d'assez d'espace mémoire

Pour comprendre la deuxième raison, il faut savoir comment fonctionne la classe std::vector.

Elle nous garanti en effet que les éléments seront contigus en mémoire, ce qui fait que, si tu as besoin de l'espace nécessaire pour représenter 10 000 00 de caractères, il faut trouver un espace mémoire égal à 10 Mb (enfin, à peine moins ) qui ne sont pas utilisés.

Le problème, c'est que tu as trois boucles imbriquées, ce qui fait que tu vas devoir trouver d'autant plus de mémoire pour travailler

Tu comprendras tout de suite qu'il est déjà difficile de trouver toute cette mémoire disponible en une seule fois

Mais là n'est pas le seul problème!!!

En effet, la classe vector va devoir régulièrement augmenter l'espace mémoire dont elle dispose (à l'occasion du push_back).

Et pour garantir que les données reste contigües en mémoire, elle vas travailler dans un ordre proche de

1. demander l'allocation dynamique d'une taille supérieure à la taille actuelle (souvent 1.5 * la taille actuelle il me semble)
2. copier l'ensemble du contenu actuel dans l'espace mémoire dont elle vient de demander l'allocation dynamique
3. libérer l'espace mémoire "d'origine"
4. considérer le nouvel espace mémoire comme étant celui qui contient les données

Cela signifie que, de l'étape 1 à l'étape 3, il faudra que le système ait trouvé (peu ou prou) 2,5 fois l'espace mémoire suffisant pour représenter tous les élément du vecteur, alors que je viens d'attirer ton attention sur le fait qu'il risque, déjà, d'avoir du mal à trouver l'espace mémoire suffisant pour représenter tous les éléments!!!

Tu comprendras qu'il n'est pas particulièrement étonnant que le système se plaigne, à un moment ou à un autre, de ne plus trouver assez de mémoire

D'autres collections (je penses en particulier à std:: list ) ne posent pas ce problème car chaque élément est relié à l'élément suivant.

Cela permet de se contenter d'un espace mémoire suffisant pour représenter un pointeur (vers l'élément suivant) + l'espace mémoire pour représenter l'élément en question, mais...:

• Déjà, les données ne sont plus contigues en mémoire (ou, du moins, on n'a strictement aucune garantie qu'elles le soient)
• Etant donné que tes données "significatives" sont des char, cela implique que la taille du lien vers l'élément suivant est plus importante que celle de la donnée que tu veux placer dans la liste
• Pour pouvoir accéder au 10 000 000 eme element, tu auras du parcourir les 9 999 999 premiers

Au final, et malgré ce que je disais au début de mon intervention, on en revient à la troisième raison, quel que soit la solution envisagée: il semblerait que tu essayes définitivement de gérer trop de données d'un coup

Es tu sur qu'il faille d'office l'ensemble des différents éléments

Ne pourrais tu pas envisager de travailler par "secteurs" voir par "couche" de ta sphère

Cela nécessiterait sans doute des temps de chargements et ou de calcul entre différents secteurs ou couches, mais ca te permettrait très certainement de limiter le nombre d'éléments à gérer "en même temps"