lb namespace
Classes
- struct BaseLB
- struct ClusterInfo
- 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 NodeInfo
- struct OfflineLB
- struct PhaseInfo
- struct RandomLB
- struct RotateLB
- struct RotateObjMsg
- struct TemperedLB
- struct TemperedWMin
- struct TestSerializationLB
-
template<typename Transfer>struct TransferMsg
- struct WorkBreakdown
Enums
- enum class DataDistStrategy: uint8_t { scatter = 0, bcast = 1, pt2pt = 2 }
- How to distribute the data after the centralized LB makes a decision.
- enum class HeapExtractEnum: int8_t { LoadOverLessThan = 1, LoadOverGreaterThan = 2, LoadOverRandom = 3, LoadOverOneEach = 4 }
- enum class StatisticQuantity: int8_t { min, max, avg, std, var, skw, kur, car, imb, npr, sum }
- enum class Statistic: int8_t { 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 class CriterionEnum: uint8_t { Grapevine = 0, ModifiedGrapevine = 1 }
- enum class InformTypeEnum: uint8_t { SyncInform = 0, AsyncInform = 1 }
- Enum for information propagation approach.
- enum class TransferTypeEnum: uint8_t { Original = 0, Recursive = 1, SwapClusters = 2 }
- Enum for the strategy to be used in transfer stage.
- enum class ObjectOrderEnum: uint8_t { Arbitrary = 0, ElmID = 1, FewestMigrations = 2, SmallObjects = 3, LargestObjects = 4 }
- Enum for the order in which local objects are considered for transfer.
- enum class CMFTypeEnum: uint8_t { Original = 0, NormByMax = 1, NormByMaxExcludeIneligible = 2 }
- Enum for how the CMF is computed.
- enum class KnowledgeEnum: uint8_t { 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>
- using BytesType = double
- using ClusterSummaryType = std::unordered_map<SharedIDType, ClusterInfo>
- using RankSummaryType = std::tuple<BytesType, ClusterSummaryType>
Functions
- auto format_as(DataDistStrategy c) -> auto
-
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>&
- auto format_as(CriterionEnum c) -> auto
- auto format_as(ClusterInfo const& e) -> auto
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 class vt::
How to distribute the data after the centralized LB makes a decision.
enum class vt::
enum class vt::
enum class vt::
enum class vt::
enum class 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 class vt::
Enum for the strategy to be used in transfer stage.
| Enumerators | |
|---|---|
| Original |
Original strategy. Transfer one object per transfer as in original Grapevine approach. |
| Recursive |
Original strategy improved by recursion. When single object transfer is rejected, attempt to recurse in order to pull more objects into the transfer and hereby minimize work added by said transfer. This is especially useful when communication is taken into account, as object transfers typically disrupt local vs. global communication edges. |
| SwapClusters |
Form object clusters and attempt to perform swaps. Object can be clustered including to arbitrary definition, and swaps of entire clusters, including the nullset, between ranks are attempted. This is especially useful when shared memory constraints are present, as breaking shared memory clusters results in higher overall memory footprint, in contrast with whole cluster swaps. |
enum class 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 class 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. |
| 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 class 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::
using vt::
using vt::
using vt::
Function documentation
auto vt::
vt::
nlohmann::json vt::
std::unordered_map<Statistic, std::string>& vt::
auto vt::
auto 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::