Discussion :

[Kaluza]

Bonjour à tous.

Je suis en train de coder un ensemble de classes pour faire une arborescence (BGL ne me permettant pas bien de faire ce que je souhaite faire). Et ce qui serait plus simple pour moi c'est que chaque objet est un pointeur vers son père et un pointeur vers un tableau de fils dans la structure en arborescence.

Bref, j'aurai besoin d'un truc de ce type :

Code :

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

1
2
3
4
5
6
class MaClasse
{
    private:
        MaClasse* pere;
        MaClasse* fils[8];
};

Question : est-ce que ce genre de chose fonctionne bien et même dans le cas où cela fonctionne est-ce que c'est considéré comme "propre" ?

Merci

[gbdivers]

pour l´utilisation du nom de la classe, pas de problème (class MaClass est une définition de MaClass donc elle peut être utilisée ensuite)
Par contre, c´est un choix d´utiliser des pointeurs nus et de pas utiliser un vector ?

[Kaluza]

Pour la question sur les vector : pure raison de perfs. J'ai noté des différences de perfs entre les vector et les tableaux C (j'ai posté une question là dessus récemment), et comme c'est un code destiné à tourner sur supercalculateurs, je veux éviter de perdre du temps avec des vectors alors que des tableaux C sont aussi simples à utiliser dans ce cas précis (il y aura surement des vectors dans d'autre parties de mon code mais pas là). (pour préciser l'arborescence comptera en général plus de 100 milliards d'éléments donc il faut que le truc soit plutôt bien conçu).

[Joel F]

turlututu, std::vector est tout a fait utilsiable dans un contexte HPC, du moment ou on l'utilise avec un allocateur correct et qu'on compile en -NDEBUG. Utilsier des pointeurs nus c'ets chercher le bugs car on a eu la flemme d'ecrire un operateru d'affectation.

[Kaluza]

Re.

Comme vous avez beaucoup plus d'expérience que moi sur ces questions, quelle serait la bonne méthode à employer ? (pour les pointeurs j'ai des habitudes venant du C).

Sachant que ma problématique est la suivante :
- je veux du code sûr
- je travaillerai environ avec 5 millions de MaClasse par CPU et la taille prise par chaque objet en mémoire est critique
- j'ai prévu pour chaque objet MaClasse 7 datamembers : 1 entier 64 bit + 2 entiers 8 bit + 3 pointeurs vers MaClasse (racine, pere, fils) + 1 pointeur vers AutreClasse
- Le pointeur vers racine : soit est NULL, soit pointe vers 1 racine
- Le pointeur vers pere pointe : soit est NULL, soit pointe vers 1 pere
- Le pointeur vers fils : soit est NULL, soit pointe vers un tableau de 8 fils

Quel est le meilleur moyen de faire cela de façon sûre sans augmenter la place que j'ai prévu en mémoire ?

Merci beaucoup

EDIT : + je peux utiliser les nouveautés de C++2011

[JolyLoic]

turlututu, std::vector est tout a fait utilsiable dans un contexte HPC, du moment ou on l'utilise avec un allocateur correct et qu'on compile en -NDEBUG. Utilsier des pointeurs nus c'ets chercher le bugs car on a eu la flemme d'ecrire un operateru d'affectation.

Comme en l’occurrence, le nombre de fils a l'air fixe, un std::array doit probablement être plus efficace qu'un std::vector, non ?

A moins que cette valeur de 8 soit un maximum, que pour la quasi totalité des nœuds il n'y ait que 2 fils, et qu'on gagne plein de mémoire en utilisant un vector ?

[Kaluza]

En gros je commence un module de maillage adaptatif pour un futur code N-body (avec relativité générale). En N dimensions (3 en général), si on atteint 2^N particules (8 en général) dans une cellule alors on ajoute un niveau de raffinement et on génère 2^N fils. Donc en gros soit il n'y a pas de fils, soit il y en a 8....

Et juste une question : dans mon std::array je mettrai quoi : des pointeurs ou directement les objets ?

[Joel F]

Comme en l’occurrence, le nombre de fils a l'air fixe, un std::array doit probablement être plus efficace qu'un std::vector, non ?

A moins que cette valeur de 8 soit un maximum, que pour la quasi totalité des nœuds il n'y ait que 2 fils, et qu'on gagne plein de mémoire en utilisant un vector ?

Evidemment. Je rebondissais juste sur ce bon vieux FUD du vector super-lent

[oodini]

turlututu, std::vector est tout a fait utilsiable dans un contexte HPC, du moment ou on l'utilise avec un allocateur correct et qu'on compile en -NDEBUG. Utilsier des pointeurs nus c'ets chercher le bugs car on a eu la flemme d'ecrire un operateru d'affectation.

D'ailleurs, si quelqu'un connaît un site qui aborde ces problématique de performances liées au stockage, je suis preneur.