- Function objects passed into parallel algorithms as objects of type
+ Function objects passed into parallel algorithms as objects of type BinaryPredicate,
- Compare, and BinaryOperation shall not directly or indirectly modify
- objects via their arguments.
+
+
BinaryPredicate,
+ Compare, and BinaryOperation shall not directly or indirectly modify
+ objects via their arguments.
Parallel algorithms have template parameters named ExecutionPolicy which describe
the manner in which the execution of these algorithms may be parallelized and the manner in
which they apply the element access functions.
The invocations of element access functions in parallel algorithms invoked with an execution
policy object of type sequential_execution_policy execute in sequential order in
the calling thread.
The invocations of element access functions in parallel algorithms invoked with an execution
policy object of type parallel_execution_policy are permitted to execute in an
@@ -44,7 +53,9 @@
using namespace std::experimental::parallel;
int a[] = {0,1};
std::vector<int> v;
@@ -55,9 +66,10 @@ Effect of execution policies on algorithm execution
The program above has a data race because of the unsynchronized access to the container
v.
- +
+
using namespace std::experimental::parallel; std::atomic<int> x = 0; @@ -70,9 +82,10 @@Effect of execution policies on algorithm execution
The above example depends on the order of execution of the iterations, and is therefore undefined (may deadlock). -
+
+
using namespace std::experimental::parallel; int x=0; @@ -82,12 +95,39 @@+});Effect of execution policies on algorithm execution
m.lock(); ++x; m.unlock(); -});
x ensuring that it is
incremented correctly.
+
+ The invocations of element access functions in parallel algorithms invoked with an
+ execution policy of type unsequenced_policy are permitted to execute
+ in an unordered fashion in the calling thread, unsequenced with respect to one another
+ within the calling thread.
+
+
++ +
+ The invocations of element access functions in parallel algorithms invoked with an
+ executino policy of type vector_policy are permitted to execute
+ in an unordered fashion in the calling thread, unsequenced with respect to one another
+ within the calling thread, subject to the sequencing constraints of wavefront application
+ (for_loop or for_loop_strided.
+
The invocations of element access functions in parallel algorithms invoked with an execution
policy of type parallel_vector_execution_policy
@@ -163,9 +203,109 @@
+ For the purposes of this section, an evaluation is a value computation or side effect of + an expression, or an execution of a statement. Initialization of a temporary object is considered a + subexpression of the expression that necessitates the temporary object. +
+ ++ An evaluation A contains an evaluation B if: + +
+ An evaluation A is ordered before an evaluation B if A is deterministically
+ sequenced before B.
+ For an evaluation A ordered before an evaluation B, both contained in the same + invocation of an element access function, A is a vertical antecedent of B if: + +
goto statement or asm declaration that jumps to a statement outside of S, orswitch statement executed within S that transfers control into a substatement of a nested selection or iteration statement, orthrow longjmp.
+
+ In the following, Xi and Xj refer to evaluations of the same expression
+ or statement contained in the application of an element access function corresponding to the ith and
+ jth elements of the input sequence.
+ Horizontally matched is an equivalence relationship between two evaluations of the same expression. An + evaluation Bi is horizontally matched with an evaluation Bj if: + +
+ Let f be a function called for each argument list in a sequence of argument lists. + Wavefront application of f requires that evaluation Ai be sequenced + before evaluation Bi if i < j and and: + +
ExecutionPolicy algorithm overloadsExecutionPolicy algorithm overloadsThe Parallel Algorithms Library provides overloads for each of the algorithms named in Table 1, corresponding to the algorithms with the same name in the C++ Standard Algorithms Library. @@ -179,19 +319,25 @@
ExecutionPolicy algorithm overloadsExecutionPolicy&&.
+
Unless otherwise specified, the semantics of ExecutionPolicy algorithm overloads
are identical to their overloads without.
Parallel algorithms shall not participate in overload resolution unless
is_execution_policy<decay_t<ExecutionPolicy>>::value is true.
adjacent_difference |
adjacent_find |
@@ -313,16 +459,20 @@
Define GENERALIZED_SUM(op, a1, ..., aN) as follows:
@@ -340,7 +490,9 @@
Define GENERALIZED_NONCOMMUTATIVE_SUM(op, a1, ..., aN) as follows:
@@ -353,6 +505,7 @@
<experimental/algorithm> synopsis
-namespace std {
-namespace experimental {
-namespace parallel {
-inline namespace v2 {
+#include <algorithm>
+
+namespace std {
+namespace std::experimental {
+inline namespace parallelism_v2 {
+inline namespace v2 {
template<class ExecutionPolicy,
class InputIterator, class Function>
void for_each(ExecutionPolicy&& exec,
@@ -378,66 +533,103 @@ Header <experimental/algorithm> synopsis
class InputIterator, class Size, class Function>
InputIterator for_each_n(ExecutionPolicy&& exec,
InputIterator first, Size n,
- Function f);
-}
+ Function f);
+
+namespace execution {
+ }
}
}
+}
f to the result of dereferencing every iterator in the range [first,last).
first satisfies the requirements of a mutable iterator, f may
apply nonconstant functions through the dereferenced iterator.
f exactly last - first times.
+ f exactly last - first times.f returns a result, the result is ignored.
+ f returns a result, the result is ignored.for_each does not return a copy of
its Function parameter, since parallelization may not permit efficient state
accumulation.
+ for_each requires
Function to meet the requirements of CopyConstructible.
+ Function shall meet the requirements of MoveConstructible
Function need not meet the requirements of CopyConstructible.
f to the result of dereferencing every iterator in the range
[first,first + n), starting from first and proceeding to first + n - 1.
@@ -445,25 +637,37 @@ first satisfies the requirements of a mutable iterator,
f may apply nonconstant functions through the dereferenced iterator.
+ first + n for non-negative values of n and first for negative values.
+ f returns a result, the result is ignored.
+ f to the result of dereferencing every iterator in the range
[first,first + n), starting from first and proceeding to first + n - 1.
@@ -471,30 +675,174 @@ first satisfies the requirements of a mutable iterator,
f may apply nonconstant functions through the dereferenced iterator.
+ first + n for non-negative values of n and first for negative values.
+ first + n for non-negative values of n and first for negative values.f returns a result, the result is ignored.
+ f returns a result, the result is ignored.for_each_n requires
Function to meet the requirements of CopyConstructible.
+ std::forward>F<(f)(). When invoked within an element access function
+ in a parallel algorithm using vector_policy, if two calls to no_vec are
+ horizontally matched within a wavefront application of an element access function over input
+ sequence S, then the execution of f in the application for one element in S is
+ sequenced before the execution of f in the application for a subsequent element in
+ S; otherwise, there is no effect on sequencing.
+ f.
+ f returns a result, the result is ignored.f exits via an exception, then terminate will be called, consistent
+ with all other potentially-throwing operations invoked with vector_policy execution.
+
+ extern int* p;
+for_loop(vec, 0, n[&](int i) {
+ y[i] +=y[i+1];
+ if(y[i] < 0) {
+ no_vec([]{
+ *p++ = i;
+ });
+ }
+});
+
+ The updates *p++ = i will occur in the same order as if the policy were seq.
+
+class ordered_update_t {
+ T& ref_; // exposition only
+public:
+ ordered_update_t(T& loc) noexcept
+ : ref_(loc) {}
+ ordered_update_t(const ordered_update_t&) = delete;
+ ordered_update_t& operator=(const ordered_update_t&) = delete;
+
+ template <class U>
+ auto operator=(U rhs) const noexcept
+ { return no_vec([&]{ return ref_ = std::move(rhs); }); }
+ template <class U>
+ auto operator+=(U rhs) const noexcept
+ { return no_vec([&]{ return ref_ += std::move(rhs); }); }
+ template <class U>
+ auto operator-=(U rhs) const noexcept
+ { return no_vec([&]{ return ref_ -= std::move(rhs); }); }
+ template <class U>
+ auto operator*=(U rhs) const noexcept
+ { return no_vec([&]{ return ref_ *= std::move(rhs); }); }
+ template <class U>
+ auto operator/=(U rhs) const noexcept
+ { return no_vec([&]{ return ref_ /= std::move(rhs); }); }
+ template <class U>
+ auto operator%=(U rhs) const noexcept
+ { return no_vec([&]{ return ref_ %= std::move(rhs); }); }
+ template <class U>
+ auto operator>>=(U rhs) const noexcept
+ { return no_vec([&]{ return ref_ >>= std::move(rhs); }); }
+ template <class U>
+ auto operator<<=(U rhs) const noexcept
+ { return no_vec([&]{ return ref_ <<= std::move(rhs); }); }
+ template <class U>
+ auto operator&=(U rhs) const noexcept
+ { return no_vec([&]{ return ref_ &= std::move(rhs); }); }
+ template <class U>
+ auto operator^=(U rhs) const noexcept
+ { return no_vec([&]{ return ref_ ^= std::move(rhs); }); }
+ template <class U>
+ auto operator|=(U rhs) const noexcept
+ { return no_vec([&]{ return ref_ |= std::move(rhs); }); }
+
+ auto operator++() const noexcept
+ { return no_vec([&]{ return ++ref_; }); }
+ auto operator++(int) const noexcept
+ { return no_vec([&]{ return ref_++; }); }
+ auto operator--() const noexcept
+ { return no_vec([&]{ return --ref_; }); }
+ auto operator--(int) const noexcept
+ { return no_vec([&]{ return ref_--; }); }
+};
+
+
+
+ An object of type ordered_update_t is a proxy for an object of type T
+ intended to be used within a parallel application of an element access function using a
+ policy object of type ><T<>vector_policy. Simple increments, assignments, and compound
+ assignments to the object are forwarded to the proxied object, but are sequenced as though
+ executed within a no_vec invocation.
+
+
{ loc }.
+ <experimental/numeric> synopsis<experimental/numeric> synopsis
namespace std {
namespace experimental {
@@ -658,267 +1006,364 @@ Header <experimental/numeric> synopsis
}
}
+reduce(first, last, typename iterator_traits<InputIterator>::value_type{}).
+ reduce(first, last, typename iterator_traits<InputIterator>::value_type{}).reduce(first, last, init, plus<>()).
+ reduce(first, last, init, plus<>()).GENERALIZED_SUM(binary_op, init, *first, ..., *(first + (last - first) - 1)).
+ GENERALIZED_SUM(binary_op, init, *first, ..., *(first + (last - first) - 1)).binary_op shall not invalidate iterators or subranges, nor modify elements in the
- range [first,last).
+ binary_op shall not invalidate iterators or subranges, nor modify elements in the
+ range [first,last).last - first) applications of binary_op.
+ last - first) applications of binary_op.reduce and accumulate is that the behavior
of reduce may be non-deterministic for non-associative or non-commutative binary_op.
+ exclusive_scan(first, last, result, init, plus<>()).
+ exclusive_scan(first, last, result, init, plus<>()).i in [result,result + (last - first)) the
value of GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, init, *first, ..., *(first + (i - result) - 1)).
+ result.
+ result.binary_op shall not invalidate iterators or subranges, nor modify elements in the
ranges [first,last) or [result,result + (last - first)).
+ last - first) applications of binary_op.
+ last - first) applications of binary_op.exclusive_scan and inclusive_scan is that
exclusive_scan excludes the ith input element from the ith
sum. If binary_op is not mathematically associative, the behavior of
exclusive_scan may be non-deterministic.
+ inclusive_scan(first, last, result, plus<>()).
+ i in [result,result + (last - first)) the value of
GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, *first, ..., *(first + (i - result))) or
GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, init, *first, ..., *(first + (i - result)))
if init is provided.
+ result.
+ binary_op shall not invalidate iterators or subranges, nor modify elements in the
ranges [first,last) or [result,result + (last - first)).
+ last - first) applications of binary_op.
+ last - first) applications of binary_op.exclusive_scan and inclusive_scan is that
inclusive_scan includes the ith input element in the ith sum.
If binary_op is not mathematically associative, the behavior of
inclusive_scan may be non-deterministic.
+ GENERALIZED_SUM(binary_op, init, unary_op(*first), ..., unary_op(*(first + (last - first) -1))).
+ unary_op nor binary_op shall invalidate subranges, or modify elements in the range [first,last)
+ unary_op nor binary_op shall invalidate subranges, or modify elements in the range [first,last)last - first) applications each of unary_op and binary_op.
+ last - first) applications each of unary_op and binary_op.transform_reduce does not apply unary_op to init.
+ transform_reduce does not apply unary_op to init.i in [result,result + (last - first)) the value of
GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, init, unary_op(*first), ..., unary_op(*(first + (i- result) - 1))).
+ result.
+ result.unary_op nor binary_op shall invalidate iterators or subranges, or modify elements in the
ranges [first,last) or [result,result + (last - first)).
+ last - first) applications each of unary_op and binary_op.
+ last - first) applications each of unary_op and binary_op.transform_exclusive_scan and transform_inclusive_scan is that transform_exclusive_scan
excludes the ith input element from the ith sum. If binary_op is not mathematically associative, the behavior of
transform_exclusive_scan may be non-deterministic. transform_exclusive_scan does not apply unary_op to init.
+ i in [result,result + (last - first)) the value of
GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, unary_op(*first), ..., unary_op(*(first + (i -result)))) or
GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, init, unary_op(*first), ..., unary_op(*(first + (i- result))))
if init is provided.
+ result.
+ result.unary_op nor binary_op shall invalidate iterators or subranges, or modify elements in the ranges [first,last)
or [result,result + (last - first)).
+ last - first) applications each of unary_op and binary_op.
+ last - first) applications each of unary_op and binary_op.transform_exclusive_scan and transform_inclusive_scan is that transform_inclusive_scan
includes the ith input element from the ith sum. If binary_op is not mathematically associative, the behavior of
transform_inclusive_scan may be non-deterministic. transform_inclusive_scan does not apply unary_op to init.
+ During the execution of a standard parallel algorithm, if temporary memory resources are required and none are available, @@ -14,7 +15,7 @@
class parallel_vector_execution_policy,
+ If the execution policy object is of type parallel_vector_execution_policy, unsequenced_policy, or vector_policy,
std::terminate shall be called.
<experimental/exception_list> synopsis
-namespace std {
-namespace experimental {
-namespace parallel {
-inline namespace v2 {
+namespace std {
+namespace std::experimental {
+inline namespace parallelism_v2 {
+inline namespace v2 {
class exception_list : public exception
{
public:
- typedef unspecified iterator;
+ typedef unspecified iterator;
+ using iterator = unspecified;
size_t size() const noexcept;
iterator begin() const noexcept;
@@ -70,16 +73,16 @@ Header <experimental/exception_list> synopsis
const char* what() const noexcept override;
};
+}
}
}
-}
-}
+}
- The class exception_list owns a sequence of exception_ptr objects. The parallel
+ The class exception_list owns a sequence of exception_ptr objects. The parallel
algorithms may use the
exception_list to communicate uncaught exceptions encountered during parallel execution to the
- caller of the algorithm.
+ caller of the algorithm.
diff --git a/execution_policies.html b/execution_policies.html
index 13fbe0a..0ee67d7 100644
--- a/execution_policies.html
+++ b/execution_policies.html
@@ -1,6 +1,7 @@
This clause describes classes that are execution policy types. An object
@@ -44,15 +45,18 @@ The behavior of a program that adds specializations for The class The class The class The class The invocations of element access functions in parallel algorithms invoked with an execution policy of type During the execution of a parallel algorithm with the The class The invocations of element access functions in parallel algorithms invoked with an execution policy of type During the execution of a parallel algorithm with the Objects of type The header The header Execution policies
-
In general
In general
may provide additional execution policies to those described in this
Technical Specification as extensions.
+ Header
+ <experimental/execution_policy> synopsisHeader
<experimental/execution synopsis_policy>
-namespace std {
-namespace experimental {
-namespace parallel {
-inline namespace v2 {
+#include <execution>
+
+
namespace std {
+namespace std::experimental {
+inline namespace parallelism_v2 {
+inline namespace v2 {
+namespace execution {
+ Header
<experimental/execution_policy> synopsis}
}
}
-}
+}
Execution policy type trait
@@ -93,9 +110,11 @@
Execution policy type trait
is_execution_policy is undefined.
Sequential execution policy
@@ -104,8 +123,10 @@
Sequential execution policy
sequential_execution_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.
Parallel execution policy
@@ -114,8 +135,10 @@
Parallel execution policy
parallel_execution_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.
+ Parallel+Vector execution policy
@@ -124,9 +147,44 @@
Parallel+Vector execution policy
class parallel_vector_execution_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 and parallelized.Unsequenced execution policy
+
+
+class unsequenced_policy{ unspecified };
+
+
+ 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.unsequenced_policy are permitted to execute in an unordered fashion in the calling thread, unsequenced with respect to one another within the calling thread.
+ experimental::execution::unsequenced_policy policy, if the invocation of an element access function exits via an uncaught exception, terminate() shall be called.Vector execution policy
+
+
+class vector_policy{ unspecified };
+
+
+ vector_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. Additionally, such vectorization will result in an execution that respects the sequencing constraints of wavefront application ([parallel.alg.general.wavefront]). unsequenced_policy, for example.vector_policy are permitted to execute in unordered fashion in the calling thread, unsequenced with respect to one another within the calling thread, subject to the sequencing constraints of wavefront application (for_loop or for_loop_strided.experimental::execution::vector_policy policy, if the invocation of an element access function exits via an uncaught exception, terminate() shall be called.
Dynamic execution policy
@@ -164,47 +222,56 @@
Dynamic execution policy
execution_policy shall be constructible and assignable from objects of
type T for which is_execution_policy<T>::value is true.
+ execution_policy construct/assignexecution_policy construct/assignexecution_policy object with a copy of exec's state.Constructs an execution_policy object with a copy of exec's state.
This constructor shall not participate in overload resolution unless
is_execution_policy<T>::value is true.
+
+
template<class T> execution_policy& operator=(const T& exec);exec's state to *this.Assigns a copy of exec's state to *this.*this.
+ *this
+ execution_policy object accessexecution_policy object accessconst type_info& type() const noexcept;typeid(T), such that T is the type of the execution policy object contained by *this.typeid(T), such that T is the type of the execution policy object contained by *this.template<class T> T* get() noexcept;template<class T> const T* get() const noexcept;target_type() == typeid(T), a pointer to the stored execution policy object; otherwise a null pointer.If target_type() == typeid(T), a pointer to the stored execution policy object; otherwise a null pointer.
is_execution_policy<T>::value is true.
+ is_execution_policy<T>::value is true.execution_policy object accessExecution policy objects
-constexpr sequential_execution_policy seq{};
+
- constexpr sequential_execution_policy seq{};
constexpr parallel_execution_policy par{};
-constexpr parallel_vector_execution_policy par_vec{};
+constexpr parallel_vector_execution_policy par_vec{};
+constexpr execution::unsequenced_policy unseq{};
+constexpr execution::vector_policy vec{};
<experimental/execution_policy> declares a global object associated with each type of execution policy defined by this Technical Specification.<experimental/execution declares a global object associated with each type of execution policy defined by this Technical Specification._policy>
NVIDIA Corporation
diff --git a/general.html b/general.html
index c3e9ac0..6c82000 100644
--- a/general.html
+++ b/general.html
@@ -7,7 +7,7 @@ Namespaces and headers
experimental and not part of the C++ Standard Library, they should not be
declared directly within namespace std. Unless otherwise specified, all
components described in this Technical Specification are declared in namespace
- std::experimental::parallel::v2.
std::experimental::parallelism_v2parallel::v2.
std.
@@ -15,7 +15,7 @@ Unless otherwise specified, references to such entities described in this
Technical Specification are assumed to be qualified with
- std::experimental::parallel::v2, and references to entities described in the C++
+ std::experimental::parallelism_v2, and references to entities described in the C++
Standard Library are assumed to be qualified with parallel::v2std::.
Extensions that are expected to eventually be added to an existing header @@ -36,27 +36,50 @@
__cpp_lib_experimental_parallel_algorithm__cpp_lib_experimental_parallel_algorithm<experimental/algorithm><experimental/exception_list><experimental/execution_policy><experimental/numeric>
+ __cpp_lib_experimental_parallel_task_block<experimental/exception_list><experimental/task_block>__cpp_lib_experimental_execution_vector_policy<experimental/algorithm><experimental/execution>ISO/IEC 14882:— is herein called the C++ Standard. - The library described in ISO/IEC 14882:— clauses 17-30 is herein called +
ISO/IEC 14882:2017— is herein called the C++ Standard.
+ The library described in ISO/IEC 14882:2017— clauses 20-3317-30 is herein called
the C++ Standard Library. The C++ Standard Library components described in
- ISO/IEC 14882:— clauses 25, 26.7 and 20.7.2 are herein called the C++ Standard
+ ISO/IEC 14882:2017— clauses 28, 29.8 and 23.10.1025, 26.7 and 20.7.2 are herein called the C++ Standard
Algorithms Library.
Unless otherwise specified, the whole of the C++ Standard's Library
- introduction (C++14 §20) is included into this
Technical Specification by reference.
<experimental/task_block> synopsis
-namespace std {
-namespace experimental {
-namespace parallel {
-inline namespace v2 {
+namespace std {
+namespace std::experimental {
+inline namespace parallelism_v2 {
+inline namespace v2 {
class task_cancelled_exception;
class task_block;
@@ -18,10 +18,10 @@ Header <experimental/task_block> synopsis
template<class f>
void define_task_block_restore_thread(F&& f);
+}
}
}
-}
-}
+}
@@ -29,21 +29,21 @@ <experimental/task_block> synopsistask_cancelled_exception
-namespace std {
-namespace experimental {
-namespace parallel
-inline namespace v2 {
+namespace std {
+namespace std::experimental {
+inline namespace parallelism_v2 {
+inline namespace v2 {
class task_cancelled_exception : public exception
{
public:
task_cancelled_exception() noexcept;
- virtual const char* what() const noexcept;
+ virtual const char* what() const noexcept override;
};
+}
}
}
-}
-}
+}
@@ -69,10 +69,10 @@
task_cancelled_exception member function whattask_block
-namespace std {
-namespace experimental {
-namespace parallel {
-inline namespace v2 {
+namespace std {
+namespace std::experimental {
+inline namespace parallelism_v2 {
+inline namespace v2 {
class task_block
{
@@ -89,10 +89,10 @@ Class task_block
void wait();
};
+}
}
}
-}
-}
+}
diff --git a/terms_and_definitions.html b/terms_and_definitions.html
index 22aa5e4..86a659d 100644
--- a/terms_and_definitions.html
+++ b/terms_and_definitions.html
@@ -1,6 +1,18 @@
For the purposes of this document, the terms and definitions given in the C++ Standard and the following apply. A parallel algorithm is a function template described by this Technical Specification declared in namespace Terms and definitions
+
+
+
+
+
+
+
+
std::experimental::parallel::v2 with a formal template parameter named ExecutionPolicy.Terms and definitions
+