tf::DataPipe
taskflow/algorithm/data_pipeline.hpp
typename Input
typename Output
typename C
C using tf::DataPipe< Input, Output, C >::callable_t = C callable_t

callable type of the data pipe

Input using tf::DataPipe< Input, Output, C >::input_t = Input input_t

input type of the data pipe

Output using tf::DataPipe< Input, Output, C >::output_t = Output output_t

output type of the data pipe

typename... Ps Ps
class friend class DataPipeline DataPipeline DataPipeline
PipeType PipeType tf::DataPipe< Input, Output, C >::_type _type
callable_t callable_t tf::DataPipe< Input, Output, C >::_callable _callable
tf::DataPipe< Input, Output, C >::DataPipe
()=default
DataPipe

default constructor

tf::DataPipe< Input, Output, C >::DataPipe
(PipeType d, callable_t &&callable)
DataPipe
PipeType d
callable_t && callable

constructs a data pipe

You should use the helper function, tf::make_data_pipe, to create a DataPipe object, especially when you need tf::DataPipe to automatically deduct the lambda type.

PipeType PipeType tf::DataPipe< Input, Output, C >::type () const type

queries the type of the data pipe

A data pipe can be either parallel (tf::PipeType::PARALLEL) or serial (tf::PipeType::SERIAL).

void void tf::DataPipe< Input, Output, C >::type (PipeType type) type PipeType type

assigns a new type to the data pipe

typename U
void void tf::DataPipe< Input, Output, C >::callable (U &&callable) callable U && callable

assigns a new callable to the data pipe

U

callable type

callable

a callable object constructible from the callable type of this data pipe

Assigns a new callable to the pipe using universal forwarding.

class to create a stage in a data-parallel pipeline

A data pipe represents a stage of a data-parallel pipeline. A data pipe can be either parallel direction or serial direction (specified by tf::PipeType) and is associated with a callable to invoke by the pipeline scheduler.

You need to use the template function, tf::make_data_pipe, to create a data pipe. The input and output types of a tf::DataPipe should be decayed types (though the library will always decay them for you using `std::decay`) to allow internal storage to work. The data will be passed by reference to your callable, at which you can take it by copy or reference.

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

In addition to the data, you callable can take an additional reference of tf::Pipeflow in the second argument to probe the runtime information for 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());
    returnstd::to_string(input+100);
    }
    );

- tf::DataPipe
  _callable
- tf::DataPipe
  _type
- tf::DataPipe
  callable
- tf::DataPipe
  callable_t
- tf::DataPipe
  DataPipe
- tf::DataPipe
  DataPipe
- tf::DataPipe
  DataPipeline
- tf::DataPipe
  input_t
- tf::DataPipe
  output_t
- tf::DataPipe
  type
- tf::DataPipe
  type