TraceSimple::TraceSimple(char **argv)
{
if (CkpvAccess(traceOnPe) == 0) return;
// Process runtime arguments intended for the module
CmiGetArgIntDesc(argv,"+SimplePar0", &par0, "Fake integer parameter 0");
CmiGetArgDoubleDesc(argv,"+SimplePar1", &par1, "Fake double parameter 1");
}
// called from init.C
void _loadbalancerInit()
{
CkpvInitialize(int, lbdatabaseInited);
CkpvAccess(lbdatabaseInited) = 0;
CkpvInitialize(int, numLoadBalancers);
CkpvAccess(numLoadBalancers) = 0;
CkpvInitialize(int, hasNullLB);
CkpvAccess(hasNullLB) = 0;
char **argv = CkGetArgv();
char *balancer = NULL;
CmiArgGroup("Charm++","Load Balancer");
while (CmiGetArgStringDesc(argv, "+balancer", &balancer, "Use this load balancer")) {
if (CkMyRank() == 0)
lbRegistry.addRuntimeBalancer(balancer); /* lbRegistry is a static */
}
// set up init value for LBPeriod time in seconds
// it can also be set by calling LDSetLBPeriod()
CmiGetArgDoubleDesc(argv,"+LBPeriod", &_lb_args.lbperiod(),"the minimum time period in seconds allowed for two consecutive automatic load balancing");
_lb_args.loop() = CmiGetArgFlagDesc(argv, "+LBLoop", "Use multiple load balancing strategies in loop");
// now called in cldb.c: CldModuleGeneralInit()
// registerLBTopos();
CmiGetArgStringDesc(argv, "+LBTopo", &_lbtopo, "define load balancing topology");
//Read the K parameter for RefineKLB
CmiGetArgIntDesc(argv, "+LBNumMoves", &_lb_args.percentMovesAllowed() , "Percentage of chares to be moved (used by RefineKLB) [0-100]");
/**************** FUTURE PREDICTOR ****************/
_lb_predict = CmiGetArgFlagDesc(argv, "+LBPredictor", "Turn on LB future predictor");
CmiGetArgIntDesc(argv, "+LBPredictorDelay", &_lb_predict_delay, "Number of balance steps before learning a model");
CmiGetArgIntDesc(argv, "+LBPredictorWindow", &_lb_predict_window, "Number of steps to use to learn a model");
if (_lb_predict_window < _lb_predict_delay) {
CmiPrintf("LB> [%d] Argument LBPredictorWindow (%d) less than LBPredictorDelay (%d) , fixing\n", CkMyPe(), _lb_predict_window, _lb_predict_delay);
_lb_predict_delay = _lb_predict_window;
}
/******************* SIMULATION *******************/
// get the step number at which to dump the LB database
CmiGetArgIntDesc(argv, "+LBVersion", &_lb_args.lbversion(), "LB database file version number");
CmiGetArgIntDesc(argv, "+LBCentPE", &_lb_args.central_pe(), "CentralLB processor");
int _lb_dump_activated = 0;
if (CmiGetArgIntDesc(argv, "+LBDump", &LBSimulation::dumpStep, "Dump the LB state from this step"))
_lb_dump_activated = 1;
if (_lb_dump_activated && LBSimulation::dumpStep < 0) {
CmiPrintf("LB> Argument LBDump (%d) negative, setting to 0\n",LBSimulation::dumpStep);
LBSimulation::dumpStep = 0;
}
CmiGetArgIntDesc(argv, "+LBDumpSteps", &LBSimulation::dumpStepSize, "Dump the LB state for this amount of steps");
if (LBSimulation::dumpStepSize <= 0) {
CmiPrintf("LB> Argument LBDumpSteps (%d) too small, setting to 1\n",LBSimulation::dumpStepSize);
LBSimulation::dumpStepSize = 1;
}
CmiGetArgStringDesc(argv, "+LBDumpFile", &LBSimulation::dumpFile, "Set the LB state file name");
// get the simulation flag and number. Now the flag can also be avoided by the presence of the number
LBSimulation::doSimulation = CmiGetArgIntDesc(argv, "+LBSim", &LBSimulation::simStep, "Read LB state from LBDumpFile since this step");
// check for stupid LBSim parameter
if (LBSimulation::doSimulation && LBSimulation::simStep < 0) {
CmiPrintf("LB> Argument LBSim (%d) invalid, should be >= 0\n");
CkExit();
return;
}
CmiGetArgIntDesc(argv, "+LBSimSteps", &LBSimulation::simStepSize, "Read LB state for this number of steps");
if (LBSimulation::simStepSize <= 0) {
CmiPrintf("LB> Argument LBSimSteps (%d) too small, setting to 1\n",LBSimulation::simStepSize);
LBSimulation::simStepSize = 1;
}
LBSimulation::simProcs = 0;
CmiGetArgIntDesc(argv, "+LBSimProcs", &LBSimulation::simProcs, "Number of target processors.");
LBSimulation::showDecisionsOnly =
CmiGetArgFlagDesc(argv, "+LBShowDecisions",
"Write to File: Load Balancing Object to Processor Map decisions during LB Simulation");
// force a global barrier after migration done
_lb_args.syncResume() = CmiGetArgFlagDesc(argv, "+LBSyncResume",
"LB performs a barrier after migration is finished");
// both +LBDebug and +LBDebug level should work
if (!CmiGetArgIntDesc(argv, "+LBDebug", &_lb_args.debug(),
"Turn on LB debugging printouts"))
_lb_args.debug() = CmiGetArgFlagDesc(argv, "+LBDebug",
"Turn on LB debugging printouts");
// getting the size of the team with +teamSize
if (!CmiGetArgIntDesc(argv, "+teamSize", &_lb_args.teamSize(),
"Team size"))
_lb_args.teamSize() = 1;
// ask to print summary/quality of load balancer
_lb_args.printSummary() = CmiGetArgFlagDesc(argv, "+LBPrintSummary",
"Print load balancing result summary");
// to ignore baclground load
_lb_args.ignoreBgLoad() = CmiGetArgFlagDesc(argv, "+LBNoBackground",
"Load balancer ignores the background load.");
#ifdef __BIGSIM__
_lb_args.ignoreBgLoad() = 1;
#endif
_lb_args.migObjOnly() = CmiGetArgFlagDesc(argv, "+LBObjOnly",
"Only load balancing migratable objects, ignoring all others.");
if (_lb_args.migObjOnly()) _lb_args.ignoreBgLoad() = 1;
// assume all CPUs are identical
_lb_args.testPeSpeed() = CmiGetArgFlagDesc(argv, "+LBTestPESpeed",
"Load balancer test all CPUs speed.");
_lb_args.samePeSpeed() = CmiGetArgFlagDesc(argv, "+LBSameCpus",
"Load balancer assumes all CPUs are of same speed.");
if (!_lb_args.testPeSpeed()) _lb_args.samePeSpeed() = 1;
_lb_args.useCpuTime() = CmiGetArgFlagDesc(argv, "+LBUseCpuTime",
"Load balancer uses CPU time instead of wallclock time.");
// turn instrumentation off at startup
_lb_args.statsOn() = !CmiGetArgFlagDesc(argv, "+LBOff",
"Turn load balancer instrumentation off");
// turn instrumentation of communicatin off at startup
_lb_args.traceComm() = !CmiGetArgFlagDesc(argv, "+LBCommOff",
"Turn load balancer instrumentation of communication off");
// set alpha and beeta
_lb_args.alpha() = PER_MESSAGE_SEND_OVERHEAD_DEFAULT;
_lb_args.beeta() = PER_BYTE_SEND_OVERHEAD_DEFAULT;
CmiGetArgDoubleDesc(argv,"+LBAlpha", &_lb_args.alpha(),
"per message send overhead");
CmiGetArgDoubleDesc(argv,"+LBBeta", &_lb_args.beeta(),
"per byte send overhead");
if (CkMyPe() == 0) {
if (_lb_args.debug()) {
CmiPrintf("CharmLB> Verbose level %d, load balancing period: %g seconds\n", _lb_args.debug(), _lb_args.lbperiod());
}
if (_lb_args.debug() > 1) {
CmiPrintf("CharmLB> Topology %s alpha: %es beta: %es.\n", _lbtopo, _lb_args.alpha(), _lb_args.beeta());
}
if (_lb_args.printSummary())
CmiPrintf("CharmLB> Load balancer print summary of load balancing result.\n");
if (_lb_args.ignoreBgLoad())
CmiPrintf("CharmLB> Load balancer ignores processor background load.\n");
if (_lb_args.samePeSpeed())
CmiPrintf("CharmLB> Load balancer assumes all CPUs are same.\n");
if (_lb_args.useCpuTime())
CmiPrintf("CharmLB> Load balancer uses CPU time instead of wallclock time.\n");
if (LBSimulation::doSimulation)
CmiPrintf("CharmLB> Load balancer running in simulation mode on file '%s' version %d.\n", LBSimulation::dumpFile, _lb_args.lbversion());
if (_lb_args.statsOn()==0)
CkPrintf("CharmLB> Load balancing instrumentation is off.\n");
if (_lb_args.traceComm()==0)
CkPrintf("CharmLB> Load balancing instrumentation for communication is off.\n");
if (_lb_args.migObjOnly())
CkPrintf("LB> Load balancing strategy ignores non-migratable objects.\n");
}
}
