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"); } }