Merge branch 'v2' of github.com:cplusplus/parallelism-ts into flatten-n4706-diffs

Author: jaredhoberock

README.md

@@ -1,24 +1,19 @@
-    Document Number: N4707
-    Date:            2017-11-22
+    Document Number: N4726
+    Date:            2018-02-12
     Revises:
     Project:         Programming Language C++
     Project Number:  TS 19570
     Reply-to:        Jared Hoberock
                      NVIDIA Corporation
                      [email protected]
 
-# Parallelism TS Editor's Report, post-Albuquerque mailing 
+# Parallelism TS Editor's Report, pre-Jacksonville mailing 
 
-N4706 is the proposed working draft of Parallelism TS Version 2. It contains changes to the Parallelism TS as directed by the committee at the Albuquerque meeting.
+N4725 is the proposed working draft of Parallelism TS Version 2. It contains editorial changes to the Parallelism TS.
 
-N4706 updates the previous draft, N4696, published in the pre-Toronto mailing.
-
-# Technical Changes
-
-* Apply P0776R1 - Rebase the Parallelism TS onto the C++17 Standard
-* Apply P0075R2 - Template Library for Parallel For Loops
+N4725 updates the previous draft, N4706, published in the post-Toronto mailing.
 
 # Acknowledgements
 
-Thanks to Alisdair Meredith and Pablo Halpern for reviewing these changes.
+Thanks to Pablo Halpern and Matthias Kretz for suggesting editorial changes.
 

algorithms.html

@@ -83,7 +83,7 @@ <h1>Wavefront Application</h1>
     <p>
       Let <i>f</i> be a function called for each argument list in a sequence of argument lists.
       <i>Wavefront application</i> of <i>f</i> requires that evaluation A<sub>i</sub> be sequenced
-      before evaluation B<sub>i</sub> if i &lt; j and and:
+      before evaluation B<sub>j</sub> if i &lt; j and:
 
       <ul>
         <li>A<sub>i</sub> is sequenced before some evaluation B<sub>i</sub> and B<sub>i</sub> is horizontally matched with B<sub>j</sub>, or</li>
@@ -127,7 +127,7 @@ <h1>Header <code>&lt;experimental/algorithm&gt;</code> synopsis</h1>
 
 // Exposition only: Suppress template argument deduction.
 template&lt;class T&gt; struct no_deduce { using type = T; };
-template&lt;class T&gt; struct no_dedude_t = typename no_deduce&lt;T&gt;::type;
+template&lt;class T&gt; struct no_dedu<ins>c</ins><del>d</del>e_t = typename no_deduce&lt;T&gt;::type;
 
 <cxx-ref insynopsis="" to="parallel.alg.reductions"></cxx-ref> Support for reductions
 template&lt;class T, class BinaryOperation&gt;
@@ -287,7 +287,7 @@ <h1>Reductions</h1>
           </thead>
         </table>
 
-        <cxx-example>The following code updates each element of <code>y</code> and sets <code>s</code> ot the sum of the squares.
+        <cxx-example>The following code updates each element of <code>y</code> and sets <code>s</code> to the sum of the squares.
 <pre>
 extern int n;
 extern float x[], y[], a;
@@ -330,12 +330,12 @@ <h1>Inductions</h1>
         <cxx-signature>template&lt;class T, class S&gt;
 <em>unspecified</em> induction(T&amp;&amp; var, S stride);</cxx-signature>
 
-          <cxx-returns>
-            an induction object with induction value type <code>remove_cv_t&gt;remove_reference_t&gt;T&lt;&lt;</code>,
-            initial value <code>var</code>, and (if specified) stride <code>stride</code>. If <code>T</code> is an lvalue reference
-            to non-<code>const</code> type, then the object referenced by <code>var</code> becomes the live-out object for the
-            induction object; otherwise there is no live-out object.
-          </cxx-returns>
+        <cxx-returns>
+          an induction object with induction value type <code>remove_cv_t&lt;remove_reference_t&lt;T&gt;&gt;</code>,
+          initial value <code>var</code>, and (if specified) stride <code>stride</code>. If <code>T</code> is an lvalue reference
+          to non-<code>const</code> type, then the object referenced by <code>var</code> becomes the live-out object for the
+          induction object; otherwise there is no live-out object.
+        </cxx-returns>
       </cxx-function>
     </cxx-section>
 
@@ -423,13 +423,13 @@ <h1>For loop</h1>
           The first element in the input sequence is <code>start</code>. Each subsequent element is generated by adding
           <code>stride</code> to the previous element, if <code>stride</code> is specified, otherwise by incrementing
           the previous element. <cxx-note>As described in the C++ standard, section [algorithms.general], arithmetic
-          on non-random-access iterators is performed using advance and distance.</cxx-note> <cxx-note>The order of the
+          on non-random-access iterators is performed using <code>advance</code> and <code>distance</code>.</cxx-note> <cxx-note>The order of the
           elements of the input sequence is important for determining ordinal position of an application of <em>f</em>,
           even though the applications themselves may be unordered.</cxx-note></p>
 
           The first argument to <em>f</em> is an element from the input sequence. <cxx-note>if <code>I</code> is an
           iterator type, the iterators in the input sequence are not dereferenced before
-          being passed to <em>f</em>.</cxx-note> For each member of the rest parameter pack
+          being passed to <em>f</em>.</cxx-note> For each member of the <code>rest</code> parameter pack
           excluding <em>f</em>, an additional argument is passed to each application of <em>f</em> as follows:
 
           <ul>
@@ -451,9 +451,9 @@ <h1>For loop</h1>
           Applies <em>f</em> exactly once for each element of the input sequence.
         </cxx-complexity>
 
-          <cxx-remarks>
-            If <em>f</em> returns a result, the result is ignored.
-          </cxx-remarks>
+        <cxx-remarks>
+          If <em>f</em> returns a result, the result is ignored.
+        </cxx-remarks>
       </cxx-function>
     </cxx-section>
 
@@ -556,7 +556,7 @@ <h1>Ordered update class</h1>
 </pre>
 
       <p>
-      An object of type <code>ordered_update_t<del>&gt;</del><ins>&lt;</ins>T<del>&lt;</del><ins>&gt;</ins></code> is a proxy for an object of type T
+      An object of type <code>ordered_update_t&lt;T&gt;</code> 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 <code>vector_policy</code>. Simple increments, assignments, and compound
         assignments to the object are forwarded to the proxied object, but are sequenced as though

exceptions.html

@@ -6,6 +6,7 @@ <h1>Header <code>&lt;experimental/exception_list&gt;</code> synopsis</h1>
 
 namespace std::experimental {
 inline namespace parallelism_v2 {
+
   class exception_list : public exception
   {
     public:
@@ -26,7 +27,7 @@ <h1>Header <code>&lt;experimental/exception_list&gt;</code> synopsis</h1>
       </p>
 
       <p>
-        The type <code>exception_list::iterator</code> shall fulfill the requirements of
+        The type <code>exception_list::iterator</code> <ins>fulfills</ins><del>shall fulfill</del> the requirements of
         <code>ForwardIterator</code>.
       </p>
 

execution_policies.html

@@ -1,5 +1,6 @@
 <cxx-clause id="parallel.execpol">
   <h1>Execution policies</h1>
+
   <cxx-section id="parallel.execpol.synopsis">
   <h1>Header <code>&lt;experimental/execution&gt;</code> synopsis</h1>
 
@@ -17,7 +18,7 @@ <h1>Header <code>&lt;experimental/execution&gt;</code> synopsis</h1>
 
   <cxx-ref insynopsis="" to="parallel.execpol.objects"></cxx-ref>
   inline constexpr unsequenced_policy unseq{ <i>unspecified</i> };
-  inline constexpr parallel_policy par{ <i>unspecified</i> };
+  inline constexpr vector_policy vec{ <i>unspecified</i> };
 }
 }
 }
@@ -38,7 +39,7 @@ <h1>Unsequenced execution policy</h1>
 
     <p><cxx-note>This overrides the usual guarantee from the C++ Standard, <cxx-ref in="cxx" to="intro.execution"></cxx-ref> [intro.execution] that function executions do not overlap with one another.</cxx-note></p>
 
-    <p>During the execution of a parallel algorithm with the <code>experimental::execution::unsequenced_policy</code> policy, if the invocation of an element access function exits via an uncaught exception, <code>terminate()</code> shall be called.</p>
+    <p>During the execution of a parallel algorithm with the <code>experimental::execution::unsequenced_policy</code> policy, if the invocation of an element access function exits via an uncaught exception, <code>terminate()</code> will be called.</p>
 
   </cxx-section>
 
@@ -51,18 +52,18 @@ <h1>Vector execution policy</h1>
 
     <p>The class <code>vector_policy</code> 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]). <cxx-note>The implementation thus makes stronger guarantees than for <code>unsequenced_policy</code>, for example.</cxx-note></p>
 
-    <p>The invocations of element access functions in parallel algorithms invoked with an execution policy of type <code>vector_policy</code> 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 (<cxx-ref to="parallel.alg.general.wavefront"></cxx-ref>) for the last argument to <code>for_loop</code> or <code>for_loop_strided</code>.</p>
+    <p>The invocations of element access functions in parallel algorithms invoked with an execution policy of type <code>vector_policy</code> 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 (<cxx-ref to="parallel.alg.general.wavefront"></cxx-ref>) for the last argument to <code>for_loop</code>, <code>for_loop_n</code>, <code>for_loop_strided</code>, or <code>for_loop_strided_n</code>.</p>
 
-    <p>During the execution of a parallel algorithm with the <code>experimental::execution::vector_policy</code> policy, if the invocation of an element access function exits via an uncaught exception, <code>terminate()</code> shall be called.</p>
+    <p>During the execution of a parallel algorithm with the <code>experimental::execution::vector_policy</code> policy, if the invocation of an element access function exits via an uncaught exception, <code>terminate()</code> will be called.</p>
 
   </cxx-section>
 
   <cxx-section id="parallel.execpol.objects">
     <h1>Execution policy objects</h1>
 
 <pre>
-constexpr execution::unsequenced_policy unseq{};
-constexpr execution::vector_policy vec{};
+inline constexpr execution::unsequenced_policy unseq{};
+inline constexpr execution::vector_policy vec{};
 </pre>
 
     <p>The header <code>&lt;experimental/execution&gt;</code> declares a global object associated with each type of execution policy defined by this Technical Specification.</p>

front_matter.html

@@ -1,8 +1,8 @@
 <cxx-titlepage stage="draft">
-<cxx-docnum>N4706</cxx-docnum>
+<cxx-docnum>N4725</cxx-docnum>
 <cxx-project-number>19570</cxx-project-number>
-  <time pubdate="">2017-11-22</time>
-  <cxx-revises><a href="http://wg21.link/N4698">N4698</a></cxx-revises>
+  <time pubdate="">2018-02-12</time>
+  <cxx-revises><a href="http://wg21.link/N4706">N4706</a></cxx-revises>
   <cxx-editor>
     Jared Hoberock<br/>
     NVIDIA Corporation<br/>

task_block.html

@@ -12,10 +12,10 @@ <h1>Header <code>&lt;experimental/task_block&gt;</code> synopsis</h1>
   class task_block;
 
   template&lt;class F&gt;
-    void define_task_block(F&& f);
+    void define_task_block(F&amp;&amp; f);
 
   template&lt;class f&gt;
-    void define_task_block_restore_thread(F&& f);
+    void define_task_block_restore_thread(F&amp;&amp; f);
 }
 }
      </pre>
@@ -70,12 +70,12 @@ <h1>Class <code>task_block</code></h1>
       ~task_block();
 
     public:
-      task_block(const task_block&) = delete;
-      task_block& operator=(const task_block&) = delete;
-      void operator&() const = delete;
+      task_block(const task_block&amp;) = delete;
+      task_block&amp; operator=(const task_block&amp;) = delete;
+      void operator&amp;() const = delete;
 
       template&lt;class F&gt;
-        void run(F&& f);
+        void run(F&amp;&amp; f);
 
       void wait();
   };