C++11 atomic operations

Table of Contents

Overview

Lock-free property

#define ATOMIC_BOOL_LOCK_FREE unspecified
#define ATOMIC_CHAR_LOCK_FREE unspecified
#define ATOMIC_CHAR16_T_LOCK_FREE unspecified
#define ATOMIC_CHAR32_T_LOCK_FREE unspecified
#define ATOMIC_WCHAR_T_LOCK_FREE unspecified
#define ATOMIC_SHORT_LOCK_FREE unspecified
#define ATOMIC_INT_LOCK_FREE unspecified
#define ATOMIC_LONG_LOCK_FREE unspecified
#define ATOMIC_LLONG_LOCK_FREE unspecified
#define ATOMIC_POINTER_LOCK_FREE unspecified

The ATOMIC_…LOCKFREE macros indicate the lock-free property of the corresponding atomic types, with the signed and unsigned variants grouped together. The properties also apply to the corresponding (partial) specializations of the atomic template. A value of 0 indicates that the types are never lock-free. A value of 1 indicates that the types are sometimes lock-free. A value of 2 indicates that the types are always lock-free.

The function atomicislockfree (29.6) indicates whether the object is lock-free. In any given program execution, the result of the lock-free query shall be consistent for all pointers of the same type.

Atomic types

namespace std {
template <class T> struct atomic {
  bool is_lock_free() const volatile noexcept;
  bool is_lock_free() const noexcept;
  void store(T, memory_order = memory_order_seq_cst) volatile noexcept;
  void store(T, memory_order = memory_order_seq_cst) noexcept;
  T load(memory_order = memory_order_seq_cst) const volatile noexcept;
  T load(memory_order = memory_order_seq_cst) const noexcept;
  operator T() const volatile noexcept;
  operator T() const noexcept;
  T exchange(T, memory_order = memory_order_seq_cst) volatile noexcept;
  T exchange(T, memory_order = memory_order_seq_cst) noexcept;
  bool compare_exchange_weak(T&, T, memory_order, memory_order) volatile noexcept;
  bool compare_exchange_weak(T&, T, memory_order, memory_order) noexcept;
  bool compare_exchange_strong(T&, T, memory_order, memory_order) volatile noexcept;
  bool compare_exchange_strong(T&, T, memory_order, memory_order) noexcept;
  bool compare_exchange_weak(T&, T, memory_order = memory_order_seq_cst) volatile noexcept;
  bool compare_exchange_weak(T&, T, memory_order = memory_order_seq_cst) noexcept;
  bool compare_exchange_strong(T&, T, memory_order = memory_order_seq_cst) volatile noexcept;
  bool compare_exchange_strong(T&, T, memory_order = memory_order_seq_cst) noexcept;
  atomic() noexcept = default;
  constexpr atomic(T) noexcept;
  atomic(const atomic&) = delete;
  atomic& operator=(const atomic&) = delete;
  atomic& operator=(const atomic&) volatile = delete;
  T operator=(T) volatile noexcept;
  T operator=(T) noexcept;
};

template <> struct atomic<integral > {
  bool is_lock_free() const volatile noexcept;
  bool is_lock_free() const noexcept;
  void store(integral , memory_order = memory_order_seq_cst) volatile noexcept;
  void store(integral , memory_order = memory_order_seq_cst) noexcept;
  integral load(memory_order = memory_order_seq_cst) const volatile noexcept;
  integral load(memory_order = memory_order_seq_cst) const noexcept;
  operator integral() const volatile noexcept;
  operator integral() const noexcept;
  integral exchange(integral , memory_order = memory_order_seq_cst) volatile noexcept;
  integral exchange(integral , memory_order = memory_order_seq_cst) noexcept;
  bool compare_exchange_weak(integral &, integral , memory_order, memory_order) volatile noexcept;
  bool compare_exchange_weak(integral &, integral , memory_order, memory_order) noexcept;
  bool compare_exchange_strong(integral &, integral , memory_order, memory_order) volatile noexcept;
  bool compare_exchange_strong(integral &, integral , memory_order, memory_order) noexcept;
  bool compare_exchange_weak(integral &, integral , memory_order = memory_order_seq_cst) volatile noexcept;
  bool compare_exchange_weak(integral &, integral , memory_order = memory_order_seq_cst) noexcept;
  bool compare_exchange_strong(integral &, integral , memory_order = memory_order_seq_cst) volatile noexcept;
  bool compare_exchange_strong(integral &, integral , memory_order = memory_order_seq_cst) noexcept;
  integral fetch_add(integral , memory_order = memory_order_seq_cst) volatile noexcept;
  integral fetch_add(integral , memory_order = memory_order_seq_cst) noexcept;
  integral fetch_sub(integral , memory_order = memory_order_seq_cst) volatile noexcept;
  integral fetch_sub(integral , memory_order = memory_order_seq_cst) noexcept;
  integral fetch_and(integral , memory_order = memory_order_seq_cst) volatile noexcept;
  integral fetch_and(integral , memory_order = memory_order_seq_cst) noexcept;
  integral fetch_or(integral , memory_order = memory_order_seq_cst) volatile noexcept;
  integral fetch_or(integral , memory_order = memory_order_seq_cst) noexcept;
  integral fetch_xor(integral , memory_order = memory_order_seq_cst) volatile noexcept;
  integral fetch_xor(integral , memory_order = memory_order_seq_cst) noexcept;

  atomic() noexcept = default;
  constexpr atomic(integral ) noexcept;
  atomic(const atomic&) = delete;
  atomic& operator=(const atomic&) = delete;
  atomic& operator=(const atomic&) volatile = delete;
  integral operator=(integral ) volatile noexcept;
  integral operator=(integral ) noexcept;

  integral operator++(int) volatile noexcept;
  integral operator++(int) noexcept;
  integral operator--(int) volatile noexcept;
  integral operator--(int) noexcept;
  integral operator++() volatile noexcept;
  integral operator++() noexcept;
  integral operator--() volatile noexcept;
  integral operator--() noexcept;
  integral operator+=(integral ) volatile noexcept;
  integral operator+=(integral ) noexcept;
  integral operator-=(integral ) volatile noexcept;
  integral operator-=(integral ) noexcept;
  integral operator&=(integral ) volatile noexcept;
  integral operator&=(integral ) noexcept;
  integral operator|=(integral ) volatile noexcept;
  integral operator|=(integral ) noexcept;
  integral operator^=(integral ) volatile noexcept;
  integral operator^=(integral ) noexcept;
};

template <class T> struct atomic<T*> {
  bool is_lock_free() const volatile noexcept;
  bool is_lock_free() const noexcept;
  void store(T*, memory_order = memory_order_seq_cst) volatile noexcept;
  void store(T*, memory_order = memory_order_seq_cst) noexcept;
  T* load(memory_order = memory_order_seq_cst) const volatile noexcept;
  T* load(memory_order = memory_order_seq_cst) const noexcept;
  operator T*() const volatile noexcept;
  operator T*() const noexcept;
  T* exchange(T*, memory_order = memory_order_seq_cst) volatile noexcept;
  T* exchange(T*, memory_order = memory_order_seq_cst) noexcept;
  bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile noexcept;
  bool compare_exchange_weak(T*&, T*, memory_order, memory_order) noexcept;
  bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile noexcept;
  bool compare_exchange_strong(T*&, T*, memory_order, memory_order) noexcept;
  bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst) volatile noexcept;
  bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst) noexcept;
  bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst) volatile noexcept;
  bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst) noexcept;
  T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile noexcept;
  T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) noexcept;
  T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile noexcept;
  T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) noexcept;

  atomic() noexcept = default;
  constexpr atomic(T*) noexcept;
  atomic(const atomic&) = delete;
  atomic& operator=(const atomic&) = delete;
  atomic& operator=(const atomic&) volatile = delete;

  T* operator=(T*) volatile noexcept;
  T* operator=(T*) noexcept;
  T* operator++(int) volatile noexcept;
  T* operator++(int) noexcept;
  T* operator--(int) volatile noexcept;
  T* operator--(int) noexcept;
  T* operator++() volatile noexcept;
  T* operator++() noexcept;
  T* operator--() volatile noexcept;
  T* operator--() noexcept;
  T* operator+=(ptrdiff_t) volatile noexcept;
  T* operator+=(ptrdiff_t) noexcept;
  T* operator-=(ptrdiff_t) volatile noexcept;
  T* operator-=(ptrdiff_t) noexcept;
};
}

Flag type and operations

namespace std {
typedef struct atomic_flag {
  bool test_and_set(memory_order = memory_order_seq_cst) volatile noexcept;
  bool test_and_set(memory_order = memory_order_seq_cst) noexcept;
  void clear(memory_order = memory_order_seq_cst) volatile noexcept;
  void clear(memory_order = memory_order_seq_cst) noexcept;
  atomic_flag() noexcept = default;
  atomic_flag(const atomic_flag&) = delete;
  atomic_flag& operator=(const atomic_flag&) = delete;
  atomic_flag& operator=(const atomic_flag&) volatile = delete;
} atomic_flag;
bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;
bool atomic_flag_test_and_set(atomic_flag*) noexcept;
bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order) noexcept;
bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;
void atomic_flag_clear(volatile atomic_flag*) noexcept;
void atomic_flag_clear(atomic_flag*) noexcept;
void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;
void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;
#define ATOMIC_FLAG_INIT see below
}

Memory synchronization ordering

namespace std {
typedef enum memory_order {
memory_order_relaxed, memory_order_consume, memory_order_acquire,
memory_order_release, memory_order_acq_rel, memory_order_seq_cst
} memory_order;
}

template <class T>
T kill_dependency(T y) noexcept;

extern "C" void atomic_thread_fence(memory_order order) noexcept;

extern "C" void atomic_signal_fence(memory_order order) noexcept;
  • memoryorderrelaxed: no operation orders memory.
  • memoryorderrelease, memoryorderacqrel, and memoryorderseqcst: a store operation performs a release operation on the affected memory location.
  • memoryorderconsume: a load operation performs a consume operation on the affected memory location.
  • memoryorderacquire, memoryorderacqrel, and memoryorderseqcst: a load operation performs an acquire operation on the affected memory location.

其他资料

Header synopsis

<atomic>

namespace std {
// 29.3, order and consistency
enum memory_order;
template <class T>
T kill_dependency(T y) noexcept;
// 29.4, lock-free property
#define ATOMIC_BOOL_LOCK_FREE unspecified
#define ATOMIC_CHAR_LOCK_FREE unspecified
#define ATOMIC_CHAR16_T_LOCK_FREE unspecified
#define ATOMIC_CHAR32_T_LOCK_FREE unspecified
#define ATOMIC_WCHAR_T_LOCK_FREE unspecified
#define ATOMIC_SHORT_LOCK_FREE unspecified
#define ATOMIC_INT_LOCK_FREE unspecified
#define ATOMIC_LONG_LOCK_FREE unspecified
#define ATOMIC_LLONG_LOCK_FREE unspecified
#define ATOMIC_POINTER_LOCK_FREE unspecified
// 29.5, generic types
template<class T> struct atomic;
template<> struct atomic<integral >;
template<class T> struct atomic<T*>;
// 29.6.1, general operations on atomic types
// In the following declarations, atomic-type is either
// atomic<T> or a named base class for T from
// Table 145 or inferred from Table 146 or from bool.
// If it is atomic<T>, then the declaration is a template
// declaration prefixed with template <class T>.
bool atomic_is_lock_free(const volatile atomic-type *) noexcept;
bool atomic_is_lock_free(const atomic-type *) noexcept;
void atomic_init(volatile atomic-type *, T) noexcept;
void atomic_init(atomic-type *, T) noexcept;
void atomic_store(volatile atomic-type *, T) noexcept;
void atomic_store(atomic-type *, T) noexcept;
void atomic_store_explicit(volatile atomic-type *, T, memory_order) noexcept;
void atomic_store_explicit(atomic-type *, T, memory_order) noexcept;
T atomic_load(const volatile atomic-type *) noexcept;
T atomic_load(const atomic-type *) noexcept;
T atomic_load_explicit(const volatile atomic-type *, memory_order) noexcept;
T atomic_load_explicit(const atomic-type *, memory_order) noexcept;
T atomic_exchange(volatile atomic-type *, T) noexcept;
T atomic_exchange(atomic-type *, T) noexcept;
T atomic_exchange_explicit(volatile atomic-type *, T, memory_order) noexcept;
T atomic_exchange_explicit(atomic-type *, T, memory_order) noexcept;
bool atomic_compare_exchange_weak(volatile atomic-type *, T*, T) noexcept;
bool atomic_compare_exchange_weak(atomic-type *, T*, T) noexcept;
bool atomic_compare_exchange_strong(volatile atomic-type *, T*, T) noexcept;
bool atomic_compare_exchange_strong(atomic-type *, T*, T) noexcept;
bool atomic_compare_exchange_weak_explicit(volatile atomic-type *, T*, T,
memory_order, memory_order) noexcept;
bool atomic_compare_exchange_weak_explicit(atomic-type *, T*, T.
memory_order, memory_order) noexcept;
bool atomic_compare)exchange_strong_explicit(volatile atomic-type *, T*, T,
memory_order, memory_order) noexcept;
bool atomic_compare_exchange_strong_explicit(atomic-type *, T*, T,
memory_order, memory_order) noexcept;
// 29.6.2, templated operations on atomic types
template <class T>
T atomic_fetch_add(volatile atomic<T>*, T) noexcept;
template <class T>
T atomic_fetch_add(atomic<T>*, T) noexcept;
template <class T>
T atomic_fetch_add_explicit(volatile atomic<T>*, T, memory_order) noexcept;
template <class T>
T atomic_fetch_add_explicit(atomic<T>*, T, memory_order) noexcept;
template <class T>
T atomic_fetch_sub(volatile atomic<T>*, T) noexcept;
template <class T>
T atomic_fetch_sub(atomic<T>*, T) noexcept;
template <class T>
T atomic_fetch_sub_explicit(volatile atomic<T>*, T, memory_order) noexcept;
template <class T>
T atomic_fetch_sub_explicit(atomic<T>*, T, memory_order) noexcept;
template <class T>
T atomic_fetch_and(volatile atomic<T>*, T) noexcept;
template <class T>
T atomic_fetch_and(atomic<T>*, T) noexcept;
template <class T>
T atomic_fetch_and_explicit(volatile atomic<T>*, T, memory_order) noexcept;
template <class T>
T atomic_fetch_and_explicit(atomic<T>*, T, memory_order) noexcept;
template <class T>
T atomic_fetch_or(volatile atomic<T>*, T) noexcept;
template <class T>
T atomic_fetch_or(atomic<T>*, T) noexcept;
template <class T>
T atomic_fetch_or_explicit(volatile atomic<T>*, T, memory_order) noexcept;
template <class T>
T atomic_fetch_or_explicit(atomic<T>*, T, memory_order) noexcept;
template <class T>
T atomic_fetch_xor(volatile atomic<T>*, T) noexcept;
template <class T>
T atomic_fetch_xor(atomic<T>*, T) noexcept;
template <class T>
T atomic_fetch_xor_explicit(volatile atomic<T>*, T, memory_order) noexcept;
template <class T>
T atomic_fetch_xor_explicit(atomic<T>*, T, memory_order) noexcept;
// 29.6.3, arithmetic operations on atomic types
// In the following declarations, atomic-integral is either
// atomic<T> or a named base class for T from
// Table 145 or inferred from Table 146.
// If it is atomic<T>, then the declaration is a template
// specialization declaration prefixed with template <>.
integral atomic_fetch_add(volatile atomic-integral *, integral ) noexcept;
integral atomic_fetch_add(atomic-integral *, integral ) noexcept;
integral atomic_fetch_add_explicit(volatile atomic-integral *, integral , memory_order) noexcept;
integral atomic_fetch_add_explicit(atomic-integral *, integral , memory_order) noexcept;
integral atomic_fetch_sub(volatile atomic-integral *, integral ) noexcept;
integral atomic_fetch_sub(atomic-integral *, integral ) noexcept;
integral atomic_fetch_sub_explicit(volatile atomic-integral *, integral , memory_order) noexcept;
integral atomic_fetch_sub_explicit(atomic-integral *, integral , memory_order) noexcept;
integral atomic_fetch_and(volatile atomic-integral *, integral ) noexcept;
integral atomic_fetch_and(atomic-integral *, integral ) noexcept;
integral atomic_fetch_and_explicit(volatile atomic-integral *, integral , memory_order) noexcept;
integral atomic_fetch_and_explicit(atomic-integral *, integral , memory_order) noexcept;
integral atomic_fetch_or(volatile atomic-integral *, integral ) noexcept;
integral atomic_fetch_or(atomic-integral *, integral ) noexcept;
integral atomic_fetch_or_explicit(volatile atomic-integral *, integral , memory_order) noexcept;
integral atomic_fetch_or_explicit(atomic-integral *, integral , memory_order) noexcept;
integral atomic_fetch_xor(volatile atomic-integral *, integral ) noexcept;
integral atomic_fetch_xor(atomic-integral *, integral ) noexcept;
integral atomic_fetch_xor_explicit(volatile atomic-integral *, integral , memory_order) noexcept;
integral atomic_fetch_xor_explicit(atomic-integral *, integral , memory_order) noexcept;
// 29.6.4, partial specializations for pointers
template <class T>
T* atomic_fetch_add(volatile atomic<T*>*, ptrdiff_t) noexcept;
template <class T>
T* atomic_fetch_add(atomic<T*>*, ptrdiff_t) noexcept;
template <class T>
T* atomic_fetch_add_explicit(volatile atomic<T*>*, ptrdiff_t, memory_order) noexcept;
template <class T>
T* atomic_fetch_add_explicit(atomic<T*>*, ptrdiff_t, memory_order) noexcept;
template <class T>
T* atomic_fetch_sub(volatile atomic<T*>*, ptrdiff_t) noexcept;
template <class T>
T* atomic_fetch_sub(atomic<T*>*, ptrdiff_t) noexcept;
template <class T>
T* atomic_fetch_sub_explicit(volatile atomic<T*>*, ptrdiff_t, memory_order) noexcept;
template <class T>
T* atomic_fetch_sub_explicit(atomic<T*>*, ptrdiff_t, memory_order) noexcept;
// 29.6.5, initialization
#define ATOMIC_VAR_INIT(value) see below
// 29.7, flag type and operations
struct atomic_flag;
bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;
bool atomic_flag_test_andset(atomic_flag*) noexcept;
bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order) noexcept;
bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;
void atomic_flag_clear(volatile atomic_flag*) noexcept;
void atomic_flag_clear(atomic_flag*) noexcept;
void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;
void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;
#define ATOMIC_FLAG_INIT see below
// 29.8, fences
extern "C" void atomic_thread_fence(memory_order) noexcept;
extern "C" void atomic_signal_fence(memory_order) noexcept;
}

cc













Author: Shi Shougang


Created: 2015-03-05 Thu 23:21


Emacs 24.3.1 (Org mode 8.2.10)


Validate