atomic_compare_exchange_weak, atomic_compare_exchange_strong, atomic_compare_exchange_weak_explicit, atomic_compare_exchange_strong_explicit

 

C

Language

Headers

Type support

Program utilities

Variadic function support

Error handling

Dynamic memory management

Date and time utilities

Strings library

Algorithms

Numerics

Input/output support

Localization support

Atomic operations (C11)

Thread support (C11)

Technical Specifications

 

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 contents of memory pointed to by obj with the contents of memory pointed to by expected, and if those are bitwise equal, replaces the former with desired (performs read-modify-write operation). Otherwise, loads the actual contents of memory 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 ((2) and (4)) 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. The argument is pointer to a volatile atomic type to accept addresses of both non-volatile and volatile (e.g. memory-mapped I/O) atomic variables.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.

Notes

The behavior of atomic_compare_exchange_strong is as if the following was executed atomically:

if (memcmp(obj, expected, sizeof *obj) == 0)
    memcpy(obj, &desired, sizeof *obj);
else
    memcpy(expected, obj, sizeof *obj);

References

• C11 standard (ISO/IEC 9899:2011):

• 7.17.7.4 The atomic_compare_exchange generic functions (p: 283-284)

See also

atomic_exchangeatomic_exchange_explicit (C11)

swaps a value with the value of an atomic object (function)