32 Concurrency support library [thread]

32.5 Atomic operations [atomics]

32.5.7 Class template atomic_ref [atomics.ref.generic]

32.5.7.4 Specializations for floating-point types [atomics.ref.float]

1
#
There are specializations of the atomic_ref class template for all floating-point types.
For each such type floating-point-type, the specialization atomic_ref<floating-point> provides additional atomic operations appropriate to floating-point types.
2
#
The program is ill-formed if is_always_lock_free is false and is_volatile_v<T> is true.
namespace std { template<> struct atomic_ref<floating-point-type> { private: floating-point-type* ptr; // exposition only public: using value_type = remove_cv_t<floating-point-type>; using difference_type = value_type; static constexpr size_t required_alignment = implementation-defined; static constexpr bool is_always_lock_free = implementation-defined; bool is_lock_free() const noexcept; constexpr explicit atomic_ref(floating-point-type&); constexpr atomic_ref(const atomic_ref&) noexcept; atomic_ref& operator=(const atomic_ref&) = delete; constexpr void store(floating-point-type, memory_order = memory_order::seq_cst) const noexcept; constexpr value_type operator=(value_type) const noexcept; constexpr value_type load(memory_order = memory_order::seq_cst) const noexcept; constexpr operator floating-point-type() const noexcept; constexpr value_type exchange(floating-point-type, memory_order = memory_order::seq_cst) const noexcept; constexpr bool compare_exchange_weak(value_type&, floating-point-type, memory_order, memory_order) const noexcept; constexpr bool compare_exchange_strong(value_type&, floating-point-type, memory_order, memory_order) const noexcept; constexpr bool compare_exchange_weak(value_type&, floating-point-type, memory_order = memory_order::seq_cst) const noexcept; constexpr bool compare_exchange_strong(value_type&, floating-point-type, memory_order = memory_order::seq_cst) const noexcept; constexpr value_type fetch_add(floating-point-type, memory_order = memory_order::seq_cst) const noexcept; constexpr value_type fetch_sub(floating-point-type, memory_order = memory_order::seq_cst) const noexcept; constexpr value_type operator+=(value_type) const noexcept; constexpr value_type operator-=(value_type) const noexcept; constexpr void wait(floating-point-type, memory_order = memory_order::seq_cst) const noexcept; constexpr void notify_one() const noexcept; constexpr void notify_all() const noexcept; constexpr floating-point-type* address() const noexcept; }; }
3
#
Descriptions are provided below only for members that differ from the primary template.
4
#
The following operations perform arithmetic computations.
The correspondence among key, operator, and computation is specified in Table 150.
🔗
constexpr value_type fetch_key(value_type operand, memory_order order = memory_order::seq_cst) const noexcept;
5
#
Constraints: is_const_v<floating-point-type> is false.
6
#
Effects: Atomically replaces the value referenced by *ptr with the result of the computation applied to the value referenced by *ptr and the given operand.
Memory is affected according to the value of order.
These operations are atomic read-modify-write operations ([intro.races]).
7
#
Returns: Atomically, the value referenced by *ptr immediately before the effects.
8
#
Remarks: If the result is not a representable value for its type ([expr.pre]), the result is unspecified, but the operations otherwise have no undefined behavior.
Atomic arithmetic operations on floating-point-type should conform to the std​::​numeric_limits<value_type> traits associated with the floating-point type ([limits.syn]).
The floating-point environment ([cfenv]) for atomic arithmetic operations on floating-
point-type may be different than the calling thread's floating-point environment.
🔗
constexpr value_type operator op=(value_type operand) const noexcept;
9
#
Constraints: is_const_v<floating-point-type> is false.
10
#
Effects: Equivalent to: return fetch_key(operand) op operand;