La compréhension de std::atomique::compare_exchange_weak() en C++11

, Pourquoi le faire échanger dans une boucle?

Habituellement, vous voulez que votre travail soit fait avant de vous déplacer, donc, vous mettez compare_exchange_weak dans une boucle de sorte qu'il essaie d'échange jusqu'à ce qu'il réussit (c'est à dire, les retours true).

Notez que compare_exchange_strong est souvent utilisé dans une boucle. Il ne manque pas due à des parasites de l'échec, mais il n'échouent en raison des écritures simultanées.

Pourquoi utiliser weak au lieu de strong?

Assez facile: Fausse panne ne se produit pas souvent, donc c'est pas un gros gain de performance. En contraste, en tolérant un échec, qui permet une bien plus efficace la mise en œuvre de la weak version (en comparaison à strong) sur certaines plates-formes: strong doit toujours vérifier les parasites de l'échec et de la masquer. C'est cher.

Ainsi, weak est utilisé parce qu'il est beaucoup plus rapide que strong sur certaines plates-formes

Quand devez-vous utiliser weak et quand strong?

La référence membres de conseils lors de l'utilisation de weak et quand utiliser strong:

Quand a comparer-et-exchange est dans une boucle, la version faible rendement
de meilleures performances sur certaines plates-formes. Lorsqu'un faible comparer et d'échange
aurait besoin d'une boucle et d'une forte que l'on ne serait pas, la forte est
préférable.

Donc, la réponse semble être assez simple à retenir: Si vous devez introduire une boucle seulement à cause de parasites de l'échec, de ne pas le faire; utilisation strong. Si vous avez une boucle de toute façon, puis utilisez weak.

Pourquoi est !expected dans l'exemple

Il dépend de la situation et de sa valeur sémantique, mais généralement, il n'est pas nécessaire pour l'exactitude. En omettant il serait rendement très semblable à la sémantique. Seulement dans un cas où un autre thread peut réinitialiser la valeur de false, la sémantique pourrait devenir légèrement différente (mais je ne peux pas trouver un exemple significatif endroit où vous voulez que). Voir Tony D. commentaire pour une explication détaillée.

C'est simplement une voie rapide quand un autre thread écrit true: Puis le nous abandonner au lieu d'essayer d'écrire true de nouveau.

Sur votre dernière question

Mais comme analysé ci-dessus, les deux versions dans une boucle doit donner le même rendement.
Quelle est la chose qui me manque?

De Wikipédia:

Réel implémentations de LL/SC ne réussissent pas toujours si il n'y a pas
les mises à jour simultanées à l'emplacement de la mémoire en question. Exceptionnelles
les événements entre les deux opérations, tel qu'un changement de contexte, un autre
la charge d'un lien, ou même (sur de nombreuses plateformes) une autre charge ou un magasin de
l'opération, seront la cause de la boutique, à la condition d'erreur échec. Les plus âgés
les implémentations échec si il y a des mises à jour sont diffusées au cours de la
bus mémoire.

Donc, LL/SC échouera faussement changement de contexte, par exemple. Maintenant, la version forte de apporterait sa "petite boucle" de détecter les parasites de l'échec et de la masquer par essayer de nouveau. Notez que la boucle est également plus complexe qu'un simple CAS de la boucle, car il faut distinguer entre les parasites de l'échec (et masque) et l'échec en raison de l'accès simultané (qui se traduit par un retour à la valeur false). La version faible, n'a pas de boucles.

Puisque vous fournir explicite boucle dans les deux exemples, il n'est tout simplement pas nécessaire d'avoir la petite boucle pour la version forte. Par conséquent, dans l'exemple de la strong version, la vérification de l'échec est fait en deux fois: une fois par compare_exchange_strong (ce qui est plus compliqué car il faut distinguer les parasites de l'échec et simultanées acces) et une fois par votre boucle. Ce cher vérifier est pas nécessaire et que la raison pourquoi weak sera plus rapide ici.

Notez également que votre argument (LL/SC) est à seulement un possibilité de le mettre en œuvre. Il y a plus de plates-formes qui ont même des jeux d'instructions différents. En plus (et surtout), il faut noter que std::atomic doit prendre en charge toutes les opérations pour tous les types de données possibles, de sorte que même si vous déclarez une dizaine de millions d'octets struct, vous pouvez utiliser compare_exchange sur cette. Même quand sur un CPU qui n'ont CAS, vous ne pouvez pas le CAS de dix millions d'octets, de sorte que le compilateur va générer d'autres instructions (probablement de verrouillage acquérir, suivi par un non-atomique de comparer et d'échange, suivie d'une libération du verrou). Maintenant, pensez à combien de choses peuvent se produire tout en échangeant les dix millions d'octets. Ainsi, alors que une fausse erreur peut être très rare pour 8 octets d'échanges, il peut être plus commun dans ce cas.

Donc, en un mot, C++ vous donne deux sémantique, un "best effort" (lesweak) et un "je vais le faire pour vous, n'importe comment beaucoup de mauvaises choses peuvent se produire entre les deux" un (strong). Comment ceux-ci sont mis en œuvre sur les différents types de données et plates-formes est un tout autre sujet. N'attachez pas votre modèle mental de la mise en œuvre sur votre plate-forme spécifique; la bibliothèque standard est conçu pour fonctionner avec d'autres architectures que vous pourriez être conscients de. La seule conclusion que nous pouvons tirer est que la garantie de la réussite est généralement plus difficile (et donc requièrent plus de travail) que juste essayer et laissant de la place pour l'échec possible.

Je vais essayer de répondre à moi-même, après être passé par diverses ressources en ligne (par exemple, cette une et cette une), le C++11 Standard, ainsi que les réponses données ici.

Les questions sont regroupées (par exemple, "pourquoi !prévu ?" est fusionné avec "pourquoi mettre compare_exchange_weak() dans une boucle ?") et les réponses sont données en conséquence.

---

Pourquoi ne compare_exchange_weak() doivent être dans une boucle dans presque toutes les utilisations?

Modèle Typique D'Un

Vous avez besoin de réaliser une mise à jour atomique basé sur la valeur de la variable atomique. Un échec indique que la variable n'est pas mise à jour avec notre valeur souhaitée et nous voulons réessayer il. Notez que nous n'avons pas vraiment se soucier de savoir s'il échoue en raison d'écriture simultanées ou fausse panne. Mais nous ne de soins que c'est nous qui font de ce changement.

expected = current.load();
do desired = function(expected);
while (!current.compare_exchange_weak(expected, desired));

D'un exemple réel pour plusieurs threads pour ajouter un élément à une seule liste liée simultanément. Chaque thread chargé pour la première fois la tête du pointeur, alloue un nouveau nœud et l'ajoute à la tête de ce nouveau nœud. Enfin, il tente d'échanger le nouveau nœud avec la tête.

Un autre exemple est la mise en œuvre mutex en utilisant std::atomic<bool>. Au plus un seul thread peut accéder à la section critique à la fois, en fonction sur le thread première série current à true et sortir de la boucle.

Modèle Typique B

C'est en fait le motif mentionné dans Anthony du livre. Contrairement à Un modèle, vous voulez la variable atomique à être mis à jour une fois, mais vous n'avez pas de soins qui le fait. Tant qu'il n'est pas mis à jour, que vous essayez à nouveau. Ceci est généralement utilisé avec des variables booléennes. E. g., vous avez besoin de mettre en œuvre un déclencheur pour une machine d'état de se déplacer. Le thread qui a appuyé sur la gâchette est indépendamment.

expected = false;
//!expected: if expected is set to true by another thread, it's done!
//Otherwise, it fails spuriously and we should try again.
while (!current.compare_exchange_weak(expected, true) && !expected);

Noter que nous ne sont généralement pas utiliser ce modèle pour mettre en œuvre un mutex. Sinon, plusieurs threads peuvent être à l'intérieur de la section critique en même temps.

Cela dit, il doit être rare d'utiliser compare_exchange_weak() en dehors d'une boucle. Au contraire, il y a des cas que la version forte est en cours d'utilisation. E. g.,

bool criticalSection_tryEnter(lock)
{
  bool flag = false;
  return lock.compare_exchange_strong(flag, true);
}

compare_exchange_weak n'est pas de mise ici, parce que quand il retourne en raison de parasites de l'échec, il est probable que personne n'occupe la section critique encore.

De Faim Fil?

Un point à mentionner est que ce qui se passe si les fausses pannes de continuer à se produire donc d'en priver le fil? Théoriquement, il pourrait se produire sur des plates-formes compare_exchange_XXX() est de mettre en œuvre une séquence d'instructions (par exemple, LL/SC). Fréquents accès de la même ligne de cache entre LL et SC va produire en continu des défaillances parasites. De façon plus réaliste exemple est dû à un muet de planification où tous les threads simultanés sont entrelacés de la manière suivante.

Time
 |  thread 1 (LL)
 |  thread 2 (LL)
 |  thread 1 (compare, SC), fails spuriously due to thread 2's LL
 |  thread 1 (LL)
 |  thread 2 (compare, SC), fails spuriously due to thread 1's LL
 |  thread 2 (LL)
 v  ..

Peut-il arriver?

Il ne se passe pas toujours, heureusement, grâce à ce que le C++11 exige:

Implémentations devraient veiller à ce que la faiblesse de comparer et d'échanger
l'exploitation n'est pas systématiquement renvoie false si le atomique
l'objet a une valeur différente de prévu ou il y a simultanées
modifications de l'objet atomique.

Pourquoi ne nous dérange pas utiliser compare_exchange_weak() et écrire la boucle de nous-mêmes? Nous pouvons simplement utiliser compare_exchange_strong().

Il dépend.

Cas 1: Lorsque les deux doivent être utilisés à l'intérieur d'une boucle. C++11 dit:

Quand a comparer-et-exchange est dans une boucle, la version faible rendement
de meilleures performances sur certaines plates-formes.

Sur x86 (au moins actuellement. Peut-être que ça va recourir à un semblable régime LL/SC un jour, pour des performances lorsque plus de cœurs sont introduits), les faibles et les forts de la version sont essentiellement les mêmes, car ils se résument à la seule instruction cmpxchg. Sur d'autres plates-formes où compare_exchange_XXX() n'est pas mis en œuvre atomiquement (ici, pas d'équipement unique primitive existe), la version faible à l'intérieur de la boucle peut gagner la bataille, à cause de la forte que l'on aura à gérer le faux échecs et de réessayer en conséquence.

Mais,

rarement, on peut préférer compare_exchange_strong() sur compare_exchange_weak() même dans une boucle. E. g., quand il y a beaucoup de choses à faire entre la variable atomique est chargé et calculé de la nouvelle valeur en échange (voir function() ci-dessus). Si la variable atomique elle-même ne change pas souvent, nous n'avons pas besoin de répéter le coût de calcul pour tous les parasites de l'échec. Au lieu de cela, nous pouvons espérer que compare_exchange_strong() "absorber" ces échecs et de nous contenter de répéter le calcul quand il échoue en raison d'un réel changement de valeur.

Cas 2: Lorsque seule compare_exchange_weak() doivent être utilisés à l'intérieur d'une boucle. C++11 dit aussi:

Lorsqu'un faible comparer et d'échanger des aurait besoin d'une boucle et d'une forte
ne serait pas, la forte est préférable.

C'est généralement le cas lorsque vous boucle afin d'éliminer les fausses pannes à partir de la version faible. Vous recommencez jusqu'à ce que l'échange est un succès ou un échec à cause de l'écriture simultanées.

expected = false;
//!expected: if it fails spuriously, we should try again.
while (!current.compare_exchange_weak(expected, true) && !expected);

Au mieux, c'est réinventer la roue et d'effectuer les mêmes que compare_exchange_strong(). Le pire? Cette approche ne permet pas de profiter pleinement des machines qui fournissent des non-faux de comparer et d'échange de matériel.

Dernier, si vous boucle pour d'autres choses (par exemple, voir "Schéma Typique d'Un" ci-dessus), alors il ya une bonne chance que compare_exchange_strong() doit également être mis dans une boucle, ce qui nous ramène au cas précédent.