#include \<taskflow/taskflow.hpp\> // Taskflow is header-onlyint main(){tf::Executor executor;tf::Taskflow taskflow;auto [A, B, C, D] = taskflow.emplace(// create four tasks[] () { std::cout \<\< "TaskA\n"; },[] () { std::cout \<\< "TaskB\n"; },[] () { std::cout \<\< "TaskC\n"; },[] () { std::cout \<\< "TaskD\n"; } );A.precede(B, C);// A runs before B and CD.succeed(B, C);// D runs after B and Cexecutor.run(taskflow).wait(); return 0;}

~$ git clone https://github.com/taskflow/taskflow.git# clone it only once~$ g++ -std=c++20 simple.cpp -I taskflow/ -O2 -pthread -o simple
~$ ./simple
TaskA
TaskC 
TaskB 
TaskD

# run the program with the environment variable TF\_ENABLE\_PROFILER enabled~$TF\_ENABLE\_PROFILER=simple.json ./simple
~$ cat simple.json[{"executor":"0","data":[{"worker":0,"level":0,"data":[{"span":[172,186],"name":"0\_0","type":"static"},{"span":[187,189],"name":"0\_1","type":"static"}]},{"worker":2,"level":0,"data":[{"span":[93,164],"name":"2\_0","type":"static"},{"span":[170,179],"name":"2\_1","type":"static"}]}]}]# paste the profiling json data to https://taskflow.github.io/tfprof/

tf::Task A = taskflow.emplace([](){}).name("A");tf::Task C = taskflow.emplace([](){}).name("C");tf::Task D = taskflow.emplace([](){}).name("D");tf::Task B = taskflow.emplace([] (tf::Subflow& subflow) { // subflow task Btf::Task B1 = subflow.emplace([](){}).name("B1");tf::Task B2 = subflow.emplace([](){}).name("B2");tf::Task B3 = subflow.emplace([](){}).name("B3");B3.succeed(B1, B2);// B3 runs after B1 and B2}).name("B");A.precede(B, C);// A runs before B and CD.succeed(B, C);// D runs after B and C

tf::Task init = taskflow.emplace([](){}).name("init");tf::Task stop = taskflow.emplace([](){}).name("stop");// creates a condition task that returns a random binarytf::Task cond = taskflow.emplace([](){ return std::rand() % 2; }).name("cond");// creates a feedback loop {0: cond, 1: stop}init.precede(cond);cond.precede(cond, stop);// moves on to 'cond' on returning 0, or 'stop' on 1

tf::Taskflow f1, f2;// create taskflow f1 of two taskstf::Task f1A = f1.emplace([]() { std::cout \<\< "Task f1A\n"; }).name("f1A");tf::Task f1B = f1.emplace([]() { std::cout \<\< "Task f1B\n"; }).name("f1B");// create taskflow f2 with one module task composed of f1tf::Task f2A = f2.emplace([]() { std::cout \<\< "Task f2A\n"; }).name("f2A");tf::Task f2B = f2.emplace([]() { std::cout \<\< "Task f2B\n"; }).name("f2B");tf::Task f2C = f2.emplace([]() { std::cout \<\< "Task f2C\n"; }).name("f2C");tf::Task f1\_module\_task = f2.composed\_of(f1).name("module");f1\_module\_task.succeed(f2A, f2B).precede(f2C);

tf::Executor executor;// create asynchronous tasks directly from an executorstd::future\<int\> future = executor.async([](){ std::cout \<\< "async task returns 1\n";return 1;}); executor.silent\_async([](){ std::cout \<\< "async task does not return\n"; });// create asynchronous tasks with dynamic dependenciestf::AsyncTask A = executor.silent\_dependent\_async([](){ printf("A\n"); });tf::AsyncTask B = executor.silent\_dependent\_async([](){ printf("B\n"); }, A);tf::AsyncTask C = executor.silent\_dependent\_async([](){ printf("C\n"); }, A);tf::AsyncTask D = executor.silent\_dependent\_async([](){ printf("D\n"); }, B, C);executor.wait\_for\_all();

// standard parallel CPU algorithmstf::Task task1 = taskflow.for\_each( // assign each element to 100 in parallelfirst, last, [] (auto& i) { i = 100; });tf::Task task2 = taskflow.reduce(// reduce a range of items in parallelfirst, last, init, [] (auto a, auto b) { return a + b; });tf::Task task3 = taskflow.sort(// sort a range of items in parallelfirst, last, [] (auto a, auto b) { return a \< b; });

// create a pipeline to propagate five tokens through three serial stagestf::Pipeline pl(num\_lines,tf::Pipe{tf::PipeType::SERIAL, [](tf::Pipeflow& pf) {if(pf.token() == 5) {pf.stop();}}},tf::Pipe{tf::PipeType::SERIAL, [](tf::Pipeflow& pf) {printf("stage 2: input buffer[%zu] = %d\n", pf.line(), buffer[pf.line()]);}},tf::Pipe{tf::PipeType::SERIAL, [](tf::Pipeflow& pf) {printf("stage 3: input buffer[%zu] = %d\n", pf.line(), buffer[pf.line()]);}});taskflow.composed\_of(pl)executor.run(taskflow).wait();

// runs the taskflow oncetf::Future\<void\> run\_once = executor.run(taskflow); // wait on this run to finishrun\_once.get();// run the taskflow four timesexecutor.run\_n(taskflow, 4);// runs the taskflow five timesexecutor.run\_until(taskflow, counter=5{ return --counter == 0; });// blocks the executor until all submitted taskflows completeexecutor.wait\_for\_all();

\_\_global\_\_ void saxpy(int n, float a, float \*x, float \*y) {int i = blockIdx.x\*blockDim.x + threadIdx.x;if (i \< n) {y[i] = a\*x[i] + y[i];}}// create a CUDA Graph tasktf::Task cudaflow = taskflow.emplace(& {tf::cudaGraph cg;tf::cudaTask h2d\_x = cg.copy(dx, hx.data(), N);tf::cudaTask h2d\_y = cg.copy(dy, hy.data(), N);tf::cudaTask d2h\_x = cg.copy(hx.data(), dx, N);tf::cudaTask d2h\_y = cg.copy(hy.data(), dy, N);tf::cudaTask saxpy = cg.kernel((N+255)/256, 256, 0, saxpy, N, 2.0f, dx, dy);saxpy.succeed(h2d\_x, h2d\_y).precede(d2h\_x, d2h\_y);// instantiate an executable CUDA graph and run it through a streamtf::cudaGraphExec exec(cg);tf::cudaStream stream;stream.run(exec).synchronize();}).name("CUDA Graph Task");

tf::Taskflow taskflow;tf::Task A = taskflow.emplace([](){}).name("A");tf::Task B = taskflow.emplace([](){}).name("B");tf::Task C = taskflow.emplace([](){}).name("C");tf::Task D = taskflow.emplace([](){}).name("D");tf::Task E = taskflow.emplace([](){}).name("E");A.precede(B, C, E);C.precede(D);B.precede(D, E);// dump the graph to a DOT file through std::couttaskflow.dump(std::cout);