lb namespace
Classes
- struct BaseLB
- struct CommMsg
- struct Criterion
- struct GrapevineCriterion
- struct GreedyBcastMsg
-
template<typename T>struct GreedyCompareLoadMax
-
template<typename T>struct GreedyCompareLoadMin
- struct GreedyLB
- struct GreedyLBTypes
- struct GreedyPayload
- struct GreedyProc
- struct GreedyRecord
- struct GreedySendMsg
- struct HierarchicalLB
- struct HierLBChild
- struct HierLBTypes
- struct LBTreeDownMsg
- struct LBTreeUpMsg
- struct LoadSamplerBaseLB
- struct ModifiedGrapevineCriterion
- struct OfflineLB
- struct PhaseInfo
- struct RandomLB
- struct RotateLB
- struct RotateObjMsg
- struct TemperedLB
- struct TemperedWMin
- struct TestSerializationLB
-
template<typename Transfer>struct TransferMsg
Enums
- enum DataDistStrategy { scatter = 0, bcast = 1, pt2pt = 2 }
- How to distribute the data after the centralized LB makes a decision.
- enum HeapExtractEnum { LoadOverLessThan = 1, LoadOverGreaterThan = 2, LoadOverRandom = 3, LoadOverOneEach = 4 }
- enum StatisticQuantity { min, max, avg, std, var, skw, kur, car, imb, npr, sum }
- enum Statistic { Rank_load_modeled, Rank_load_raw, Rank_comm, Rank_strategy_specific_load_modeled, Object_load_modeled, Object_load_raw, Object_comm, Object_strategy_specific_load_modeled, ObjectRatio, EdgeRatio }
- enum CriterionEnum { Grapevine = 0, ModifiedGrapevine = 1 }
- enum InformTypeEnum { SyncInform = 0, AsyncInform = 1 }
- Enum for information propagation approach.
- enum ObjectOrderEnum { Arbitrary = 0, ElmID = 1, FewestMigrations = 2, SmallObjects = 3, LargestObjects = 4 }
- Enum for the order in which local objects are considered for transfer.
- enum CMFTypeEnum { Original = 0, NormByMax = 1, NormBySelf = 2, NormByMaxExcludeIneligible = 3 }
- Enum for how the CMF is computed.
- enum KnowledgeEnum { UserDefined = 0, Complete = 1, Log = 2 }
- Enum for determining fanout and rounds.
Typedefs
- using StatisticQuantityMap = std::map<StatisticQuantity, double>
- using StatisticMap = std::unordered_map<Statistic, StatisticQuantityMap>
Functions
-
NLOHMANN_JSON_SERIALIZE_ENUM(StatisticQuantity,
{ {StatisticQuantity::
min, "min"}, {StatisticQuantity::max, "max"}, {StatisticQuantity::avg, "avg"}, {StatisticQuantity::std, "std"}, {StatisticQuantity::var, "var"}, {StatisticQuantity::skw, "skw"}, {StatisticQuantity::kur, "kur"}, {StatisticQuantity::car, "car"}, {StatisticQuantity::imb, "imb"}, {StatisticQuantity::npr, "npr"}, {StatisticQuantity::sum, "sum"}, }) nlohmann - auto jsonifyPhaseStatistics(const StatisticMap& statistics) -> nlohmann::json
- auto get_lb_stat_names() -> std::unordered_map<Statistic, std::string>&
Variables
- static int32_t const default_bin_size constexpr
- static NodeType const greedy_root constexpr
- static int32_t const greedy_bin_size constexpr
- static bool const greedy_auto_threshold_p constexpr
- static double const greedy_tolerance constexpr
- static double const greedy_threshold_p constexpr
- static double const greedy_max_threshold_p constexpr
- static double const hierlb_threshold_p constexpr
- static double const hierlb_max_threshold_p constexpr
- static NodeType const hierlb_nary constexpr
- static NodeType const hierlb_root constexpr
- static int32_t const hierlb_bin_size constexpr
- static double const hierlb_no_load_sentinel constexpr
- static double const hierlb_tolerance constexpr
- static bool const hierlb_auto_threshold_p constexpr
- static std::unordered_map<Statistic, std::string> lb_stat_names_
- static double const run_temperedlb_tolerance constexpr
- static double const temperedlb_load_threshold constexpr
Enum documentation
enum vt::
How to distribute the data after the centralized LB makes a decision.
enum vt::
enum vt::
enum vt::
enum vt::
enum vt::
Enum for information propagation approach.
| Enumerators | |
|---|---|
| SyncInform |
Synchronous sharing of underloaded processor loads. The round number is defined at the processor level. This approach propagates known loads after all messages for a round are received, maximizing the amount of information propagated per round, but has a synchronization cost. |
| AsyncInform |
Asynchronous sharing of underloaded processor loads. The round number is defined at the message level. This approach propagates known loads when the first message for a round is received, avoiding the synchronization cost but delaying the propagation of some information until the following round. |
enum vt::
Enum for the order in which local objects are considered for transfer.
| Enumerators | |
|---|---|
| Arbitrary |
|
| ElmID |
By element ID. Sort ascending by the ID member of ElementIDStruct. |
| FewestMigrations |
Order for the fewest migrations. Order starting with the object with the smallest load that can be transferred to drop the processor load below the average, then by descending load for objects with smaller loads, and finally by ascending load for objects with larger loads. |
| SmallObjects |
Order for migrating the objects with the smallest loads. Find the object with the smallest load where the sum of its own load and all smaller loads meets or exceeds the amount by which this processor's load exceeds the target load. Order starting with that object, then by descending load for objects with smaller loads, and finally by ascending load for objects with larger loads. |
| LargestObjects |
Order by descending load. |
enum vt::
Enum for how the CMF is computed.
| Enumerators | |
|---|---|
| Original |
Original approach. Remove processors from the CMF as soon as they exceed the target (e.g., processor-avg) load. Use a CMF factor of 1.0/x, where x is the target load. |
| NormByMax |
Compute the CMF factor using the largest processor load in the CMF. Do not remove processors from the CMF that exceed the target load until the next iteration. Use a CMF factor of 1.0/x, where x is the greater of the target load and the load of the most loaded processor in the CMF. |
| NormBySelf |
Compute the CMF factor using the load of this processor. Do not remove processors from the CMF that exceed the target load until the next iteration. Use a CMF factor of 1.0/x, where x is the load of the processor that is computing the CMF. |
| NormByMaxExcludeIneligible |
Narrow the CMF to only include processors that can accommodate the transfer. Use a CMF factor of 1.0/x, where x is the greater of the target load and the load of the most loaded processor in the CMF. Only include processors in the CMF that will pass the chosen Criterion for the object being considered for transfer. |
enum vt::
Enum for determining fanout and rounds.
| Enumerators | |
|---|---|
| UserDefined |
User defined values of fanout and rounds. The fanout and rounds must be set explicitly |
| Complete |
Full information. The fanout will be as large as possible, with only one round |
| Log |
Choose rounds and/or fanout based on log rule. The relationship between rounds and fanout will be approximately rounds = log(num_ranks)/log(fanout). |
Typedef documentation
using vt::
using vt::
Function documentation
vt::
nlohmann::json vt::
std::unordered_map<Statistic, std::string>& vt::
Variable documentation
static int32_t const vt::
static NodeType const vt::
static int32_t const vt::
static bool const vt::
static double const vt::
static double const vt::
static double const vt::
static double const vt::
static double const vt::
static NodeType const vt::
static NodeType const vt::
static int32_t const vt::
static double const vt::
static double const vt::
static bool const vt::
static std::unordered_map<Statistic, std::string> vt::
static double const vt::
static double const vt::