void HbmLB::ReceiveStats(double t, int frompe, int fromlevel)
{
#if CMK_LBDB_ON
FindNeighbors();
int atlevel = fromlevel + 1;
CmiAssert(tree->isroot(CkMyPe(), atlevel));
DEBUGF(("[%d] ReceiveStats from PE %d from level: %d\n", CkMyPe(), frompe, fromlevel));
int neighborIdx = NeighborIndex(frompe, atlevel);
CmiAssert(neighborIdx==0 || neighborIdx==1);
LevelData *lData = levelData[atlevel];
lData->statsList[neighborIdx] = t;
int &stats_msg_count = levelData[atlevel]->stats_msg_count;
stats_msg_count ++;
DEBUGF(("[%d] ReceiveStats at level: %d %d/%d\n", CkMyPe(), atlevel, stats_msg_count, levelData[atlevel]->nChildren));
if (stats_msg_count == levelData[atlevel]->nChildren)
{
stats_msg_count = 0;
int parent = levelData[atlevel]->parent;
// load balancing
thisProxy[CkMyPe()].Loadbalancing(atlevel);
}
#endif
}
// assmebly all stats messages from children
void HybridBaseLB::buildStats(int atlevel)
{
#if CMK_LBDB_ON
// build LDStats
LevelData *lData = levelData[atlevel];
LDStats *statsData = lData->statsData;
CLBStatsMsg **statsMsgsList = lData->statsMsgsList;
int stats_msg_count = lData->stats_msg_count;
// statsMsgsList
DEBUGF(("[%d] buildStats for %d nobj:%d\n", CkMyPe(), stats_msg_count, statsData->n_objs));
statsData->nprocs() = stats_msg_count;
statsData->objData.resize(statsData->n_objs);
statsData->commData.resize(statsData->n_comm);
statsData->from_proc.resize(statsData->n_objs);
statsData->to_proc.resize(statsData->n_objs);
int nobj = 0;
int nmigobj = 0;
int ncom = 0;
for (int n=0; n<stats_msg_count; n++) {
int i;
CLBStatsMsg *msg = statsMsgsList[n];
int pe = msg->from_pe;
for (i=0; i<msg->n_objs; i++) {
// need to map index to relative index
statsData->from_proc[nobj] = statsData->to_proc[nobj] = NeighborIndex(pe, atlevel);
statsData->objData[nobj] = msg->objData[i];
if (msg->objData[i].migratable) nmigobj++;
nobj++;
}
for (i=0; i<msg->n_comm; i++) {
statsData->commData[ncom] = msg->commData[i];
ncom++;
}
// free the message
delete msg;
statsMsgsList[n]=0;
}
if (_lb_args.debug()>1) {
CmiPrintf("[%d] n_obj:%d migratable:%d ncom:%d at level %d at %f.\n", CkMyPe(), nobj, nmigobj, ncom, atlevel, CkWallTimer());
}
CmiAssert(statsData->n_objs == nobj);
CmiAssert(statsData->n_comm == ncom);
statsData->n_migrateobjs = nmigobj;
#endif
}
// store stats message in a level data
void HybridBaseLB::depositLBStatsMessage(CLBStatsMsg *m, int atlevel)
{
int pe = m->from_pe;
int neighborIdx = NeighborIndex(pe, atlevel);
CLBStatsMsg **statsMsgsList = levelData[atlevel]->statsMsgsList;
LDStats *statsData = levelData[atlevel]->statsData;
CmiAssert(statsMsgsList && statsData);
if (statsMsgsList[neighborIdx] != 0) {
CkPrintf("*** Unexpected CLBStatsMsg in ReceiveStats from PE %d-%d ***\n", pe,neighborIdx);
CkAbort("HybridBaseLB> Abort!");
}
// replace real pe to relative pe number in preparation for calling Strategy()
for (int i=0; i<m->n_comm; i++) {
LDCommData &commData = m->commData[i];
// modify processor to be this local pe
if (commData.from_proc()) m->commData[i].src_proc = neighborIdx;
if (commData.receiver.get_type() == LD_PROC_MSG) m->commData[i].receiver.setProc(neighborIdx);
}
statsMsgsList[neighborIdx] = m;
// store per processor data right away
struct ProcStats &procStat = statsData->procs[neighborIdx];
procStat.pe = pe; // real PE
procStat.total_walltime = m->total_walltime;
procStat.idletime = m->idletime;
procStat.bg_walltime = m->bg_walltime;
#if CMK_LB_CPUTIMER
procStat.total_cputime = m->total_cputime;
procStat.bg_cputime = m->bg_cputime;
#endif
procStat.pe_speed = m->pe_speed; // important
procStat.available = true;
procStat.n_objs = m->n_objs;
statsData->n_objs += m->n_objs;
statsData->n_comm += m->n_comm;
}
