atomic_compare_exchange_weak, atomic_compare_exchange_strong, atomic_compare_exchange_weak_explicit, atomic_compare_exchange_strong_explicit

 

C

Language

Standard Library

Type support

Dynamic memory management

Error handling

Program utilities

Date and time utilities

Strings library

Algorithms

Numerics

Input/output support

Localization support

Thread support (C11)

Atomic operations (C11)

 

Atomic operations library

Types

memory_order

atomic_flag

Macros

ATOMIC_***_LOCK_FREE

ATOMIC_FLAG_INIT

ATOMIC_VAR_INIT

kill_dependency

Functions

atomic_flag_test_and_set

atomic_flag_clear

atomic_init

atomic_is_lock_free

atomic_store

atomic_load

atomic_exchange

atomic_compare_exchange

atomic_fetch_add

atomic_fetch_sub

atomic_fetch_or

atomic_fetch_xor

atomic_fetch_and

atomic_thread_fence

atomic_signal_fence

 

Defined in header <stdatomic.h>
_Bool atomic_compare_exchange_strong( volatile A* obj,                                       C* expected, C desired );	(1)	(since C11)
_Bool atomic_compare_exchange_weak( volatile A *obj,                                     C* expected, C desired );	(2)	(since C11)
_Bool atomic_compare_exchange_strong_explicit( volatile A* obj,                                                C* expected, C desired,                                                memory_order succ,                                                memory_order fail );	(3)	(since C11)
_Bool atomic_compare_exchange_weak_explicit( volatile A *obj,                                              C* expected, C desired,                                              memory_order succ,                                              memory_order fail );	(4)	(since C11)

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 memory models for the read-modify-write and load operations are succ and fail respectively. The (1-2) versions use memory_order_seq_cst by default.

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.

This is a generic function defined for all atomic object types. A is the type of an atomic object, C is the non-atomic type corresponding to A.

Parameters

obj	-	pointer to the atomic object to test and modify
expected	-	pointer to the value expected to be found in the atomic object
desired	-	the value to store in the atomic object if it is as expected
succ	-	the memory synchronization ordering for the read-modify-write operation if the comparison succeeds. All values are permitted.
fail	-	the memory synchronization ordering for the load operation if the comparison fails. Cannot be memory_order_release or memory_order_acq_rel and cannot specify stronger ordering than succ

Return value

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

See also

atomic_exchange atomic_exchange_explicit (C11)	swaps a value with the value of an atomic object (function)
C++ documentation for atomic_compare_exchange_weak, atomic_compare_exchange_strong, atomic_compare_exchange_weak_explicit, atomic_compare_exchange_strong_explicit