void mpi_get_argv(int *c, char *str, int *ierr, int len)
{
char ** argv = CkGetArgv();
int nc = CkGetArgc();
if (*c < nc) {
strncpy(str, argv[*c], strlen(argv[*c]));
for (int j=strlen(argv[*c]); j<len; j++) str[j] = ' ';
*ierr = 0;
}
else {
memset(str, ' ', len);
*ierr = 1;
}
}
void POSEreadCmdLine()
{
char **argv = CkGetArgv();
CmiArgGroup("Charm++","POSE");
pose_config.stats=CmiGetArgFlagDesc(argv, "+stats_pose",
"Gather timing information and other statistics");
/* semantic meaning for these still to be determined
CmiGetArgIntDesc(argv, "+start_proj_pose",&pose_config.start_proj,
"GVT to initiate projections tracing");
CmiGetArgIntDesc(argv, "+end_proj_pose",&pose_config.end_proj,
"GVT to end projections tracing");
*/
pose_config.trace=CmiGetArgFlagDesc(argv, "+trace_pose",
"Traces key POSE operations like Forward Execution, Rollback, Cancellation, Fossil Collection, etc. via user events for display in projections");
/* DOP command-line parameter truth table:
|---- Input ---| |------------ Output --------------|
dop dopSkipCalcs DOP logs written DOP calcs performed
--- ------------ ---------------- -------------------
F F No No
F T Yes No
T F Yes Yes
T T Yes No
*/
pose_config.dop=CmiGetArgFlagDesc(argv, "+dop_pose",
"Critical path analysis by measuring degree of parallelism");
pose_config.dopSkipCalcs=CmiGetArgFlagDesc(argv, "+dop_pose_skip_calcs",
"Records degree of parallelism logs but doesn't perform end-of-simulation calculations");
if (pose_config.dopSkipCalcs) {
pose_config.dop = true;
}
CmiGetArgIntDesc(argv, "+memman_pose", &pose_config.max_usage , "Coarse memory management: Restricts forward execution of objects with over <max_usage>/<checkpoint store_rate> checkpoints; default to 10");
/*
pose_config.msg_pool=CmiGetArgFlagDesc(argv, "+pose_msgpool", "Store and reuse pools of messages under a certain size default 1000");
CmiGetArgIntDesc(argv, "+msgpoolsize_pose", &pose_config.msg_pool_size , "Store and reuse pools of messages under a certain size default 1000");
CmiGetArgIntDesc(argv, "+msgpoolmax_pose", &pose_config.max_pool_msg_size , "Store and reuse pools of messages under a certain size");
char *strat;
CmiGetArgStringDesc(argv, "+commlib_strat_pose", &strat , "Use commlib with strat in {stream|mesh|prio}");
if(strcmp("stream",strat)==0)
pose_config.commlib_strat=stream;
if(strcmp("mesh",strat)==0)
pose_config.commlib_strat=mesh;
if(strcmp("prio",strat)==0)
pose_config.commlib_strat=prio;
CmiGetArgIntDesc(argv, "+commlib_timeout-pose", &pose_config.commlib_timeout , "Use commlib with timeout N; default 1ms");
CmiGetArgIntDesc(argv, "+commlib_maxmsg_pose", &pose_config.commlib_maxmsg , "Use commlib with max msg N; default 5");
*/
pose_config.lb_on=CmiGetArgFlagDesc(argv, "+lb_on_pose", "Use load balancing");
CmiGetArgIntDesc(argv, "+lb_skip_pose", &pose_config.lb_skip , "Load balancing skip N; default 51");
CmiGetArgIntDesc(argv, "+lb_threshold_pose", &pose_config.lb_threshold , "Load balancing threshold N; default 4000");
CmiGetArgIntDesc(argv, "+lb_diff_pose", &pose_config.lb_diff , "Load balancing min diff between min and max load PEs; default 2000");
CmiGetArgIntDesc(argv, "+checkpoint_rate_pose", &pose_config.store_rate , "Sets checkpoint to 1 for every <rate> events. Default to 1. ");
CmiGetArgIntDesc(argv, "+checkpoint_gvt_pose", &pose_config.checkpoint_gvt_interval,
"Checkpoint approximately every <gvt #> of GVT ticks; default = 0 = no checkpointing; overrides +checkpoint_time_pose");
if (pose_config.checkpoint_gvt_interval < 0) {
CmiAbort("+checkpoint_gvt_pose value must be >= 0; 0 = no checkpointing\n");
}
CmiGetArgIntDesc(argv, "+checkpoint_time_pose", &pose_config.checkpoint_time_interval,
"Checkpoint approximately every <time> seconds; default = 0 = no checkpointing; overridden by checkpoint_gvt_pose");
if (pose_config.checkpoint_time_interval < 0) {
CmiAbort("+checkpoint_time_pose value must be >= 0; 0 = no checkpointing\n");
}
if ((pose_config.checkpoint_gvt_interval > 0) && (pose_config.checkpoint_time_interval > 0)) {
CmiPrintf("WARNING: checkpoint GVT and time values both set; ignoring time value\n");
pose_config.checkpoint_time_interval = 0;
}
/* load balancing */
CmiGetArgIntDesc(argv, "+lb_gvt_pose", &pose_config.lb_gvt_interval,
"Load balancing approximately every <gvt #> of GVT ticks; default = 0 = no lb");
if (pose_config.lb_gvt_interval < 0) {
CmiAbort("+lb_gvt_pose value must be >= 0; 0 = no load balancing\n");
}
/* max_iteration seems to be defunct */
// CmiGetArgIntDesc(argv, "+FEmax_pose", &pose_config.max_iter , "Sets max events executed in single forward execution step. Default to 100.");
CmiGetArgIntDesc(argv, "+leash_specwindow_pose", &pose_config.spec_window , "Sets speculative window behavior.");
CmiGetArgIntDesc(argv, "+leash_min_pose", &pose_config.min_leash , "Sets speculative window behavior minimum leash. Default 10.");
CmiGetArgIntDesc(argv, "+leash_max_pose", &pose_config.max_leash , "Sets speculative window behavior maximum leash. Default 100.");
CmiGetArgIntDesc(argv, "+leash_flex_pose", &pose_config.max_leash , "Sets speculative window behavior leash flex. Default 10.");
if(pose_config.deterministic= CmiGetArgFlagDesc(argv, "+deterministic_pose", "sorts events of same timestamp by event id for repeatable behavior "))
{
CkPrintf("WARNING: deterministic_pose: enter at your own risk, though this feature is hopefully not broken anymore\n");
}
}
// 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");
}
}
