[execpol] Move [execpol] to the end of subclause [algorithms.parallel]

Part of the C++26 clause restructuring (#5315).

Author: tkoeppe

source/algorithms.tex

@@ -620,6 +620,173 @@
 Parallel algorithms shall not participate in overload resolution unless
 \tcode{is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>} is \tcode{true}.
 
+\rSec2[execpol]{Execution policies}
+
+\rSec3[execpol.general]{General}
+
+\pnum
+Subclause~\ref{execpol} describes classes that are \defn{execution policy} types. An
+object of an execution policy type indicates the kinds of parallelism allowed
+in the execution of an algorithm and expresses the consequent requirements on
+the element access functions.
+Execution policy types are declared in header \libheaderref{execution}.
+\begin{example}
+\begin{codeblock}
+using namespace std;
+vector<int> v = @\commentellip@;
+
+// standard sequential sort
+sort(v.begin(), v.end());
+
+// explicitly sequential sort
+sort(execution::seq, v.begin(), v.end());
+
+// permitting parallel execution
+sort(execution::par, v.begin(), v.end());
+
+// permitting vectorization as well
+sort(execution::par_unseq, v.begin(), v.end());
+\end{codeblock}
+\end{example}
+\begin{note}
+Implementations can provide additional execution policies
+to those described in this document as extensions
+to address parallel architectures that require idiosyncratic
+parameters for efficient execution.
+\end{note}
+
+\rSec3[execpol.type]{Execution policy type trait}
+
+\indexlibraryglobal{is_execution_policy}%
+\begin{itemdecl}
+template<class T> struct is_execution_policy { @\seebelow@ };
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\tcode{is_execution_policy} can be used to detect execution policies for the
+purpose of excluding function signatures from otherwise ambiguous overload
+resolution participation.
+
+\pnum
+\tcode{is_execution_policy<T>} is a \oldconcept{UnaryTypeTrait} with a
+base characteristic of \tcode{true_type} if \tcode{T} is the type of a standard
+or \impldef{additional execution policies supported by parallel algorithms}
+execution policy, otherwise \tcode{false_type}.
+
+\begin{note}
+This provision reserves the privilege of creating non-standard execution
+policies to the library implementation.
+\end{note}
+
+\pnum
+The behavior of a program that adds specializations for
+\tcode{is_execution_policy} is undefined.
+\end{itemdescr}
+
+\rSec3[execpol.seq]{Sequenced execution policy}
+
+\indexlibraryglobal{execution::sequenced_policy}%
+\begin{itemdecl}
+class execution::sequenced_policy { @\unspec@ };
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+The class \tcode{execution::sequenced_policy} is an execution policy type used
+as a unique type to disambiguate parallel algorithm overloading and require
+that a parallel algorithm's execution may not be parallelized.
+
+\pnum
+During the execution of a parallel algorithm with
+the \tcode{execution::sequenced_policy} policy,
+if the invocation of an element access function exits via an exception,
+\tcode{terminate} is invoked\iref{except.terminate}.
+\end{itemdescr}
+
+\rSec3[execpol.par]{Parallel execution policy}
+
+\indexlibraryglobal{execution::parallel_policy}%
+\begin{itemdecl}
+class execution::parallel_policy { @\unspec@ };
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+The class \tcode{execution::parallel_policy} is an execution policy type used as
+a unique type to disambiguate parallel algorithm overloading and indicate that
+a parallel algorithm's execution may be parallelized.
+
+\pnum
+During the execution of a parallel algorithm with
+the \tcode{execution::parallel_policy} policy,
+if the invocation of an element access function exits via an exception,
+\tcode{terminate} is invoked\iref{except.terminate}.
+\end{itemdescr}
+
+\rSec3[execpol.parunseq]{Parallel and unsequenced execution policy}
+
+\indexlibraryglobal{execution::parallel_unsequenced_policy}%
+\begin{itemdecl}
+class execution::parallel_unsequenced_policy { @\unspec@ };
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+The class \tcode{execution::parallel_unsequenced_policy} is an execution policy type
+used as a unique type to disambiguate parallel algorithm overloading and
+indicate that a parallel algorithm's execution may be parallelized and
+vectorized.
+
+\pnum
+During the execution of a parallel algorithm with
+the \tcode{execution::parallel_unsequenced_policy} policy,
+if the invocation of an element access function exits via an exception,
+\tcode{terminate} is invoked\iref{except.terminate}.
+\end{itemdescr}
+
+\rSec3[execpol.unseq]{Unsequenced execution policy}
+
+\indexlibraryglobal{execution::unsequenced_policy}%
+\begin{itemdecl}
+class execution::unsequenced_policy { @\unspec@ };
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+The class \tcode{unsequenced_policy} is an execution policy type
+used as a unique type to disambiguate parallel algorithm overloading and
+indicate that a parallel algorithm's execution may be vectorized,
+e.g., executed on a single thread using instructions
+that operate on multiple data items.
+
+\pnum
+During the execution of a parallel algorithm with
+the \tcode{execution::unsequenced_policy} policy,
+if the invocation of an element access function exits via an exception,
+\tcode{terminate} is invoked\iref{except.terminate}.
+\end{itemdescr}
+
+\rSec3[execpol.objects]{Execution policy objects}
+
+\indexlibraryglobal{seq}%
+\indexlibraryglobal{par}%
+\indexlibraryglobal{par_unseq}%
+\indexlibrarymember{execution}{seq}%
+\indexlibrarymember{execution}{par}%
+\indexlibrarymember{execution}{par_unseq}%
+\begin{itemdecl}
+inline constexpr execution::sequenced_policy            execution::seq{ @\unspec@ };
+inline constexpr execution::parallel_policy             execution::par{ @\unspec@ };
+inline constexpr execution::parallel_unsequenced_policy execution::par_unseq{ @\unspec@ };
+inline constexpr execution::unsequenced_policy          execution::unseq{ @\unspec@ };
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+The header \libheaderref{execution} declares global objects associated with each type of execution policy.
+\end{itemdescr}
+
 \rSec1[algorithm.syn]{Header \tcode{<algorithm>} synopsis}
 \indexheader{algorithm}%
 

source/utilities.tex

@@ -15217,172 +15217,6 @@
 \tcode{hash<type_index>()(index)} shall evaluate to the same result as \tcode{index.hash_code()}.
 \end{itemdescr}
 
-\rSec1[execpol]{Execution policies}
-\rSec2[execpol.general]{General}
-
-\pnum
-Subclause~\ref{execpol} describes classes that are \defn{execution policy} types. An
-object of an execution policy type indicates the kinds of parallelism allowed
-in the execution of an algorithm and expresses the consequent requirements on
-the element access functions.
-Execution policy types are declared in header \libheaderref{execution}.
-\begin{example}
-\begin{codeblock}
-using namespace std;
-vector<int> v = @\commentellip@;
-
-// standard sequential sort
-sort(v.begin(), v.end());
-
-// explicitly sequential sort
-sort(execution::seq, v.begin(), v.end());
-
-// permitting parallel execution
-sort(execution::par, v.begin(), v.end());
-
-// permitting vectorization as well
-sort(execution::par_unseq, v.begin(), v.end());
-\end{codeblock}
-\end{example}
-\begin{note}
-Implementations can provide additional execution policies
-to those described in this document as extensions
-to address parallel architectures that require idiosyncratic
-parameters for efficient execution.
-\end{note}
-
-\rSec2[execpol.type]{Execution policy type trait}
-
-\indexlibraryglobal{is_execution_policy}%
-\begin{itemdecl}
-template<class T> struct is_execution_policy { @\seebelow@ };
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\tcode{is_execution_policy} can be used to detect execution policies for the
-purpose of excluding function signatures from otherwise ambiguous overload
-resolution participation.
-
-\pnum
-\tcode{is_execution_policy<T>} is a \oldconcept{UnaryTypeTrait} with a
-base characteristic of \tcode{true_type} if \tcode{T} is the type of a standard
-or \impldef{additional execution policies supported by parallel algorithms}
-execution policy, otherwise \tcode{false_type}.
-
-\begin{note}
-This provision reserves the privilege of creating non-standard execution
-policies to the library implementation.
-\end{note}
-
-\pnum
-The behavior of a program that adds specializations for
-\tcode{is_execution_policy} is undefined.
-\end{itemdescr}
-
-\rSec2[execpol.seq]{Sequenced execution policy}
-
-\indexlibraryglobal{execution::sequenced_policy}%
-\begin{itemdecl}
-class execution::sequenced_policy { @\unspec@ };
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-The class \tcode{execution::sequenced_policy} is an execution policy type used
-as a unique type to disambiguate parallel algorithm overloading and require
-that a parallel algorithm's execution may not be parallelized.
-
-\pnum
-During the execution of a parallel algorithm with
-the \tcode{execution::sequenced_policy} policy,
-if the invocation of an element access function exits via an exception,
-\tcode{terminate} is invoked\iref{except.terminate}.
-\end{itemdescr}
-
-\rSec2[execpol.par]{Parallel execution policy}
-
-\indexlibraryglobal{execution::parallel_policy}%
-\begin{itemdecl}
-class execution::parallel_policy { @\unspec@ };
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-The class \tcode{execution::parallel_policy} is an execution policy type used as
-a unique type to disambiguate parallel algorithm overloading and indicate that
-a parallel algorithm's execution may be parallelized.
-
-\pnum
-During the execution of a parallel algorithm with
-the \tcode{execution::parallel_policy} policy,
-if the invocation of an element access function exits via an exception,
-\tcode{terminate} is invoked\iref{except.terminate}.
-\end{itemdescr}
-
-\rSec2[execpol.parunseq]{Parallel and unsequenced execution policy}
-
-\indexlibraryglobal{execution::parallel_unsequenced_policy}%
-\begin{itemdecl}
-class execution::parallel_unsequenced_policy { @\unspec@ };
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-The class \tcode{execution::parallel_unsequenced_policy} is an execution policy type
-used as a unique type to disambiguate parallel algorithm overloading and
-indicate that a parallel algorithm's execution may be parallelized and
-vectorized.
-
-\pnum
-During the execution of a parallel algorithm with
-the \tcode{execution::parallel_unsequenced_policy} policy,
-if the invocation of an element access function exits via an exception,
-\tcode{terminate} is invoked\iref{except.terminate}.
-\end{itemdescr}
-
-\rSec2[execpol.unseq]{Unsequenced execution policy}
-
-\indexlibraryglobal{execution::unsequenced_policy}%
-\begin{itemdecl}
-class execution::unsequenced_policy { @\unspec@ };
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-The class \tcode{unsequenced_policy} is an execution policy type
-used as a unique type to disambiguate parallel algorithm overloading and
-indicate that a parallel algorithm's execution may be vectorized,
-e.g., executed on a single thread using instructions
-that operate on multiple data items.
-
-\pnum
-During the execution of a parallel algorithm with
-the \tcode{execution::unsequenced_policy} policy,
-if the invocation of an element access function exits via an exception,
-\tcode{terminate} is invoked\iref{except.terminate}.
-\end{itemdescr}
-
-\rSec2[execpol.objects]{Execution policy objects}
-
-\indexlibraryglobal{seq}%
-\indexlibraryglobal{par}%
-\indexlibraryglobal{par_unseq}%
-\indexlibrarymember{execution}{seq}%
-\indexlibrarymember{execution}{par}%
-\indexlibrarymember{execution}{par_unseq}%
-\begin{itemdecl}
-inline constexpr execution::sequenced_policy            execution::seq{ @\unspec@ };
-inline constexpr execution::parallel_policy             execution::par{ @\unspec@ };
-inline constexpr execution::parallel_unsequenced_policy execution::par_unseq{ @\unspec@ };
-inline constexpr execution::unsequenced_policy          execution::unseq{ @\unspec@ };
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-The header \libheaderref{execution} declares global objects associated with each type of execution policy.
-\end{itemdescr}
-
 \rSec1[charconv]{Primitive numeric conversions}
 
 \rSec2[charconv.syn]{Header \tcode{<charconv>} synopsis}