Quick Start

Modern C++ Parallel Task Programming

Cpp-Taskflow helps you quickly write parallel task programs with high performance scalability and simultaneous high productivity. It is faster, more expressive, fewer lines of code, and easier for drop-in integration than many of existing task programming frameworks.

Cpp-Taskflow is committed to support both academic and industry research projects, making it reliable and cost-efficient to develop large-scale parallel applications. Our users say:

• "Cpp-Taskflow has the cleanest task API I've ever seen." Damien Hocking @Corelium Inc
• "Cpp-Taskflow has a very simple and elegant tasking interface. The performance also scales very well." Glen Fraser
• "Cpp-Taskflow lets me handle parallel processing in a smart way." Hayabusa @Cpp-Learning
• "Cpp-Taskflow helps improve the throughput of our graph processing engine in just a few hours of coding." Jean-Michaël @KDAB
• "Best poster award for the open-source parallel programming library." 2018 Cpp Conference
• "Second Place in Open Source Software Competition." 2019 ACM Multimedia Conference

See a quick presentation and visit our GitHub to learn more about Cpp-Taskflow.

Static and Dynamic Tasking

Cpp-Taskflow has a unified interface for both static tasking and dynamic tasking, allowing users to quickly master our parallel task programming model in a natural idiom.

Static Tasking	Dynamic Tasking

Conditional Tasking

Cpp-Taskflow supports conditional tasking for you to implement cyclic and dynamic control flows that are otherwise difficult to do with existing task programming frameworks.

Composable Tasking

Cpp-Taskflow is composable. You can create large parallel graphs through composition of modular and reusable blocks that are easier to optimize at an individual scope.

Concurrent CPU-GPU Tasking

Cpp-Taskflow supports heterogeneous tasking for you to accelerate a wide range of scientific computing applications by harnessing the power of CPU-GPU collaborative computing.

How to Install Cpp-Taskflow?

Cpp-Taskflow is header-only and there is no need for installation. Simply download the source and copy the headers under the directory taskflow/ to your project.

~$ git clone https://github.com/cpp-taskflow/cpp-taskflow.git
~$ cd cpp-taskflow/
~$ cp -r taskflow myproject/include/

A Simple First Program

Here is a rather simple program to get you started.

#include <taskflow/taskflow.hpp>  // Cpp-Taskflow is header-only

int main(){
  
  tf::Executor executor;
  tf::Taskflow taskflow;

  auto [A, B, C, D] = taskflow.emplace(
    [] () { std::cout << "TaskA\n"; },               //  task dependency graph
    [] () { std::cout << "TaskB\n"; },               // 
    [] () { std::cout << "TaskC\n"; },               //          +---+          
    [] () { std::cout << "TaskD\n"; }                //    +---->| B |-----+   
  );                                                 //    |     +---+     |
                                                     //  +---+           +-v-+ 
  A.precede(B);  // A runs before B                  //  | A |           | D | 
  A.precede(C);  // A runs before C                  //  +---+           +-^-+ 
  B.precede(D);  // B runs before D                  //    |     +---+     |    
  C.precede(D);  // C runs before D                  //    +---->| C |-----+    
                                                     //          +---+          
  executor.run(taskflow).wait();

  return 0;
}

The program creates four tasks A, B, C, and D. The dependency constraints force A to run before B and C, and D to run after B and C. The maximum concurrency is this example is two, where B and C can run at the same time.

Compile and Run Your First Program

Cpp-Taskflow is written in C++14 and is built on top of C++ standardized threading libraries. To compile the above program, you need to tell the compiler where to find the Cpp-Taskflow header files. For example, with gcc you need the -I option.

~$ g++ simple.cpp -I myproject/include/ -O2 -pthread -o simple
~$ ./simple
TaskA
TaskC 
TaskB 
TaskD

The execution order of B and C might differ as they can run concurrently.

Supported Compilers

To use Cpp-Taskflow, you only need a compiler that supports C++14:

• GNU C++ Compiler at least v5.0 with -std=c++14
• Clang C++ Compiler at least v4.0 with -std=c++14
• Microsoft Visual Studio at least v15.7 (MSVC++ 19.14)
• AppleClang Xode Version at least v8
• Nvidia CUDA Toolkit and Compiler (nvcc) at least v10.0 with -std=c++14

Cpp-Taskflow works on Linux, Windows, and Mac OS X.

License

Cpp-Taskflow is open-source under permissive MIT license.