CnC
Public Types | Public Member Functions | Protected Member Functions | List of all members
default_partitioner< grainSize > Class Template Reference

Interface for partitioners: configuring how ranges are partitioned. More...

Inherited by tag_partitioner< grainSize >.

Public Types

typedef range_is_range_type split_type
 

Public Member Functions

template<typename Range , typename StepInstance >
bool divide_and_originate (Range &range, StepInstance &si) const
 divide given range into in arbitrary number of ranges of type Range More...
 

Protected Member Functions

template<typename Range >
bool is_divisible (const Range &range) const
 return true, if given range is divisible, false otherwise
 
int grain_size (size_t fullRangeSize) const
 

Detailed Description

template<int grainSize = 0>
class CnC::default_partitioner< grainSize >

Interface for partitioners: configuring how ranges are partitioned.

The default_partitioner implements the template interface that each partitioner must satisfy.

Given a range type "R", a partitioner "P" must provide a copy-constructor and the following (template) interface:

The default_partitioner can be parametrized as follows: Set template argument to > 0 to let it use a fixed grainsize. If it equals 0, the grainsize is set to "original_rangeSize / #threads / 4" If it is < 0, the grainsize of the given range is obeyed.

Definition at line 58 of file default_partitioner.h.

Member Typedef Documentation

◆ split_type

typedef range_is_range_type split_type

set to range_is_tag_type if tag is self-dividing, e.g. if the range-type is also the tag-type as passed to the step set to range_is_range_type if tag is undivisible, e.g. if range-type != step_type

Definition at line 91 of file default_partitioner.h.

Member Function Documentation

◆ divide_and_originate()

bool divide_and_originate ( Range &  range,
StepInstance &  si 
) const
inline

divide given range into in arbitrary number of ranges of type Range

Call si.originate_range( r ) for each new range. The original - but modified - range must not be passed to originate_range! If tag-types are self-dividing (e.g. if range-type == tag-type) you should call "originate" instead of "originate_range" for leaves of the recursive range-tree.

Returns
true if the orignal - but modified - range needs further splitting, false if no further splitting is desired.

The aggregated set of the members of the sub-ranges applied to "t.originate[_range]" must equal the set of member in given range. Overlapping ranges or gaps may lead to arbitrary effects.

Parameters
rangethe original range to split, may be altered
siopaque object, call t.originate[_range]( r ) for all split-off sub-ranges

Definition at line 150 of file default_partitioner.h.

151  {
152  return this->divide_and_originate( range, si, this->grain_size( range.size() ) );
153  }
bool divide_and_originate(Range &range, StepInstance &si) const
divide given range into in arbitrary number of ranges of type Range
int grain_size(size_t fullRangeSize) const

◆ grain_size()

int grain_size ( size_t  fullRangeSize) const
inlineprotected
Returns
grainsize for given size of unsplitted range

Definition at line 119 of file default_partitioner.h.

120  {
121  if( grainSize != 0 ) return grainSize;
122  else {
123  if( m_grainSize <= 0 ) {
124 #define MX( _a, _b ) ((_a) > (_b) ? (_a) : (_b))
125  const_cast< int & >( m_grainSize ) = rangeSize > 0 ? MX( 1, (int)(rangeSize / (size_t)m_nt / 4) ) : 1;
126  }
127  return m_grainSize;
128  }
129  }

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