.. _Partitioner_Summary:

Partitioner Summary

The parallel loop templates parallel_for and parallel_reduce take an optional partitioner argument, which specifies a strategy for executing the loop. The following table summarizes partitioners and their effect when used in conjunction with blocked_range.

.. container:: tablenoborder

.. list-table:: :header-rows: 1

  * -     Partitioner    
    -     Description    
    -     When Used with ``blocked_range(i,j,g)``
  * -     ``simple_partitioner``
    -     Chunksize bounded by grain size.    
    -      ``g/2 ≤ chunksize ≤ g``
  * -      ``auto_partitioner`` (default)    
    -     Automatic chunk size.    
    -     ``g/2 ≤ chunksize``     
  * -     ``affinity_partitioner``     
    -      Automatic chunk size, cache affinity and uniform distribution of iterations.    
    -     ``g/2 ≤ chunksize``     
  * -     ``static_partitioner``     
    -      Deterministic chunk size, cache affinity and uniform distribution of iterations without load balancing.    
    -     ``max(g/3, problem_size/num_of_resources) ≤ chunksize``      

An auto_partitioner is used when no partitioner is specified. In general, the auto_partitioner or affinity_partitioner should be used, because these tailor the number of chunks based on available execution resources. affinity_partitioner and static_partitioner may take advantage of Range ability to split in a given ratio (see "Advanced Topic: Other Kinds of Iteration Spaces") for distributing iterations in nearly equal chunks between computing resources.

simple_partitioner can be useful in the following situations:

• The subrange size for operator() must not exceed a limit. That might be advantageous, for example, if your operator() needs a temporary array proportional to the size of the range. With a limited subrange size, you can use an automatic variable for the array instead of having to use dynamic memory allocation.

• A large subrange might use cache inefficiently. For example, suppose the processing of a subrange involves repeated sweeps over the same memory locations. Keeping the subrange below a limit might enable the repeatedly referenced memory locations to fit in cache.

• You want to tune to a specific machine.