Merge 2017-11 LWG Motion 16

Author: zygoloid

source/atomics.tex

@@ -623,6 +623,7 @@
 \indexlibrary{\idxcode{atomic}!constructor}%
 \indexlibrary{\idxcode{atomic<T*>}!constructor}%
 \indexlibrary{\idxcode{atomic<\placeholder{integral}>}!constructor}%
+\indexlibrary{\idxcode{atomic<\placeholder{floating-point}>}!constructor}%
 \begin{itemdecl}
 atomic() noexcept = default;
 \end{itemdecl}
@@ -639,6 +640,7 @@
 \indexlibrary{\idxcode{atomic}!constructor}%
 \indexlibrary{\idxcode{atomic<T*>}!constructor}%
 \indexlibrary{\idxcode{atomic<\placeholder{integral}>}!constructor}%
+\indexlibrary{\idxcode{atomic<\placeholder{floating-point}>}!constructor}%
 \begin{itemdecl}
 constexpr atomic(T desired) noexcept;
 \end{itemdecl}
@@ -678,6 +680,7 @@
 \indexlibrarymember{is_always_lock_free}{atomic}%
 \indexlibrarymember{is_always_lock_free}{atomic<T*>}%
 \indexlibrarymember{is_always_lock_free}{atomic<\placeholder{integral}>}%
+\indexlibrarymember{is_always_lock_free}{atomic<\placeholder{floating-point}>}%
 \begin{itemdecl}
 static constexpr bool is_always_lock_free = @\impdefx{whether a given \tcode{atomic} type's operations are always lock free}@;
 \end{itemdecl}
@@ -696,6 +699,7 @@
 \indexlibrarymember{is_lock_free}{atomic}%
 \indexlibrarymember{is_lock_free}{atomic<T*>}%
 \indexlibrarymember{is_lock_free}{atomic<\placeholder{integral}>}%
+\indexlibrarymember{is_lock_free}{atomic<\placeholder{floating-point}>}%
 \begin{itemdecl}
 bool is_lock_free() const volatile noexcept;
 bool is_lock_free() const noexcept;
@@ -715,6 +719,7 @@
 \indexlibrarymember{store}{atomic}%
 \indexlibrarymember{store}{atomic<T*>}%
 \indexlibrarymember{store}{atomic<\placeholder{integral}>}%
+\indexlibrarymember{store}{atomic<\placeholder{floating-point}>}%
 \begin{itemdecl}
 void store(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
 void store(T desired, memory_order order = memory_order::seq_cst) noexcept;
@@ -734,6 +739,7 @@
 \indexlibrarymember{operator=}{atomic}%
 \indexlibrarymember{operator=}{atomic<T*>}%
 \indexlibrarymember{operator=}{atomic<\placeholder{integral}>}%
+\indexlibrarymember{operator=}{atomic<\placeholder{floating-point}>}%
 \begin{itemdecl}
 T operator=(T desired) volatile noexcept;
 T operator=(T desired) noexcept;
@@ -752,6 +758,7 @@
 \indexlibrarymember{load}{atomic}%
 \indexlibrarymember{load}{atomic<T*>}%
 \indexlibrarymember{load}{atomic<\placeholder{integral}>}%
+\indexlibrarymember{load}{atomic<\placeholder{floating-point}>}%
 \begin{itemdecl}
 T load(memory_order order = memory_order::seq_cst) const volatile noexcept;
 T load(memory_order order = memory_order::seq_cst) const noexcept;
@@ -771,6 +778,7 @@
 \indexlibrarymember{operator \placeholder{type}}{atomic}%
 \indexlibrarymember{operator T*}{atomic<T*>}%
 \indexlibrarymember{operator \placeholder{integral}}{atomic<\placeholder{integral}>}%
+\indexlibrarymember{operator \placeholder{floating-point}}{atomic<\placeholder{floating-point}>}%
 \begin{itemdecl}
 operator T() const volatile noexcept;
 operator T() const noexcept;
@@ -787,6 +795,7 @@
 \indexlibrarymember{exchange}{atomic}%
 \indexlibrarymember{exchange}{atomic<T*>}%
 \indexlibrarymember{exchange}{atomic<\placeholder{integral}>}%
+\indexlibrarymember{exchange}{atomic<\placeholder{floating-point}>}%
 \begin{itemdecl}
 T exchange(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
 T exchange(T desired, memory_order order = memory_order::seq_cst) noexcept;
@@ -810,9 +819,11 @@
 \indexlibrarymember{compare_exchange_weak}{atomic}%
 \indexlibrarymember{compare_exchange_weak}{atomic<T*>}%
 \indexlibrarymember{compare_exchange_weak}{atomic<\placeholder{integral}>}%
+\indexlibrarymember{compare_exchange_weak}{atomic<\placeholder{floating-point}>}%
 \indexlibrarymember{compare_exchange_strong}{atomic}%
 \indexlibrarymember{compare_exchange_strong}{atomic<T*>}%
 \indexlibrarymember{compare_exchange_strong}{atomic<\placeholder{integral}>}%
+\indexlibrarymember{compare_exchange_strong}{atomic<\placeholder{floating-point}>}%
 \begin{itemdecl}
 bool compare_exchange_weak(T& expected, T desired,
                            memory_order success, memory_order failure) volatile noexcept;
@@ -1116,6 +1127,153 @@
 \effects Equivalent to: \tcode{return fetch_\placeholder{key}(operand) \placeholder{op} operand;}
 \end{itemdescr}
 
+\rSec2[atomics.types.float]{Specializations for floating-point types}
+
+\indexlibrary{\idxcode{atomic<\placeholder{floating-point}>}}%
+\pnum
+There are specializations of the \tcode{atomic}
+template for the floating-point types
+\tcode{float},
+\tcode{double}, and
+\tcode{long double}.
+For each such floating-point type \tcode{\placeholdernc{floating-point}},
+the specialization \tcode{atomic<\placeholder{floating-point}>}
+provides additional atomic operations appropriate to floating-point types.
+
+\begin{codeblock}
+namespace std {
+  template<> struct atomic<@\placeholder{floating-point}@> {
+    static constexpr bool is_always_lock_free = @\impdefx{whether a given \tcode{atomic} type's operations are always lock free}@;
+    bool is_lock_free() const volatile noexcept;
+    bool is_lock_free() const noexcept;
+    void store(@\placeholdernc{floating-point}@, memory_order = memory_order_seq_cst) volatile noexcept;
+    void store(@\placeholdernc{floating-point}@, memory_order = memory_order_seq_cst) noexcept;
+    @\placeholdernc{floating-point}@ load(memory_order = memory_order_seq_cst) volatile noexcept;
+    @\placeholdernc{floating-point}@ load(memory_order = memory_order_seq_cst) noexcept;
+    operator @\placeholdernc{floating-point}@() volatile noexcept;
+    operator @\placeholdernc{floating-point}@() noexcept;
+    @\placeholdernc{floating-point}@ exchange(@\placeholdernc{floating-point}@,
+                            memory_order = memory_order_seq_cst) volatile noexcept;
+    @\placeholdernc{floating-point}@ exchange(@\placeholdernc{floating-point}@,
+                            memory_order = memory_order_seq_cst) noexcept;
+    bool compare_exchange_weak(@\placeholder{floating-point}@&, @\placeholdernc{floating-point}@,
+                               memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_weak(@\placeholder{floating-point}@&, @\placeholdernc{floating-point}@,
+                               memory_order, memory_order) noexcept;
+    bool compare_exchange_strong(@\placeholder{floating-point}@&, @\placeholdernc{floating-point}@,
+                                 memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_strong(@\placeholder{floating-point}@&, @\placeholdernc{floating-point}@,
+                                 memory_order, memory_order) noexcept;
+    bool compare_exchange_weak(@\placeholder{floating-point}@&, @\placeholdernc{floating-point}@,
+                               memory_order = memory_order_seq_cst) volatile noexcept;
+    bool compare_exchange_weak(@\placeholder{floating-point}@&, @\placeholdernc{floating-point}@,
+                               memory_order = memory_order_seq_cst) noexcept;
+    bool compare_exchange_strong(@\placeholder{floating-point}@&, @\placeholdernc{floating-point}@,
+                                 memory_order = memory_order_seq_cst) volatile noexcept;
+    bool compare_exchange_strong(@\placeholder{floating-point}@&, @\placeholdernc{floating-point}@,
+                                 memory_order = memory_order_seq_cst) noexcept;
+
+    @\placeholdernc{floating-point}@ fetch_add(@\placeholdernc{floating-point}@,
+                             memory_order = memory_order_seq_cst) volatile noexcept;
+    @\placeholdernc{floating-point}@ fetch_add(@\placeholdernc{floating-point}@,
+                             memory_order = memory_order_seq_cst) noexcept;
+    @\placeholdernc{floating-point}@ fetch_sub(@\placeholdernc{floating-point}@,
+                             memory_order = memory_order_seq_cst) volatile noexcept;
+    @\placeholdernc{floating-point}@ fetch_sub(@\placeholdernc{floating-point}@,
+                             memory_order = memory_order_seq_cst) noexcept;
+
+    atomic() noexcept = default;
+    constexpr atomic(@\placeholder{floating-point}@) noexcept;
+    atomic(const atomic&) = delete;
+    atomic& operator=(const atomic&) = delete;
+    atomic& operator=(const atomic&) volatile = delete;
+    @\placeholdernc{floating-point}@ operator=(@\placeholder{floating-point}@) volatile noexcept;
+    @\placeholdernc{floating-point}@ operator=(@\placeholder{floating-point}@) noexcept;
+
+    @\placeholdernc{floating-point}@ operator+=(@\placeholder{floating-point}@) volatile noexcept;
+    @\placeholdernc{floating-point}@ operator+=(@\placeholder{floating-point}@) noexcept;
+    @\placeholdernc{floating-point}@ operator-=(@\placeholder{floating-point}@) volatile noexcept;
+    @\placeholdernc{floating-point}@ operator-=(@\placeholder{floating-point}@) noexcept;
+  };
+}
+\end{codeblock}
+
+\pnum
+The atomic floating-point specializations
+are standard-layout structs.
+They each have a trivial default constructor
+and a trivial destructor.
+
+\pnum
+Descriptions are provided below only for members that differ from the primary template.
+
+\pnum
+The following operations perform arithmetic addition and subtraction computations.
+The key, operator, and computation correspondence are identified in
+Table~\ref{tab:atomic.arithmetic.computations}.
+
+\indexlibrary{\idxcode{atomic_fetch_add}}%
+\indexlibrary{\idxcode{atomic_fetch_sub}}%
+\indexlibrary{\idxcode{atomic_fetch_add_explicit}}%
+\indexlibrary{\idxcode{atomic_fetch_sub_explicit}}%
+\indexlibrarymember{fetch_add}{atomic<\placeholder{floating-point}>}%
+\indexlibrarymember{fetch_sub}{atomic<\placeholder{floating-point}>}%
+\begin{itemdecl}
+T A::fetch_@\placeholdernc{key}@(T operand, memory_order order = memory_order_seq_cst) volatile noexcept;
+T A::fetch_@\placeholdernc{key}@(T operand, memory_order order = memory_order_seq_cst) noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Atomically replaces the value pointed to by \tcode{this}
+with the result of the computation applied to the value pointed
+to by \tcode{this} and the given \tcode{operand}.
+Memory is affected according to the value of \tcode{order}.
+These operations are atomic read-modify-write operations\iref{intro.multithread}.
+
+\pnum
+\returns
+Atomically, the value pointed to by \tcode{this} immediately before the effects.
+
+\pnum
+\remarks
+If the result is not a representable value for its type\iref{expr.pre}
+the result is unspecified, but the operations otherwise have no undefined
+behavior. Atomic arithmetic operations on \tcode{\placeholder{floating-point}}
+should conform to the \tcode{std::numeric_limits<\placeholder{floating-point}>}
+traits associated with the floating-point type\iref{limits.syn}.
+The floating-point environment\iref{cfenv} for atomic arithmetic operations
+on \tcode{\placeholder{floating-point}} may be different than the
+calling thread's floating-point environment.
+\end{itemdescr}
+
+\indexlibrarymember{operator+=}{atomic<T*>}%
+\indexlibrarymember{operator-=}{atomic<T*>}%
+\indexlibrarymember{operator+=}{atomic<\placeholder{floating-point}>}%
+\indexlibrarymember{operator-=}{atomic<\placeholder{floating-point}>}%
+\begin{itemdecl}
+T operator @\placeholder{op}@=(T operand) volatile noexcept;
+T operator @\placeholder{op}@=(T operand) noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Equivalent to: \tcode{return fetch_\placeholder{key}(operand) \placeholder{op} operand;}
+
+\pnum
+\remarks
+If the result is not a representable value for its type\iref{expr.pre}
+the result is unspecified, but the operations otherwise have no undefined
+behavior. Atomic arithmetic operations on \tcode{\placeholder{floating-point}}
+should conform to the \tcode{std::numeric_limits<\placeholder{floating-point}>}
+traits associated with the floating-point type\iref{limits.syn}.
+The floating-point environment\iref{cfenv} for atomic arithmetic operations
+on \tcode{\placeholder{floating-point}} may be different than the
+calling thread's floating-point environment.
+\end{itemdescr}
+
 \rSec2[atomics.types.pointer]{Partial specialization for pointers}
 \indexlibrary{\idxcode{atomic<T*>}}%