Taskflow: Static Tasking(静态任务)

静态图，由程序自己定义的并行结构，并且无法从正在运行的依赖关系图中产生新Task

创建一个依赖关系图

Task: 可被调用的对象， 即能够被std::invoke 调用，比如函数，lambda表达式，重载了operator() 的 class， bind的返回值。

Taskflow 提供 tf::Taskflow::placeholder 和 tf::Taskflow::emplace 来创建一个Task。

    tf::Taskflow taskflow; // 创建一个taskflow流图对象

    tf::Task taskA = taskflow.placeholder(); // 创建一个task占位符
    tf::Task taskB = taskflow.emplace([] () {}); // 根据一个可调用对象创建一个task

    // 结构化绑定，创建三个Task（通过std::tuple）
    auto [D, E, F] = taskflow.emplace(
        [](){ std::cout << "Task A\n"; },
        [](){ std::cout << "Task B\n"; },
        [](){ std::cout << "Task C\n"; }
    );

task本身也包含很多方法：

#include <taskflow/taskflow.hpp>
int main() {
    tf::Taskflow taskflow;
    tf::Task A = taskflow.emplace([] () { std::cout << "create a task A\n"; });
    tf::Task B = taskflow.emplace([] () { std::cout << "create a task B\n"; });

    A.name("TaskA"); // 命名
    A.work([] () { std::cout << "reassign A to a new callable\n"; }); // 替换可调用对象
    A.precede(B); // 添加依赖关系， A 在 B 前面执行

    std::cout << A.name() << std::endl;            // TaskA
    std::cout << A.num_successors() << std::endl;  // 1： 表示A的后继节点个数
    std::cout << A.num_dependents() << std::endl;  // 0: 表示A的前驱节点个数

    std::cout << B.num_successors() << std::endl;  // 0: 表示B的后继节点个数
    std::cout << B.num_dependents() << std::endl;  // 1: 表示B的前驱节点个数
    return 0;
}

task是通过std::function 来存储和调用对象的，所以也需要遵守规则来创建Task, 在创建的过程中需要拷贝可调用对象，所以，如果调用对象是不可拷贝的，那么编译会出错：

tf::Task A = taskflow.emplace([ptr = std::unique_ptr<int>(new int(1))] () { std::cout << "create a task A\n"; });

编译错误会指出尝试复制一个 lambda 函数对象，但是该 lambda 没有定义拷贝构造函数，因此默认情况下它是删除（deleted）的。在 C++ 中，如果 lambda 表达式捕获列表中包含 by-value 捕获（即捕获一个局部变量副本到闭包中），那么编译器将不会自动生成拷贝构造函数和赋值操作符。

使用placeholder占位符延迟赋予Task可调用对象

#include <taskflow/taskflow.hpp>
int main() {
    tf::Executor executor;
    tf::Taskflow taskflow;
    tf::Task A = taskflow.placeholder(); // 创建一个task占位符
    A.work([](){std::cout<<"work A\n";}); // 设置task工作
    A.name("This is Task 0"); // 设置task名字

    executor.run(taskflow).wait(); // 执行
    return 0;
}

捎带数据

每个task可以通过tf::Task::data(void*) 捎带数据， 通过 tf::Task::data()访问数据，注意，data的生命周期管理需要用户自己 关注。（同样，保证task可调用，也是用户所需要关心的问题）

#include <taskflow/taskflow.hpp>
int main() {
    tf::Executor executor;
    tf::Taskflow taskflow;
    tf::Task A = taskflow.placeholder(); // 创建一个task占位符
    int data = 5;
    
    A.data(&data).work([A](){
        int my_date = *(static_cast<int*>(A.data()));
        std::cout<<"work A, data = "<<my_date<<std::endl;
    });

    // 语义与上面一致
    // A = A.data(&data); 
    // A.work([&A](){
    //     int my_date = *(static_cast<int*>(A.data()));
    //     std::cout<<"work A, data = "<<my_date<<std::endl;
    // });

    executor.run(taskflow).wait(); // 执行
    return 0;
}

Taskflow 间的任务移动

每个task只属于一个Taskflow，而每个Taskflow间的task都是可以动的：

tf::Taskflow taskflow1, taskflow3;

taskflow1.emplace([](){});

// move-construct taskflow2 from taskflow1
tf::Taskflow taskflow2(std::move(taskflow1));
assert(taskflow2.num_tasks() == 1 && taskflow1.num_tasks() == 0);

// move-assign taskflow3 to taskflow2
taskflow3 = std::move(taskflow2);
assert(taskflow3.num_tasks() == 1 && taskflow2.num_tasks() == 0);

注意： move 一个正在执行的Taskflow可能会导致未定义行为