Here are the classes, structs, unions and interfaces with brief descriptions:

oned::DirectCut< T, Pr > | Greedily allocates to each processor the smallest interval with load less than average load |

oned::DirectCutRefB< T, Pr > | Same as DIRECT-CUT except this one recalculates average load after each allocation |

oned::GreedyBisection< T, Pr > | Grabs the interval with largest load and cuts it into two equal loaded pieces |

oned::Nicol< T, Pr > | [Use NicolPlus instead] this is the implementation of the nicols algorithm as it is provided in "Ali Pinar and Cevdet Aykanat, Fast Optimal Load Balancing Algorithms for 1D Partitioning, JPDC, 2004" in figure 5b. NicolPlus should be preferred over Nicol due to speed |

oned::Nicol_plus_interval< T, Pr > | Given a prefix sum array in interval notation, this algorithm applies NicolPlus |

oned::NicolMinus< T, Pr > | [Use NicolPlus instead] this is the implementation of the nicol's algorithm as it is provided in "Ali Pinar and Cevdet Aykanat, Fast Optimal Load Balancing Algorithms for 1D Partitioning, JPDC, 2004" in figure 5a. NicolPlus should be preferred over NicolMinus due to speed |

oned::NicolPlus< T, Pr, DEBUG > | This is the implementation of the nicols algorithm as it is provided in "Ali Pinar and Cevdet Aykanat, Fast Optimal Load Balancing Algorithms for 1D Partitioning, JPDC, 2004" in figure 10. This algorithm should be preferred over NicolMinus and Nicol due to speed |

oned::Parser< T, Pr > | Converts text into corresponding 1D algorithm function pointer |

oned::RecursiveBisection< T, Pr > | Recursive 1D partitioning algorithm which partition an array in two parts of similiar load and allocates half the processor in each part |

oned::RecursiveBisectionMinMax< T, Pr > | 1D relaxed hierarchical heuristic |

oned::Uniform< T, Pr > | Cuts prefix sum array into p fixed and equal length parts where p is the processor number |

twod::HierRelaxed< T, Pr, type, middle > | Implements the hierarchical relaxed heuristic and some variants |

twod::Hybrid< T, Pr > | Hybrid algorithms for 2d partitioning. A first partitioning is done with a 2d algorithm. Then, each part is partitioned during a second level using an other algorithm |

twod::JagMHeurBest< T, Pr > | Implements an m-way jagged partitioning heuristic using as the main dimension the one that leads to the best load balance |

twod::JagMHeurHor< T, Pr, onedalgoY, onedalgoX > | Implements an m-way jagged partitioning heuristic using the first dimension as the main dimension |

twod::JagMHeurProbeBest< T, Pr > | Finds least max proc load value by applying binary search over it. First cut direction is decided by tring both horizontal and vertical first dimension cuts. See section 3.2.2 PROBE-M algorithm of "E. Saule, E. O. Bas, U. V. Catalyurek, Load-Balancing Spatially Located Computations using Rectangular Partitions Paper, Tech. Report, ArXiv, no. arXiv:1104.2566v1, 2011" |

twod::JagMHeurProbeHor< T, Pr, onedalgoY, onedalgoX > | Finds least max proc load value by applying binary search over it. First cut direction is horizontal. See section 3.2.2 PROBE-M algorithm of "E. Saule, E. O. Bas, U. V. Catalyurek, Load-Balancing Spatially Located Computations using Rectangular Partitions Paper, Tech. Report, ArXiv, no. arXiv:1104.2566v1, 2011" |

twod::JagMHeurProbeVer< T, Pr, onedalgoY, onedalgoX > | Finds least max proc load value by applying binary search over it. First cut direction is vertical. See section 3.2.2 PROBE-M algorithm of "E. Saule, E. O. Bas, U. V. Catalyurek, Load-Balancing Spatially Located Computations using Rectangular Partitions Paper, Tech. Report, ArXiv, no. arXiv:1104.2566v1, 2011" |

twod::JagMHeurVer< T, Pr, onedalgoY, onedalgoX > | Implements an m-way jagged partitioning heuristic using the second dimension as the main dimension |

twod::JagMOptBest< T, Pr > | An optimal m-way jagged algorithm based on dynamic programming |

twod::JagMOptHor< T, Pr > | An optimal m-way jagged algorithm based on dynamic programming |

twod::JagMOptVer< T, Pr > | An optimal m-way jagged algorithm based on dynamic programming |

twod::JagPQHeurBest< T, Pr > | Implements a PxQ jagged partitioning heuristic taking as the main dimension the one that leads to the best load balance |

twod::JagPQHeurHor< T, Pr, onedalgoY, onedalgoX > | Implements a PxQ jagged partitioning heuristic using the first dimension as main dimension |

twod::JagPQHeurVer< T, Pr, onedalgoY, onedalgoX > | Implements a PxQ jagged partitioning heuristic using the second dimension as main dimension |

twod::JagPQOptBest< T, Pr > | Optimal PxQ-way jagged partitionning algorithm using a Dynamic Programming based algorithm |

twod::JagPQOptHor< T, Pr > | Optimal PxQ-way jagged partitionning algorithm using a Dynamic Programming based algorithm |

twod::JagPQOptIntervalBest< T, Pr > | Optimal PxQ jagged algorithm from "Ali Pinar and Cevdet Aykanat, Sparse Matrix Decomposition with Optimal Load Balancing, HiPC 1997" . It selects the main dimension to get the best possible load balance |

twod::JagPQOptIntervalHor< T, Pr > | Optimal PxQ jagged algorithm from "Ali Pinar and Cevdet Aykanat, Sparse Matrix Decomposition with Optimal Load Balancing, HiPC 1997" using the first dimension as the main dimension |

twod::JagPQOptIntervalVer< T, Pr > | Optimal PxQ jagged algorithm from "Ali Pinar and Cevdet Aykanat, Sparse Matrix Decomposition with Optimal Load Balancing, HiPC 1997" using the second dimension as the main dimension |

twod::JagPQOptVer< T, Pr > | Optimal PxQ-way jagged partitionning algorithm using a Dynamic Programming based algorithm |

twod::Parser< T, Pr > | Converts text into corresponding 2D algorithm objects |

twod::PartBase< T, Pr > | Base class for the 2D partitioning algorithm |

twod::RecBisect2D< T, Pr, type > | Implements variants of the recursive bisection algorithm originally published in "Marsha Berger and Shahid Bokhari, A Partitioning Strategy for Nonuniform Problems on Multiprocessors, IEEE TC, 1987" |

twod::RectNicol< T, Pr, DEBUG > | Implements the rectilinear partitioning algorithm with iterative refinement described in "David Nicol, Rectilinear Partitioning of Irregular Data Parallel Computations, JPDC, 1994" |

twod::Uniform< T, Pr > | Implements the area based rectilinear of the space |

util::Aggreg2Dto1D< T, Pr, row > | 1D representation of a section of a prefix sum array by summing its element row-wise or column-wise |

util::Aggreg2Dto1Dpart< T, Pr > | This class implements the interval notation for 1d array as defined by util::PrefixSumArray1DOfTInterval |

util::AggregMax2Dto1D< T, Pr, row > | Reduces a 2D matrix with stripes into 1D dimension by returning the load of the most loaded stripe |

util::Comm_cost_2d< T, Pr > | Methods to measure communication cost |

util::Compact2D< T, DEBUG > | Provides a 2D array of T which is compact in memory to optimize caches and memory allocations |

util::Compact3D< T > | Provide three dimensional arrays which are compact in memory (for cache performance) |

util::MProbe< T, SubMa, Ma > | M-way partitioning algorithm feasibility check. The check is done on a set of arrays as described in section 3.2.2 of "E. Saule, E. O. Bas, U. V. Catalyurek, Load-Balancing Spatially Located Computations using Rectangular Partitions Paper, Tech. Report, ArXiv, no. arXiv:1104.2566v1, 2011" |

util::Multiarrays< T, Pr > | A wrapper class to hold multiple arrays |

util::ParametricSearch< T, Pr > | Several probe algorithms used for 1d partitioning |

util::Prefix2D< T, DEBUG > | Prefix sum array (2d) |

util::PrefixSumArray1DOfTBracket< T > | Skeleton of prefix sum array using the bracket notation[] for 1d partitioning algorithm (this class does not actually exist) |

util::PrefixSumArray1DOfTInterval< T > | Skeleton of prefix sum array using the interval notation for 1d partitioning algorithm (this class does not actually exist) |

util::PrefixSumArray2DOfTBracket< T > | Skeleton of prefix sum array using the bracket notation for 2d partitioning algorithm (this class does not actually exist) |

util::rectangle | Rectangular region (inside a matrix) |

util::RectList< T, Pr > | List of rectangle inside Pr |

util::SubPSA< T, Pr > | Represent a rectangular region of a prefix sum array as an prefix sum array |

util::SubPSA< T, Pr >::Intermediate | Row from a SubPSA |

util::timestamp | Allow to keep track of time with a precision of a microseconds |

util::TransposePrefix2D< T, Pr > | Transpose of a prefix sum array |

util::TransposePrefix2D< T, Pr >::Intermediate | Internal data structure of TransposePrefix2D |

Generated on Mon Aug 8 2011 20:27:29 by 1.7.1