std::atomic_compare_exchange_weak, std::atomic_compare_exchange_strong, std::atomic_compare_exchange_weak_explicit, std::atomic_compare_exchange_strong_explicit

<metanoindex/>

 

C++

Langage

Concepts

Bibliothèque d'utilitaires

Bibliothèque pour les chaînes de caractères

Bibliothèque de conteneurs

Bibliothèque d'algorithmes

Bibliothèque d'itérateurs

Bibliothèque pour le calcul numérique

Bibliothèque pour les entrées/sorties

Bibliothèque pour la régionalisation

Bibliothèque pour les expressions régulières (C++11)

Bibliothèque pour les opérations atomiques (C++11)

Bibliothèque pour les processus légers (threads) (C++11)

 

Atomique opérations de la bibliothèque

Types Original: Types The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

atomic (C++11)

atomic_is_lock_free (C++11)

Fonctions Original: Functions The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

atomic_store atomic_store_explicit (C++11) (C++11)

atomic_load atomic_load_explicit (C++11) (C++11)

atomic_exchange atomic_exchange_explicit (C++11) (C++11)

atomic_compare_exchange_weak atomic_compare_exchange_weak_explicit atomic_compare_exchange_strong atomic_compare_exchange_strong_explicit (C++11) (C++11) (C++11) (C++11)

atomic_fetch_add atomic_fetch_add_explicit (C++11) (C++11)

atomic_fetch_sub atomic_fetch_sub_explicit (C++11) (C++11)

atomic_fetch_and atomic_fetch_and_explicit (C++11) (C++11)

atomic_fetch_or atomic_fetch_or_explicit (C++11) (C++11)

atomic_fetch_xor atomic_fetch_xor_explicit (C++11) (C++11)

Drapeaux atomiques Original: Atomic flags The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

atomic_flag (C++11)

atomic_flag_test_and_set atomic_flag_test_and_set_explicit (C++11) (C++11)

atomic_flag_clear atomic_flag_clear_explicit (C++11) (C++11)

Initialisation Original: Initialization The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

atomic_init (C++11)

ATOMIC_VAR_INIT (C++11)

ATOMIC_FLAG_INIT (C++11)

Mémoire de la commande Original: Memory ordering The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

memory_order (C++11)

kill_dependency (C++11)

atomic_thread_fence (C++11)

atomic_signal_fence (C++11)

 

<tbody> </tbody>

Déclaré dans l'en-tête <atomic>
template< class T > bool atomic_compare_exchange_weak( std::atomic<T>* obj, T* expected, T desired ); template< class T > bool atomic_compare_exchange_weak( volatile std::atomic<T>* obj, T* expected, T desired );	(1)	(depuis C++11)
template< class T > bool atomic_compare_exchange_strong( std::atomic<T>* obj, T* expected, T desired ); template< class T > bool atomic_compare_exchange_strong( volatile std::atomic<T>* obj, T* expected, T desired );	(2)	(depuis C++11)
template< class T > bool atomic_compare_exchange_weak_explicit( std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail ); template< class T > bool atomic_compare_exchange_weak_explicit( volatile std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail );	(3)	(depuis C++11)
template< class T > bool atomic_compare_exchange_strong_explicit( std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail ); template< class T > bool atomic_compare_exchange_strong_explicit( volatile std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail );	(4)	(depuis C++11)

Compare atomiquement la valeur pointée par obj avec la valeur pointée par expected, et si ceux-ci sont égaux, remplace l'ancien desired (effectue lecture-modification-écriture). Dans le cas contraire, la valeur réelle charge pointée par obj en *expected (effectue une opération de charge) .

Original:

Atomically compares the value pointed to by obj with the value pointed to by expected, and if those are equal, replaces the former with desired (performs read-modify-write operation). Otherwise, loads the actual value pointed to by obj into *expected (performs load operation).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Les modèles de la mémoire pour la lecture-modification-écriture et les opérations de chargement et sont succ fail respectivement. Les versions (1-2) std::memory_order_seq_cst utiliser par défaut .

Original:

The memory models for the read-modify-write and load operations are succ and fail respectively. The (1-2) versions use std::memory_order_seq_cst by default.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Les formes faibles ((1) et (3)) des fonctions sont autorisés à ne pas faussement, qui est, comme si *obj != *expected même si elles sont égales. Quand une comparaison et d'échange est dans une boucle, la version faible donnera de meilleures performances sur certaines plates-formes. Quand un faible compare-and-échange, il faudrait une boucle et une forte ne serait pas, le fort est préférable .

Original:

The weak forms ((1) and (3)) of the functions are allowed to fail spuriously, that is, act as if *obj != *expected even if they are equal. When a compare-and-exchange is in a loop, the weak version will yield better performance on some platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the strong one is preferable.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Ces fonctions sont définies en termes de fonctions membres de std::atomic:

Original:

These functions are defined in terms of member functions of std::atomic:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

1) obj->compare_exchange_weak(exp, desr)

2) obj->compare_exchange_strong(exp, desr)

3) obj->compare_exchange_weak(exp, desr, succ, fail)

4) obj->compare_exchange_strong(exp, desr, succ, fail)

Paramètres

obj	-	pointeur vers l'objet atomique pour tester et modifier Original: pointer to the atomic object to test and modify The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
expected	-	pointeur à la valeur prévue pour être trouvé dans l'objet atomique Original: pointer to the value expected to be found in the atomic object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
desired	-	la valeur à stocker dans l'objet atomique si elle est conforme aux attentes Original: the value to store in the atomic object if it is as expected The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
succ	-	la sycnhronization mémoire de commande pour la lecture-modification-écriture, si la comparaison aboutit. Toutes les valeurs sont permises . Original: the memory sycnhronization ordering for the read-modify-write operation if the comparison succeeds. All values are permitted. The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
fail	-	sycnhronization la mémoire de commande pour l'opération de chargement si la comparaison échoue. Ne peut pas être std::memory_order_release ou std::memory_order_ack_rel et ne pouvez pas spécifier plus forte que succ ordre Original: the memory sycnhronization ordering for the load operation if the comparison fails. Cannot be std::memory_order_release or std::memory_order_ack_rel and cannot specify stronger ordering than succ The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Retourne la valeur

Le résultat de la comparaison: si true *obj était égal à *exp, false autrement .

Original:

The result of the comparison: true if *obj was equal to *exp, false otherwise.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Exceptions

noexcept specification:  

<tbody> </tbody>

noexcept

   (depuis C++11)

Exemple

Cet exemple montre comment compare-and-échange peuvent être utilisés pour mettre en œuvre sans verrou ajout à une liste simplement chaînée

Original:

This example shows how compare-and-exchange may be used to implement lock-free append to a singly linked list

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

void append(list* s, node* n)
{
    node* head;
    do {
        head = s->head;
        n->next = head;
    } while(! std::atomic_compare_exchange_weak(s->head, head, n));
}

Voir aussi

compare_exchange_weak compare_exchange_strong	compare atomiquement la valeur de l'objet atomique avec un argument non atomique, et réalise un échange atomique s'ils sont égaux, ou un chargement atomique sinon Original: atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction membre publique de std::atomic)
atomic_exchange atomic_exchange_explicit (C++11) (C++11)	remplace atomiquement la valeur de l'objet atomique avec des non-atomique argument et retourne l'ancienne valeur de l'atomique Original: atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction générique)
std::atomic_compare_exchange_weak(std::shared_ptr) std::atomic_compare_exchange_strong(std::shared_ptr)	se spécialise opérations atomiques pour std :: shared_ptr Original: specializes atomic operations for std::shared_ptr The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction générique)
C documentation for atomic_compare_exchange, atomic_compare_exchange_explicit