performance du new

Bonjour,


J'ai une boucle qui tourne à l'infini et dans cette boucle, je construis une enveloppe convexe à partir de quelques points.
Voici mon code :

Code:

---

1 2 3 4 5 6

while(true) { //....... delete convexHull; convexHull = new ConvexHull(points); //......... }

---

Est-ce que le delete+new est quelque chose de lent ou d'assez rapide ?
Faut-il préférer un delete+new de 16 octets ou un clear de deux std::list<int> d'une dizaine d'éléments par exemple ?

Je me doute bien que le new et le delete dépende un peu de l'OS mais j'aimerais avoir quand même une petite idée la dessus.

Et tant que je suis, quel est la différence de rapidité entre les 2 lignes:

Code:

---

1 2	A a; A *a = new A();

---

Merci d'avance...

Citation:

---

Est-ce que le delete+new est quelque chose de lent ou d'assez rapide ?

---

Lent. Déjà ça dépends de l'implémentation fournie par le compilateur, souvent fait pour gérer les "cas généraux". Ensuite il y a le fait qu'il y a pas mal de vérifications effectuées, et que l'OS aussi doit effectuer l'allocation.

Si ça pose un problème, il y a plusieurs solutions qui permettent d'accélérer le tout. Globalement elles reviennent toutes à éviter totallement toute allocation/désallocation de mémoire pendant le traitement des données. (voir placement new, std::vector::reserve(), boost::pool ...)

Souvent dans le développement de jeux vidéos (pour d'autres raisons aussi) on alloue dés le départ des pool de mémoire qui sont donc réservés du point de vue de l'OS, et qu'on peut ensuite utiliser pour créer des objets via des placement new, souvent avec un peu de sucre syntactique histoire de faciliter l'ecriture.

Dans les cas simples, réserver la mémoire nécessaire avant l'utilisation, comme reserver la mémoire d'un vector avant de l'utiliser, est largement suffisant.

Citation:

---

Envoyé par zenux

Et tant que je suis, quel est la différence de rapidité entre les 2 lignes:

Code:

---

1 2	A a; A *a = new A();

---

Merci d'avance...

---

Si tu poses cette question, c'est qu'il te manque les notions de base de C++.
La première version met la variable sur la pile, ce qui est extrémement rapide et permet aussi une gestion mémoire automatique (l'objet meurt lorsqu'il sort de la portée).
La deuxième version alloue dynamiquement un objet dans une zone libre. C'est assez coûteux et il te faudra toi-même libérer cette mémoire. Il est très fortement conseillé d'utiliser l'idiome RAII pour gérer cette mémoire de manière automatique, d'une manière en fait similaire à une variable sur la pile.

Code:

---

1 2 3 4 5 6 7

while(true) { //....... delete convexHull; convexHull = new ConvexHull(points); //......... }

---

c'est presque gratuit (presque...) avec la plupart des malloc, qui vont reutiliser le meme bloc. mais c'est tres tres deconseille car une variable locale semble bien plus indiquée ici.

Je ne vais pas répeter ce qui a été dit précédemment et qui est tout à fait pertinent... Dans l'exemple sus-cité, une variable locale semble bien plus appropriée...

Néanmoins, j'aimerai apporté quelques nuances:

Citation:

---

Envoyé par zenux

Est-ce que le delete+new est quelque chose de lent ou d'assez rapide ?

---

Le "new" du C++ est *tres* versatile... C'est un shortcut de language sur: une allocation (operator new(size_t)) et un appel au constructeur de l'objet (placed new).
Le premier peut être surchargé par unité de compilation, classe, namespace... Il est donc assez difficile de donner une réponse quant à sa rapidité...
L'implémentation par défaut est un appel à "malloc", qui peut être assez lent, en particulier dans un contexte multi-threadé.

Le "delete" du C++ est le pendant exact du new, à savoir: un appel au destructeur de l'objet, puis une désallocation (operator delete(void*)) de la mémoire. Et ce dernier est obligatoirement symétrique avec le new... donc... par défaut... un appel à "free", qui va lui aussi être lent en contexte multi-threadé.

Code:

---

A a;

---

Va faire:
- Déplacer le pointeur de pile du thread en cours de sizeof(A) (le plus souvent une seule fois, quand nécessaire, pour toutes les variables 'utiles').
- Appeler le constructeur par défaut de A sur la partie ainsi "allouée".
...
- Appeler le destructeur de A
- Déplacer le pointeur de pile du thread en cours en arriere (d'ailleurs le plus souvent en une seule fois, à la sortie de la fonction, pour toutes les variables).

Ainsi...

Code:

---

1 2

A a; A b;

---

Va faire 1 seul déplacement de pile et deux appels constructeurs...

Code:

---

1 2 3

A *a = new A(); delete a;

---

Va faire:
- Allocation de sizeof(A) octets. Soit:
- - Semaphore-Lock
- - Recherche zone mémoire capable de contenir sizeof(A)
- - Reservation de la mémoire.
- - Semaphore-Unlock
- Appel du constructeur de A
...
- Appel du destructeur de A
- Libération de la zone... soit:
- - Semaphore-Lock
- - Libération de la mémoire... avec éventuellement, aggrégation des zones libres.
- - Semaphore-Unlock