l'affirmation selon laquelle unique_ptr fonctionne aussi bien qu'un pointeur brut après optimisation s'applique principalement uniquement aux opérations de base sur un seul pointeur, telles que la création, le déréférencement, l'assignation d'un seul pointeur et la suppression. Ces opérations sont définies assez simplement pour qu'un compilateur d'optimisation puisse généralement effectuer les transformations nécessaires de sorte que le code résultant soit équivalent (ou presque) en performance à la version brute ⁰ .

un endroit qui tombe en morceaux est particulièrement higher level language-based optimizations sur les conteneurs à base de tableaux tels que std::vector , comme vous l'avez noté avec votre test. Ces conteneurs utilisent généralement niveau source optimisations qui dépendent des caractéristiques du type pour déterminer au moment de la compilation si un type peut être copié en toute sécurité en utilisant une copie byte sage comme memcpy , et déléguer à une telle méthode si oui, ou sinon, revenez à une boucle de copie par élément.

pour pouvoir être copié en toute sécurité avec memcpy un objet doit être trivialement copiable . Maintenant std::unique_ptr n'est pas trivialement copiable car en effet il ne répond pas à plusieurs des exigences comme avoir seulement la copie triviale ou supprimé et déplacer les constructeurs. Le mécanisme exact dépend de la bibliothèque standard concernée, mais en général une qualité std::vector la mise en œuvre finira par appeler une forme spécialisée de quelque chose comme std::uninitialized_copy pour les types trivialement-copiables qui délègue juste à memmove .

les détails typiques de la mise en œuvre sont assez torturés, mais pour libstc++ (utilisé par gcc ) vous pouvez voir la divergence de haut niveau dans std::uninitialized_copy :

 template<typename _InputIterator, typename _ForwardIterator>
 inline _ForwardIterator
 uninitialized_copy(_InputIterator __first, _InputIterator __last,
                    _ForwardIterator __result)
 {
        ...
   return std::__uninitialized_copy<__is_trivial(_ValueType1)
                                    && __is_trivial(_ValueType2)
                                    && __assignable>::
     __uninit_copy(__first, __last, __result);
 }

de là, vous pouvez prendre ma parole que beaucoup de les méthodes std::vector " mouvement "finissent ici, et que __uninitialized_copy<true>::__uinit_copy(...) appelle finalement memmove alors que la version <false> ne le fait pas - ou vous pouvez tracer à travers le code vous-même (mais vous avez déjà vu le résultat dans votre benchmark).

finalement alors, vous finissez avec plusieurs boucles qui effectuent les étapes de copie requises pour les objets non-triviaux, comme appeler le constructeur de déplacement de l'objet de destination, et ensuite appeler le destructeur de tous les objets de la source. Ce sont des boucles séparées et même les compilateurs modernes ne seront pas en mesure de raisonner sur quelque chose comme "OK, dans la première boucle j'ai déplacé tous les objets de destination de sorte que leur ptr membre sera nul, donc la deuxième boucle est un no-op". Enfin, pour égaler la vitesse des pointeurs bruts, non seulement les compilateurs devraient optimiser à travers ces deux boucles, ils devraient avoir une transformation qui reconnaît que l'ensemble peut être remplacé par memcpy ou memmove ² .

donc une réponse à votre question Est que les compilateurs ne sont tout simplement pas assez intelligents pour faire cette optimisation, mais c'est en grande partie parce que la version" brute " a beaucoup d'aide de compilation pour sauter le besoin de cette optimisation entièrement.

"1519790920 Boucle" Fusion

tel que mentionné les implémentations existantes vector implémentent une opération de type redimensionnement dans deux boucles distinctes (en plus de Travaux hors boucle tels que l'attribution du nouveau stockage et la libération de l'ancien stockage):

• copier les objets source dans le tableau de destination nouvellement attribué (en utilisant conceptuellement quelque chose comme le placement new appelant le constructeur move).
"1519840920 de" Détruire la source des objets dans l'ancienne région.

conceptuellement, vous pourriez imaginer une autre façon: faire tout cela en une boucle, copier chaque élément et immédiatement détruire. Il est possible qu'un compilateur puisse même remarquer que les deux boucles itèrent sur le même ensemble de valeurs et fusionnent les deux boucles en une seule. [Apparemment], howevever, ( https://gcc.gnu.org/ml/gcc/2015-04/msg00291.html ) gcc ne pas faire "1519460920 boucle" fusion aujourd'hui, et à ne pas faire clang ou icc si vous croyez que ce test .

alors nous sommes laissés essayant de mettre les boucles ensemble explicitement au niveau de la source.

maintenant l'implémentation à deux boucles aide à préserver le contrat de sécurité d'exception de l'opération en ne détruisant aucun objet source jusqu'à ce que nous sachions que la partie construction de la copie est terminée, mais elle aide aussi à optimiser la copie et la destruction lorsque nous avons des objets respectivement trivialement-copiables et trivialement-destructibles. En particulier, avec des traits simples basés sur sélection Nous pouvons remplacer la copie par une memmove et la boucle de destruction peut être supprimée entièrement ³ .

ainsi l'approche à deux boucles aide quand ces optimisations s'appliquent, mais cela fait mal dans le cas général des objets qui ne sont ni trivialement copiables ou destructibles. Cela signifie que vous avez besoin de deux passes sur les objets et vous perdez l'occasion d'optimiser et d'éliminer le code entre la copie de l'objet et il est subséquent destruction. Dans le cas unique_ptr vous perdez la capacité pour le compilateur de propager la connaissance que la source unique_ptr aura un NULL interne ptr membre et donc sauter le if (ptr) delete ptr vérifier entièrement ⁴ .

Trivialement Mobile

maintenant, on peut se demander si nous pourrions appliquer les mêmes caractéristiques d'optimisation du temps de compilation au cas unique_ptr . Par exemple, on pourrait s'intéresser à la trivially copiable exigences et voir qu'ils sont peut-être trop strictes pour le commun move opérations dans std::vector . Bien sûr, un unique_ptr n'est évidemment pas trivialement copiable puisqu'une copie bit-wise laisserait à la fois la source et la destination objet dû le même pointeur( et le résultat de la double-suppression), mais il semble qu'il devrait être bit-wise mobile : si vous déplacez un unique_ptr d'une zone de mémoire à un autre, tel que vous ne considériez plus la source comme un objet vivant (et donc n'appellera pas son destructeur) il devrait "juste fonctionner", pour l'implémentation typique unique_ptr .

malheureusement, il n'existe pas de concept" trivial move", bien que vous puissiez essayer de lancer le vôtre. Il semble y avoir un débat ouvert à savoir si C'est UB ou non pour les objets qui peuvent être copiés byte-wise et ne dépendent pas de leur comportement du constructeur ou du destructeur dans le scénario de déplacement.

vous pouvez toujours implémenter votre propre concept trivialement mobile, qui serait quelque chose comme (a) l'objet a un constructeur de mouvements trivial et (b) lorsqu'il est utilisé comme argument source du constructeur de mouvements, l'objet est laissé dans un état où son destructeur n'a aucun effet . Notez qu'une telle définition est actuellement la plupart du temps inutile, car "trivial move constructor" (essentiellement au niveau des éléments) copie et rien d'autre) n'est pas cohérent avec la modification de l'objet source. Ainsi, par exemple, un constructeur trivial move ne peut pas définir le ptr membre de la source unique_ptr à zéro. Donc, vous auriez besoin de sauter à travers quelques cerceaux tels que l'introduction du concept d'une mouvement destructif opération qui laisse l'objet source détruit, plutôt que dans un état valide-mais-non spécifié.

vous pouvez trouver une discussion plus détaillée de ce" trivially movable "sur ce fil sur le groupe de discussion ISO C++ usenet. Dans le particulier, dans la réponse liée, la question exacte des vecteurs de unique_ptr est adressée:

Il s'avère que de nombreux pointeurs intelligents (unique_ptr et shared_ptr inclus) de ces trois catégories et en les appliquant vous pouvez ont vecteurs de pointeurs intelligents, pratiquement zéro frais généraux brut les pointeurs de même dans les constructions de débogage non optimisées.

Voir aussi la relocator proposal.

---

⁰ bien que les exemples non vectoriels à la fin de votre question montrent que ce n'est pas toujours le cas. Ici, il est en raison d'un possible alias comme zneak explique dans sa réponse . Les pointeurs bruts éviteront beaucoup de ces problèmes d'aliasing puisqu'ils manquent le unique_ptr A (E. g, vous passez un pointeur brut par valeur, plutôt qu'une structure avec un pointeur par référence) et peut souvent omettre le if (ptr) delete ptr vérifier entièrement.

² c'est en fait plus difficile que vous pourriez le penser, parce que memmove , par exemple, a une sémantique subtilement différente d'une boucle de copie d'objet, lorsque la source et la destination se chevauchent. Bien sûr, le code de caractères de type de haut niveau qui fonctionne pour les points bruts sait (par contrat) qu'il n'y a pas de chevauchement, ou que le comportement de memmove est cohérent, même s'il y a chevauchement, mais prouver la même chose lors d'un passage ultérieur d'optimisation arbitraire peut être beaucoup plus difficile.

³ il est important de noter que ces optimisations sont plus ou moins indépendantes. Par exemple, de nombreux objets sont trivialement destructibles qui ne sont pas trivialement copiable.

⁴ bien que mon test ni gcc ni clang n'ont été en mesure de supprimer le contrôle, même avec __restrict__ appliqué, apparemment en raison d'une analyse d'alias insuffisamment puissante, ou peut-être parce que std::move supprime le qualificatif" restreindre " d'une façon ou d'une autre.