Энтони Уильямс - Параллельное программирование на С++ в действии. Практика разработки многопоточных программ

T* load(memory_order = memory_order_seq_cst)

const volatile noexcept;

T* load(memory_order = memory_order_seq_cst) 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_strong(

T* & old_value, T* new_value,

memory_order order = memory_order_seq_cst)

volatile noexcept;

bool compare_exchange_strong(

T* & old_value, T* new_value,

memory_order order = memory_order_seq_cst) noexcept;

bool compare_exchange_strong(

T* & old_value, T* new_value,

memory_order success_order, memory_order failure_order)

volatile noexcept;

bool compare_exchange_strong(

T* & old_value, T* new_value,

memory_order success_order,

memory_order failure_order) noexcept;

bool compare_exchange_weak(

T* & old_value, T* new_value,

memory_order order = memory_order_seq_cst) volatile noexcept;

bool compare_exchange_weak(

T* & old_value, T* new_value,

memory_order order = memory_order_seq_cst) noexcept;

bool compare_exchange_weak(

T* & old_value, T* new_value,

memory_order success_order, memory_order failure_order)

volatile noexcept;

bool compare_exchange_weak(

T* & old_value, T* new_value,

memory_order success_order,

memory_order failure_order) noexcept;

operator T*() const volatile noexcept;

operator T*() const 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;

T* operator++() volatile noexcept;

T* operator++() noexcept;

T* operator++(int) volatile noexcept;

T* operator++(int) noexcept;

T* operator--() volatile noexcept;

T* operator--() noexcept;

T* operator--(int) volatile noexcept;

T* operator--(int) noexcept;

T* operator+=(ptrdiff_t) volatile noexcept;

T* operator+=(ptrdiff_t) noexcept;

T* operator-=(ptrdiff_t) volatile noexcept;

T* operator-=(ptrdiff_t) noexcept;

};

bool atomic_is_lock_free(volatile const atomic*) noexcept;

bool atomic_is_lock_free(const atomic*) noexcept;

void atomic_init(volatile atomic*, T*) noexcept;

void atomic_init(atomic*, T*) noexcept;

T* atomic_exchange(volatile atomic*, T*) noexcept;

T* atomic_exchange(atomic*, T*) noexcept;

T* atomic_exchange_explicit(

volatile atomic*, T*, memory_order) noexcept;

T* atomic_exchange_explicit(

atomic*, T*, memory_order) noexcept;

void atomic_store(volatile atomic*, T*) noexcept;

void atomic_store(atomic*, T*) noexcept;

void atomic_store_explicit(

volatile atomic*, T*, memory_order) noexcept;

void atomic_store_explicit(

atomic*, T*, memory_order) noexcept;

T* atomic_load(volatile const atomic*) noexcept;

T* atomic_load(const atomic*) noexcept;

T* atomic_load_explicit(

volatile const atomic*, memory_order) noexcept;

T* atomic_load_explicit(

const atomic*, memory_order) noexcept;

bool atomic_compare_exchange_strong(

volatile atomic*, T** old_value, T* new_value) noexcept;

bool atomic_compare_exchange_strong(

volatile atomic*, T** old_value, T* new_value) noexcept;

bool atomic_compare_exchange_strong_explicit(

atomic*, T** old_value, T* new_value,

memory_order success_order,

memory_order failure_order) noexcept;

bool atomic_compare_exchange_strong_explicit(

atomic*, T** old_value, T* new_value,

memory_order success_order,

memory_order failure_order) noexcept;

bool atomic_compare_exchange_weak(

volatile atomic*, T** old_value, T* new_value) noexcept;

bool atomic_compare_exchange_weak(

atomic*, T** old_value, T* new_value) noexcept;

bool atomic_compare_exchange_weak_explicit(

volatile atomic*,

T** old_value, T* new_value,

memory_order success_order,

memory_order failure_order) noexcept;

bool atomic_compare_exchange_weak_explicit(

atomic*, T** old_value, T* new_value,

memory_order success_order,

memory_order failure_order) noexcept;

T* atomic_fetch_add(volatile atomic*, ptrdiff_t) noexcept;

T* atomic_fetch_add(atomic*, ptrdiff_t) noexcept;

T* atomic_fetch_add_explicit(

volatile atomic*, ptrdiff_t, memory_order) noexcept;

T* atomic_fetch_add_explicit(

atomic*, ptrdiff_t, memory_order) noexcept;

T* atomic_fetch_sub(volatile atomic*, ptrdiff_t) noexcept;

T* atomic_fetch_sub(atomic*, ptrdiff_t) noexcept;

T* atomic_fetch_sub_explicit(

volatile atomic*, ptrdiff_t, memory_order) noexcept;

T* atomic_fetch_sub_explicit(

atomic*, ptrdiff_t, memory_order) noexcept;

Те операции, которые предоставляются также основным шаблоном (см. приложение D.3.8), имеют точно такую же семантику.

STD::ATOMIC::FETCH_ADD , ФУНКЦИЯ-ЧЛЕН

Атомарно загружает значение, заменяет его суммой этого значения и аргумента i, применяя стандартные правила арифметики указателей, и возвращает старое значение.

Объявление

T* fetch_add(

ptrdiff_t i, memory_order order = memory_order_seq_cst)

volatile noexcept;

T* fetch_add(

ptrdiff_t i, memory_order order = memory_order_seq_cst) noexcept;

Результат

Атомарно возвращает текущее значение *thisи сохраняет в *thisзначение old-value + i.

Возвращаемое значение

Значение *thisнепосредственно перед сохранением.

Исключения

Нет.

Примечание. Это атомарная операция чтения-модификации-записи для ячейки памяти, содержащей *this.

STD::ATOMIC_FETCH_ADD_EXPLICIT , ФУНКЦИЯ, НЕ ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomicи заменяет его суммой этого значения и аргумента i, применяя стандартные правила арифметики указателей.

Объявление

T* atomic_fetch_add_explicit(

volatile atomic* p, ptrdiff_t i, memory_order order)

noexcept;

T* atomic_fetch_add_explicit(

atomic* p, ptrdiff_t i, memory_order order) noexcept;

Результат

return p->fetch_add(i, order);

STD::ATOMIC::FETCH_SUB , ФУНКЦИЯ-ЧЛЕН

Атомарно загружает значение, заменяет его разностью этого значения и аргумента i, применяя стандартные правила арифметики указателей, и возвращает старое значение.

Объявление

T* fetch_sub(

ptrdiff_t i, memory_order order = memory_order_seq_cst)

volatile noexcept;

T* fetch_sub(

ptrdiff_t i, memory_order order = memory_order_seq_cst)

noexcept;

Результат

Атомарно возвращает текущее значение *thisи сохраняет в *thisзначение old-value - i.

Возвращаемое значение

Значение *thisнепосредственно перед сохранением.

Исключения

Нет.

Примечание. Это атомарная операция чтения-модификации-записи для ячейки памяти, содержащей *this.

STD::ATOMIC_FETCH_SUB , ФУНКЦИЯ, НЕ ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomicи заменяет его разностью этого значения и аргумента i, применяя стандартные правила арифметики указателей.

Объявление

T* atomic_fetch_sub(

volatile atomic* p, ptrdiff_t i) noexcept;

T* atomic_fetch_sub(atomic* p, ptrdiff_t i) noexcept;

Результат

return p->fetch_sub(i);

STD::ATOMIC_FETCH_SUB_EXPLICIT , ФУНКЦИЯ, HE ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomicи заменяет его разностью этого значения и аргумента i, применяя стандартные правила арифметики указателей.

Объявление

T* atomic_fetch_sub_explicit(

volatile atomic* p, ptrdiff_t i, memory_order order)

noexcept;

T* atomic_fetch_sub_explicit(

atomic* p, ptrdiff_t i, memory_order order) noexcept;