Entièrement thread-safe shared_ptr mise en œuvre

L'ajout de la nécessaire obstacles à une telle entièrement thread-safe shared_ptr mise en œuvre serait susceptible d'influer sur les performances. Envisager la course suivante (note: pseudo-code abonde):

Thread 1:
global_ptr = A;

Filetage 2:
global_ptr = B;

Fil 3:
local_ptr = global_ptr;

Si l'on se constituantes d'opérations:

Thread 1:

A.refcnt++;
tmp_ptr = exchange(global_ptr, A);
if (!--tmp_ptr.refcnt) delete tmp_ptr;

Filetage 2:

B.refcnt++;
tmp_ptr = exchange(global_ptr, B);
if (!--tmp_ptr.refcnt) delete tmp_ptr;

Fil 3:

local_ptr = global_ptr;
local_ptr.refcnt++;

Clairement, si le thread 3 lit le pointeur après Un swap, alors B va et le supprime avant que le nombre de références peut être incrémenté, les mauvaises choses vont arriver.

Pour gérer cela, nous avons besoin d'une valeur factice être utilisé pendant que le thread 3 est en train de faire la refcnt mise à jour:
(note: compare_exchange(variable, attendue, de nouvelles) atomiquement remplace la valeur dans la variable avec de nouveau, si elle est actuellement égal à nouveau, puis renvoie la valeur true si elle l'a fait avec succès)

Thread 1:

A.refcnt++;
tmp_ptr = global_ptr;
while (tmp_ptr == BAD_PTR || !compare_exchange(global_ptr, tmp_ptr, A))
    tmp_ptr = global_ptr;
if (!--tmp_ptr.refcnt) delete tmp_ptr;

Filetage 2:

B.refcnt++;
while (tmp_ptr == BAD_PTR || !compare_exchange(global_ptr, tmp_ptr, A))
    tmp_ptr = global_ptr;
if (!--tmp_ptr.refcnt) delete tmp_ptr;

Fil 3:

tmp_ptr = global_ptr;
while (tmp_ptr == BAD_PTR || !compare_exchange(global_ptr, tmp_ptr, BAD_PTR))
    tmp_ptr = global_ptr;
local_ptr = tmp_ptr;
local_ptr.refcnt++;
global_ptr = tmp_ptr;

Vous avez dû ajouter une boucle, avec atomics dans le milieu de votre /de lecture/de l'opération. Ce n'est pas une bonne chose - et il peut être extrêmement coûteux sur certains Processeurs. Qui plus est, vous vous êtes occupé d'attente. Vous pouvez commencer à obtenir à l'aise avec les futexes et autres joyeusetés - mais à ce stade, vous avez réinventé le verrou.

Ce coût, qui doit être pris en charge par chaque opération, et est de nature très semblable à ce qu'un verrou serait vous donner de toute façon, c'est pourquoi vous n'avez généralement pas voir un tel thread-safe shared_ptr implémentations. Si vous avez besoin d'une telle chose, je vous recommande l'enveloppant d'un mutex et shared_ptr dans une classe utilitaire pour automatiser le verrouillage.

OriginalL'auteur bdonlan

Je ne sais pas du tel un pointeur intelligent de mise en œuvre, même si je dois poser la question: comment cela pourrait-il être le comportement utile? La seule scénarios que je peux penser à où vous trouverez simultanée pointeur de mises à jour des conditions de course (c'est à dire les bugs).

Ce n'est pas une critique -- il pourrait être légitime de cas d'utilisation, je ne peux pas penser à elle. S'il vous plaît laissez-moi savoir!

Re: EDIT2
Merci de fournir un couple de scénarios. Il ne sonne comme atomique pointeur écrit serait utile dans ces situations. (Une petite chose: pour le deuxième exemple, quand vous avez écrit "Si ce n'est pas NULL, il empêche le processeur de la destruction par l'attribution à ses propres partagé-ptr", j'espère que vous vouliez dire que vous affectez le global partagé pointeur vers le local pointeur partagé première puis vérifier si le local partagé pointeur est NULL -- comme vous l'avez décrit, elle est sujette à une condition de concurrence où le pointeur partagé devient NULLE après vous tester pour elle et avant de l'affecter à la locale.)

OriginalL'auteur j_random_hacker

Votre compilateur peut déjà fournir le thread-safe pointeurs intelligents dans les nouvelles Normes C++. Je crois TBB est la planification sur l'ajout d'un pointeur intelligent, mais je ne pense pas que c'est encore comprises. Vous pouvez être en mesure d'utiliser l'un des TBB est thread-safe conteneurs.

OriginalL'auteur

Je ne pense pas que ce si facile, il n'est pas assez pour envelopper votre sh_ptr classes avec un CS. Il est vrai que si vous maintenez un seul CS pour tous les pointeurs partagés il peut faire en sorte d'éviter la mutuelle de l'accès et de suppression des sh_ptr objets entre les différents threads. Mais ce serait terrible, un objet CS pour chaque pointeur partagé serait un véritable goulot d'étranglement. Il serait approprié si tous les wrappable nouveau ptr -s ont différentes CS s", mais de cette façon, nous devons créer notre CS dinamically, et de s'assurer de la copie ctors de sh_ptr classes de transmettre cette Cs. Maintenant, nous sommes arrivés à le même problème: qui quaranties que ce Cs ptr est déjà supprimé ou non. Nous pouvons être un peu plus smarty avec des volatiles m_bReleased drapeaux par exemple, mais de cette façon, nous ne pouvons pas collé les lacunes en matière de sécurité entre la vérification de l'indicateur et l'utilisation partagée de Cs. Je ne vois pas complètement sûr de la résolution de ce problème. Peut-être que terrible global Cs serait le mineur mauvais que le fait de tuer l'application. (désolé pour mon anglais)

OriginalL'auteur

À mon avis, la solution la plus simple est d'utiliser un intrusive_ptr avec quelques légères (mais nécessaire) de modifications.

J'ai partagé mes de mise en œuvre ci-dessous:

http://www.philten.com/boost-smartptr-mt/

OriginalL'auteur Phil Ten