P0660R10 Stop Token and Joining Thread

source/algorithms.tex

@@ -439,6 +439,7 @@
 in a thread of execution implicitly created by the library
 to support parallel algorithm execution.
 If the threads of execution created by \tcode{thread}\iref{thread.thread.class}
+or \tcode{jthread}\iref{thread.jthread.class}
 provide concurrent forward progress guarantees\iref{intro.progress},
 then a thread of execution implicitly created by the library will provide
 parallel forward progress guarantees;

source/basic.tex

@@ -5923,11 +5923,12 @@
 
 \pnum
 It is \impldef{whether the thread that executes \tcode{main} and the threads created
-by \tcode{std::thread} provide concurrent forward progress guarantees} whether the
+by \tcode{std::thread} or \tcode{std::jthread} provide concurrent forward progress guarantees} whether the
 implementation-created thread of execution that executes
 \tcode{main}\iref{basic.start.main} and the threads of execution created by
-\tcode{std::thread}\iref{thread.thread.class} provide concurrent forward progress
-guarantees.
+\tcode{std::thread}\iref{thread.thread.class}
+or \tcode{std::jthread}\iref{thread.jthread.class}
+provide concurrent forward progress guarantees.
 \begin{note}
 General-purpose implementations should provide these guarantees.
 \end{note}

source/lib-intro.tex

@@ -1218,8 +1218,9 @@
 \tcode{<sstream>} \\
 \tcode{<stack>} \\
 \tcode{<stdexcept>} \\
-\tcode{<streambuf>} \\
+\tcode{<stop_token>} \\
 \columnbreak
+\tcode{<streambuf>} \\
 \tcode{<string>} \\
 \tcode{<string_view>} \\
 \tcode{<strstream>} \\

source/numerics.tex

@@ -163,7 +163,9 @@
 The floating-point environment has thread storage
 duration\iref{basic.stc.thread}. The initial state for a thread's floating-point
 environment is the state of the floating-point environment of the thread that constructs
-the corresponding \tcode{thread} object\iref{thread.thread.class} at the time it
+the corresponding \tcode{thread} object\iref{thread.thread.class}
+or \tcode{jthread} object\iref{thread.jthread.class}
+at the time it
 constructed the object. \begin{note} That is, the child thread gets the floating-point
 state of the parent thread at the time of the child's creation. \end{note}
 

source/support.tex

@@ -640,10 +640,16 @@
   \tcode{<type_traits>} \\ \rowsep
 \defnlibxname{cpp_lib_is_invocable}                         & \tcode{201703L} &
   \tcode{<type_traits>} \\ \rowsep
+\defnlibxname{cpp_lib_is_layout_compatible}                 & \tcode{201907L} &
+  \tcode{<type_traits>} \\ \rowsep
 \defnlibxname{cpp_lib_is_null_pointer}                      & \tcode{201309L} &
   \tcode{<type_traits>} \\ \rowsep
-\defnlibxname{cpp_lib_is_swappable}                         & \tcode{201603L} &
+\defnlibxname{cpp_lib_is_pointer_interconvertible}          & \tcode{201907L} &
   \tcode{<type_traits>} \\ \rowsep
+\defnlibxname{cpp_lib_is_swappable}                         & \tcode{201603L} &
+  \tcode{stop_token} \tcode{<type_traits>} \\ \rowsep
+\defnlibxname{cpp_lib_jthread}                              & \tcode{201907L} &
+  \tcode{<thread>} \\ \rowsep
 \defnlibxname{cpp_lib_latch}                                & \tcode{201907L} &
   \tcode{<latch>} \\ \rowsep
 \defnlibxname{cpp_lib_launder}                              & \tcode{201606L} &
@@ -5147,9 +5153,9 @@
 Resuming a coroutine via \tcode{resume}, \tcode{operator()}, or \tcode{destroy}
 on an execution agent other than the one on which it was suspended
 has implementation-defined behavior unless
-each execution agent is either
-an instance of \tcode{std::thread} or
-the thread that executes \tcode{main}.
+each execution agent either is
+an instance of \tcode{std::thread} or \tcode{std::jthread},
+or is the thread that executes \tcode{main}.
 \begin{note}
 A coroutine that is resumed on a different execution agent should
 avoid relying on consistent thread identity throughout, such as holding