LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.

| :------------: | :-------------: |

|  | <img align="right" src="image/dynamic_graph.png" width="100%"> |

<p float="left">

</p>

Cpp-Taskflow is committed to support both academic and industry research projects,

visit the [documentation][wiki] to learn more about Cpp-Taskflow.

Calling `wait_for_all` will block until all tasks complete.

designed for this purpose. The `tf::Framework` allows you to create reusable task dependency graphs

and you can compose several task graphs to build a large task graph.

The `tf::Framework` provides the same API as `tf::Taskflow` to create tasks.

The following example shows using `tf::Framework` to create a task graph .

B.precede(C, D); // B runs before C and D

to let you query the execution status.

A powerful feature of `tf::Framework` is its composability. You can create task graphs for

different parts of your workload and compose them to build a whole task graph through the `composed_of` method.

f2B.precede(f1_module_task);

f1_module_task.precede(f2C);

The class `tf::Taskflow` is the main place to create and execute task dependency graph.

The table below summarizes a list of commonly used methods.

| Method | Argument | Return | Description |

| -------- | --------- | ------- | ----------- |

| Taskflow | size | none | construct a taskflow with a given number of workers |

| emplace | callables | tasks | create a task with a given callable(s) |

| placeholder | none | task | insert a node without any work; work can be assigned later |

| parallel_for | beg, end, callable, group | task pair | apply the callable in parallel and group-by-group to the result of dereferencing every iterator in the range |

| parallel_for | beg, end, step, callable, group | task pair | apply the callable in parallel and group-by-group to a index-based range |

| reduce | beg, end, res, bop | task pair | reduce a range of elements to a single result through a binary operator |

| transform_reduce | beg, end, res, bop, uop | task pair | apply a unary operator to each element in the range and reduce them to a single result through a binary operator |

| dispatch | none | future | dispatch the current graph and return a shared future to block on completion |

| wait_for_all | none | none | dispatch the current graph and block until all graphs finish, including all previously dispatched ones, and then clear all graphs |

| wait_for_topologies | none | none | block until all dispatched graphs (topologies) finish, and then clear these graphs |

| num_nodes | none | size | query the number of nodes in the current graph |

The method `parallel_for` creates a subgraph that applies the callable to each item in the given range of

By default, all reduce methods distribute the workload evenly across threads.

Dispatching a taskflow graph will schedule threads to execute the current graph and return immediately.

auto future = tf.dispatch();

A task handle is a lightweight object that defines a set of methods for users to

access and modify the attributes of the associated task.

The table below summarizes the list of commonly used methods.

| Method | Argument | Return | Description |

| -------------- | ----------- | ------ | ----------- |