*"Cpp-Taskflow has a very simple and elegant tasking interface. The performance also scales very well." [totalgee][totalgee]*

tf::Taskflow tf(std::thread::hardware_concurrency());

auto [A, B, C, D] = tf.silent_emplace(

[] () { std::cout << "TaskB\n"; }, //

[] () { std::cout << "TaskC\n"; }, // +---+

[] () { std::cout << "TaskD\n"; } // +---->| B |-----+

); // | +---+ |

// +---+ +-v-+

// +---+

return 0;

}

| [reduce.cpp](./example/reduce.cpp)| performs reduce operations over linear containers |

| [subflow.cpp](./example/subflow.cpp)| demonstrates how to create a subflow graph that spawns three dynamic tasks |

| [threadpool.cpp](./example/threadpool.cpp)| benchmarks different threadpool implementations |

| [threadpool_cxx14.cpp](./example/threadpool_cxx14.cpp)| shows use of the C++14-compatible threadpool implementation, which may be used when you have no inter-task (taskflow) dependencies to express |

Please [let me know][email me] if I forgot your project!

Cpp-Taskflow is licensed under the [MIT License](./LICENSE).

[Chun-Xun Lin]: https://github.com/clin99

[Martin Wong]: https://ece.illinois.edu/directory/profile/mdfwong

[Andreas Olofsson]: https://github.com/aolofsson

[PayMe]: https://www.paypal.me/twhuang/10

[C++17]: https://en.wikipedia.org/wiki/C%2B%2B17

[email me]: mailto:[email protected]

After you create a task dependency graph,

In this tutorial, we will show you how to execute a

task dependency graph.

The graph exists until users dispatch it for execution.

Each taskflow object has a list of topologies to keep track of the

execution status of dispatched graphs.

One way to dispatch the present task dependency graph

is to use the method `wait_for_all`.

1: tf::Taskflow tf(4);

Debrief:

+ Line 1-5 creates a graph with two tasks and one dependency

+ Line 10 blocks the program until this topology finishes

If you do not care the status of a dispatched graph,

use the method `silent_dispatch`.

This method does not return anything.

1: tf::Taskflow tf(4);

2:

Debrief

+ Line 1 creates a taskflow object with four worker threads

+ Line 3-5 creates a dependency graph of two tasks and one dependency

to access the execution status

+ Line 9 starts with a new dependency graph with one task

Calling the method `wait_for_topologies` blocks the

1: #include <taskflow/taskflow.hpp>

Debrief:

+ Line 5 creates a taskflow object with four worker threads

+ Line 7-8 creates a vector of integer items and an integer variable to store the summation value

+ Line 23-39 creates another dependency graph that sums up the values in the vector

+ Line 25-27 creates a task that initializes the variable `sum` to zero, and overlaps its execution with the first dependency graph

+ Line 42 blocks until the second dependency graph finishes

+ Line 44 puts an assertion guard on the final summation value

It is very common for a parallel program to

In this tutorial, we are going to demonstrate how to enable dynamic tasking

in Cpp-Taskflow.

*subflow* dependency graph.

Cpp-Taskflow has an unified interface for static and dynamic tasking.

To create a subflow for dynamic tasking, emplace a callable

passed to the task.

1: tf::Taskflow tf(4); // create a taskflow object with four worker threads

Cpp-Taskflow has a STL-style method `parallel_for`

that takes a range of items and applies a callable to each of the item in parallel.

The method constructs a sub-graph representing this workload

1: tf::Taskflow tf(4);

14: tf.wait_for_all();

using only the basic methods `silent_emplace` and `precede`.

Debrief:

+ Line 5 creates a taskflow object with four worker threads

+ Line 7 creates a vector of 1024 uninitialized integers

+ Line 8 creates an atomic integer variable

+ Line 10-14 creates a task that captures the vector to initialize all items to one

+ Line 20-22 creates a task that outputs the summation value

+ Line 24-25 pipelines the parallel-for workload with the two tasks

+ Line 27 dispatches the graph to threads and blocks until the execution completes