Annex D (normative) Compatibility features [depr] (original) (raw)

D.22 Deprecated atomic operations [depr.atomics]

D.22.1 General [depr.atomics.general]

The header has the following additions.

namespace std { template<class T> void atomic_init(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;template<class T> void atomic_init(atomic<T>*, typename atomic<T>::value_type) noexcept;template<class T> constexpr T kill_dependency(T y) noexcept; inline constexpr memory_order memory_order_consume = memory_order::consume; #define ATOMIC_VAR_INIT(value) see below }

D.22.2 Volatile access [depr.atomics.volatile]

If an atomic ([atomics.types.generic]) specialization has one of the following overloads, then that overload participates in overload resolution even if atomic<T>​::​is_always_lock_free is false:void store(T desired, memory_order order = memory_order::seq_cst) volatile noexcept; T operator=(T desired) volatile noexcept; T load(memory_order order = memory_order::seq_cst) const volatile noexcept;operator T() const volatile noexcept; T exchange(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;bool compare_exchange_weak(T& expected, T desired, memory_order success, memory_order failure) volatile noexcept;bool compare_exchange_strong(T& expected, T desired, memory_order success, memory_order failure) volatile noexcept;bool compare_exchange_weak(T& expected, T desired, memory_order order = memory_order::seq_cst) volatile noexcept;bool compare_exchange_strong(T& expected, T desired, memory_order order = memory_order::seq_cst) volatile noexcept; T fetch_ key(T operand, memory_order order = memory_order::seq_cst) volatile noexcept; T operator _op_=(T operand) volatile noexcept; T* fetch_ key(ptrdiff_t operand, memory_order order = memory_order::seq_cst) volatile noexcept;

D.22.3 Non-member functions [depr.atomics.nonmembers]

template<class T> void atomic_init(volatile atomic<T>* object, typename atomic<T>::value_type desired) noexcept;template<class T> void atomic_init(atomic<T>* object, typename atomic<T>::value_type desired) noexcept;

Effects: Equivalent to: atomic_store_explicit(object, desired, memory_order​::​relaxed);

D.22.4 Operations on atomic types [depr.atomics.types.operations]

#define ATOMIC_VAR_INIT(value) _see below_

The macro expands to a token sequence suitable for constant initialization of an atomic variable with static storage duration of a type that is initialization-compatible with value.

[Note 1:

This operation possibly needs to initialize locks.

— _end note_]

Concurrent access to the variable being initialized, even via an atomic operation, constitutes a data race.

[Example 1: atomic<int> v = ATOMIC_VAR_INIT(5); — _end example_]

D.22.5 memory_order​::​consume [depr.atomics.order]

The memory_order enumeration contains an additional enumerator:consume = 1

The memory_order​::​consume enumerator is allowed wherevermemory_order​::​acquire is allowed, and it has the same meaning.

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