All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages

reduce.h File Reference

Include dependency graph for reduce.h:

Go to the source code of this file.

## Functions | |

template<typename Fn , typename Rn , typename V > | |

V | WorkParallelReduceN (const V &identity, size_t n, Fn &&loopCallback, Rn &&reductionCallback, size_t grainSize) |

Recursively splits the range [0, `n` ) into subranges, which are then reduced by invoking `loopCallback` in parallel. More... | |

template<typename Fn , typename Rn , typename V > | |

V | WorkParallelReduceN (const V &identity, size_t n, Fn &&loopCallback, Rn &&reductionCallback) |

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.This overload does not accept a grain size parameter and instead attempts to automatically deduce a grain size that is optimal for the current resource utilization and provided workload. More... | |

V WorkParallelReduceN | ( | const V & | identity, |

size_t | n, |
||

Fn && | loopCallback, |
||

Rn && | reductionCallback, |
||

size_t | grainSize |
||

) |

Recursively splits the range [0, `n`

) into subranges, which are then reduced by invoking `loopCallback`

in parallel.

Each invocation of `loopCallback`

returns a single value that is the result of joining the elements in the respective subrange. These values are then further joined using the binary operator `reductionCallback`

, until only a single value remains. This single value is then the result of joining all elements over the entire range [0, `n`

).

The `loopCallback`

must be of the form:

V LoopCallback(size_t begin, size_t end, const V &identity);

The `reductionCallback`

must be of the form:

V ReductionCallback(const V &lhs, const V &rhs);

For example, the following code reduces an array of mesh points into a single bounding box:

```{.cpp}

// Get the mesh points from which we are going to generate the bounding box. const std::vector<Vector3> &points = GetMeshPoints();

// Generate the bounding box by parallel reducing the points. BoundingBox bbox = WorkParallelReduceN( BoundingBox(), points.size(), [&points](size_t b, size_t e, const BoundingBox &identity){ BoundingBox bbox(identity);

// Insert each point in this subrange into the local bounding box. for (size_t i = b; i != e; ++i) { bbox.InsertPoint(points[i]); }

// Return the local bounding box, which now encapsulates all the // points in this subrange. return bbox; }, [](const BoundingBox &lhs, const BoundingBox &rhs){ // Join two bounding boxes into a single bounding box. The // algorithm will apply this reduction step recursively until there // is only a single bounding box left. BoundingBox bbox(lhs); bbox.UnionWith(rhs); return bbox; } );

```

`grainSize`

specifies a minimum amount of work to be done per-thread. There is overhead to launching a task and a typical guideline is that you want to have at least 10,000 instructions to count for the overhead of launching that task.

V WorkParallelReduceN | ( | const V & | identity, |

size_t | n, |
||

Fn && | loopCallback, |
||

Rn && | reductionCallback |
||

) |

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.This overload does not accept a grain size parameter and instead attempts to automatically deduce a grain size that is optimal for the current resource utilization and provided workload.