building methods of a task dependency graph More...

#include <flow_builder.hpp>

Inheritance diagram for tf::FlowBuilder:

Public Member Functions
template<typename C >
std::enable_if_t< is_static_task_v< C >, Task >	emplace (C &&callable)
	creates a static task from a given callable object More...

template<typename C >
std::enable_if_t< is_dynamic_task_v< C >, Task >	emplace (C &&callable)
	creates a dynamic task from a given callable object More...

template<typename C >
std::enable_if_t< is_condition_task_v< C >, Task >	emplace (C &&callable)
	creates a condition task from a given callable object More...

template<typename C >
std::enable_if_t< is_cudaflow_task_v< C >, Task >	emplace (C &&callable)
	creates a cudaflow task from a given callable object More...

template<typename... C, std::enable_if_t<(sizeof...(C)> 1>
auto	emplace (C &&... callables)
	creates multiple tasks from a list of callable objects More...

Task	composed_of (Taskflow &taskflow)
	creates a module task from a taskflow More...

Task	placeholder ()
	creates an empty task More...

void	precede (Task A, Task B)
	adds a dependency link from task A to task B More...

void	linearize (std::vector< Task > &tasks)
	adds adjacent dependency links to a linear list of tasks More...

void	linearize (std::initializer_list< Task > tasks)
	adds adjacent dependency links to a linear list of tasks More...

void	broadcast (Task A, std::vector< Task > &others)
	adds dependency links from one task A to many tasks More...

void	broadcast (Task A, std::initializer_list< Task > others)
	adds dependency links from one task A to many tasks More...

void	succeed (std::vector< Task > &others, Task A)
	adds dependency links from many tasks to one task A More...

void	succeed (std::initializer_list< Task > others, Task A)
	adds dependency links from many tasks to one task A More...

template<typename B , typename E , typename C >
Task	for_each (B &&first, E &&last, C &&callable)
	constructs a STL-styled parallel-for task More...

template<typename B , typename E , typename C , typename H = size_t>
Task	for_each_guided (B &&beg, E &&end, C &&callable, H &&chunk_size=1)
	constructs a STL-styled parallel-for task using the guided partition algorithm More...

template<typename B , typename E , typename C , typename H = size_t>
Task	for_each_dynamic (B &&beg, E &&end, C &&callable, H &&chunk_size=1)
	constructs a STL-styled parallel-for task using the dynamic partition algorithm More...

template<typename B , typename E , typename C , typename H = size_t>
Task	for_each_static (B &&beg, E &&end, C &&callable, H &&chunk_size=0)
	constructs a STL-styled parallel-for task using the dynamic partition algorithm More...

template<typename B , typename E , typename S , typename C >
Task	for_each_index (B &&first, E &&last, S &&step, C &&callable)
	constructs an index-based parallel-for task More...

template<typename B , typename E , typename S , typename C , typename H = size_t>
Task	for_each_index_guided (B &&beg, E &&end, S &&step, C &&callable, H &&chunk_size=1)
	constructs an index-based parallel-for task using the guided partition algorithm. More...

template<typename B , typename E , typename S , typename C , typename H = size_t>
Task	for_each_index_dynamic (B &&beg, E &&end, S &&step, C &&callable, H &&chunk_size=1)
	constructs an index-based parallel-for task using the dynamic partition algorithm. More...

template<typename B , typename E , typename S , typename C , typename H = size_t>
Task	for_each_index_static (B &&beg, E &&end, S &&step, C &&callable, H &&chunk_size=0)
	constructs an index-based parallel-for task using the static partition algorithm. More...

template<typename B , typename E , typename T , typename O >
Task	reduce (B &&first, E &&last, T &init, O &&bop)
	constructs a STL-styled parallel-reduce task More...

template<typename B , typename E , typename T , typename O , typename H = size_t>
Task	reduce_guided (B &&first, E &&last, T &init, O &&bop, H &&chunk_size=1)
	constructs a STL-styled parallel-reduce task using the guided partition algorithm More...

template<typename B , typename E , typename T , typename O , typename H = size_t>
Task	reduce_dynamic (B &&first, E &&last, T &init, O &&bop, H &&chunk_size=1)
	constructs a STL-styled parallel-reduce task using the dynamic partition algorithm More...

template<typename B , typename E , typename T , typename O , typename H = size_t>
Task	reduce_static (B &&first, E &&last, T &init, O &&bop, H &&chunk_size=0)
	constructs a STL-styled parallel-reduce task using the static partition algorithm More...

template<typename B , typename E , typename T , typename BOP , typename UOP >
Task	transform_reduce (B &&first, E &&last, T &init, BOP &&bop, UOP &&uop)
	constructs a STL-styled parallel transform-reduce task More...

template<typename B , typename E , typename T , typename BOP , typename UOP , typename H = size_t>
Task	transform_reduce_guided (B &&first, E &&last, T &init, BOP &&bop, UOP &&uop, H &&chunk_size=1)
	constructs a STL-styled parallel transform-reduce task using the guided partition algorithm More...

template<typename B , typename E , typename T , typename BOP , typename UOP , typename H = size_t>
Task	transform_reduce_static (B &&first, E &&last, T &init, BOP &&bop, UOP &&uop, H &&chunk_size=0)
	constructs a STL-styled parallel transform-reduce task using the static partition algorithm More...

template<typename B , typename E , typename T , typename BOP , typename UOP , typename H = size_t>
Task	transform_reduce_dynamic (B &&first, E &&last, T &init, BOP &&bop, UOP &&uop, H &&chunk_size=1)
	constructs a STL-styled parallel transform-reduce task using the dynamic partition algorithm More...

Protected Member Functions
	FlowBuilder (Graph &graph)
	constructs a flow builder with a graph

Protected Attributes
Graph &	_graph
	associated graph object

Friends
class	Executor

Detailed Description

building methods of a task dependency graph

Member Function Documentation

◆ broadcast() [1/2]

void tf::FlowBuilder::broadcast	(	Task	A,
		std::vector< Task > &	others
	)

inline

adds dependency links from one task A to many tasks

Parameters

A	task A
others	a task set which A precedes

◆ broadcast() [2/2]

void tf::FlowBuilder::broadcast	(	Task	A,
		std::initializer_list< Task >	others
	)

inline

adds dependency links from one task A to many tasks

Parameters

A	task A
others	a task set which A precedes

◆ composed_of()

Task tf::FlowBuilder::composed_of ( Taskflow & taskflow )

inline

creates a module task from a taskflow

Parameters

taskflow a taskflow object for the module

Returns: a Task handle

◆ emplace() [1/5]

template<typename C >

std::enable_if_t< is_static_task_v< C >, Task > tf::FlowBuilder::emplace ( C && callable )

creates a static task from a given callable object

Template Parameters

C	callable type

Parameters

callable a callable object constructible from std::function<void()>

Returns: a Task handle

◆ emplace() [2/5]

template<typename C >

std::enable_if_t< is_dynamic_task_v< C >, Task > tf::FlowBuilder::emplace ( C && callable )

creates a dynamic task from a given callable object

Template Parameters

C	callable type

Parameters

callable a callable object constructible from std::function<void(Subflow&)>

Returns: a Task handle

◆ emplace() [3/5]

template<typename C >

std::enable_if_t< is_condition_task_v< C >, Task > tf::FlowBuilder::emplace ( C && callable )

creates a condition task from a given callable object

Template Parameters

C	callable type

Parameters

callable a callable object constructible from std::function<int()>

Returns: a Task handle

◆ emplace() [4/5]

template<typename C >

std::enable_if_t< is_cudaflow_task_v< C >, Task > tf::FlowBuilder::emplace ( C && callable )

creates a cudaflow task from a given callable object

Template Parameters

C	callable type

Parameters

callable a callable object constructible from std::function<void(cudaFlow&)>

Returns: a Task handle

◆ emplace() [5/5]

template<typename... C, std::enable_if_t<(sizeof...(C)> 1>

auto tf::FlowBuilder::emplace ( C &&... callables )

creates multiple tasks from a list of callable objects

Template Parameters

C...	callable types

Parameters

callables one or multiple callable objects constructible from each task category

Returns: a Task handle

◆ for_each()

template<typename B , typename E , typename C >

Task tf::FlowBuilder::for_each	(	B &&	first,
		E &&	last,
		C &&	callable
	)

constructs a STL-styled parallel-for task

Template Parameters

B	beginning iterator type
E	ending iterator type
C	callable type

Parameters

first	iterator to the beginning (inclusive)
last	iterator to the end (exclusive)
callable	a callable object to apply to the dereferenced iterator

Returns: a Task handle

The task spawns a subflow that applies the callable object to each object obtained by dereferencing every iterator in the range [first, last). By default, we employ the guided partition algorithm with chunk size equal to one.

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

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

Arguments templated to enable stateful passing using std::reference_wrapper.

The callable needs to take a single argument of the dereferenced type.

◆ for_each_dynamic()

template<typename B , typename E , typename C , typename H = size_t>

Task tf::FlowBuilder::for_each_dynamic	(	B &&	beg,
		E &&	end,
		C &&	callable,
		H &&	chunk_size = `1`
	)

constructs a STL-styled parallel-for task using the dynamic partition algorithm

Template Parameters

B	beginning iterator type
E	ending iterator type
C	callable type
H	chunk size type

Parameters

beg	iterator to the beginning (inclusive)
end	iterator to the end (exclusive)
callable	a callable object to apply to the dereferenced iterator
chunk_size	chunk size

Returns: a Task handle

The task spawns a subflow that applies the callable object to each object obtained by dereferencing every iterator in the range [beg, end). The runtime partitions the range into chunks of the given chunk size, where each chunk is processed by a worker.

Arguments are templated to enable stateful passing using std::reference_wrapper.

The callable needs to take a single argument of the dereferenced type.

◆ for_each_guided()

template<typename B , typename E , typename C , typename H = size_t>

Task tf::FlowBuilder::for_each_guided	(	B &&	beg,
		E &&	end,
		C &&	callable,
		H &&	chunk_size = `1`
	)

constructs a STL-styled parallel-for task using the guided partition algorithm

Template Parameters

B	beginning iterator type
E	ending iterator type
C	callable type
H	chunk size type

Parameters

beg	iterator to the beginning (inclusive)
end	iterator to the end (exclusive)
callable	a callable object to apply to the dereferenced iterator
chunk_size	chunk size

Returns: a Task handle

The task spawns a subflow that applies the callable object to each object obtained by dereferencing every iterator in the range [beg, end). The runtime partitions the range into chunks of the given chunk size, where each chunk is processed by a worker.

Arguments are templated to enable stateful passing using std::reference_wrapper.

The callable needs to take a single argument of the dereferenced type.

◆ for_each_index()

template<typename B , typename E , typename S , typename C >

Task tf::FlowBuilder::for_each_index	(	B &&	first,
		E &&	last,
		S &&	step,
		C &&	callable
	)

constructs an index-based parallel-for task

Template Parameters

B	beginning index type (must be integral)
E	ending index type (must be integral)
S	step type (must be integral)
C	callable type

Parameters

first	index of the beginning (inclusive)
last	index of the end (exclusive)
step	step size
callable	a callable object to apply to each valid index

Returns: a Task handle

The task spawns a subflow that applies the callable object to each index in the range [first, last) with the step size. By default, we employ the guided partition algorithm with chunk size equal to one.

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

// case 1: step size is positive
for(auto i=first; i<last; i+=step) {
  callable(i);
}
// case 2: step size is negative
for(auto i=first, i>last; i+=step) {
  callable(i);
}

Arguments are templated to enable stateful passing using std::reference_wrapper.

The callable needs to take a single argument of the index type.

◆ for_each_index_dynamic()

template<typename B , typename E , typename S , typename C , typename H = size_t>

Task tf::FlowBuilder::for_each_index_dynamic	(	B &&	beg,
		E &&	end,
		S &&	step,
		C &&	callable,
		H &&	chunk_size = `1`
	)

constructs an index-based parallel-for task using the dynamic partition algorithm.

Template Parameters

B	beginning index type (must be integral)
E	ending index type (must be integral)
S	step type (must be integral)
C	callable type
H	chunk size type

Parameters

beg	index of the beginning (inclusive)
end	index of the end (exclusive)
step	step size
callable	a callable object to apply to each valid index
chunk_size	chunk size (default 1)

Returns: a Task handle

The task spawns a subflow that applies the callable object to each index in the range [beg, end) with the step size. The runtime partitions the range into chunks of the given size, where each chunk is processed by a worker.

Arguments are templated to enable stateful passing using std::reference_wrapper.

The callable needs to take a single argument of the index type.

◆ for_each_index_guided()

template<typename B , typename E , typename S , typename C , typename H = size_t>

Task tf::FlowBuilder::for_each_index_guided	(	B &&	beg,
		E &&	end,
		S &&	step,
		C &&	callable,
		H &&	chunk_size = `1`
	)

constructs an index-based parallel-for task using the guided partition algorithm.

Template Parameters

B	beginning index type (must be integral)
E	ending index type (must be integral)
S	step type (must be integral)
C	callable type
H	chunk size type

Parameters

beg	index of the beginning (inclusive)
end	index of the end (exclusive)
step	step size
callable	a callable object to apply to each valid index
chunk_size	chunk size (default 1)

Returns: a Task handle

The task spawns a subflow that applies the callable object to each index in the range [beg, end) with the step size. The runtime partitions the range into chunks of the given size, where each chunk is processed by a worker.

Arguments are templated to enable stateful passing using std::reference_wrapper.

The callable needs to take a single argument of the index type.

◆ for_each_index_static()

template<typename B , typename E , typename S , typename C , typename H = size_t>

Task tf::FlowBuilder::for_each_index_static	(	B &&	beg,
		E &&	end,
		S &&	step,
		C &&	callable,
		H &&	chunk_size = `0`
	)

constructs an index-based parallel-for task using the static partition algorithm.

Template Parameters

B	beginning index type (must be integral)
E	ending index type (must be integral)
S	step type (must be integral)
C	callable type
H	chunk size type

Parameters

beg	index of the beginning (inclusive)
end	index of the end (exclusive)
step	step size
callable	a callable object to apply to each valid index
chunk_size	chunk size (default 0)

Returns: a Task handle

The task spawns a subflow that applies the callable object to each index in the range [beg, end) with the step size. The runtime partitions the range into chunks of the given size, where each chunk is processed by a worker. When the given chunk size is zero, the runtime distributes the work evenly across workers.

Arguments are templated to enable stateful passing using std::reference_wrapper.

The callable needs to take a single argument of the index type.

◆ for_each_static()

template<typename B , typename E , typename C , typename H = size_t>

Task tf::FlowBuilder::for_each_static	(	B &&	beg,
		E &&	end,
		C &&	callable,
		H &&	chunk_size = `0`
	)

constructs a STL-styled parallel-for task using the dynamic partition algorithm

Template Parameters

B	beginning iterator type
E	ending iterator type
C	callable type
H	chunk size type

Parameters

beg	iterator to the beginning (inclusive)
end	iterator to the end (exclusive)
callable	a callable object to apply to the dereferenced iterator
chunk_size	chunk size

Returns: a Task handle

The task spawns a subflow that applies the callable object to each object obtained by dereferencing every iterator in the range [beg, end). The runtime partitions the range into chunks of the given chunk size, where each chunk is processed by a worker. When the given chunk size is zero, the runtime distributes the work evenly across workers.

Arguments are templated to enable stateful passing using std::reference_wrapper.

The callable needs to take a single argument of the dereferenced type.

◆ linearize() [1/2]

void tf::FlowBuilder::linearize ( std::vector< Task > & tasks )

inline

adds adjacent dependency links to a linear list of tasks

Parameters

tasks a vector of tasks

◆ linearize() [2/2]

void tf::FlowBuilder::linearize ( std::initializer_list< Task > tasks )

inline

adds adjacent dependency links to a linear list of tasks

Parameters

tasks an initializer list of tasks

◆ placeholder()

Task tf::FlowBuilder::placeholder ( )

inline

creates an empty task

Returns: a Task handle

◆ precede()

void tf::FlowBuilder::precede	(	Task	A,
		Task	B
	)

inline

adds a dependency link from task A to task B

Parameters

A	task A
B	task B

◆ reduce()

template<typename B , typename E , typename T , typename O >

Task tf::FlowBuilder::reduce	(	B &&	first,
		E &&	last,
		T &	init,
		O &&	bop
	)

constructs a STL-styled parallel-reduce task

Template Parameters

B	beginning iterator type
E	ending iterator type
T	result type
O	binary reducer type

Parameters

first	iterator to the beginning (inclusive)
last	iterator to the end (exclusive)
init	initial value of the reduction and the storage for the reduced result
bop	binary operator that will be applied

Returns: a Task handle

The task spawns a subflow to perform parallel reduction over init and the elements in the range [first, last). The reduced result is store in init. The runtime partitions the range into chunks of the given chunk size, where each chunk is processed by a worker. By default, we employ the guided partition algorithm.

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

for(auto itr=first; itr!=last; itr++) {
  init = bop(init, *itr);
}

Arguments are templated to enable stateful passing using std::reference_wrapper.

◆ reduce_dynamic()

template<typename B , typename E , typename T , typename O , typename H = size_t>

Task tf::FlowBuilder::reduce_dynamic	(	B &&	first,
		E &&	last,
		T &	init,
		O &&	bop,
		H &&	chunk_size = `1`
	)

constructs a STL-styled parallel-reduce task using the dynamic partition algorithm

Template Parameters

B	beginning iterator type
E	ending iterator type
T	result type
O	binary reducer type
H	chunk size type

Parameters

first	iterator to the beginning (inclusive)
last	iterator to the end (exclusive)
init	initial value of the reduction and the storage for the reduced result
bop	binary operator that will be applied
chunk_size	chunk size

The task spawns a subflow to perform parallel reduction over init and the elements in the range [first, last). The reduced result is store in init. The runtime partitions the range into chunks of size chunk_size, where each chunk is processed by a worker.

Arguments are templated to enable stateful passing using std::reference_wrapper.

Returns: a Task handle

◆ reduce_guided()

template<typename B , typename E , typename T , typename O , typename H = size_t>

Task tf::FlowBuilder::reduce_guided	(	B &&	first,
		E &&	last,
		T &	init,
		O &&	bop,
		H &&	chunk_size = `1`
	)

constructs a STL-styled parallel-reduce task using the guided partition algorithm

Template Parameters

B	beginning iterator type
E	ending iterator type
T	result type
O	binary reducer type
H	chunk size type

Parameters

first	iterator to the beginning (inclusive)
last	iterator to the end (exclusive)
init	initial value of the reduction and the storage for the reduced result
bop	binary operator that will be applied
chunk_size	chunk size

The task spawns a subflow to perform parallel reduction over init and the elements in the range [first, last). The reduced result is store in init. The runtime partitions the range into chunks of size chunk_size, where each chunk is processed by a worker.

Arguments are templated to enable stateful passing using std::reference_wrapper.

Returns: a Task handle

◆ reduce_static()

template<typename B , typename E , typename T , typename O , typename H = size_t>

Task tf::FlowBuilder::reduce_static	(	B &&	first,
		E &&	last,
		T &	init,
		O &&	bop,
		H &&	chunk_size = `0`
	)

constructs a STL-styled parallel-reduce task using the static partition algorithm

Template Parameters

B	beginning iterator type
E	ending iterator type
T	result type
O	binary reducer type
H	chunk size type

Parameters

first	iterator to the beginning (inclusive)
last	iterator to the end (exclusive)
init	initial value of the reduction and the storage for the reduced result
bop	binary operator that will be applied
chunk_size	chunk size

The task spawns a subflow to perform parallel reduction over init and the elements in the range [first, last). The reduced result is store in init. The runtime partitions the range into chunks of size chunk_size, where each chunk is processed by a worker.

Arguments are templated to enable stateful passing using std::reference_wrapper.

Returns: a Task handle

◆ succeed() [1/2]

void tf::FlowBuilder::succeed	(	std::vector< Task > &	others,
		Task	A
	)

inline

adds dependency links from many tasks to one task A

Parameters

others	a task set to precede A
A	task A

◆ succeed() [2/2]

void tf::FlowBuilder::succeed	(	std::initializer_list< Task >	others,
		Task	A
	)

inline

adds dependency links from many tasks to one task A

Parameters

others	a task set to precede A
A	task A

◆ transform_reduce()

template<typename B , typename E , typename T , typename BOP , typename UOP >

Task tf::FlowBuilder::transform_reduce	(	B &&	first,
		E &&	last,
		T &	init,
		BOP &&	bop,
		UOP &&	uop
	)

constructs a STL-styled parallel transform-reduce task

Template Parameters

B	beginning iterator type
E	ending iterator type
T	result type
BOP	binary reducer type
UOP	unary transformion type

Parameters

first	iterator to the beginning (inclusive)
last	iterator to the end (exclusive)
init	initial value of the reduction and the storage for the reduced result
bop	binary operator that will be applied in unspecified order to the results of `uop`
uop	unary operator that will be applied to transform each element in the range to the result type

Returns: a Task handle

The task spawns a subflow to perform parallel reduction over init and the transformed elements in the range [first, last). The reduced result is store in init. The runtime partitions the range into chunks of the given chunk size, where each chunk is processed by a worker. By default, we employ the guided partition algorithm.

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

for(auto itr=first; itr!=last; itr++) {
  init = bop(init, uop(*itr));
}

Arguments are templated to enable stateful passing using std::reference_wrapper.

◆ transform_reduce_dynamic()

template<typename B , typename E , typename T , typename BOP , typename UOP , typename H = size_t>

Task tf::FlowBuilder::transform_reduce_dynamic	(	B &&	first,
		E &&	last,
		T &	init,
		BOP &&	bop,
		UOP &&	uop,
		H &&	chunk_size = `1`
	)

constructs a STL-styled parallel transform-reduce task using the dynamic partition algorithm

Template Parameters

B	beginning iterator type
E	ending iterator type
T	result type
BOP	binary reducer type
UOP	unary transformion type
H	chunk size type

Parameters

first	iterator to the beginning (inclusive)
last	iterator to the end (exclusive)
init	initial value of the reduction and the storage for the reduced result
bop	binary operator that will be applied in unspecified order to the results of `uop`
uop	unary operator that will be applied to transform each element in the range to the result type
chunk_size	chunk size

Returns: a Task handle

The task spawns a subflow to perform parallel reduction over init and the transformed elements in the range [first, last). The reduced result is store in init. The runtime partitions the range into chunks of size chunk_size, where each chunk is processed by a worker.

Arguments are templated to enable stateful passing using std::reference_wrapper.

◆ transform_reduce_guided()

template<typename B , typename E , typename T , typename BOP , typename UOP , typename H = size_t>

Task tf::FlowBuilder::transform_reduce_guided	(	B &&	first,
		E &&	last,
		T &	init,
		BOP &&	bop,
		UOP &&	uop,
		H &&	chunk_size = `1`
	)

constructs a STL-styled parallel transform-reduce task using the guided partition algorithm

Template Parameters

B	beginning iterator type
E	ending iterator type
T	result type
BOP	binary reducer type
UOP	unary transformion type
H	chunk size type

Parameters

first	iterator to the beginning (inclusive)
last	iterator to the end (exclusive)
init	initial value of the reduction and the storage for the reduced result
bop	binary operator that will be applied in unspecified order to the results of `uop`
uop	unary operator that will be applied to transform each element in the range to the result type
chunk_size	chunk size

Returns: a Task handle

The task spawns a subflow to perform parallel reduction over init and the transformed elements in the range [first, last). The reduced result is store in init. The runtime partitions the range into chunks of size chunk_size, where each chunk is processed by a worker.

Arguments are templated to enable stateful passing using std::reference_wrapper.

◆ transform_reduce_static()

template<typename B , typename E , typename T , typename BOP , typename UOP , typename H = size_t>

Task tf::FlowBuilder::transform_reduce_static	(	B &&	first,
		E &&	last,
		T &	init,
		BOP &&	bop,
		UOP &&	uop,
		H &&	chunk_size = `0`
	)

constructs a STL-styled parallel transform-reduce task using the static partition algorithm

Template Parameters

B	beginning iterator type
E	ending iterator type
T	result type
BOP	binary reducer type
UOP	unary transformion type
H	chunk size type

Parameters

first	iterator to the beginning (inclusive)
last	iterator to the end (exclusive)
init	initial value of the reduction and the storage for the reduced result
bop	binary operator that will be applied in unspecified order to the results of `uop`
uop	unary operator that will be applied to transform each element in the range to the result type
chunk_size	chunk size

Returns: a Task handle

The task spawns a subflow to perform parallel reduction over init and the transformed elements in the range [first, last). The reduced result is store in init. The runtime partitions the range into chunks of size chunk_size, where each chunk is processed by a worker.

Arguments are templated to enable stateful passing using std::reference_wrapper.

The documentation for this class was generated from the following file:

flow_builder.hpp

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Function Documentation

◆ broadcast() [1/2]

◆ broadcast() [2/2]

◆ composed_of()

◆ emplace() [1/5]

◆ emplace() [2/5]

◆ emplace() [3/5]

◆ emplace() [4/5]

◆ emplace() [5/5]

◆ for_each()

◆ for_each_dynamic()

◆ for_each_guided()

◆ for_each_index()

◆ for_each_index_dynamic()

◆ for_each_index_guided()

◆ for_each_index_static()

◆ for_each_static()

◆ linearize() [1/2]

◆ linearize() [2/2]

◆ placeholder()

◆ precede()

◆ reduce()

◆ reduce_dynamic()

◆ reduce_guided()

◆ reduce_static()

◆ succeed() [1/2]

◆ succeed() [2/2]

◆ transform_reduce()

◆ transform_reduce_dynamic()

◆ transform_reduce_guided()

◆ transform_reduce_static()