From Jason Turner

[execpol]

C++20 → C++23 3.9 KB 33 lines
Current Draft | LaTeX Source
Archived: C++20 | C++23
Markdown: C++20 | C++23
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpwvkotkt0/{from.md → to.md} +13 -13
tmp/tmpwvkotkt0/{from.md → to.md} RENAMED
@@ -26,22 +26,22 @@ sort(execution::par, v.begin(), v.end());
26
  sort(execution::par_unseq, v.begin(), v.end());
27
  ```
28
 
29
  — *end example*]
30
 
31
- [*Note 1*: Because different parallel architectures may require
32
- idiosyncratic parameters for efficient execution, implementations may
33
- provide additional execution policies to those described in this
34
- standard as extensions. — *end note*]
35
 
36
  ### Header `<execution>` synopsis <a id="execution.syn">[[execution.syn]]</a>
37
 
38
  ``` cpp
39
  namespace std {
40
  // [execpol.type], execution policy type trait
41
  template<class T> struct is_execution_policy;
42
- template<class T> inline constexpr bool is_execution_policy_v = is_execution_policy<T>::value;
43
  }
44
 
45
  namespace std::execution {
46
  // [execpol.seq], sequenced execution policy
47
  class sequenced_policy;
@@ -94,12 +94,12 @@ The class `execution::sequenced_policy` is an execution policy type used
94
  as a unique type to disambiguate parallel algorithm overloading and
95
  require that a parallel algorithm’s execution may not be parallelized.
96
 
97
  During the execution of a parallel algorithm with the
98
  `execution::sequenced_policy` policy, if the invocation of an element
99
- access function exits via an uncaught exception, `terminate()` is
100
- called.
101
 
102
  ### Parallel execution policy <a id="execpol.par">[[execpol.par]]</a>
103
 
104
  ``` cpp
105
  class execution::parallel_policy { unspecified };
@@ -109,12 +109,12 @@ The class `execution::parallel_policy` is an execution policy type used
109
  as a unique type to disambiguate parallel algorithm overloading and
110
  indicate that a parallel algorithm’s execution may be parallelized.
111
 
112
  During the execution of a parallel algorithm with the
113
  `execution::parallel_policy` policy, if the invocation of an element
114
- access function exits via an uncaught exception, `terminate()` is
115
- called.
116
 
117
  ### Parallel and unsequenced execution policy <a id="execpol.parunseq">[[execpol.parunseq]]</a>
118
 
119
  ``` cpp
120
  class execution::parallel_unsequenced_policy { unspecified };
@@ -125,12 +125,12 @@ policy type used as a unique type to disambiguate parallel algorithm
125
  overloading and indicate that a parallel algorithm’s execution may be
126
  parallelized and vectorized.
127
 
128
  During the execution of a parallel algorithm with the
129
  `execution::parallel_unsequenced_policy` policy, if the invocation of an
130
- element access function exits via an uncaught exception, `terminate()`
131
- is called.
132
 
133
  ### Unsequenced execution policy <a id="execpol.unseq">[[execpol.unseq]]</a>
134
 
135
  ``` cpp
136
  class execution::unsequenced_policy { unspecified };
@@ -142,12 +142,12 @@ that a parallel algorithm’s execution may be vectorized, e.g., executed
142
  on a single thread using instructions that operate on multiple data
143
  items.
144
 
145
  During the execution of a parallel algorithm with the
146
  `execution::unsequenced_policy` policy, if the invocation of an element
147
- access function exits via an uncaught exception, `terminate()` is
148
- called.
149
 
150
  ### Execution policy objects <a id="execpol.objects">[[execpol.objects]]</a>
151
 
152
  ``` cpp
153
  inline constexpr execution::sequenced_policy execution::seq{ unspecified };
 
26
  sort(execution::par_unseq, v.begin(), v.end());
27
  ```
28
 
29
  — *end example*]
30
 
31
+ [*Note 1*: Implementations can provide additional execution policies to
32
+ those described in this standard as extensions to address parallel
33
+ architectures that require idiosyncratic parameters for efficient
34
+ execution. — *end note*]
35
 
36
  ### Header `<execution>` synopsis <a id="execution.syn">[[execution.syn]]</a>
37
 
38
  ``` cpp
39
  namespace std {
40
  // [execpol.type], execution policy type trait
41
  template<class T> struct is_execution_policy;
42
+ template<class T> constexpr bool is_execution_policy_v = is_execution_policy<T>::value;
43
  }
44
 
45
  namespace std::execution {
46
  // [execpol.seq], sequenced execution policy
47
  class sequenced_policy;
 
94
  as a unique type to disambiguate parallel algorithm overloading and
95
  require that a parallel algorithm’s execution may not be parallelized.
96
 
97
  During the execution of a parallel algorithm with the
98
  `execution::sequenced_policy` policy, if the invocation of an element
99
+ access function exits via an exception, `terminate` is
100
+ invoked [[except.terminate]].
101
 
102
  ### Parallel execution policy <a id="execpol.par">[[execpol.par]]</a>
103
 
104
  ``` cpp
105
  class execution::parallel_policy { unspecified };
 
109
  as a unique type to disambiguate parallel algorithm overloading and
110
  indicate that a parallel algorithm’s execution may be parallelized.
111
 
112
  During the execution of a parallel algorithm with the
113
  `execution::parallel_policy` policy, if the invocation of an element
114
+ access function exits via an exception, `terminate` is
115
+ invoked [[except.terminate]].
116
 
117
  ### Parallel and unsequenced execution policy <a id="execpol.parunseq">[[execpol.parunseq]]</a>
118
 
119
  ``` cpp
120
  class execution::parallel_unsequenced_policy { unspecified };
 
125
  overloading and indicate that a parallel algorithm’s execution may be
126
  parallelized and vectorized.
127
 
128
  During the execution of a parallel algorithm with the
129
  `execution::parallel_unsequenced_policy` policy, if the invocation of an
130
+ element access function exits via an exception, `terminate` is
131
+ invoked [[except.terminate]].
132
 
133
  ### Unsequenced execution policy <a id="execpol.unseq">[[execpol.unseq]]</a>
134
 
135
  ``` cpp
136
  class execution::unsequenced_policy { unspecified };
 
142
  on a single thread using instructions that operate on multiple data
143
  items.
144
 
145
  During the execution of a parallel algorithm with the
146
  `execution::unsequenced_policy` policy, if the invocation of an element
147
+ access function exits via an exception, `terminate` is invoked
148
+ [[except.terminate]].
149
 
150
  ### Execution policy objects <a id="execpol.objects">[[execpol.objects]]</a>
151
 
152
  ``` cpp
153
  inline constexpr execution::sequenced_policy execution::seq{ unspecified };