| Taskflow: A General-purpose Task-parallel Programming System

Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | List of all members
tf::RandomPartitioner< C > Class Template Reference

class to construct a random partitioner for scheduling parallel algorithms More...

`#include <taskflow/algorithm/partitioner.hpp>`

Inheritance diagram for tf::RandomPartitioner< C >:
[legend]
Collaboration diagram for tf::RandomPartitioner< C >:
[legend]

## Public Member Functions
| RandomPartitioner ()=default
| default constructor
| RandomPartitioner (size_t sz)
| construct a dynamic partitioner with the given chunk size
| RandomPartitioner (size_t sz, C &&closure)
| construct a random partitioner with the given chunk size and the closure
| RandomPartitioner (float alpha, float beta)
| constructs a random partitioner with the given parameters
| RandomPartitioner (float alpha, float beta, C &&closure)
| constructs a random partitioner with the given parameters and the closure
float | alpha () const
| queries the `alpha` value
float | beta () const
| queries the `beta` value
std::pair< size_t, size_t > | chunk_size_range (size_t N, size_t W) const
| queries the range of chunk size
Public Member Functions inherited from tf::PartitionerBase< DefaultClosureWrapper >
| PartitionerBase ()=default
| default constructor
| PartitionerBase (size_t chunk_size)
| construct a partitioner with the given chunk size
| PartitionerBase (size_t chunk_size, DefaultClosureWrapper &&closure_wrapper)
| construct a partitioner with the given chunk size and closure wrapper
size_t | chunk_size () const
| query the chunk size of this partitioner
void | chunk_size (size_t cz)
| update the chunk size of this partitioner
const DefaultClosureWrapper & | closure_wrapper () const
| acquire an immutable access to the closure wrapper object
DefaultClosureWrapper & | closure_wrapper ()
| acquire a mutable access to the closure wrapper object
void | closure_wrapper (F &&fn)
| modify the closure wrapper object
TF_FORCE_INLINE decltype(auto) | operator() (F &&callable)
| wraps the given callable with the associated closure wrapper

## Static Public Member Functions
static constexpr PartitionerType | type ()
| queries the partition type (dynamic)

## Additional Inherited Members
Public Types inherited from tf::PartitionerBase< DefaultClosureWrapper >
using | closure_wrapper_type
| the closure type
Static Public Attributes inherited from tf::PartitionerBase< DefaultClosureWrapper >
static constexpr bool | is_default_wrapper_v
| indicating if the given closure wrapper is a default wrapper (i.e., empty)

## Detailed Description

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

class to construct a random partitioner for scheduling parallel algorithms

Template Parameters

  C | closure wrapper type (default tf::DefaultClosureWrapper)

Similar to tf::DynamicPartitioner, the partitioner splits iterations into many partitions but each with a random chunk size in the range, `c = [alpha * N * W, beta * N * W]`. By default, `alpha` is `0.01` and `beta` is `0.5`, respectively.

In addition to partition size, the application can specify a closure wrapper for a random 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::RandomPartitioner(0, [](auto&& closure){
// do something before invoking the partitioned task
// ...
// invoke the partitioned task
closure();
// do something else after invoking the partitioned task
// ...
}
);
executor.run(taskflow).wait();
tf::FlowBuilder::for_each_index
Task for_each_index(B first, E last, S step, C callable, P part=P())
constructs an index-based parallel-for task
tf::RandomPartitioner
class to construct a random partitioner for scheduling parallel algorithms
Definition partitioner.hpp:737
tf::Taskflow
class to create a taskflow object
Definition taskflow.hpp:64

## Member Function Documentation

## ◆ chunk_size_range()

template<typename C = DefaultClosureWrapper>

std::pair< size_t, size_t > tf::RandomPartitioner< C >::chunk_size_range | ( | size_t | N,
|  | size_t | W ) const
| inline

queries the range of chunk size

Parameters

  N | number of iterations
  W | number of workers

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

- taskflow/algorithm/partitioner.hpp