| Taskflow: A General-purpose Task-parallel Programming System

Loading...
Searching...
No Matches
Conditional Tasking

One of the most powerful features that distinguishes Taskflow from other systems is its support for conditional tasking, also known as the control taskflow programming model (CTFG). CTFG allows you to embed control flow directly within a taskflow graph, enabling tasks to make decisions dynamically during execution. This mechanism supports advanced in-graph control flow patterns, such as dynamic branching, loops, and conditionals—that are typically difficult or impossible to express in traditional task graph models.

# Create a Condition Task

A condition task returns an integer index indicating which successor task to execute next. The index corresponds to the position of the successor in the order it was added during task construction. The following example creates an if-else block using a condition task.

1: tf::Taskflow taskflow;
2:
3: auto [init, cond, yes, no] = taskflow.emplace(
4: [] () { },
5: [] () { return 0; },
6: [] () { std::cout << "yes\n"; },
7: [] () { std::cout << "no\n"; }
8: );
9:
10: cond.succeed(init)
11: .precede(yes, no); // executes yes if cond returns 0
12: // executes no if cond returns 1
tf::FlowBuilder::emplace
Task emplace(C &&callable)
creates a static task
Definition flow_builder.hpp:1352
tf::Task::succeed
Task & succeed(Ts &&... tasks)
adds precedence links from other tasks to this
Definition task.hpp:955
tf::Task::precede
Task & precede(Ts &&... tasks)
adds precedence links from this to other tasks
Definition task.hpp:947
tf::Taskflow
class to create a taskflow object
Definition taskflow.hpp:64

Line 5 creates a condition task `cond` and line 11 creates two dependencies from `cond` to two other tasks, `yes` and `no`. With this order, when `cond` returns 0, the execution moves on to task `yes`. When `cond` returns 1, the execution moves on to task `no`.

Attention
  It is your responsibility to ensure that the return value of a condition task corresponds to a valid successor. If the returned index is out of range, the executor will not schedule any successor tasks.

A condition task can form a cycle to express iterative control flow. The example below demonstrates a simple yet commonly used feedback loop implemented using a condition task (lines 7–10) that returns a random binary value. If the return value from `cond` is `0`, the task loops back to itself; otherwise, it proceeds to `stop`.

1: tf::Taskflow taskflow;
2:
3: tf::Task init = taskflow.emplace([](){}).name("init");
4: tf::Task stop = taskflow.emplace([](){}).name("stop");
5:
6: // creates a condition task that returns 0 or 1
7: tf::Task cond = taskflow.emplace([](){
8: std::cout << "flipping a coin\n";
9: return std::rand() % 2;
10: }).name("cond");
11:
12: // creates a feedback loop {0: cond, 1: stop}
13: init.precede(cond);
14: cond.precede(cond, stop); // returns 0 to 'cond' or 1 to 'stop'
15:
16: executor.run(taskflow).wait();
tf::Task
class to create a task handle over a taskflow node
Definition task.hpp:263

Creating a taskflow with complex control flow often requires only a few lines of code to implement. Different control flow paths can execute in parallel, making it easy to express both logic and concurrency. The code below creates a taskflow with three condition tasks to demonstrate this capability:

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");
tf::Task F = taskflow.emplace([](){}).name("F");
tf::Task G = taskflow.emplace([](){}).name("G");
tf::Task H = taskflow.emplace([](){}).name("H");
tf::Task I = taskflow.emplace([](){}).name("I");
tf::Task K = taskflow.emplace([](){}).name("K");
tf::Task L = taskflow.emplace([](){}).name("L");
tf::Task M = taskflow.emplace([](){}).name("M");
tf::Task cond_1 = taskflow.emplace([](){ return std::rand()%2; }).name("cond_1");
tf::Task cond_2 = taskflow.emplace([](){ return std::rand()%2; }).name("cond_2");
tf::Task cond_3 = taskflow.emplace([](){ return std::rand()%2; }).name("cond_3");
A.precede(B, F);
B.precede(C);
C.precede(D);
D.precede(cond_1);
E.precede(K);
F.precede(cond_2);
H.precede(I);
I.precede(cond_3);
L.precede(M);
cond_1.precede(B, E); // return 0 to 'B' or 1 to 'E'
cond_2.precede(G, H); // return 0 to 'G' or 1 to 'H'
cond_3.precede(cond_3, L); // return 0 to 'cond_3' or 1 to 'L'
taskflow.dump(std::cout);
tf::Taskflow::dump
void dump(std::ostream &ostream) const
dumps the taskflow to a DOT format through a std::ostream target
Definition taskflow.hpp:433

The above code creates three condition tasks to implement three different control-flow tasks:

1. A condition task `cond_1` that loops back to `B` on returning `0`, or proceeds to `E` on returning `1`,
2. A condition task `cond_2` that goes to `G` on returning `0`, or `H` on returning `1`,
3. A condition task `cond_3` that loops back to itself on returning `0`, or proceeds to `L` on returning `1`

In this particular example, we can clearly see the advantage of CTFG: the execution of `cond_1` can overlap with `cond_2` or `cond_3`, enabling greater concurrency in control-driven workloads. Unlike traditional task graph models that require static structure or external orchestration to handle control flow, CTFG allows tasks to make decisions dynamically and continue execution without global synchronization barriers. This design leads to better parallelism, reduced overhead, and more expressive task graphs, especially in workloads with branching or iterative control flows.

# Understand our Task-level Scheduling

In order to understand how an executor schedules condition tasks, we define two dependency types, strong dependency and weak dependency. A strong dependency is a preceding link from one non-condition task to another task. A weak dependency is a preceding link from one condition task to another task. The number of dependencies of a task is the sum of its strong dependencies and weak dependencies. The table below lists the number of strong dependencies and weak dependencies of each task in the previous example:

task | strong dependency | weak dependency | dependencies
--- | --- | --- | ---
A | 0 | 0 | 0
B | 1 | 1 | 2
C | 1 | 0 | 1
D | 1 | 0 | 1
E | 0 | 1 | 1
F | 1 | 0 | 1
G | 0 | 1 | 1
H | 0 | 1 | 1
I | 1 | 0 | 1
K | 1 | 0 | 1
L | 0 | 1 | 1
M | 1 | 0 | 1
cond_1 | 1 | 0 | 1
cond_2 | 1 | 0 | 1
cond_3 | 1 | 1 | 2

You can query the number of strong dependencies, the number of weak dependencies, and the number of dependencies of a task.

1: tf::Taskflow taskflow;
2:
3: tf::Task task = taskflow.emplace([](){});
4:
5: // ... add more tasks and preceding links
6:
7: std::cout << task.num_predecessors() << '\n';
8: std::cout << task.num_strong_dependencies() << '\n';
9: std::cout << task.num_weak_dependencies() << '\n';
tf::Task::num_strong_dependencies
size_t num_strong_dependencies() const
queries the number of strong dependencies of the task
Definition task.hpp:1087
tf::Task::num_weak_dependencies
size_t num_weak_dependencies() const
queries the number of weak dependencies of the task
Definition task.hpp:1092
tf::Task::num_predecessors
size_t num_predecessors() const
queries the number of predecessors of the task
Definition task.hpp:1082

When you submit a task to an executor, the scheduler starts with tasks of zero dependencies (both zero strong and weak dependencies) and continues to execute successive tasks whenever their strong dependencies are met. However, the scheduler skips this rule when executing a condition task and jumps directly to its successors indexed by the return value.

Each task has an atomic join counter to keep track of strong dependencies that are met at runtime. When a task completes, the join counter is restored to the task's strong dependency number in the graph, such that the subsequent execution can reuse the counter again.

## Example

Let's take a look at an example to understand how task-level scheduling works. Suppose we have the following taskflow of one condition task `cond` that forms a loop to itself on returning `0` and moves on to `stop` on returning `1`:

The scheduler starts with `init` task because it has no dependencies (both strong and weak dependencies). Then, the scheduler moves on to the condition task `cond`. If `cond` returns `0`, the scheduler enqueues `cond` and runs it again. If `cond` returns `1`, the scheduler enqueues `stop` and then moves on.

# Avoid Common Pitfalls

Condition tasks are handy in creating dynamic and cyclic control flows, but they are also easy to make mistakes. It is your responsibility to ensure a taskflow is properly conditioned. Top things to avoid include no source tasks to start with and task race. The figure below shows common pitfalls and their remedies.

In the `error1` scenario, there is no source task for the scheduler to start with, and the simplest fix is to add a task `S` that has no dependencies. In the `error2` scenario, `D` might be scheduled twice by `E` through the strong dependency and `C` through the weak dependency (on returning `1`). To fix this problem, you can add an auxiliary task `D-aux` to break the mixed use of strong dependency and weak dependency. In the risky scenario, task `X` may be raced by `M` and `P` if `M` returns `0` and P returns `1`.

Attention
  It is your responsibility to ensure a written taskflow graph is properly conditioned. We suggest that you Understand our Task-level Scheduling and infer if task race exists in the execution of your graph.

# Implement Control-flow Graphs

## Implement If-Else Control Flow

You can use conditional tasking to implement if-else control flow. The following example creates a nested if-else control flow diagram that executes three condition tasks to check the range of `i`.

tf::Taskflow taskflow;
int i;
// create three condition tasks for nested control flow
auto initi = taskflow.emplace([&](){ i=3; });
auto cond1 = taskflow.emplace([&](){ return i>1 ? 1 : 0; });
auto cond2 = taskflow.emplace([&](){ return i>2 ? 1 : 0; });
auto cond3 = taskflow.emplace([&](){ return i>3 ? 1 : 0; });
auto equl1 = taskflow.emplace([&](){ std::cout << "i=1\n"; });
auto equl2 = taskflow.emplace([&](){ std::cout << "i=2\n"; });
auto equl3 = taskflow.emplace([&](){ std::cout << "i=3\n"; });
auto grtr3 = taskflow.emplace([&](){ std::cout << "i>3\n"; });
initi.precede(cond1);
cond1.precede(equl1, cond2); // goes to cond2 if i>1
cond2.precede(equl2, cond3); // goes to cond3 if i>2
cond3.precede(equl3, grtr3); // goes to grtr3 if i>3

## Implement Switch Control Flow

You can use condition tasks to implement switch-style control flow. The following example demonstrates this by creating a switch structure that randomly selects and executes one of three cases using four condition tasks.

tf::Taskflow taskflow;
auto [source, swcond, case1, case2, case3, target] = taskflow.emplace(
[](){ std::cout << "source\n"; },
[](){ std::cout << "switch\n"; return rand()%3; },
[](){ std::cout << "case 1\n"; return 0; },
[](){ std::cout << "case 2\n"; return 0; },
[](){ std::cout << "case 3\n"; return 0; },
[](){ std::cout << "target\n"; }
);
source.precede(swcond);
swcond.precede(case1, case2, case3);
target.succeed(case1, case2, case3);

Assuming `swcond` returns 1, the program outputs:

source
switch
case 2
target

Keep in mind, both switch and case tasks must be described as condition tasks. The following implementation is a common mistake in which case tasks are not described as condition tasks.

// wrong implementation of switch control flow using only one condition task
tf::Taskflow taskflow;
auto [source, swcond, case1, case2, case3, target] = taskflow.emplace(
[](){ std::cout << "source\n"; },
[](){ std::cout << "switch\n"; return rand()%3; },
[](){ std::cout << "case 1\n"; },
[](){ std::cout << "case 2\n"; },
[](){ std::cout << "case 3\n"; },
[](){ std::cout << "target\n"; } // target has three strong dependencies
);
source.precede(swcond);
swcond.precede(case1, case2, case3);
target.succeed(case1, case2, case3);

In this faulty implementation, task `target` has three strong dependencies but only one of them will be met. This is because `swcond` is a condition task, and only one case task will be executed depending on the return of `swcond`.

## Implement Do-While-Loop Control Flow

You can use conditional tasking to implement do-while-loop control flow. The following example creates a do-while-loop control flow diagram that repeatedly increments variable `i` five times using one condition task.

tf::Taskflow taskflow;
int i;
auto [init, body, cond, done] = taskflow.emplace(
[&](){ std::cout << "i=0\n"; i=0; },
[&](){ std::cout << "i++ => i="; i++; },
[&](){ std::cout << i << '\n'; return i<5 ? 0 : 1; },
[&](){ std::cout << "done\n"; }
);
init.precede(body);
body.precede(cond);
cond.precede(body, done);

The program outputs:

i=0
i++ => i=1
i++ => i=2
i++ => i=3
i++ => i=4
i++ => i=5
done

## Implement While-Loop Control Flow

You can use conditional tasking to implement while-loop control flow. The following example creates a while-loop control flow diagram that repeatedly increments variable `i` five times using two condition task.

tf::Taskflow taskflow;
int i;
auto [init, cond, body, back, done] = taskflow.emplace(
[&](){ std::cout << "i=0\n"; i=0; },
[&](){ std::cout << "while i<5\n"; return i < 5 ? 0 : 1; },
[&](){ std::cout << "i++=" << i++ << '\n'; },
[&](){ std::cout << "back\n"; return 0; },
[&](){ std::cout << "done\n"; }
);
init.precede(cond);
cond.precede(body, done);
body.precede(back);
back.precede(cond);

The program outputs:

i=0
while i<5
i++=0
back
while i<5
i++=1
back
while i<5
i++=2
back
while i<5
i++=3
back
while i<5
i++=4
back
while i<5
done

Notice that, when you implement a while-loop block, you cannot direct a dependency from the body task to the loop condition task. Doing so will introduce a strong dependency between the body task and the loop condition task, and the loop condition task will never be executed. The following code shows a common faulty implementation of while-loop control flow.

// wrong implementation of while-loop using only one condition task
tf::Taskflow taskflow;
int i;
auto [init, cond, body, done] = taskflow.emplace(
[&](){ std::cout << "i=0\n"; i=0; },
[&](){ std::cout << "while i<5\n"; return i < 5 ? 0 : 1; },
[&](){ std::cout << "i++=" << i++ << '\n'; },
[&](){ std::cout << "done\n"; }
);
init.precede(cond);
cond.precede(body, done);
body.precede(cond);

In the taskflow diagram above, the scheduler starts with `init` and then decrements the strong dependency of the loop condition task, `while i<5`. After this, there remains one strong dependency, i.e., introduced by the loop body task, `i++`. However, task `i++` will not be executed until the loop condition task returns `0`, causing a deadlock.

# Create a Multi-condition Task

A multi-condition task is a generalized version of conditional tasking. In some cases, applications need to jump to multiple branches from a parent task. This can be done by creating a multi-condition task which allows a task to select one or more successor tasks to execute. Similar to a condition task, a multi-condition task returns a vector of integer indices that indicate the successors to execute when the multi-condition task completes. The index is defined with respect to the order of successors preceded by a multi-condition task. For example, the following code creates a multi-condition task, `A`, that informs the scheduler to run on its two successors, `B` and `D`.

tf::Executor executor;
tf::Taskflow taskflow;
auto A = taskflow.emplace([&]() -> tf::SmallVector<int> {
std::cout << "A\n";
return {0, 2};
}).name("A");
auto B = taskflow.emplace([&](){ std::cout << "B\n"; }).name("B");
auto C = taskflow.emplace([&](){ std::cout << "C\n"; }).name("C");
auto D = taskflow.emplace([&](){ std::cout << "D\n"; }).name("D");
A.precede(B, C, D);
executor.run(taskflow).wait();
tf::Executor
class to create an executor
Definition executor.hpp:62
tf::Executor::run
tf::Future< void > run(Taskflow &taskflow)
runs a taskflow once
tf::SmallVector
class to define a vector optimized for small array
Definition small_vector.hpp:931

Attention
  The return type of a multi-condition task is tf::SmallVector, which provides C++ vector-style functionalities but comes with small buffer optimization.