template<typename C = DefaultClosureWrapper> tf::PartitionerBase class

class to derive a partitioner for scheduling parallel algorithms

The class provides base methods to derive a partitioner that can be used to schedule parallel iterations (e.g., tf::Taskflow::for_each).

An partitioner defines the scheduling method for running parallel algorithms, such tf::Taskflow::for_each, tf::Taskflow::reduce, and so on. By default, we provide the following partitioners:

• tf::GuidedPartitioner to enable guided scheduling algorithm of adaptive chunk size
• tf::DynamicPartitioner to enable dynamic scheduling algorithm of equal chunk size
• tf::StaticPartitioner to enable static scheduling algorithm of static chunk size
• tf::RandomPartitioner to enable random scheduling algorithm of random chunk size

Depending on applications, partitioning algorithms can impact the performance a lot. For example, if a parallel-iteration workload contains a regular work unit per iteration, tf::StaticPartitioner can deliver the best performance. On the other hand, if the work unit per iteration is irregular and unbalanced, tf::GuidedPartitioner or tf::DynamicPartitioner can outperform tf::StaticPartitioner. In most situations, tf::GuidedPartitioner can deliver decent performance and is thus used as our default partitioner.

In addition to partition size, the application can specify a closure wrapper for a partitioner. A closure wrapper allows the application to wrap a partitioned task (i.e., closure) with a custom function object that performs additional tasks. For example:

std::atomic\<int\> count = 0;tf::Taskflow taskflow;taskflow.for\_each\_index(0, 100, 1, [](){printf("%d\n", i); },tf::StaticPartitioner(0, [](auto&& closure){// do something before invoking the partitioned task// ...// invoke the partitioned taskclosure();// do something else after invoking the partitioned task// ...});executor.run(taskflow).wait();

Public types

using closure_wrapper_type = C the closure type

Public static variables

static bool is_default_wrapper_v constexprindicating if the given closure wrapper is a default wrapper (i.e., empty)

Constructors, destructors, conversion operators

PartitionerBase() defaulteddefault constructorPartitionerBase(size_t chunk_size) explicit construct a partitioner with the given chunk sizePartitionerBase(size_t chunk_size, C&& closure_wrapper)construct a partitioner with the given chunk size and closure wrapper

Public functions

auto chunk_size() const -> size_tquery the chunk size of this partitionervoid chunk_size(size_t cz)update the chunk size of this partitionerauto closure_wrapper() const -> const C&acquire an immutable access to the closure wrapper objectauto closure_wrapper() -> C&acquire a mutable access to the closure wrapper object template<typename F> void closure_wrapper(F&& fn)modify the closure wrapper object template<typename F> auto operator()(F&& callable) -> decltype(auto) TF_FORCE_INLINEwraps the given callable with the associated closure wrapper

Protected variables

size_t _chunk_sizechunk size C _closure_wrapperclosure wrapper