tf namespace

enum class tf::TaskType: int

#include <taskflow/core/task.hpp>

enumeration of all task types

enum class tf::ObserverType: int

#include <taskflow/core/observer.hpp>

enumeration of all observer types

enum class tf::PartitionerType: int

#include <taskflow/algorithm/partitioner.hpp>

enumeration of all partitioner types

enum class tf::PipeType: int

#include <taskflow/algorithm/pipeline.hpp>

enumeration of all pipe types

enum class tf::cudaTaskType: int

#include <taskflow/cuda/cuda_task.hpp>

enumeration of all cudaTask types

using tf::observer_stamp_t = std::chrono::time_point<std::chrono::steady_clock>

#include <taskflow/core/observer.hpp>

default time point type of observers

using tf::DefaultPartitioner = GuidedPartitioner<>

#include <taskflow/algorithm/partitioner.hpp>

default partitioner set to tf::GuidedPartitioner

Guided partitioning algorithm can achieve stable and decent performance for most parallel algorithms.

using tf::cudaDefaultExecutionPolicy = cudaExecutionPolicy<512, 7>

#include <taskflow/cuda/cuda_execution_policy.hpp>

default execution policy

template<typename T, std::enable_if_t<(std::is_unsigned_v<std::decay_t<T>> && sizeof(T)==8), void>* = nullptr>

T tf::next_pow2(T x) constexpr

rounds the given 64-bit unsigned integer to the nearest power of 2

rounds the given 32-bit unsigned integer to the nearest power of 2

template<typename T, std::enable_if_t<std::is_integral_v<std::decay_t<T>>, void>* = nullptr>

bool tf::is_pow2(const T& x) constexpr

checks if the given number is a power of 2

This function determines if the given integer is a power of 2.

template<typename T>

int tf::log2(T n) constexpr

Computes the floor of log2 of the given positive integer.

This function calculates the largest integer log such that 2^log <= n.

template<typename RandItr, typename C>

RandItr tf::median_of_three(RandItr l, RandItr m, RandItr r, C cmp)

finds the median of three numbers pointed to by iterators using the given comparator

This function determines the median value of the elements pointed to by three random-access iterators using the provided comparator.

template<typename RandItr, typename C>

RandItr tf::pseudo_median_of_nine(RandItr beg, RandItr end, C cmp)

finds the pseudo median of a range of items using a spread of nine numbers

This function computes an approximate median of a range of items by sampling nine values spread across the range and finding their median. It uses a combination of the median_of_three function to determine the pseudo median.

template<typename Iter, typename Compare>

void tf::sort2(Iter a, Iter b, Compare comp)

sorts two elements of dereferenced iterators using the given comparison function

This function compares two elements pointed to by iterators and swaps them if they are out of order according to the provided comparator.

template<typename Iter, typename Compare>

void tf::sort3(Iter a, Iter b, Iter c, Compare comp)

Sorts three elements of dereferenced iterators using the given comparison function.

This function sorts three elements pointed to by iterators in ascending order according to the provided comparator. The sorting is performed using a sequence of calls to the sort2 function to ensure the correct order of elements.

template<typename T, std::enable_if_t<std::is_integral_v<T>, void>* = nullptr>

T tf::unique_id()

generates a program-wide unique ID of the given type in a thread-safe manner

This function provides a globally unique identifier of the specified integral type. It uses a static std::atomic counter to ensure thread safety and increments the counter in a relaxed memory ordering for efficiency.

template<typename T>

void tf::atomic_max(std::atomic<T>& v, const T& max_v) noexcept

updates an atomic variable with the maximum value

This function atomically updates the provided atomic variable v to hold the maximum of its current value and max_v. The update is performed using a relaxed memory ordering for efficiency in non-synchronizing contexts.

template<typename T>

void tf::atomic_min(std::atomic<T>& v, const T& min_v) noexcept

updates an atomic variable with the minimum value

This function atomically updates the provided atomic variable v to hold the minimum of its current value and min_v. The update is performed using a relaxed memory ordering for efficiency in non-synchronizing contexts.

template<typename T>

T tf::seed() noexcept

generates a random seed based on the current system clock

This function returns a seed value derived from the number of clock ticks since the epoch as measured by the system clock. The seed can be used to initialize random number generators.

std::string tf::get_env(const std::string& str)

retrieves the value of an environment variable

This function fetches the value of an environment variable by name. If the variable is not found, it returns an empty string.

bool tf::has_env(const std::string& str)

checks whether an environment variable is defined

This function determines if a specific environment variable exists in the current environment.

void tf::pause()

This function is used in spin-wait loops to hint the CPU that the current thread is in a busy-wait state. It helps reduce power consumption and improves performance on hyper-threaded processors by preventing the CPU from consuming unnecessary cycles while waiting. It is particularly useful in low-contention scenarios, where the thread is likely to quickly acquire the lock or condition it's waiting for, avoiding an expensive context switch. On modern x86 processors, this instruction can be invoked using __builtin_ia32_pause() in GCC/Clang or _mm_pause() in MSVC. In non-x86 architectures, alternative mechanisms such as yielding the CPU may be used instead.

template<typename P>

void tf::spin_until(P&& predicate)

spins until the given predicate becomes true

This function repeatedly checks the provided predicate in a spin-wait loop and uses a backoff strategy to minimize CPU waste during the wait. Initially, it uses the pause() instruction for the first 100 iterations to hint to the CPU that the thread is waiting, thus reducing power consumption and avoiding unnecessary cycles. After 100 iterations, it switches to yielding the CPU using std::this_thread::yield() to allow other threads to run and improve system responsiveness.

The function operates as follows:

1. For the first 100 iterations, it invokes pause() to reduce power consumption during the spin-wait.
2. After 100 iterations, it uses std::this_thread::yield() to relinquish the CPU, allowing other threads to execute.

const char* tf::to_string(TaskType type)

#include <taskflow/core/task.hpp>

convert a task type to a human-readable string

The name of each task type is the litte-case string of its characters.

TaskType::PLACEHOLDER     ->  "placeholder"
TaskType::STATIC          ->  "static"
TaskType::SUBFLOW         ->  "subflow"
TaskType::CONDITION       ->  "condition"
TaskType::MODULE          ->  "module"
TaskType::ASYNC           ->  "async"

std::ostream& tf::operator<<(std::ostream& os, const Task& task)

#include <taskflow/core/task.hpp>

overload of ostream inserter operator for Task

#include <taskflow/core/semaphore.hpp>

template<typename I, std::enable_if_t<std::is_same_v<deref_t<I>, Semaphore>, void>* = nullptr>

bool tf::try_acquire(I first, I last)

tries to acquire all semaphores in the specified range

Tries to acquire all semaphores in the specified range.

#include <taskflow/core/semaphore.hpp>

template<typename... S, std::enable_if_t<all_same_v<Semaphore, std::decay_t<S>...>, void>* = nullptr>

bool tf::try_acquire(S && ... semaphores)

tries to acquire all semaphores

Tries to acquire all the semaphores.

#include <taskflow/core/semaphore.hpp>

template<typename I, std::enable_if_t<std::is_same_v<deref_t<I>, Semaphore>, void>* = nullptr>

void tf::release(I first, I last)

tries to acquire all semaphores in the specified range

Releases all the semaphores in the given range.

#include <taskflow/core/semaphore.hpp>

template<typename... S, std::enable_if_t<all_same_v<Semaphore, std::decay_t<S>...>, void>* = nullptr>

void tf::release(S && ... semaphores)

tries to acquire all semaphores

Releases all the semaphores.

const char* tf::to_string(ObserverType type)

#include <taskflow/core/observer.hpp>

convert an observer type to a human-readable string

template<typename Input, typename Output, typename C>

auto tf::make_data_pipe(PipeType d, C&& callable)

function to construct a data pipe (tf::DataPipe)

tf::make_data_pipe is a helper function to create a data pipe (tf::DataPipe) in a data-parallel pipeline (tf::DataPipeline). The first argument specifies the direction of the data pipe, either tf::PipeType::SERIAL or tf::PipeType::PARALLEL, and the second argument is a callable to invoke by the pipeline scheduler. Input and output data types are specified via template parameters, which will always be decayed by the library to its original form for storage purpose. The callable must take the input data type in its first argument and returns a value of the output data type.

tf::make_data_pipe<int, std::string>(
  tf::PipeType::SERIAL, 
  [](int& input) {
    return std::to_string(input + 100);
  }
);

The callable can additionally take a reference of tf::Pipeflow, which allows you to query the runtime information of a stage task, such as its line number and token number.

tf::make_data_pipe<int, std::string>(
  tf::PipeType::SERIAL, 
  [](int& input, tf::Pipeflow& pf) {
    printf("token=%lu, line=%lu\n", pf.token(), pf.line());
    return std::to_string(input + 100);
  }
);

size_t tf::cuda_get_num_devices()

#include <taskflow/cuda/cuda_device.hpp>

queries the number of available devices

int tf::cuda_get_device()

#include <taskflow/cuda/cuda_device.hpp>

gets the current device associated with the caller thread

void tf::cuda_set_device(int id)

#include <taskflow/cuda/cuda_device.hpp>

switches to a given device context

void tf::cuda_get_device_property(int i, cudaDeviceProp& p)

#include <taskflow/cuda/cuda_device.hpp>

obtains the device property

cudaDeviceProp tf::cuda_get_device_property(int i)

#include <taskflow/cuda/cuda_device.hpp>

obtains the device property

void tf::cuda_dump_device_property(std::ostream& os, const cudaDeviceProp& p)

#include <taskflow/cuda/cuda_device.hpp>

dumps the device property

size_t tf::cuda_get_device_max_threads_per_block(int d)

#include <taskflow/cuda/cuda_device.hpp>

queries the maximum threads per block on a device

size_t tf::cuda_get_device_max_x_dim_per_block(int d)

#include <taskflow/cuda/cuda_device.hpp>

queries the maximum x-dimension per block on a device

size_t tf::cuda_get_device_max_y_dim_per_block(int d)

#include <taskflow/cuda/cuda_device.hpp>

queries the maximum y-dimension per block on a device

size_t tf::cuda_get_device_max_z_dim_per_block(int d)

#include <taskflow/cuda/cuda_device.hpp>

queries the maximum z-dimension per block on a device

size_t tf::cuda_get_device_max_x_dim_per_grid(int d)

#include <taskflow/cuda/cuda_device.hpp>

queries the maximum x-dimension per grid on a device

size_t tf::cuda_get_device_max_y_dim_per_grid(int d)

#include <taskflow/cuda/cuda_device.hpp>

queries the maximum y-dimension per grid on a device

size_t tf::cuda_get_device_max_z_dim_per_grid(int d)

#include <taskflow/cuda/cuda_device.hpp>

queries the maximum z-dimension per grid on a device

size_t tf::cuda_get_device_max_shm_per_block(int d)

#include <taskflow/cuda/cuda_device.hpp>

queries the maximum shared memory size in bytes per block on a device

size_t tf::cuda_get_device_warp_size(int d)

#include <taskflow/cuda/cuda_device.hpp>

queries the warp size on a device

int tf::cuda_get_device_compute_capability_major(int d)

#include <taskflow/cuda/cuda_device.hpp>

queries the major number of compute capability of a device

int tf::cuda_get_device_compute_capability_minor(int d)

#include <taskflow/cuda/cuda_device.hpp>

queries the minor number of compute capability of a device

bool tf::cuda_get_device_unified_addressing(int d)

#include <taskflow/cuda/cuda_device.hpp>

queries if the device supports unified addressing

int tf::cuda_get_driver_version()

#include <taskflow/cuda/cuda_device.hpp>

queries the latest CUDA version (1000 * major + 10 * minor) supported by the driver

int tf::cuda_get_runtime_version()

#include <taskflow/cuda/cuda_device.hpp>

queries the CUDA Runtime version (1000 * major + 10 * minor)

size_t tf::cuda_get_free_mem(int d)

#include <taskflow/cuda/cuda_memory.hpp>

queries the free memory (expensive call)

size_t tf::cuda_get_total_mem(int d)

#include <taskflow/cuda/cuda_memory.hpp>

queries the total available memory (expensive call)

#include <taskflow/cuda/cuda_memory.hpp>

template<typename T>

T* tf::cuda_malloc_device(size_t N, int d)

allocates memory on the given device for holding N elements of type T

The function calls cudaMalloc to allocate N*sizeof(T) bytes of memory on the given device d and returns a pointer to the starting address of the device memory.

#include <taskflow/cuda/cuda_memory.hpp>

template<typename T>

T* tf::cuda_malloc_device(size_t N)

allocates memory on the current device associated with the caller

The function calls malloc_device from the current device associated with the caller.

#include <taskflow/cuda/cuda_memory.hpp>

template<typename T>

T* tf::cuda_malloc_shared(size_t N)

allocates shared memory for holding N elements of type T

The function calls cudaMallocManaged to allocate N*sizeof(T) bytes of memory and returns a pointer to the starting address of the shared memory.

#include <taskflow/cuda/cuda_memory.hpp>

template<typename T>

void tf::cuda_free(T* ptr, int d)

frees memory on the GPU device

This methods call cudaFree to free the memory space pointed to by ptr using the given device context.

#include <taskflow/cuda/cuda_memory.hpp>

template<typename T>

void tf::cuda_free(T* ptr)

frees memory on the GPU device

This methods call cudaFree to free the memory space pointed to by ptr using the current device context of the caller.

void tf::cuda_memcpy_async(cudaStream_t stream, void* dst, const void* src, size_t count)

#include <taskflow/cuda/cuda_memory.hpp>

copies data between host and device asynchronously through a stream

The method calls cudaMemcpyAsync with the given stream using cudaMemcpyDefault to infer the memory space of the source and the destination pointers. The memory areas may not overlap.

void tf::cuda_memset_async(cudaStream_t stream, void* devPtr, int value, size_t count)

#include <taskflow/cuda/cuda_memory.hpp>

initializes or sets GPU memory to the given value byte by byte

The method calls cudaMemsetAsync with the given stream to fill the first count bytes of the memory area pointed to by devPtr with the constant byte value value.

const char* tf::to_string(cudaTaskType type) constexpr

#include <taskflow/cuda/cuda_task.hpp>

convert a cuda_task type to a human-readable string

std::ostream& tf::operator<<(std::ostream& os, const cudaTask& ct)

#include <taskflow/cuda/cuda_task.hpp>

overload of ostream inserter operator for cudaTask

#include <taskflow/cuda/algorithm/for_each.hpp>

template<typename P, typename C>

void tf::cuda_single_task(P&& p, C c)

runs a callable asynchronously using one kernel thread

The function launches a single kernel thread to run the given callable through the stream in the execution policy object.

#include <taskflow/cuda/algorithm/for_each.hpp>

template<typename P, typename I, typename C>

void tf::cuda_for_each(P&& p, I first, I last, C c)

performs asynchronous parallel iterations over a range of items

This function is equivalent to a parallel execution of the following loop on a GPU:

for(auto itr = first; itr != last; itr++) {
  c(*itr);
}

#include <taskflow/cuda/algorithm/for_each.hpp>

template<typename P, typename I, typename C>

void tf::cuda_for_each_index(P&& p, I first, I last, I inc, C c)

performs asynchronous parallel iterations over an index-based range of items

This function is equivalent to a parallel execution of the following loop on a GPU:

// step is positive [first, last)
for(auto i=first; i<last; i+=step) {
  c(i);
}

// step is negative [first, last)
for(auto i=first; i>last; i+=step) {
  c(i);
}

#include <taskflow/cuda/algorithm/transform.hpp>

template<typename P, typename I, typename O, typename C>

void tf::cuda_transform(P&& p, I first, I last, O output, C op)

performs asynchronous parallel transforms over a range of items

This method is equivalent to the parallel execution of the following loop on a GPU:

while (first != last) {
  *output++ = op(*first++);
}

#include <taskflow/cuda/algorithm/transform.hpp>

template<typename P, typename I1, typename I2, typename O, typename C>

void tf::cuda_transform(P&& p, I1 first1, I1 last1, I2 first2, O output, C op)

performs asynchronous parallel transforms over two ranges of items

This method is equivalent to the parallel execution of the following loop on a GPU:

while (first1 != last1) {
  *output++ = op(*first1++, *first2++);
}

#include <taskflow/cuda/algorithm/reduce.hpp>

template<typename P, typename I, typename T, typename O>

void tf::cuda_reduce(P&& p, I first, I last, T* res, O op, void* buf)

performs asynchronous parallel reduction over a range of items

This method is equivalent to the parallel execution of the following loop on a GPU:

while (first != last) {
  *result = op(*result, *first++);
}

#include <taskflow/cuda/algorithm/reduce.hpp>

template<typename P, typename I, typename T, typename O>

void tf::cuda_uninitialized_reduce(P&& p, I first, I last, T* res, O op, void* buf)

performs asynchronous parallel reduction over a range of items without an initial value

This method is equivalent to the parallel execution of the following loop on a GPU:

*result = *first++;  // no initial values partitipcate in the loop
while (first != last) {
  *result = op(*result, *first++);
}

#include <taskflow/cuda/algorithm/reduce.hpp>

template<typename P, typename I, typename T, typename O, typename U>

void tf::cuda_transform_reduce(P&& p, I first, I last, T* res, O bop, U uop, void* buf)

performs asynchronous parallel reduction over a range of transformed items without an initial value

This method is equivalent to the parallel execution of the following loop on a GPU:

while (first != last) {
  *result = bop(*result, uop(*first++));
}

#include <taskflow/cuda/algorithm/reduce.hpp>

template<typename P, typename I, typename T, typename O, typename U>

void tf::cuda_uninitialized_transform_reduce(P&& p, I first, I last, T* res, O bop, U uop, void* buf)

performs asynchronous parallel reduction over a range of transformed items with an initial value

This method is equivalent to the parallel execution of the following loop on a GPU:

*result = uop(*first++);  // no initial values partitipcate in the loop
while (first != last) {
  *result = bop(*result, uop(*first++));
}

#include <taskflow/cuda/algorithm/scan.hpp>

template<typename P, typename I, typename O, typename C>

void tf::cuda_inclusive_scan(P&& p, I first, I last, O output, C op, void* buf)

performs asynchronous inclusive scan over a range of items

#include <taskflow/cuda/algorithm/scan.hpp>

template<typename P, typename I, typename O, typename C, typename U>

void tf::cuda_transform_inclusive_scan(P&& p, I first, I last, O output, C bop, U uop, void* buf)

performs asynchronous inclusive scan over a range of transformed items

#include <taskflow/cuda/algorithm/scan.hpp>

template<typename P, typename I, typename O, typename C>

void tf::cuda_exclusive_scan(P&& p, I first, I last, O output, C op, void* buf)

performs asynchronous exclusive scan over a range of items

#include <taskflow/cuda/algorithm/scan.hpp>

template<typename P, typename I, typename O, typename C, typename U>

void tf::cuda_transform_exclusive_scan(P&& p, I first, I last, O output, C bop, U uop, void* buf)

performs asynchronous exclusive scan over a range of items

#include <taskflow/cuda/algorithm/merge.hpp>

template<typename P, typename a_keys_it, typename a_vals_it, typename b_keys_it, typename b_vals_it, typename c_keys_it, typename c_vals_it, typename C>

void tf::cuda_merge_by_key(P&& p, a_keys_it a_keys_first, a_keys_it a_keys_last, a_vals_it a_vals_first, b_keys_it b_keys_first, b_keys_it b_keys_last, b_vals_it b_vals_first, c_keys_it c_keys_first, c_vals_it c_vals_first, C comp, void* buf)

performs asynchronous key-value merge over a range of keys and values

Performs a key-value merge that copies elements from [a_keys_first, a_keys_last) and [b_keys_first, b_keys_last) into a single range, [c_keys_first, c_keys_last + (a_keys_last - a_keys_first) + (b_keys_last - b_keys_first)) such that the resulting range is in ascending key order.

At the same time, the merge copies elements from the two associated ranges [a_vals_first + (a_keys_last - a_keys_first)) and [b_vals_first + (b_keys_last - b_keys_first)) into a single range, [c_vals_first, c_vals_first + (a_keys_last - a_keys_first) + (b_keys_last - b_keys_first)) such that the resulting range is in ascending order implied by each input element's associated key.

For example, assume:

• a_keys = {1, 8};
• a_vals = {2, 1};
• b_keys = {3, 7};
• b_vals = {3, 4};

After the merge, we have:

• c_keys = {1, 3, 7, 8}
• c_vals = {2, 3, 4, 1}

#include <taskflow/cuda/algorithm/merge.hpp>

template<typename P, typename a_keys_it, typename b_keys_it, typename c_keys_it, typename C>

void tf::cuda_merge(P&& p, a_keys_it a_keys_first, a_keys_it a_keys_last, b_keys_it b_keys_first, b_keys_it b_keys_last, c_keys_it c_keys_first, C comp, void* buf)

performs asynchronous key-only merge over a range of keys

This function is equivalent to tf::cuda_merge_by_key without values.

#include <taskflow/cuda/algorithm/sort.hpp>

template<typename P, typename K, typename V = cudaEmpty>

unsigned tf::cuda_sort_buffer_size(unsigned count)

queries the buffer size in bytes needed to call sort kernels for the given number of elements

The function is used to allocate a buffer for calling tf::cuda_sort.

#include <taskflow/cuda/algorithm/sort.hpp>

template<typename P, typename K_it, typename V_it, typename C>

void tf::cuda_sort_by_key(P&& p, K_it k_first, K_it k_last, V_it v_first, C comp, void* buf)

performs asynchronous key-value sort on a range of items

Sorts key-value elements in [k_first, k_last) and [v_first, v_first + (k_last - k_first)) into ascending key order using the given comparator comp. If i and j are any two valid iterators in [k_first, k_last) such that i precedes j, and p and q are iterators in [v_first, v_first + (k_last - k_first)) corresponding to i and j respectively, then comp(*j, *i) evaluates to false.

For example, assume:

• keys are {1, 4, 2, 8, 5, 7}
• values are {'a', 'b', 'c', 'd', 'e', 'f'}

After sort:

• keys are {1, 2, 4, 5, 7, 8}
• values are {'a', 'c', 'b', 'e', 'f', 'd'}

#include <taskflow/cuda/algorithm/sort.hpp>

template<typename P, typename K_it, typename C>

void tf::cuda_sort(P&& p, K_it k_first, K_it k_last, C comp, void* buf)

performs asynchronous key-only sort on a range of items

This method is equivalent to tf::cuda_sort_by_key without values.

#include <taskflow/cuda/algorithm/find.hpp>

template<typename P, typename I, typename U>

void tf::cuda_find_if(P&& p, I first, I last, unsigned* idx, U op)

finds the index of the first element that satisfies the given criteria

The function launches kernels asynchronously to find the index idx of the first element in the range [first, last) such that op(*(first+idx)) is true. This is equivalent to the parallel execution of the following loop:

unsigned idx = 0;
for(; first != last; ++first, ++idx) {
  if (p(*first)) {
    return idx;
  }
}
return idx;

#include <taskflow/cuda/algorithm/find.hpp>

template<typename P, typename I, typename O>

void tf::cuda_min_element(P&& p, I first, I last, unsigned* idx, O op, void* buf)

finds the index of the minimum element in a range

The function launches kernels asynchronously to find the smallest element in the range [first, last) using the given comparator op. You need to provide a buffer that holds at least tf::cuda_min_element_bufsz bytes for internal use. The function is equivalent to a parallel execution of the following loop:

if(first == last) {
  return 0;
}
auto smallest = first;
for (++first; first != last; ++first) {
  if (op(*first, *smallest)) {
    smallest = first;
  }
}
return std::distance(first, smallest);

#include <taskflow/cuda/algorithm/find.hpp>

template<typename P, typename I, typename O>

void tf::cuda_max_element(P&& p, I first, I last, unsigned* idx, O op, void* buf)

finds the index of the maximum element in a range

The function launches kernels asynchronously to find the largest element in the range [first, last) using the given comparator op. You need to provide a buffer that holds at least tf::cuda_max_element_bufsz bytes for internal use. The function is equivalent to a parallel execution of the following loop:

if(first == last) {
  return 0;
}
auto largest = first;
for (++first; first != last; ++first) {
  if (op(*largest, *first)) {
    largest = first;
  }
}
return std::distance(first, largest);

const char* tf::version() constexpr

#include <taskflow/taskflow.hpp>

queries the version information in a string format major.minor.patch

Release notes are available here: https://taskflow.github.io/taskflow/Releases.html

#include <taskflow/core/graph.hpp>

template<typename P>

bool tf::is_task_params_v constexpr

determines if the given type is a task parameter type

Task parameters can be specified in one of the following types:

• tf::TaskParams: assign the struct of defined parameters
• tf::DefaultTaskParams: assign nothing
• std::string: assign a name to the task

std::array<TaskType, 6> tf::TASK_TYPES constexpr

#include <taskflow/core/task.hpp>

array of all task types (used for iterating task types)

#include <taskflow/core/task.hpp>

template<typename C>

bool tf::is_subflow_task_v constexpr

determines if a callable is a dynamic task

A dynamic task is a callable object constructible from std::function<void(Subflow&)>.

#include <taskflow/core/task.hpp>

template<typename C>

bool tf::is_condition_task_v constexpr

determines if a callable is a condition task

A condition task is a callable object constructible from std::function<int()> or std::function<int(tf::Runtime&)>.

#include <taskflow/core/task.hpp>

template<typename C>

bool tf::is_multi_condition_task_v constexpr

determines if a callable is a multi-condition task

A multi-condition task is a callable object constructible from std::function<tf::SmallVector<int>()> or std::function<tf::SmallVector<int>(tf::Runtime&)>.

#include <taskflow/core/task.hpp>

template<typename C>

bool tf::is_static_task_v constexpr

determines if a callable is a static task

A static task is a callable object constructible from std::function<void()> or std::function<void(tf::Runtime&)>.

#include <taskflow/algorithm/partitioner.hpp>

template<typename P>

bool tf::is_partitioner_v constexpr

determines if a type is a partitioner

A partitioner is a derived type from tf::PartitionerBase.