template<class T> execution_policy(const T& exec);

Effects:

Constructs an execution_policy object with a copy of exec's state.

Remarks:

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);

Effects:

Assigns a copy of exec's state to *this.

Returns:

*this.

const type_info& type() const noexcept;

Returns:

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;

Returns:

If target_type() == typeid(T), a pointer to the stored execution policy object; otherwise a null pointer.

Requires:

is_execution_policy<T>::value is true.

template<class ExecutionPolicy,
      class InputIterator, class Function>
void for_each(ExecutionPolicy&& exec,
              InputIterator first, InputIterator last,
              Function f);

Effects:

Applies f to the result of dereferencing every iterator in the range [first,last). [ Note: If the type of first satisfies the requirements of a mutable iterator, f may apply nonconstant functions through the dereferenced iterator. — end note ]

Complexity:

Applies f exactly last - first times.

Remarks:

If f returns a result, the result is ignored.

Notes:

Unlike its sequential form, the parallel overload of for_each does not return a copy of its Function parameter, since parallelization may not permit efficient state accumulation.

Requires:

Unlike its sequential form, the parallel overload of for_each requires Function to meet the requirements of CopyConstructible.

template<class InputIterator, class Size, class Function>
InputIterator for_each_n(InputIterator first, Size n,
                         Function f);

Requires:

Function shall meet the requirements of MoveConstructible [ Note: Function need not meet the requirements of CopyConstructible. — end note ]

Effects:

Applies f to the result of dereferencing every iterator in the range [first,first + n), starting from first and proceeding to first + n - 1. [ Note: If the type of first satisfies the requirements of a mutable iterator, f may apply nonconstant functions through the dereferenced iterator. — end note ]

Returns:

first + n for non-negative values of n and first for negative values.

Remarks:

If f returns a result, the result is ignored.

template<class ExecutionPolicy,
      class InputIterator, class Size, class Function>
InputIterator for_each_n(ExecutionPolicy && exec,
                         InputIterator first, Size n,
                         Function f);

Effects:

Applies f to the result of dereferencing every iterator in the range [first,first + n), starting from first and proceeding to first + n - 1. [ Note: If the type of first satisfies the requirements of a mutable iterator, f may apply nonconstant functions through the dereferenced iterator. — end note ]

Returns:

first + n for non-negative values of n and first for negative values.

Remarks:

If f returns a result, the result is ignored.

Notes:

Unlike its sequential form, the parallel overload of for_each_n requires Function to meet the requirements of CopyConstructible.

template<class InputIterator>
typename iterator_traits<InputIterator>::value_type
    reduce(InputIterator first, InputIterator last);

Effects:

Same as reduce(first, last, typename iterator_traits<InputIterator>::value_type{}).

template<class InputIterator, class T>
T reduce(InputIterator first, InputIterator last, T init);

Effects:

Same as reduce(first, last, init, plus<>()).

template<class InputIterator, class T, class BinaryOperation>
T reduce(InputIterator first, InputIterator last, T init,
         BinaryOperation binary_op);

Returns:

GENERALIZED_SUM(binary_op, init, *first, ..., *(first + (last - first) - 1)).

Requires:

binary_op shall not invalidate iterators or subranges, nor modify elements in the range [first,last).

Complexity:

O(last - first) applications of binary_op.

Notes:

The primary difference between reduce and accumulate is that the behavior of reduce may be non-deterministic for non-associative or non-commutative binary_op.

template<class InputIterator, class OutputIterator, class T>
OutputIterator exclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
                              T init);

Effects:

Same as exclusive_scan(first, last, result, init, plus<>()).

template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
OutputIterator exclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
                              T init, BinaryOperation binary_op);

Effects:

Assigns through each iterator i in [result,result + (last - first)) the value of GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, init, *first, ..., *(first + (i - result) - 1)).

Returns:

The end of the resulting range beginning at result.

Requires:

binary_op shall not invalidate iterators or subranges, nor modify elements in the ranges [first,last) or [result,result + (last - first)).

Complexity:

O(last - first) applications of binary_op.

Notes:

The difference between 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.

template<class InputIterator, class OutputIterator>
OutputIterator inclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result);

Effects:

Same as inclusive_scan(first, last, result, plus<>()).

template<class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator inclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
                              BinaryOperation binary_op);template<class InputIterator, class OutputIterator, class BinaryOperation, class T>
OutputIterator inclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
                              BinaryOperation binary_op, T init);

Effects:

Assigns through each iterator 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.

Returns:

The end of the resulting range beginning at result.

Requires:

binary_op shall not invalidate iterators or subranges, nor modify elements in the ranges [first,last) or [result,result + (last - first)).

Complexity:

O(last - first) applications of binary_op.

Notes:

The difference between 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.

template<class InputIterator, class UnaryFunction, class T, class BinaryOperation>
T transform_reduce(InputIterator first, InputIterator last,
                   UnaryOperation unary_op, T init, BinaryOperation binary_op);

Returns:

GENERALIZED_SUM(binary_op, init, unary_op(*first), ..., unary_op(*(first + (last - first) -
1))).

Requires:

Neither unary_op nor binary_op shall invalidate subranges, or modify elements in the range [first,last)

Complexity:

O(last - first) applications each of unary_op and binary_op.

Notes:

transform_reduce does not apply unary_op to init.

template<class InputIterator, class OutputIterator,
      class UnaryOperation,
      class T, class BinaryOperation>
OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
                                        OutputIterator result,
                                        UnaryOperation unary_op,
                                        T init, BinaryOperation binary_op);

Effects:

Assigns through each iterator i in [result,result + (last - first)) the value of GENERALIZED_NONCOMMUTATIVE_SUM(binary_op, init, unary_op(*first), ..., unary_op(*(first + (i
- result) - 1))).

Returns:

The end of the resulting range beginning at result.

Requires:

Neither unary_op nor binary_op shall invalidate iterators or subranges, or modify elements in the ranges [first,last) or [result,result + (last - first)).

Complexity:

O(last - first) applications each of unary_op and binary_op.

Notes:

The difference between 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.

template<class InputIterator, class OutputIterator,
      class UnaryOperation,
      class BinaryOperation>
OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
                                        OutputIterator result,
                                        UnaryOperation unary_op,
                                        BinaryOperation binary_op);template<class InputIterator, class OutputIterator,
      class UnaryOperation,
      class BinaryOperation, class T>
OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
                                        OutputIterator result,
                                        UnaryOperation unary_op,
                                        BinaryOperation binary_op, T init);

Effects:

Assigns through each iterator 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.

Returns:

The end of the resulting range beginning at result.

Requires:

Neither unary_op nor binary_op shall invalidate iterators or subranges, or modify elements in the ranges [first,last) or [result,result + (last - first)).

Complexity:

O(last - first) applications each of unary_op and binary_op.

Notes:

The difference between 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.

virtual const char* what() const noexcept

Returns:

An implementation-defined NTBS.

template<class F> void run(F&& f);

Requires:

F shall be MoveConstructible. DECAY_COPY(std::forward<F>(f))() shall be a valid expression.

Preconditions:

*this shall be the active task_block.

Effects:

Evaluates DECAY_COPY(std::forward<F>(f))(), where DECAY_COPY(std::forward<F>(f)) is evaluated synchronously within the current thread. The call to the resulting copy of the function object is permitted to run on an unspecified thread created by the implementation in an unordered fashion relative to the sequence of operations following the call to run(f) (the continuation), or indeterminately sequenced within the same thread as the continuation. The call to run synchronizes with the call to the function object. The completion of the call to the function object synchronizes with the next invocation of wait on the same task_block or completion of the nearest enclosing task block (i.e., the define_task_block or define_task_block_restore_thread that created this task_block).

Throws:

task_cancelled_exception, as described in 8.5.

Remarks:

The run function may return on a thread other than the one on which it was called; in such cases, completion of the call to run synchronizes with the continuation. [ Note: The return from run is ordered similarly to an ordinary function call in a single thread. — end note ]

Remarks:

The invocation of the user-supplied function object f may be immediate or may be delayed until compute resources are available. run might or might not return before the invocation of f completes.

void wait();

Preconditions:

*this shall be the active task_block.

Effects:

Blocks until the tasks spawned using this task_block have completed.

Throws:

task_cancelled_exception, as described in 8.5.

Postconditions:

All tasks spawned by the nearest enclosing task block have completed.

Remarks:

The wait function may return on a thread other than the one on which it was called; in such cases, completion of the call to wait synchronizes with subsequent operations. [ Note: The return from wait is ordered similarly to an ordinary function call in a single thread. — end note ] [ Example:

define_task_block([&](auto& tb) {
  tb.run([&]{ process(a, w, x); }); // Process a[w] through a[x]
  if (y < x) tb.wait();             // Wait if overlap between [w,x) and [y,z)
  process(a, y, z);                 // Process a[y] through a[z]
});

— end example ]