Release Notes » Release 3.10.0 (Master)

Download

To download the newest version of Taskflow, please clone the master branch from Taskflow's GitHub.

System Requirements

To use Taskflow v3.10.0, you need a compiler that supports C++17:

• GNU C++ Compiler at least v8.4 with -std=c++17
• Clang C++ Compiler at least v6.0 with -std=c++17
• Microsoft Visual Studio at least v19.27 with /std:c++17
• AppleClang Xcode Version at least v12.0 with -std=c++17
• Nvidia CUDA Toolkit and Compiler (nvcc) at least v11.1 with -std=c++17
• Intel C++ Compiler at least v19.0.1 with -std=c++17
• Intel DPC++ Clang Compiler at least v13.0.0 with -std=c++17

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

Release Summary

This release improves scheduling performance through optimized work-stealing threshold tuning and a constrained decentralized buffer. It also introduces index-range-based parallel-for and parallel-reduction algorithms and modifies subflow tasking behavior to significantly enhance the performance of recursive parallelism.

New Features

// initialize data1 and data2 to 10 using two different approaches
std::vector<int> data1(100), data2(100);

// Approach 1: initialize data1 using explicit index range
taskflow.for_each_index(0, 100, 1, [&](int i){ data1[i] = 10; });

// Approach 2: initialize data2 using tf::IndexRange
tf::IndexRange<int> range(0, 100, 1);
taskflow.for_each_by_index(range, [&](tf::IndexRange<int>& subrange){
  for(int i=subrange.begin(); i<subrange.end(); i+=subrange.step_size()) {
    data2[i] = 10;
  }
});

std::vector<double> data(100000);
double res = 1.0;
taskflow.reduce_by_index(
  // index range
  tf::IndexRange<size_t>(0, N, 1),
  // final result
  res,
  // local reducer
  [&](tf::IndexRange<size_t> subrange, std::optional<double> running_total) { 
    double residual = running_total ? *running_total : 0.0;
    for(size_t i=subrange.begin(); i<subrange.end(); i+=subrange.step_size()) {
      data[i] = 1.0;
      residual += data[i];
    }
    printf("partial sum = %lf\n", residual);
    return residual;
  },
  // global reducer
  std::plus<double>()
);

Bug Fixes

• fixed the compilation error of CLI11 due to version incompatibility (#672)
• fixed the compilation error of template deduction on packaged_task (#657)
• fixed the MSVC compilation error due to macro clash with std::min and std::max (#670)
• fixed the runtime error due to the use of latch in tf::Executor::Executor (#667)
• fixed the compilation error due to incorrect const qualifier used in algorithms (#673)
• fixed the tsan error when using find-if algorithm tasks with closure wrapper (#675)
• fixed the task trait bug in incorrect detection for subflow and runtime tasks (#679)
• fixed the infinite steal caused by incorrect num_empty_steals (#681)

Breaking Changes

• corrected the terminology by replacing 'dependents' with 'predecessors'
  • tf::Task::num_predecessors (previously tf::Task::num_dependents)
  • tf::Task::for_each_predecessor (previously tf::Task::for_each_dependent)
  • tf::Task::num_strong_dependencies (previously tf::Task::num_strong_dependents)
  • tf::Task::num_weak_dependencies (previously tf::Task::num_weak_dependents)
• disabled the support for tf::Subflow::detach due to multiple intricate and unresolved issues:
  • detached subflows are inherently difficult to reason about their execution logic
  • detached subflows can incur excessive memory consumption, especially in recursive workloads
  • detached subflows lack a manner to safe life cycle control and graph cleanup
  • detached subflows have limited practical benefits for most use cases
  • detached subflows can be re-implemented using taskflow composition
• changed the default behavior of tf::Subflow to no longer retain its task graph after join
  • default retention can incur significant memory consumption problem (#674)
  • users must explicitly call tf::Subflow::retain to retain a subflow after join

tf::Taskflow taskflow;
tf::Executor executor;

taskflow.emplace([&](tf::Subflow& sf){
  sf.retain(true);  // retain the subflow after join for visualization
  auto A = sf.emplace([](){ std::cout << "A\n"; });
  auto B = sf.emplace([](){ std::cout << "B\n"; });
  auto C = sf.emplace([](){ std::cout << "C\n"; });
  A.precede(B, C);  // A runs before B and C
});  // subflow implicitly joins here

executor.run(taskflow).wait();

// The subflow graph is now retained and can be visualized using taskflow.dump(...)
taskflow.dump(std::cout);

• disabled the support for tf::cudaFlow and tf::cudaFlowCapturer
  • introduced a cleaner interface tf::cudaGraph directly atop CUDA Graph (see GPU Tasking)
  • tf::cudaGraph has similar interface to tf::cudaFlow and can be changed as follows:

// programming tf::cudaGraph is consistent with Nvidia CUDA Graph but offers a simpler 
// and more intuitive interface by abstracting away low-level CUDA Graph boilerplate.
tf::cudaGraph cg;
cg.kernel(...);   // same as cudaFlow/cudaFlowCapturer

// unlike cudaFlow/cudaFlowCapturer, you need to explicitly instantiate an executable 
// CUDA graph now and submit it to a stream for execution
tf::cudaGraphExec exec(cg);
tf::cudaStream stream;
stream.run(exec).synchronize();

Documentation

• added Module Algorithm
• revised Subflow Tasking
• revised Asynchronous Tasking
• revised Runtime Tasking
• revised Executor
• revised Parallel Iterations
• revised Parallel Reduction
• revised Parallel Find
• revised Fibonacci Number

Miscellaneous Items

If you are interested in collaborating with us on applying Taskflow to your projects, please feel free to reach out to Dr. Tsung-Wei Huang!