void master_init(int argc, char **argv){
cpuTime_start = CmiCpuTimer();
wallTime_start = CmiWallTimer();
if ( CmiMyPe() ) {
all_init(argc, argv);
CsdScheduler(-1);
ConverseExit(); // should never return
}
all_init(argc, argv);
// Create branch-office chares
BOCgroup group;
group.workDistrib = CProxy_WorkDistrib::ckNew();
group.proxyMgr = CProxy_ProxyMgr::ckNew();
group.patchMgr = CProxy_PatchMgr::ckNew();
group.computeMgr = CProxy_ComputeMgr::ckNew();
group.reductionMgr = CProxy_ReductionMgr::ckNew();
// group.computePmeMgr set in constructor during startup
group.nodePmeMgr = CProxy_NodePmeMgr::ckNew();
#ifdef OPENATOM_VERSION
group.computeMoaMgr = CProxy_ComputeMoaMgr::ckNew();
#endif // OPENATOM_VERSION
group.computeExtMgr = CProxy_ComputeExtMgr::ckNew();
group.computeGBISserMgr = CProxy_ComputeGBISserMgr::ckNew();
group.computeMsmSerialMgr = CProxy_ComputeMsmSerialMgr::ckNew();
#ifdef CHARM_HAS_MSA
group.computeMsmMsaMgr = CProxy_ComputeMsmMsaMgr::ckNew();
#endif
group.computeMsmMgr = CProxy_ComputeMsmMgr::ckNew();
// Charm CkMulticast library module
group.multicastMgr = CProxy_CkMulticastMgr::ckNew();
#ifdef MEM_OPT_VERSION
group.ioMgr=CProxy_ParallelIOMgr::ckNew();
#endif
group.sync = CProxy_Sync::ckNew();
#ifdef USE_NODEPATCHMGR
group.nodeProxyMgr = CProxy_NodeProxyMgr::ckNew();
#endif
#if USE_CKLOOP
group.ckLoop = CkLoop_Init();
#endif
CkChareID collectionMaster = CProxy_CollectionMaster::ckNew(0);
SlaveInitMsg *initmsg7 = new SlaveInitMsg;
initmsg7->master = collectionMaster;
group.collectionMgr = CProxy_CollectionMgr::ckNew(initmsg7);
group.broadcastMgr = CProxy_BroadcastMgr::ckNew();
group.ldbCoordinator = CProxy_LdbCoordinator::ckNew();
GroupInitMsg *msg = new GroupInitMsg;
msg->group = group;
CProxy_Node::ckNew(msg);
}
void CmsExit(void)
{
void *msg;
msg = CmiAlloc(CmiMsgHeaderSizeBytes + 8);
CmiSetHandler(msg, CpvAccess(stopHandlerIndex));
CmiSyncBroadcastAndFree(CmiMsgHeaderSizeBytes + 8, msg);
ConverseExit();
}
// called on proc 0 by front end
void BackEnd::exit(void) {
float cpuTime = CmiCpuTimer() - cpuTime_start;
float wallTime = CmiWallTimer() - wallTime_start;
CmiPrintf("====================================================\n\n"
"WallClock: %f CPUTime: %f Memory: %f MB\n",
wallTime, cpuTime, memusage_MB());
int i;
for(i=1; i < CmiNumPes(); i++)
ExitSchedOn(i);
ConverseExit();
}
void CmsInit(CmsWorkerFn f, int maxResponses)
{
char *argv[1];
int argc = 0;
argv[0] = 0;
ConverseInit(argc, argv, (CmiStartFn) initForCms, 1, 1);
cms_registerHandlers(f);
CpvAccess(tableSize) = maxResponses;
if (CmiMyPe() == 0) { /*
* I am the manager
*/
CpvAccess(responses) =
(ResponseRecord *) CmiAlloc(maxResponses * sizeof(ResponseRecord));
CpvAccess(counter) = 0;
} else { /*
* I am a worker
*/
CsdScheduler(-1);
ConverseExit();
}
}
//! process command line arguments!
void TraceCounter::traceInit(char **argv)
{
CpvInitialize(CountLogPool*, _logPool);
CpvInitialize(char*, _logName);
CpvInitialize(double, version);
CpvInitialize(char**, _counterNames);
CpvInitialize(char**, _counterDesc);
CpvInitialize(int, _numCounters);
CpvInitialize(int, _reductionID);
CpvAccess(_logName) = (char *) malloc(strlen(argv[0])+1);
_MEMCHECK(CpvAccess(_logName));
strcpy(CpvAccess(_logName), argv[0]);
CpvAccess(version) = VER;
int i;
// parse command line args
char* counters = NULL;
commandLine_ = NULL;
bool badArg = false;
int numCounters = 0;
if (CmiGetArgStringDesc(argv, "+counters", &counters, "Measure these performance counters")) {
if (CmiMyPe()==0) { CmiPrintf("Counters: %s\n", counters); }
int offset = 0;
int limit = strlen(counters);
char* ptr = counters;
while (offset < limit &&
(ptr = strtok(&counters[offset], ",")) != NULL)
{
offset += strlen(ptr)+1;
ptr = &ptr[strlen(ptr)+1];
numCounters++;
}
if (CmiMyPe()==0) {
CmiPrintf("There are %d counters\n", numCounters);
}
commandLine_ = new CounterArg[numCounters];
ptr = counters;
for (i=0; i<numCounters; i++) {
commandLine_[i].arg = ptr;
if (!matchArg(&commandLine_[i])) {
if (CmiMyPe()==0) { CmiPrintf("Bad arg: [%s]\n", ptr); }
badArg = true;
}
ptr = &ptr[strlen(ptr)+1];
}
}
commandLineSz_ = numCounters;
// check to see if args are valid, output if not
if (badArg || CmiGetArgFlagDesc(argv, "+count-help", "List available performance counters")) {
if (CmiMyPe() == 0) { printHelp(); }
ConverseExit(); return;
}
else if (counters == NULL) {
if (CmiMyPe() == 0) { usage(); }
ConverseExit(); return;
}
// get optional command line args
overview_ = CmiGetArgFlag(argv, "+count-overview");
switchRandom_ = CmiGetArgFlag(argv, "+count-switchrandom");
switchByPhase_ = CmiGetArgFlag(argv, "+count-switchbyphase");
noLog_ = CmiGetArgFlag(argv, "+count-nolog");
writeByPhase_ = CmiGetArgFlag(argv, "+count-writebyphase");
char* logName = NULL;
if (CmiGetArgString(argv, "+count-logname", &logName)) {
CpvAccess(_logName) = logName;
if (noLog_) {
if (CkMyPe()==0) {
CmiPrintf("+count-logname and +count-nolog are MUTUALLY EXCLUSIVE\n");
usage();
CmiAbort("");
}
}
}
if (switchByPhase_ && overview_) {
if (CkMyPe()==0) {
CmiPrintf(
"+count-switchbyphase and +count-overview are MUTUALLY EXCLUSIVE\n"
"+count-overview automatically switches by phase.\n");
usage();
CmiAbort("");
}
}
if (writeByPhase_ && noLog_) {
if (CkMyPe()==0) {
CmiPrintf("+count-writebyphase and +count-nolog are MUTUALLY EXCLUSIVE\n");
usage();
CmiAbort("");
}
}
// parse through commandLine_, figure out which belongs on which list (1 vs 2)
CounterArg* last1 = NULL;
CounterArg* last2 = NULL;
CounterArg* tmp = NULL;
counter1Sz_ = counter2Sz_ = 0;
for (i=0; i<commandLineSz_; i++) {
tmp = &commandLine_[i];
if (tmp->code < NUM_COUNTER_ARGS/2) {
if (counter1_ == NULL) { counter1_ = tmp; last1 = counter1_; }
else { last1->next = tmp; last1 = tmp; }
counter1Sz_++;
}
else {
if (counter2_ == NULL) { counter2_ = tmp; last2 = counter2_; }
else { last2->next = tmp; last2 = tmp; }
counter2Sz_++;
}
}
if (counter1_ == NULL) {
printHelp();
if (CmiMyPe()==0) {
CmiPrintf("\nMust specify some counters with code < %d\n",
NUM_COUNTER_ARGS/2);
}
ConverseExit();
}
if (counter2_ == NULL) {
printHelp();
if (CmiMyPe()==0) {
CmiPrintf("\nMust specify some counters with code >= %d\n",
NUM_COUNTER_ARGS/2);
}
ConverseExit();
}
last1->next = counter1_;
last2->next = counter2_;
// all args valid, now set up logging
if (CmiMyPe() == 0) {
CmiPrintf("Running with tracemode=counter and args:\n");
// print out counter1 set
tmp = counter1_;
i = 0;
do {
CmiPrintf(" <counter1-%d>=%d %s %s\n", i, tmp->code, tmp->arg, tmp->desc);
tmp = tmp->next;
i++;
} while (tmp != counter1_);
// print out counter2 set
tmp = counter2_;
i = 0;
do {
CmiPrintf(" <counter2-%d>=%d %s %s\n", i, tmp->code, tmp->arg, tmp->desc);
tmp = tmp->next;
i++;
} while (tmp != counter2_);
CmiPrintf(
"+count-overview %d\n+count-switchrandom %d\n"
"+count-switchbyphase %d\n+count-nolog %d\n"
"+count-logname %s\n+count-writebyphase %d\n",
overview_, switchRandom_, switchByPhase_, noLog_,
logName, writeByPhase_);
}
// DEBUGF((" DEBUG: Counter1=%d Counter2=%d\n", counter1_, counter2_));
CpvAccess(_logPool) = new CountLogPool();
// allocate names so can do reduction/analysis on the fly
char** counterNames = new char*[counter1Sz_+counter2Sz_];
char** counterDesc = new char*[counter1Sz_+counter2Sz_];
tmp = counter1_;
for (i=0; i<counter1Sz_; i++) {
tmp->index = i;
counterNames[i] = tmp->arg;
counterDesc[i] = tmp->desc;
tmp = tmp->next;
}
tmp = counter2_;
for (i=0; i<counter2Sz_; i++) {
tmp->index = counter1Sz_+i;
counterNames[counter1Sz_+i] = tmp->arg;
counterDesc[counter1Sz_+i] = tmp->desc;
tmp = tmp->next;
}
CpvAccess(_counterNames) = counterNames;
CpvAccess(_counterDesc) = counterDesc;
CpvAccess(_numCounters) = numCounters;
// don't erase counterNames or counterDesc,
// the reduction client will do it on the final reduction
_MEMCHECK(CpvAccess(_logPool));
CpvAccess(_logPool)->init(numCounters);
DEBUGF(("%d/%d DEBUG: Created _logPool at %08x\n",
CmiMyPe(), CmiNumPes(), CpvAccess(_logPool)));
}
static void _exitHandler(envelope *env)
{
DEBUGF(("exitHandler called on %d msgtype: %d\n", CkMyPe(), env->getMsgtype()));
switch(env->getMsgtype()) {
case StartExitMsg:
CkAssert(CkMyPe()==0);
if (!_CkExitFnVec.isEmpty()) {
CkExitFn fn = _CkExitFnVec.deq();
fn();
break;
}
// else goto next
case ExitMsg:
CkAssert(CkMyPe()==0);
if(_exitStarted) {
CmiFree(env);
return;
}
_exitStarted = 1;
CkNumberHandler(_charmHandlerIdx,(CmiHandler)_discardHandler);
CkNumberHandler(_bocHandlerIdx, (CmiHandler)_discardHandler);
env->setMsgtype(ReqStatMsg);
env->setSrcPe(CkMyPe());
// if exit in ring, instead of broadcasting, send in ring
if (_ringexit){
DEBUGF(("[%d] Ring Exit \n",CkMyPe()));
const int stride = CkNumPes()/_ringtoken;
int pe = 0;
while (pe<CkNumPes()) {
CmiSyncSend(pe, env->getTotalsize(), (char *)env);
pe += stride;
}
CmiFree(env);
}else{
CmiSyncBroadcastAllAndFree(env->getTotalsize(), (char *)env);
}
break;
case ReqStatMsg:
#if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
_messageLoggingExit();
#endif
DEBUGF(("ReqStatMsg on %d\n", CkMyPe()));
CkNumberHandler(_charmHandlerIdx,(CmiHandler)_discardHandler);
CkNumberHandler(_bocHandlerIdx, (CmiHandler)_discardHandler);
/*FAULT_EVAC*/
if(CmiNodeAlive(CkMyPe())){
#if CMK_WITH_STATS
_sendStats();
#endif
_mainDone = 1; // This is needed because the destructors for
// readonly variables will be called when the program
// exits. If the destructor is called while _mainDone
// is 0, it will assume that the readonly variable was
// declared locally. On all processors other than 0,
// _mainDone is never set to 1 before the program exits.
#if CMK_TRACE_ENABLED
if (_ringexit) traceClose();
#endif
}
if (_ringexit) {
int stride = CkNumPes()/_ringtoken;
int pe = CkMyPe()+1;
if (pe < CkNumPes() && pe % stride != 0)
CmiSyncSendAndFree(pe, env->getTotalsize(), (char *)env);
else
CmiFree(env);
}
else
CmiFree(env);
//everyone exits here - there may be issues with leftover messages in the queue
#if CMK_WITH_STATS
if(CkMyPe())
#endif
{
DEBUGF(("[%d] Calling converse exit \n",CkMyPe()));
ConverseExit();
if(CharmLibInterOperate)
CpvAccess(interopExitFlag) = 1;
}
break;
#if CMK_WITH_STATS
case StatMsg:
CkAssert(CkMyPe()==0);
_allStats[env->getSrcPe()] = (Stats*) EnvToUsr(env);
_numStatsRecd++;
DEBUGF(("StatMsg on %d with %d\n", CkMyPe(), _numStatsRecd));
/*FAULT_EVAC*/
if(_numStatsRecd==CkNumValidPes()) {
_printStats();
DEBUGF(("[%d] Calling converse exit \n",CkMyPe()));
ConverseExit();
if(CharmLibInterOperate)
CpvAccess(interopExitFlag) = 1;
}
break;
#endif
default:
CmiAbort("Internal Error(_exitHandler): Unknown-msg-type. Contact Developers.\n");
}
}
static void stopHandler(void *msg)
{
CsdExitScheduler();
ConverseExit();
}
