docs/ParallelIterations.html · uxsys/cpp-taskflow

Fetch the repository succeeded.

richgiteeai

Watch

Unwatch Watching Releases Only Ignoring

1 Star 0 Fork 37

uxsys/cpp-taskflow

forked from Gitee 极速下载/cpp-taskflow

Code Wiki Insights Pipelines

Service

Tencent Cloud Serverless

Create your Gitee Account

Explore and code with more than 14 million developers,Free private repositories !:)

Already have an account? Sign in

文件

master

Branches (3)

Tags (15)

Manage

master

dev

cpp14

v3.4.0

v3.3.0

v3.2.0

v3.1.0

v3.0.0

v2.7.0

v2.6.0

v2.5.0

2.5.0

v2.4.0

v2.3.1

v2.3.0

v2.2.0

v2.1.0

v2.0.0

Clone or Download

Clone/Download

HTTPS SSH SVN SVN+SSH Download ZIP

Prompt

To download the code, please copy the following command and execute it in the terminal

To ensure that your submitted code identity is correctly recognized by Gitee, please execute the following command.

git config --global user.name userName 
git config --global user.email userEmail

When using the SSH protocol for the first time to clone or push code, follow the prompts below to complete the SSH configuration.

1 Generate RSA keys.

2 Obtain the content of the RSA public key and configure it in SSH Public Keys

To use SVN on Gitee, please visit the usage guide

When using the HTTPS protocol, the command line will prompt for account and password verification as follows. For security reasons, Gitee recommends configure and use personal access tokens instead of login passwords for cloning, pushing, and other operations.

Username for 'https://gitee.com': userName

Password for 'https://userName@gitee.com': # Private Token

Branches 3

Tags 15

cpp-taskflow

docs

ParallelIterations.html

ParallelIterations.html 30.41 KB

<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8" />
 <title>Taskflow Algorithms &raquo; Parallel Iterations | Taskflow QuickStart</title>
 <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Source+Sans+Pro:400,400i,600,600i%7CSource+Code+Pro:400,400i,600" />
 <link rel="stylesheet" href="m-dark+documentation.compiled.css" />
 <link rel="icon" href="favicon.ico" type="image/vnd.microsoft.icon" />
 <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 <meta name="theme-color" content="#22272e" />
</head>
<body>
<header><nav id="navigation">
 <div class="m-container">
 <div class="m-row">
 
 <a href="https://taskflow.github.io"><img src="taskflow_logo.png" alt="" />Taskflow</a> | <a href="index.html" class="m-thin">QuickStart</a>
 
 <div class="m-col-t-4 m-hide-m m-text-right m-nopadr">
 <a href="#search" class="m-doc-search-icon" title="Search" onclick="return showSearch()"><svg style="height: 0.9rem;" viewBox="0 0 16 16">
 <path id="m-doc-search-icon-path" d="m6 0c-3.31 0-6 2.69-6 6 0 3.31 2.69 6 6 6 1.49 0 2.85-0.541 3.89-1.44-0.0164 0.338 0.147 0.759 0.5 1.15l3.22 3.79c0.552 0.614 1.45 0.665 2 0.115 0.55-0.55 0.499-1.45-0.115-2l-3.79-3.22c-0.392-0.353-0.812-0.515-1.15-0.5 0.895-1.05 1.44-2.41 1.44-3.89 0-3.31-2.69-6-6-6zm0 1.56a4.44 4.44 0 0 1 4.44 4.44 4.44 4.44 0 0 1-4.44 4.44 4.44 4.44 0 0 1-4.44-4.44 4.44 4.44 0 0 1 4.44-4.44z"/>
 </svg></a>
 <a id="m-navbar-show" href="#navigation" title="Show navigation"></a>
 <a id="m-navbar-hide" href="#" title="Hide navigation"></a>
 </div>
 <div id="m-navbar-collapse" class="m-col-t-12 m-show-m m-col-m-none m-right-m">
 <div class="m-row">
 <ol class="m-col-t-6 m-col-m-none">
 <li><a href="pages.html">Handbook</a></li>
 <li><a href="namespaces.html">Namespaces</a></li>
 </ol>
 <ol class="m-col-t-6 m-col-m-none" start="3">
 <li><a href="annotated.html">Classes</a></li>
 <li><a href="files.html">Files</a></li>
 <li class="m-show-m"><a href="#search" class="m-doc-search-icon" title="Search" onclick="return showSearch()"><svg style="height: 0.9rem;" viewBox="0 0 16 16">
 <use href="#m-doc-search-icon-path" />
 </svg></a></li>
 </ol>
 </div>
 </div>
 </div>
 </div>
</nav></header>
<main><article>
 <div class="m-container m-container-inflatable">
 <div class="m-row">
 <div class="m-col-l-10 m-push-l-1">
 <h1>
 <a href="Algorithms.html">Taskflow Algorithms</a> &raquo;
 Parallel Iterations
 </h1>
 <nav class="m-block m-default">
 <h3>Contents</h3>
 <ul>
 <li><a href="#A1IndexBasedParallelFor">Create an Index-based Parallel-Iteration Task</a></li>
 <li><a href="#A1IteratorBasedParallelFor">Create an Iterator-based Parallel-Iteration Task</a></li>
 </ul>
 </nav>
Taskflow provides template functions for constructing tasks to perform parallel iterations over ranges of items.<section id="A1IndexBasedParallelFor"><h2><a href="#A1IndexBasedParallelFor">Create an Index-based Parallel-Iteration Task</a></h2>Index-based parallel-for performs parallel iterations over a range <code>[first, last)</code> with the given <code>step</code> size. The task created by <a href="classtf_1_1FlowBuilder.html#a38ffe176bc3ae1827b9964322e3769d4" class="m-doc">tf::Taskflow::for_each_index(B first, E last, S step, C callable)</a> represents parallel execution of the following loop:<pre class="m-code">// positive step
for(auto i=first; i&lt;last; i+=step) {
 callable(i);
}

// negative step
for(auto i=first; i&gt;last; i+=step) {
 callable(i);
}</pre>We support only integer-based range. The range can go positive or negative direction.<pre class="m-code">taskflow.for_each_index(0, 100, 2, [](int i) { }); // 50 loops with a + step
taskflow.for_each_index(100, 0, -2, [](int i) { }); // 50 loops with a - step</pre>Notice that either positive or negative direction is defined in terms of the range, <code>[first, last)</code>, where <code>end</code> is excluded. In the positive case, the 50 items are 0, 2, 4, 6, 8, ..., 96, 98. In the negative case, the 50 items are 100, 98, 96, 04, ... 4, 2. An example of the Taskflow graph for the positive case under 12 workers is depicted below:<div class="m-graph"><svg style="width: 77.062rem; height: 7.375rem;" viewBox="0.00 0.00 1232.51 117.54">
<g transform="scale(1 1) rotate(0) translate(4 113.5391)">
<title>Taskflow</title>
<g class="m-node m-flat">
<title>p0xce2720</title>
<ellipse cx="596.7193" cy="-18.3848" rx="181.9532" ry="18.2703"/>
<text text-anchor="middle" x="596.7193" y="-14.5848">[0, 100) with the step size of 2</text>
</g>
<g class="m-node m-flat">
<title>p0x7f322c000b50</title>
<ellipse cx="41.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="41.7193" y="-87.3543">pfg_0</text>
</g>
<g class="m-edge">
<title>p0x7f322c000b50&#45;&gt;p0xce2720</title>
<path d="M72.2973,-78.5711C78.632,-76.3457 85.3253,-74.2654 91.7193,-72.7696 199.5302,-47.5474 323.0709,-33.9837 420.9751,-26.7098"/>
<polygon points="421.2503,-30.1992 430.9698,-25.9824 420.7421,-23.2176 421.2503,-30.1992"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c000c58</title>
<ellipse cx="142.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="142.7193" y="-87.3543">pfg_1</text>
</g>
<g class="m-edge">
<title>p0x7f322c000c58&#45;&gt;p0xce2720</title>
<path d="M173.597,-78.6094C179.8497,-76.4085 186.4355,-74.3278 192.7193,-72.7696 274.7292,-52.4323 368.1146,-39.2357 444.4284,-30.9428"/>
<polygon points="445.0304,-34.3985 454.6016,-29.8552 444.2862,-27.4381 445.0304,-34.3985"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c000d60</title>
<ellipse cx="243.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="243.7193" y="-87.3543">pfg_2</text>
</g>
<g class="m-edge">
<title>p0x7f322c000d60&#45;&gt;p0xce2720</title>
<path d="M274.9214,-78.7316C281.0891,-76.5467 287.5604,-74.4408 293.7193,-72.7696 353.6903,-56.4961 421.6881,-43.7864 478.051,-34.7602"/>
<polygon points="478.7432,-38.1943 488.0732,-33.1742 477.649,-31.2803 478.7432,-38.1943"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c000e68</title>
<ellipse cx="344.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="344.7193" y="-87.3543">pfg_3</text>
</g>
<g class="m-edge">
<title>p0x7f322c000e68&#45;&gt;p0xce2720</title>
<path d="M376.3124,-79.0535C382.388,-76.8641 388.7255,-74.6742 394.7193,-72.7696 434.7538,-60.048 479.8473,-47.7202 517.256,-38.0272"/>
<polygon points="518.2809,-41.3775 527.0915,-35.4933 516.5345,-34.5988 518.2809,-41.3775"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c000f70</title>
<ellipse cx="445.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="445.7193" y="-87.3543">pfg_4</text>
</g>
<g class="m-edge">
<title>p0x7f322c000f70&#45;&gt;p0xce2720</title>
<path d="M474.1212,-77.4669C495.4838,-67.1719 525.2224,-52.8404 550.06,-40.8707"/>
<polygon points="551.8226,-43.9066 559.3116,-36.4122 548.7837,-37.6006 551.8226,-43.9066"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c001078</title>
<ellipse cx="546.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="546.7193" y="-87.3543">pfg_5</text>
</g>
<g class="m-edge">
<title>p0x7f322c001078&#45;&gt;p0xce2720</title>
<path d="M558.8229,-73.5389C564.6646,-65.0368 571.8001,-54.652 578.2974,-45.1959"/>
<polygon points="581.2511,-47.0775 584.0295,-36.8534 575.4817,-43.1133 581.2511,-47.0775"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c001180</title>
<ellipse cx="647.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="647.7193" y="-87.3543">pfg_6</text>
</g>
<g class="m-edge">
<title>p0x7f322c001180&#45;&gt;p0xce2720</title>
<path d="M635.3736,-73.5389C629.415,-65.0368 622.1369,-54.652 615.5096,-45.1959"/>
<polygon points="618.2684,-43.0338 609.6629,-36.8534 612.536,-47.0513 618.2684,-43.0338"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c001288</title>
<ellipse cx="748.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="748.7193" y="-87.3543">pfg_7</text>
</g>
<g class="m-edge">
<title>p0x7f322c001288&#45;&gt;p0xce2720</title>
<path d="M720.1293,-77.4669C698.6252,-67.1719 668.6897,-52.8404 643.6876,-40.8707"/>
<polygon points="644.9057,-37.5735 634.3747,-36.4122 641.883,-43.8872 644.9057,-37.5735"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c001390</title>
<ellipse cx="849.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="849.7193" y="-87.3543">pfg_8</text>
</g>
<g class="m-edge">
<title>p0x7f322c001390&#45;&gt;p0xce2720</title>
<path d="M818.1281,-79.0475C812.0523,-76.8587 805.7143,-74.6705 799.7193,-72.7696 759.4921,-60.0142 714.1758,-47.6831 676.5809,-37.9966"/>
<polygon points="677.2522,-34.5556 666.6964,-35.4648 675.5152,-41.3367 677.2522,-34.5556"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c001498</title>
<ellipse cx="950.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="950.7193" y="-87.3543">pfg_9</text>
</g>
<g class="m-edge">
<title>p0x7f322c001498&#45;&gt;p0xce2720</title>
<path d="M919.518,-78.7288C913.3502,-76.5442 906.8787,-74.439 900.7193,-72.7696 840.5518,-56.4613 772.3298,-43.7484 715.7806,-34.729"/>
<polygon points="716.1482,-31.2439 705.7252,-33.1444 715.0584,-38.1585 716.1482,-31.2439"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c0015a0</title>
<ellipse cx="1059.7193" cy="-91.1543" rx="48.5816" ry="18.2703"/>
<text text-anchor="middle" x="1059.7193" y="-87.3543">pfg_10</text>
</g>
<g class="m-edge">
<title>p0x7f322c0015a0&#45;&gt;p0xce2720</title>
<path d="M1023.7847,-78.6996C1016.5411,-76.4913 1008.935,-74.3848 1001.7193,-72.7696 916.7466,-53.7482 820.1559,-40.4648 742.6206,-31.7898"/>
<polygon points="742.619,-28.2684 732.2951,-30.6491 741.8502,-35.2261 742.619,-28.2684"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c0016a8</title>
<ellipse cx="1175.7193" cy="-91.1543" rx="48.5816" ry="18.2703"/>
<text text-anchor="middle" x="1175.7193" y="-87.3543">pfg_11</text>
</g>
<g class="m-edge">
<title>p0x7f322c0016a8&#45;&gt;p0xce2720</title>
<path d="M1139.8211,-78.531C1132.5746,-76.3365 1124.958,-74.2783 1117.7193,-72.7696 1002.5873,-48.773 870.8259,-35.1425 768.6148,-27.5285"/>
<polygon points="768.7331,-24.0279 758.504,-26.7877 768.2215,-31.0092 768.7331,-24.0279"/>
</g>
</g>
</svg>
</div>The index types, <code>B</code>, <code>E</code>, and <code>S</code>, are templates to preserve the variable types and their underlying types must be of the same integral type (e.g., <code>int</code>, <code>size_t</code>, <code>unsigned</code>). By default, <a href="classtf_1_1FlowBuilder.html#a38ffe176bc3ae1827b9964322e3769d4" class="m-doc">tf::Taskflow::for_each_index</a> creates a task that spawns a subflow (see <a href="DynamicTasking.html" class="m-doc">Dynamic Tasking</a>) to run iterations in parallel. The subflow closure captures all input arguments through perfect forwarding to form a stateful closure such that any changes on the arguments will be visible to the execution context of the subflow. For example:<pre class="m-code">int* vec;
int first, last;

auto init = taskflow.emplace([&amp;](){
 first = 0;
 last = 1000;
 vec = new int[1000]; 
});

auto pf = taskflow.for_each_index(std::ref(first), std::ref(last), 1, 
 [&amp;] (int i) {
 std::cout &lt;&lt; &quot;parallel iteration on index &quot; &lt;&lt; vec[i] &lt;&lt; &#39;\n&#39;;
 }
);

// wrong! must use std::ref, or first and last are captured by copy
// auto pf = taskflow.for_each_index(first, last, 1, [&amp;](int i) {
// std::cout &lt;&lt; &quot;parallel iteration on index &quot; &lt;&lt; vec[i] &lt;&lt; &#39;\n&#39;;
// });

init.precede(pf);</pre>When <code>init</code> finishes, the parallel-for task <code>pf</code> will see <code>first</code> as 0 and <code>last</code> as 1000 and performs parallel iterations over the 1000 items. This property is especially important for task graph parallelism, because users can define end-to-end parallelism through stateful closures that marshal parameter exchange between dependent tasks.</section><section id="A1IteratorBasedParallelFor"><h2><a href="#A1IteratorBasedParallelFor">Create an Iterator-based Parallel-Iteration Task</a></h2>Iterator-based parallel-for performs parallel iterations over a range specified by two <a href="https://en.cppreference.com/w/cpp/iterator/iterator">STL-styled iterators</a>, <code>first</code> and <code>last</code>. The task created by <a href="classtf_1_1FlowBuilder.html#ab405d7b10040530d8b04c11767b4960d" class="m-doc">tf::Taskflow::for_each(B first, E last, C callable)</a> represents a parallel execution of the following loop:<pre class="m-code">for(auto i=first; i&lt;last; i++) {
 callable(*i);
}</pre>By default, <a href="classtf_1_1FlowBuilder.html#ab405d7b10040530d8b04c11767b4960d" class="m-doc">tf::Taskflow::for_each(B first, E last, C callable)</a> creates a task that spawns a subflow (see <a href="DynamicTasking.html" class="m-doc">Dynamic Tasking</a>) that applies the callable to the object obtained by dereferencing every iterator in the range <code>[first, last)</code>. It is user&#x27;s responsibility for ensuring the range is valid within the execution of the parallel-for task. Iterators must have the post-increment operator ++ defined. This version of parallel-for applies to all iterable STL containers.<pre class="m-code">std::vector&lt;int&gt; vec = {1, 2, 3, 4, 5};
taskflow.for_each(vec.begin(), vec.end(), [](int i){ 
 std::cout &lt;&lt; &quot;parallel for on item &quot; &lt;&lt; i &lt;&lt; &#39;\n&#39;; 
});

std::list&lt;std::string&gt; list = {&quot;hi&quot;, &quot;from&quot;, &quot;t&quot;, &quot;a&quot;, &quot;s&quot;, &quot;k&quot;, &quot;f&quot;, &quot;low&quot;};
taskflow.for_each(list.begin(), list.end(), [](const std::string&amp; str){ 
 std::cout &lt;&lt; &quot;parallel for on item &quot; &lt;&lt; str &lt;&lt; &#39;\n&#39;; 
});</pre>Similar to index-based parallel-for, the iterator types are templates to enable users to leverage the property of stateful closure. For example:<pre class="m-code">std::vector&lt;int&gt; vec;
std::vector&lt;int&gt;::iterator first, last;;

tf::Task init = taskflow.emplace([&amp;](){
 vec.resize(1000);
 first = vec.begin();
 last = vec.end();
});

tf::Task pf = taskflow.for_each(std::ref(first), std::ref(last), [&amp;](int i) {
 std::cout &lt;&lt; &quot;parallel iteration on item &quot; &lt;&lt; i &lt;&lt; &#39;\n&#39;;
});

// wrong! must use std::ref, or first and last are captured by copy
// tf::Task pf = taskflow.for_each(first, last, [&amp;](int i) {
// std::cout &lt;&lt; &quot;parallel iteration on item &quot; &lt;&lt; i &lt;&lt; &#39;\n&#39;;
// });

Copy Edit Raw Blame History

twhuang authored 2022年08月16日 02:24 +08:00 . revised doc

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297

<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8" />
 <title>Taskflow Algorithms &raquo; Parallel Iterations | Taskflow QuickStart</title>
 <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Source+Sans+Pro:400,400i,600,600i%7CSource+Code+Pro:400,400i,600" />
 <link rel="stylesheet" href="m-dark+documentation.compiled.css" />
 <link rel="icon" href="favicon.ico" type="image/vnd.microsoft.icon" />
 <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 <meta name="theme-color" content="#22272e" />
</head>
<body>
<header><nav id="navigation">
 <div class="m-container">
 <div class="m-row">
 <span id="m-navbar-brand" class="m-col-t-8 m-col-m-none m-left-m">
 <a href="https://taskflow.github.io"><img src="taskflow_logo.png" alt="" />Taskflow</a> <span class="m-breadcrumb">|</span> <a href="index.html" class="m-thin">QuickStart</a>
 </span>
 <div class="m-col-t-4 m-hide-m m-text-right m-nopadr">
 <a href="#search" class="m-doc-search-icon" title="Search" onclick="return showSearch()"><svg style="height: 0.9rem;" viewBox="0 0 16 16">
 <path id="m-doc-search-icon-path" d="m6 0c-3.31 0-6 2.69-6 6 0 3.31 2.69 6 6 6 1.49 0 2.85-0.541 3.89-1.44-0.0164 0.338 0.147 0.759 0.5 1.15l3.22 3.79c0.552 0.614 1.45 0.665 2 0.115 0.55-0.55 0.499-1.45-0.115-2l-3.79-3.22c-0.392-0.353-0.812-0.515-1.15-0.5 0.895-1.05 1.44-2.41 1.44-3.89 0-3.31-2.69-6-6-6zm0 1.56a4.44 4.44 0 0 1 4.44 4.44 4.44 4.44 0 0 1-4.44 4.44 4.44 4.44 0 0 1-4.44-4.44 4.44 4.44 0 0 1 4.44-4.44z"/>
 </svg></a>
 <a id="m-navbar-show" href="#navigation" title="Show navigation"></a>
 <a id="m-navbar-hide" href="#" title="Hide navigation"></a>
 </div>
 <div id="m-navbar-collapse" class="m-col-t-12 m-show-m m-col-m-none m-right-m">
 <div class="m-row">
 <ol class="m-col-t-6 m-col-m-none">
 <li><a href="pages.html">Handbook</a></li>
 <li><a href="namespaces.html">Namespaces</a></li>
 </ol>
 <ol class="m-col-t-6 m-col-m-none" start="3">
 <li><a href="annotated.html">Classes</a></li>
 <li><a href="files.html">Files</a></li>
 <li class="m-show-m"><a href="#search" class="m-doc-search-icon" title="Search" onclick="return showSearch()"><svg style="height: 0.9rem;" viewBox="0 0 16 16">
 <use href="#m-doc-search-icon-path" />
 </svg></a></li>
 </ol>
 </div>
 </div>
 </div>
 </div>
</nav></header>
<main><article>
 <div class="m-container m-container-inflatable">
 <div class="m-row">
 <div class="m-col-l-10 m-push-l-1">
 <h1>
 <span class="m-breadcrumb"><a href="Algorithms.html">Taskflow Algorithms</a> &raquo;</span>
 Parallel Iterations
 </h1>
 <nav class="m-block m-default">
 <h3>Contents</h3>
 <ul>
 <li><a href="#A1IndexBasedParallelFor">Create an Index-based Parallel-Iteration Task</a></li>
 <li><a href="#A1IteratorBasedParallelFor">Create an Iterator-based Parallel-Iteration Task</a></li>
 </ul>
 </nav>
<p>Taskflow provides template functions for constructing tasks to perform parallel iterations over ranges of items.</p><section id="A1IndexBasedParallelFor"><h2><a href="#A1IndexBasedParallelFor">Create an Index-based Parallel-Iteration Task</a></h2><p>Index-based parallel-for performs parallel iterations over a range <code>[first, last)</code> with the given <code>step</code> size. The task created by <a href="classtf_1_1FlowBuilder.html#a38ffe176bc3ae1827b9964322e3769d4" class="m-doc">tf::<wbr />Taskflow::<wbr />for_each_index(B first, E last, S step, C callable)</a> represents parallel execution of the following loop:</p><pre class="m-code"><span class="c1">// positive step</span>
<span class="k">for</span><span class="p">(</span><span class="k">auto</span><span class="w"> </span><span class="n">i</span><span class="o">=</span><span class="n">first</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">&lt;</span><span class="n">last</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">+=</span><span class="n">step</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w"> </span><span class="n">callable</span><span class="p">(</span><span class="n">i</span><span class="p">);</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>

<span class="c1">// negative step</span>
<span class="k">for</span><span class="p">(</span><span class="k">auto</span><span class="w"> </span><span class="n">i</span><span class="o">=</span><span class="n">first</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">&gt;</span><span class="n">last</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">+=</span><span class="n">step</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w"> </span><span class="n">callable</span><span class="p">(</span><span class="n">i</span><span class="p">);</span><span class="w"></span>
<span class="p">}</span><span class="w"></span></pre><p>We support only integer-based range. The range can go positive or negative direction.</p><pre class="m-code"><span class="n">taskflow</span><span class="p">.</span><span class="n">for_each_index</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="mi">100</span><span class="p">,</span><span class="w"> </span><span class="mi">2</span><span class="p">,</span><span class="w"> </span><span class="p">[](</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="p">});</span><span class="w"> </span><span class="c1">// 50 loops with a + step</span>
<span class="n">taskflow</span><span class="p">.</span><span class="n">for_each_index</span><span class="p">(</span><span class="mi">100</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="mi">-2</span><span class="p">,</span><span class="w"> </span><span class="p">[](</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="p">});</span><span class="w"> </span><span class="c1">// 50 loops with a - step</span></pre><p>Notice that either positive or negative direction is defined in terms of the range, <code>[first, last)</code>, where <code>end</code> is excluded. In the positive case, the 50 items are 0, 2, 4, 6, 8, ..., 96, 98. In the negative case, the 50 items are 100, 98, 96, 04, ... 4, 2. An example of the Taskflow graph for the positive case under 12 workers is depicted below:</p><div class="m-graph"><svg style="width: 77.062rem; height: 7.375rem;" viewBox="0.00 0.00 1232.51 117.54">
<g transform="scale(1 1) rotate(0) translate(4 113.5391)">
<title>Taskflow</title>
<g class="m-node m-flat">
<title>p0xce2720</title>
<ellipse cx="596.7193" cy="-18.3848" rx="181.9532" ry="18.2703"/>
<text text-anchor="middle" x="596.7193" y="-14.5848">[0, 100) with the step size of 2</text>
</g>
<g class="m-node m-flat">
<title>p0x7f322c000b50</title>
<ellipse cx="41.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="41.7193" y="-87.3543">pfg_0</text>
</g>
<g class="m-edge">
<title>p0x7f322c000b50&#45;&gt;p0xce2720</title>
<path d="M72.2973,-78.5711C78.632,-76.3457 85.3253,-74.2654 91.7193,-72.7696 199.5302,-47.5474 323.0709,-33.9837 420.9751,-26.7098"/>
<polygon points="421.2503,-30.1992 430.9698,-25.9824 420.7421,-23.2176 421.2503,-30.1992"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c000c58</title>
<ellipse cx="142.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="142.7193" y="-87.3543">pfg_1</text>
</g>
<g class="m-edge">
<title>p0x7f322c000c58&#45;&gt;p0xce2720</title>
<path d="M173.597,-78.6094C179.8497,-76.4085 186.4355,-74.3278 192.7193,-72.7696 274.7292,-52.4323 368.1146,-39.2357 444.4284,-30.9428"/>
<polygon points="445.0304,-34.3985 454.6016,-29.8552 444.2862,-27.4381 445.0304,-34.3985"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c000d60</title>
<ellipse cx="243.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="243.7193" y="-87.3543">pfg_2</text>
</g>
<g class="m-edge">
<title>p0x7f322c000d60&#45;&gt;p0xce2720</title>
<path d="M274.9214,-78.7316C281.0891,-76.5467 287.5604,-74.4408 293.7193,-72.7696 353.6903,-56.4961 421.6881,-43.7864 478.051,-34.7602"/>
<polygon points="478.7432,-38.1943 488.0732,-33.1742 477.649,-31.2803 478.7432,-38.1943"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c000e68</title>
<ellipse cx="344.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="344.7193" y="-87.3543">pfg_3</text>
</g>
<g class="m-edge">
<title>p0x7f322c000e68&#45;&gt;p0xce2720</title>
<path d="M376.3124,-79.0535C382.388,-76.8641 388.7255,-74.6742 394.7193,-72.7696 434.7538,-60.048 479.8473,-47.7202 517.256,-38.0272"/>
<polygon points="518.2809,-41.3775 527.0915,-35.4933 516.5345,-34.5988 518.2809,-41.3775"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c000f70</title>
<ellipse cx="445.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="445.7193" y="-87.3543">pfg_4</text>
</g>
<g class="m-edge">
<title>p0x7f322c000f70&#45;&gt;p0xce2720</title>
<path d="M474.1212,-77.4669C495.4838,-67.1719 525.2224,-52.8404 550.06,-40.8707"/>
<polygon points="551.8226,-43.9066 559.3116,-36.4122 548.7837,-37.6006 551.8226,-43.9066"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c001078</title>
<ellipse cx="546.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="546.7193" y="-87.3543">pfg_5</text>
</g>
<g class="m-edge">
<title>p0x7f322c001078&#45;&gt;p0xce2720</title>
<path d="M558.8229,-73.5389C564.6646,-65.0368 571.8001,-54.652 578.2974,-45.1959"/>
<polygon points="581.2511,-47.0775 584.0295,-36.8534 575.4817,-43.1133 581.2511,-47.0775"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c001180</title>
<ellipse cx="647.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="647.7193" y="-87.3543">pfg_6</text>
</g>
<g class="m-edge">
<title>p0x7f322c001180&#45;&gt;p0xce2720</title>
<path d="M635.3736,-73.5389C629.415,-65.0368 622.1369,-54.652 615.5096,-45.1959"/>
<polygon points="618.2684,-43.0338 609.6629,-36.8534 612.536,-47.0513 618.2684,-43.0338"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c001288</title>
<ellipse cx="748.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="748.7193" y="-87.3543">pfg_7</text>
</g>
<g class="m-edge">
<title>p0x7f322c001288&#45;&gt;p0xce2720</title>
<path d="M720.1293,-77.4669C698.6252,-67.1719 668.6897,-52.8404 643.6876,-40.8707"/>
<polygon points="644.9057,-37.5735 634.3747,-36.4122 641.883,-43.8872 644.9057,-37.5735"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c001390</title>
<ellipse cx="849.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="849.7193" y="-87.3543">pfg_8</text>
</g>
<g class="m-edge">
<title>p0x7f322c001390&#45;&gt;p0xce2720</title>
<path d="M818.1281,-79.0475C812.0523,-76.8587 805.7143,-74.6705 799.7193,-72.7696 759.4921,-60.0142 714.1758,-47.6831 676.5809,-37.9966"/>
<polygon points="677.2522,-34.5556 666.6964,-35.4648 675.5152,-41.3367 677.2522,-34.5556"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c001498</title>
<ellipse cx="950.7193" cy="-91.1543" rx="41.9398" ry="18.2703"/>
<text text-anchor="middle" x="950.7193" y="-87.3543">pfg_9</text>
</g>
<g class="m-edge">
<title>p0x7f322c001498&#45;&gt;p0xce2720</title>
<path d="M919.518,-78.7288C913.3502,-76.5442 906.8787,-74.439 900.7193,-72.7696 840.5518,-56.4613 772.3298,-43.7484 715.7806,-34.729"/>
<polygon points="716.1482,-31.2439 705.7252,-33.1444 715.0584,-38.1585 716.1482,-31.2439"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c0015a0</title>
<ellipse cx="1059.7193" cy="-91.1543" rx="48.5816" ry="18.2703"/>
<text text-anchor="middle" x="1059.7193" y="-87.3543">pfg_10</text>
</g>
<g class="m-edge">
<title>p0x7f322c0015a0&#45;&gt;p0xce2720</title>
<path d="M1023.7847,-78.6996C1016.5411,-76.4913 1008.935,-74.3848 1001.7193,-72.7696 916.7466,-53.7482 820.1559,-40.4648 742.6206,-31.7898"/>
<polygon points="742.619,-28.2684 732.2951,-30.6491 741.8502,-35.2261 742.619,-28.2684"/>
</g>
<g class="m-node m-flat">
<title>p0x7f322c0016a8</title>
<ellipse cx="1175.7193" cy="-91.1543" rx="48.5816" ry="18.2703"/>
<text text-anchor="middle" x="1175.7193" y="-87.3543">pfg_11</text>
</g>
<g class="m-edge">
<title>p0x7f322c0016a8&#45;&gt;p0xce2720</title>
<path d="M1139.8211,-78.531C1132.5746,-76.3365 1124.958,-74.2783 1117.7193,-72.7696 1002.5873,-48.773 870.8259,-35.1425 768.6148,-27.5285"/>
<polygon points="768.7331,-24.0279 758.504,-26.7877 768.2215,-31.0092 768.7331,-24.0279"/>
</g>
</g>
</svg>
</div><p>The index types, <code>B</code>, <code>E</code>, and <code>S</code>, are templates to preserve the variable types and their underlying types must be of the same <em>integral</em> type (e.g., <code>int</code>, <code>size_t</code>, <code>unsigned</code>). By default, <a href="classtf_1_1FlowBuilder.html#a38ffe176bc3ae1827b9964322e3769d4" class="m-doc">tf::<wbr />Taskflow::<wbr />for_each_index</a> creates a task that spawns a subflow (see <a href="DynamicTasking.html" class="m-doc">Dynamic Tasking</a>) to run iterations in parallel. The subflow closure captures all input arguments through perfect forwarding to form a stateful closure such that any changes on the arguments will be visible to the execution context of the subflow. For example:</p><pre class="m-code"><span class="kt">int</span><span class="o">*</span><span class="w"> </span><span class="n">vec</span><span class="p">;</span><span class="w"></span>
<span class="kt">int</span><span class="w"> </span><span class="n">first</span><span class="p">,</span><span class="w"> </span><span class="n">last</span><span class="p">;</span><span class="w"></span>

<span class="k">auto</span><span class="w"> </span><span class="n">init</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">taskflow</span><span class="p">.</span><span class="n">emplace</span><span class="p">([</span><span class="o">&amp;</span><span class="p">](){</span><span class="w"></span>
<span class="w"> </span><span class="n">first</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"></span>
<span class="w"> </span><span class="n">last</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1000</span><span class="p">;</span><span class="w"></span>
<span class="w"> </span><span class="n">vec</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="kt">int</span><span class="p">[</span><span class="mi">1000</span><span class="p">];</span><span class="w"> </span>
<span class="p">});</span><span class="w"></span>

<span class="k">auto</span><span class="w"> </span><span class="n">pf</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">taskflow</span><span class="p">.</span><span class="n">for_each_index</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">ref</span><span class="p">(</span><span class="n">first</span><span class="p">),</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">ref</span><span class="p">(</span><span class="n">last</span><span class="p">),</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span>
<span class="w"> </span><span class="p">[</span><span class="o">&amp;</span><span class="p">]</span><span class="w"> </span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot;parallel iteration on index &quot;</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">vec</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="sc">&#39;\n&#39;</span><span class="p">;</span><span class="w"></span>
<span class="w"> </span><span class="p">}</span><span class="w"></span>
<span class="p">);</span><span class="w"></span>

<span class="c1">// wrong! must use std::ref, or first and last are captured by copy</span>
<span class="c1">// auto pf = taskflow.for_each_index(first, last, 1, [&amp;](int i) {</span>
<span class="c1">// std::cout &lt;&lt; &quot;parallel iteration on index &quot; &lt;&lt; vec[i] &lt;&lt; &#39;\n&#39;;</span>
<span class="c1">// });</span>

<span class="n">init</span><span class="p">.</span><span class="n">precede</span><span class="p">(</span><span class="n">pf</span><span class="p">);</span><span class="w"></span></pre><p>When <code>init</code> finishes, the parallel-for task <code>pf</code> will see <code>first</code> as 0 and <code>last</code> as 1000 and performs parallel iterations over the 1000 items. This property is especially important for task graph parallelism, because users can define end-to-end parallelism through stateful closures that marshal parameter exchange between dependent tasks.</p></section><section id="A1IteratorBasedParallelFor"><h2><a href="#A1IteratorBasedParallelFor">Create an Iterator-based Parallel-Iteration Task</a></h2><p>Iterator-based parallel-for performs parallel iterations over a range specified by two <a href="https://en.cppreference.com/w/cpp/iterator/iterator">STL-styled iterators</a>, <code>first</code> and <code>last</code>. The task created by <a href="classtf_1_1FlowBuilder.html#ab405d7b10040530d8b04c11767b4960d" class="m-doc">tf::<wbr />Taskflow::<wbr />for_each(B first, E last, C callable)</a> represents a parallel execution of the following loop:</p><pre class="m-code"><span class="k">for</span><span class="p">(</span><span class="k">auto</span><span class="w"> </span><span class="n">i</span><span class="o">=</span><span class="n">first</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">&lt;</span><span class="n">last</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w"> </span><span class="n">callable</span><span class="p">(</span><span class="o">*</span><span class="n">i</span><span class="p">);</span><span class="w"></span>
<span class="p">}</span><span class="w"></span></pre><p>By default, <a href="classtf_1_1FlowBuilder.html#ab405d7b10040530d8b04c11767b4960d" class="m-doc">tf::<wbr />Taskflow::<wbr />for_each(B first, E last, C callable)</a> creates a task that spawns a subflow (see <a href="DynamicTasking.html" class="m-doc">Dynamic Tasking</a>) that applies the callable to the object obtained by dereferencing every iterator in the range <code>[first, last)</code>. It is user&#x27;s responsibility for ensuring the range is valid within the execution of the parallel-for task. Iterators must have the post-increment operator ++ defined. This version of parallel-for applies to all iterable STL containers.</p><pre class="m-code"><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;</span><span class="w"> </span><span class="n">vec</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="mi">2</span><span class="p">,</span><span class="w"> </span><span class="mi">3</span><span class="p">,</span><span class="w"> </span><span class="mi">4</span><span class="p">,</span><span class="w"> </span><span class="mi">5</span><span class="p">};</span><span class="w"></span>
<span class="n">taskflow</span><span class="p">.</span><span class="n">for_each</span><span class="p">(</span><span class="n">vec</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span><span class="w"> </span><span class="n">vec</span><span class="p">.</span><span class="n">end</span><span class="p">(),</span><span class="w"> </span><span class="p">[](</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="p">){</span><span class="w"> </span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot;parallel for on item &quot;</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="sc">&#39;\n&#39;</span><span class="p">;</span><span class="w"> </span>
<span class="p">});</span><span class="w"></span>

<span class="n">std</span><span class="o">::</span><span class="n">list</span><span class="o">&lt;</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">&gt;</span><span class="w"> </span><span class="n">list</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="s">&quot;hi&quot;</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;from&quot;</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;t&quot;</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;a&quot;</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;s&quot;</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;k&quot;</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;f&quot;</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;low&quot;</span><span class="p">};</span><span class="w"></span>
<span class="n">taskflow</span><span class="p">.</span><span class="n">for_each</span><span class="p">(</span><span class="n">list</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span><span class="w"> </span><span class="n">list</span><span class="p">.</span><span class="n">end</span><span class="p">(),</span><span class="w"> </span><span class="p">[](</span><span class="k">const</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">&amp;</span><span class="w"> </span><span class="n">str</span><span class="p">){</span><span class="w"> </span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot;parallel for on item &quot;</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">str</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="sc">&#39;\n&#39;</span><span class="p">;</span><span class="w"> </span>
<span class="p">});</span><span class="w"></span></pre><p>Similar to index-based parallel-for, the iterator types are templates to enable users to leverage the property of stateful closure. For example:</p><pre class="m-code"><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;</span><span class="w"> </span><span class="n">vec</span><span class="p">;</span><span class="w"></span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;::</span><span class="n">iterator</span><span class="w"> </span><span class="n">first</span><span class="p">,</span><span class="w"> </span><span class="n">last</span><span class="p">;;</span><span class="w"></span>

<span class="n">tf</span><span class="o">::</span><span class="n">Task</span><span class="w"> </span><span class="n">init</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">taskflow</span><span class="p">.</span><span class="n">emplace</span><span class="p">([</span><span class="o">&amp;</span><span class="p">](){</span><span class="w"></span>
<span class="w"> </span><span class="n">vec</span><span class="p">.</span><span class="n">resize</span><span class="p">(</span><span class="mi">1000</span><span class="p">);</span><span class="w"></span>
<span class="w"> </span><span class="n">first</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">vec</span><span class="p">.</span><span class="n">begin</span><span class="p">();</span><span class="w"></span>
<span class="w"> </span><span class="n">last</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">vec</span><span class="p">.</span><span class="n">end</span><span class="p">();</span><span class="w"></span>
<span class="p">});</span><span class="w"></span>

<span class="n">tf</span><span class="o">::</span><span class="n">Task</span><span class="w"> </span><span class="n">pf</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">taskflow</span><span class="p">.</span><span class="n">for_each</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">ref</span><span class="p">(</span><span class="n">first</span><span class="p">),</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">ref</span><span class="p">(</span><span class="n">last</span><span class="p">),</span><span class="w"> </span><span class="p">[</span><span class="o">&amp;</span><span class="p">](</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot;parallel iteration on item &quot;</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="sc">&#39;\n&#39;</span><span class="p">;</span><span class="w"></span>
<span class="p">});</span><span class="w"></span>

<span class="c1">// wrong! must use std::ref, or first and last are captured by copy</span>
<span class="c1">// tf::Task pf = taskflow.for_each(first, last, [&amp;](int i) {</span>
<span class="c1">// std::cout &lt;&lt; &quot;parallel iteration on item &quot; &lt;&lt; i &lt;&lt; &#39;\n&#39;;</span>
<span class="c1">// });</span>

<span class="n">init</span><span class="p">.</span><span class="n">precede</span><span class="p">(</span><span class="n">pf</span><span class="p">);</span><span class="w"></span></pre><p>When <code>init</code> finishes, the parallel-for task <code>pf</code> will see <code>first</code> pointing to the beginning of <code>vec</code> and <code>last</code> pointing to the end of <code>vec</code> and performs parallel iterations over the 1000 items. The two tasks form an end-to-end task graph where the parameters of parallel-for are computed on the fly.</p></section>
 </div>
 </div>
 </div>
</article></main>
<div class="m-doc-search" id="search">
 <a href="#!" onclick="return hideSearch()"></a>
 <div class="m-container">
 <div class="m-row">
 <div class="m-col-m-8 m-push-m-2">
 <div class="m-doc-search-header m-text m-small">
 <div><span class="m-label m-default">Tab</span> / <span class="m-label m-default">T</span> to search, <span class="m-label m-default">Esc</span> to close</div>
 <div id="search-symbolcount">&hellip;</div>
 </div>
 <div class="m-doc-search-content">
 <form>
 <input type="search" name="q" id="search-input" placeholder="Loading &hellip;" disabled="disabled" autofocus="autofocus" autocomplete="off" spellcheck="false" />
 </form>
 <noscript class="m-text m-danger m-text-center">Unlike everything else in the docs, the search functionality <em>requires</em> JavaScript.</noscript>
 <div id="search-help" class="m-text m-dim m-text-center">
 <p class="m-noindent">Search for symbols, directories, files, pages or
 modules. You can omit any prefix from the symbol or file path; adding a
 <code>:</code> or <code>/</code> suffix lists all members of given symbol or
 directory.</p>
 <p class="m-noindent">Use <span class="m-label m-dim">&darr;</span>
 / <span class="m-label m-dim">&uarr;</span> to navigate through the list,
 <span class="m-label m-dim">Enter</span> to go.
 <span class="m-label m-dim">Tab</span> autocompletes common prefix, you can
 copy a link to the result using <span class="m-label m-dim">⌘</span>
 <span class="m-label m-dim">L</span> while <span class="m-label m-dim">⌘</span>
 <span class="m-label m-dim">M</span> produces a Markdown link.</p>
 </div>
 <div id="search-notfound" class="m-text m-warning m-text-center">Sorry, nothing was found.</div>
 <ul id="search-results"></ul>
 </div>
 </div>
 </div>
 </div>
</div>
<script src="search-v2.js"></script>
<script src="searchdata-v2.js" async="async"></script>
<footer><nav>
 <div class="m-container">
 <div class="m-row">
 <div class="m-col-l-10 m-push-l-1">
 <p>Taskflow handbook is part of the <a href="https://taskflow.github.io">Taskflow project</a>, copyright © <a href="https://tsung-wei-huang.github.io/">Dr. Tsung-Wei Huang</a>, 2018&ndash;2022.<br />Generated by <a href="https://doxygen.org/">Doxygen</a> 1.8.14 and <a href="https://mcss.mosra.cz/">m.css</a>.</p>
 </div>
 </div>
 </div>
</nav></footer>
</body>
</html>