Communicate::Communicate(void)
{
CkpvInitialize(CmmTable, CsmMessages);
CsmHandlerIndex = CmiRegisterHandler((CmiHandler) CsmHandler);
CsmAckHandlerIndex = CmiRegisterHandler((CmiHandler) CsmAckHandler);
CkpvAccess(CsmMessages) = CmmNew();
if ( CmiMyNode() * 2 + 2 < CmiNumNodes() ) nchildren = 2;
else if ( CmiMyNode() * 2 + 1 < CmiNumNodes() ) nchildren = 1;
else nchildren = 0;
CkpvInitialize(int, CsmAcks);
CkpvAccess(CsmAcks) = nchildren;
}
CmiStartFn mymain(int argc, char** argv)
{
if(CmiMyRank() == CmiMyNodeSize()) return 0;
CpvInitialize(int,msgSize);
CpvInitialize(int,cycleNum);
CpvInitialize(int,sizeNum);
CpvAccess(sizeNum) = 1;
CpvAccess(msgSize)= CmiMsgHeaderSizeBytes + 8;
CpvInitialize(int,exitHandler);
CpvAccess(exitHandler) = CmiRegisterHandler((CmiHandler) exitHandlerFunc);
CpvInitialize(int,node0Handler);
CpvAccess(node0Handler) = CmiRegisterHandler((CmiHandler) node0HandlerFunc);
CpvInitialize(int,node1Handler);
CpvAccess(node1Handler) = CmiRegisterHandler((CmiHandler) node1HandlerFunc);
CpvInitialize(int,ackHandler);
CpvAccess(ackHandler) = CmiRegisterHandler((CmiHandler) ackHandlerFunc);
CpvInitialize(double,startTime);
CpvInitialize(double,endTime);
CpvInitialize(double, IdleStartTime);
CpvInitialize(double, IdleTime);
CpvInitialize(int,ackCount);
CpvAccess(ackCount) = 0;
CpvInitialize(int,twoway);
CpvAccess(twoway) = 0;
CcdCallOnConditionKeep(CcdPROCESSOR_BEGIN_IDLE, ApplIdleStart, NULL);
CcdCallOnConditionKeep(CcdPROCESSOR_END_IDLE, ApplIdleEnd, NULL);
if(argc > 1)
CpvAccess(twoway) = atoi(argv[1]);
if(CmiMyPe() == 0) {
if(!CpvAccess(twoway))
CmiPrintf("Starting Pingpong with oneway traffic \n");
else
CmiPrintf("Starting Pingpong with twoway traffic\n");
}
if ((CmiMyPe() < CmiNumPes()/2) || CpvAccess(twoway))
startPingpong();
return 0;
}
void proc_moduleinit(void)
{
CpvInitialize(int, success);
CpvInitialize(int, nreported);
CpvInitialize(int, collect_handler);
CpvInitialize(int, trial_handler);
CpvInitialize(double, Time1);
CpvInitialize(double, TimeN);
CpvInitialize(int, isSingle);
CpvInitialize(double, seqPI);
CpvInitialize(double, parPI);
CpvAccess(collect_handler) = CmiRegisterHandler((CmiHandler)collectNumbers);
CpvAccess(trial_handler) = CmiRegisterHandler((CmiHandler)doTrials);
}
extern "C" void initQd(char **argv)
{
CpvInitialize(QdState*, _qd);
CpvAccess(_qd) = new QdState();
if (CmiMyRank() == 0) {
#if !defined(CMK_CPV_IS_SMP) && !CMK_SHARED_VARS_UNIPROCESSOR
CpvAccessOther(_qd, 1) = new QdState(); // for i/o interrupt
#endif
}
_qdHandlerIdx = CmiRegisterHandler((CmiHandler)_qdHandler);
_qdCommHandlerIdx = CmiRegisterHandler((CmiHandler)_qdCommHandler);
if (CmiGetArgIntDesc(argv,"+qd",&_dummy_dq, "QD time in seconds")) {
if (CmiMyPe()==0)
CmiPrintf("Charm++> Fake QD using %d seconds.\n", _dummy_dq);
}
}
/** At startup on each processor, this method is called.
This sets up the converse level comlib strategies.
This is called before any mainchare main functions.
*/
void initConvComlibManager(){
if(!CkpvInitialized(conv_com_object))
CkpvInitialize(ConvComlibManager, conv_com_object);
if(CkpvAccess(conv_com_object).getInitialized()) {
CmiPrintf("Comlib initialized more than once!\n");
return;
}
CkpvInitialize(int, RecvdummyHandle);
CkpvAccess(RecvdummyHandle) = CkRegisterHandler((CmiHandler)recv_dummy);
CkpvInitialize(int, comlib_receive_table);
CkpvAccess(comlib_receive_table) = CkRegisterHandler((CmiHandler)comlibReceiveTableHandler);
CkpvInitialize(int, comlib_table_received);
CkpvAccess(comlib_table_received) = CkRegisterHandler((CmiHandler)comlibTableReceivedHandler);
CkpvInitialize(int, comlib_ready);
CkpvAccess(comlib_ready) = CkRegisterHandler((CmiHandler)comlibReadyHandler);
// init strategy specific variables
// router strategy
CkpvInitialize(int, RouterRecvHandle);
CkpvAccess(RouterRecvHandle) = CkRegisterHandler((CmiHandler)routerRecvManyCombinedMsg);
CkpvInitialize(int, RouterProcHandle);
CkpvAccess(RouterProcHandle) = CkRegisterHandler((CmiHandler)routerProcManyCombinedMsg);
CkpvInitialize(int, RouterDummyHandle);
CkpvAccess(RouterDummyHandle) = CkRegisterHandler((CmiHandler)routerDummyMsg);
// streaming strategy
CpvInitialize(int, streaming_handler_id);
CpvAccess(streaming_handler_id) = CmiRegisterHandler(StreamingHandlerFn);
// mesh streaming strategy
CkpvInitialize(int, streaming_column_handler_id);
CkpvAccess(streaming_column_handler_id) = CkRegisterHandler(streaming_column_handler);
// pipelined broadcast
CkpvInitialize(int, pipeline_handler);
CkpvInitialize(int, pipeline_frag_handler);
CkpvAccess(pipeline_handler) = CkRegisterHandler((CmiHandler)PipelineHandler);
CkpvAccess(pipeline_frag_handler) = CkRegisterHandler((CmiHandler)PipelineFragmentHandler);
// general handler
CkpvInitialize(int, comlib_handler);
CkpvAccess(comlib_handler) = CkRegisterHandler((CmiHandler) strategyHandler);
//PUPable_reg(Strategy); ABSTRACT
//PUPable_reg(ConvComlibInstanceHandle);
if (CmiMyRank() == 0) {
PUPable_reg(RouterStrategy);
PUPable_reg(StreamingStrategy);
PUPable_reg(MeshStreamingStrategy);
PUPable_reg(PipeBroadcastConverse);
PUPable_reg(MessageHolder);
}
CkpvAccess(conv_com_object).setInitialized();
}
void CpdInit(void)
{
#if ! CMK_BIGSIM_CHARM
CpvInitialize(int, freezeModeFlag);
CpvAccess(freezeModeFlag) = 0;
CpvInitialize(void *, debugQueue);
CpvAccess(debugQueue) = CdsFifo_Create();
#endif
CpvInitialize(void *, conditionalQueue);
CpvAccess(conditionalQueue) = CdsFifo_Create();
CcsRegisterHandler("debug/converse/freeze", (CmiHandler)CpdDebugHandlerFreeze);
CcsRegisterHandler("debug/converse/status", (CmiHandler)CpdDebugHandlerStatus);
CcsSetMergeFn("debug/converse/status", CcsMerge_concat);
CcsRegisterHandler("debug/memory/allocationTree", (CmiHandler)CpdDebugCallAllocationTree);
CpvInitialize(int, CpdDebugCallAllocationTree_Index);
CpvAccess(CpdDebugCallAllocationTree_Index) = CmiRegisterHandler((CmiHandler)CpdDebugCallAllocationTree);
CcsRegisterHandler("debug/memory/stat", (CmiHandler)CpdDebugCallMemStat);
CpvInitialize(int, CpdDebugCallMemStat_Index);
CpvAccess(CpdDebugCallMemStat_Index) = CmiRegisterHandler((CmiHandler)CpdDebugCallMemStat);
CcsRegisterHandler("debug/memory/leak",(CmiHandler)CpdSearchLeaks);
CpvInitialize(int, CpdSearchLeaks_Index);
CpvAccess(CpdSearchLeaks_Index) = CmiRegisterHandler((CmiHandler)CpdSearchLeaks);
CpvInitialize(int, CpdSearchLeaksDone_Index);
CpvAccess(CpdSearchLeaksDone_Index) = CmiRegisterHandler((CmiHandler)CpdSearchLeaksDone);
CcsRegisterHandler("debug/memory/mark",(CmiHandler)CpdMemoryMarkClean);
CcsSetMergeFn("debug/memory/mark", CcsMerge_concat);
_debugHandlerIdx = CmiRegisterHandler((CmiHandler)handleDebugMessage);
#if 0
CpdInitializeObjectTable();
CpdInitializeHandlerArray();
CpdInitializeBreakPoints();
/* To allow start in freeze state: */
msgListCleanup();
msgListCache();
#endif
}
// constructor
StatTable::StatTable():
stats_(NULL), numStats_(0)
{
DEBUGF(("%d/%d DEBUG: StatTable::StatTable %08x size %d\n",
CmiMyPe(), CmiNumPes(), this));
DEBUGF(("%d/%d registering reductionID\n", CmiMyPe(), CmiNumPes()));
CpvAccess(_reductionID) = CmiRegisterHandler((CmiHandler)StatTableReduction);
}
static void cms_registerHandlers(CmsWorkerFn f)
{
CpvInitialize(int, stopHandlerIndex);
CpvInitialize(int, workHandler);
CpvInitialize(int, responseHandler);
CpvInitialize(int, infoIdx);
CpvInitialize(ResponseRecord *, responses);
CpvInitialize(CmsWorkerFn, clientWorker);
CpvInitialize(CmsConsumerFn, consumerFunction);
CpvInitialize(int, counter);
CpvInitialize(int, tableSize);
CpvAccess(stopHandlerIndex) =
CmiRegisterHandler((CmiHandler) stopHandler);
CpvAccess(workHandler) = CmiRegisterHandler((CmiHandler) callWorker);
CpvAccess(responseHandler) = CmiRegisterHandler((CmiHandler) response);
CpvAccess(infoIdx) = CldRegisterInfoFn(cms_infoFn);
CpvAccess(clientWorker) = f;
CpvAccess(consumerFunction) = (CmsConsumerFn) 0;
}
void CldModuleInit(char **argv)
{
peinfo *pinf;
CpvInitialize(peinfo, peinf);
/* srand48(time(0)+CmiMyPe()); */
CrnSrand((int) (time(0)+CmiMyPe()));
pinf = &CpvAccess(peinf);
pinf->mype = CmiMyPe();
pinf->EnqueueHandler = CmiRegisterHandler((CmiHandler)CldEnqueueHandler);
pinf->ReduceHandler = CmiRegisterHandler((CmiHandler)CldReduceHandler);
pinf->AverageHandler = CmiRegisterHandler((CmiHandler)CldAverageHandler);
pinf->HopHandler = CmiRegisterHandler((CmiHandler)CldHopHandler);
pinf->load_total = 0.0;
pinf->load_count = 0;
pinf->spantree_children = CmiNumSpanTreeChildren(CmiMyPe());
pinf->spantree_parent = CmiSpanTreeParent(CmiMyPe());
pinf->spantree_root = 0;
pinf->rebalance = 0;
CldModuleGeneralInit(argv);
CldInitiateReduction();
}
void broadcast_moduleinit(void)
{
CpvInitialize(int, numiter);
CpvInitialize(int, nextidx);
CpvInitialize(double, starttime);
CpvInitialize(double, lasttime);
CpvInitialize(pdouble, timediff);
CpvInitialize(int, currentPe);
CpvInitialize(int, bcast_handler);
CpvInitialize(int, bcast_reply);
CpvInitialize(int, bcast_central);
CpvInitialize(int, reduction_handler);
CpvInitialize(int, sync_starter);
CpvInitialize(int, sync_reply);
CpvAccess(numiter) = 0;
CpvAccess(nextidx) = 0;
CpvAccess(currentPe) = 0;
CpvAccess(timediff) = (pdouble)malloc(CmiNumPes()*sizeof(double));
CpvAccess(bcast_handler) = CmiRegisterHandler((CmiHandler)bcast_handler);
CpvAccess(bcast_reply) = CmiRegisterHandler((CmiHandler)bcast_reply);
CpvAccess(bcast_central) = CmiRegisterHandler((CmiHandler)bcast_central);
CpvAccess(reduction_handler) = CmiRegisterHandler((CmiHandler)reduction_handler);
CpvAccess(sync_starter) = CmiRegisterHandler((CmiHandler)sync_starter);
CpvAccess(sync_reply) = CmiRegisterHandler((CmiHandler)sync_reply);
}
void CcsInit(char **argv)
{
CpvInitialize(CkHashtable_c, ccsTab);
CpvAccess(ccsTab) = CkCreateHashtable_string(sizeof(CcsHandlerRec),5);
CpvInitialize(CcsImplHeader *, ccsReq);
CpvAccess(ccsReq) = NULL;
_ccsHandlerIdx = CmiRegisterHandler((CmiHandler)req_fw_handler);
#if CMK_BIGSIM_CHARM
CpvInitialize(int, _bgCcsHandlerIdx);
CpvAccess(_bgCcsHandlerIdx) = 0;
CpvInitialize(int, _bgCcsAck);
CpvAccess(_bgCcsAck) = 0;
#endif
CpvInitialize(int, cmiArgDebugFlag);
CpvInitialize(char *, displayArgument);
CpvInitialize(int, cpdSuspendStartup);
CpvAccess(cmiArgDebugFlag) = 0;
CpvAccess(displayArgument) = NULL;
CpvAccess(cpdSuspendStartup) = 0;
CcsBuiltinsInit(argv);
rep_fw_handler_idx = CmiRegisterHandler((CmiHandler)rep_fw_handler);
#if NODE_0_IS_CONVHOST
#if ! CMK_CMIPRINTF_IS_A_BUILTIN
print_fw_handler_idx = CmiRegisterHandler((CmiHandler)print_fw_handler);
#endif
{
int ccs_serverPort=0;
char *ccs_serverAuth=NULL;
if (CmiGetArgFlagDesc(argv,"++server", "Create a CCS server port") |
CmiGetArgIntDesc(argv,"++server-port",&ccs_serverPort, "Listen on this TCP/IP port number") |
CmiGetArgStringDesc(argv,"++server-auth",&ccs_serverAuth, "Use this CCS authentication file"))
if (CmiMyPe()==0)
{/*Create and occasionally poll on a CCS server port*/
CcsServer_new(NULL,&ccs_serverPort,ccs_serverAuth);
CcdCallOnConditionKeep(CcdPERIODIC,(CcdVoidFn)CcsServerCheck,NULL);
}
}
#endif
/* if in parallel debug mode i.e ++cpd, freeze */
if (CmiGetArgFlagDesc(argv, "+cpd", "Used *only* in conjunction with parallel debugger"))
{
CpvAccess(cmiArgDebugFlag) = 1;
if (CmiGetArgStringDesc(argv, "+DebugDisplay",&(CpvAccess(displayArgument)), "X display for gdb used only in cpd mode"))
{
if (CpvAccess(displayArgument) == NULL)
CmiPrintf("WARNING> NULL parameter for +DebugDisplay\n***");
}
else if (CmiMyPe() == 0)
{
/* only one processor prints the warning */
CmiPrintf("WARNING> x term for gdb needs to be specified as +DebugDisplay by debugger\n***\n");
}
if (CmiGetArgFlagDesc(argv, "+DebugSuspend", "Suspend execution at beginning of program")) {
CpvAccess(cpdSuspendStartup) = 1;
}
}
CcsReleaseMessages();
}
static void register_exit_sched(void)
{
CkpvInitialize(int,exitSchedHndlr);
CkpvAccess(exitSchedHndlr) = CmiRegisterHandler((CmiHandler)exit_sched);
}
void handler_moduleinit()
{
int i, dummy_idx;
for(i=0;i<300;i++)
dummy_idx = CmiRegisterHandler(handler_dummy);
}
void CmiInitCPUAffinity(char **argv)
{
static skt_ip_t myip;
int ret, i, exclude;
hostnameMsg *msg;
char *pemap = NULL;
char *commap = NULL;
char *pemapfile = NULL;
int show_affinity_flag;
int affinity_flag = CmiGetArgFlagDesc(argv,"+setcpuaffinity",
"set cpu affinity");
while (CmiGetArgIntDesc(argv,"+excludecore", &exclude, "avoid core when setting cpuaffinity")) {
if (CmiMyRank() == 0) add_exclude(exclude);
affinity_flag = 1;
}
if (CmiGetArgStringDesc(argv, "+pemapfile", &pemapfile, "define pe to core mapping file")) {
FILE *fp;
char buf[128];
pemap = (char*)malloc(1024);
fp = fopen(pemapfile, "r");
if (fp == NULL) CmiAbort("pemapfile does not exist");
while (!feof(fp)) {
if (fgets(buf, 128, fp)) {
if (buf[strlen(buf)-1] == '\n') buf[strlen(buf)-1] = 0;
strcat(pemap, buf);
}
}
fclose(fp);
if (CmiMyPe()==0) CmiPrintf("Charm++> read from pemap file '%s': %s\n", pemapfile, pemap);
}
CmiGetArgStringDesc(argv, "+pemap", &pemap, "define pe to core mapping");
if (pemap!=NULL && excludecount>0)
CmiAbort("Charm++> +pemap can not be used with +excludecore.\n");
CmiGetArgStringDesc(argv, "+commap", &commap, "define comm threads to core mapping");
if (pemap!=NULL || commap!=NULL) affinity_flag = 1;
show_affinity_flag = CmiGetArgFlagDesc(argv,"+showcpuaffinity",
"print cpu affinity");
cpuAffinityHandlerIdx =
CmiRegisterHandler((CmiHandler)cpuAffinityHandler);
cpuAffinityRecvHandlerIdx =
CmiRegisterHandler((CmiHandler)cpuAffinityRecvHandler);
if (CmiMyRank() ==0) {
affLock = CmiCreateLock();
}
#if CMK_BLUEGENEP || CMK_BLUEGENEQ
if(affinity_flag){
affinity_flag = 0;
if(CmiMyPe()==0) CmiPrintf("Charm++> cpu affinity setting is not needed on Blue Gene, thus ignored.\n");
}
if(show_affinity_flag){
show_affinity_flag = 0;
if(CmiMyPe()==0) CmiPrintf("Charm++> printing cpu affinity is not supported on Blue Gene.\n");
}
#endif
if (!affinity_flag) {
if (show_affinity_flag) CmiPrintCPUAffinity();
return;
}
if (CmiMyPe() == 0) {
CmiPrintf("Charm++> cpu affinity enabled. \n");
if (excludecount > 0) {
CmiPrintf("Charm++> cpuaffinity excludes core: %d", excludecore[0]);
for (i=1; i<excludecount; i++) CmiPrintf(" %d", excludecore[i]);
CmiPrintf(".\n");
}
if (pemap!=NULL)
CmiPrintf("Charm++> cpuaffinity PE-core map : %s\n", pemap);
}
if (CmiMyPe() >= CmiNumPes()) { /* this is comm thread */
/* comm thread either can float around, or pin down to the last rank.
however it seems to be reportedly slower if it is floating */
CmiNodeAllBarrier();
if (commap != NULL) {
int mycore = search_pemap(commap, CmiMyPeGlobal()-CmiNumPesGlobal());
if(CmiMyPe()-CmiNumPes()==0) printf("Charm++> set comm %d on node %d to core #%d\n", CmiMyPe()-CmiNumPes(), CmiMyNode(), mycore);
if (-1 == CmiSetCPUAffinity(mycore))
CmiAbort("set_cpu_affinity abort!");
CmiNodeAllBarrier();
if (show_affinity_flag) CmiPrintCPUAffinity();
return; /* comm thread return */
}
else {
/* if (CmiSetCPUAffinity(CmiNumCores()-1) == -1) CmiAbort("set_cpu_affinity abort!"); */
#if !CMK_CRAYXT && !CMK_CRAYXE && !CMK_CRAYXC && !CMK_BLUEGENEQ
if (pemap == NULL) {
#if CMK_MACHINE_PROGRESS_DEFINED
while (affinity_doneflag < CmiMyNodeSize()) CmiNetworkProgress();
#else
#if CMK_SMP
#error "Machine progress call needs to be implemented for cpu affinity!"
#endif
#endif
}
#endif
#if CMK_CRAYXT || CMK_CRAYXE || CMK_CRAYXC
/* if both pemap and commmap are NULL, will compute one */
if (pemap != NULL)
#endif
{
CmiNodeAllBarrier();
if (show_affinity_flag) CmiPrintCPUAffinity();
return; /* comm thread return */
}
}
}
if (pemap != NULL && CmiMyPe()<CmiNumPes()) { /* work thread */
int mycore = search_pemap(pemap, CmiMyPeGlobal());
if(show_affinity_flag) CmiPrintf("Charm++> set PE %d on node %d to core #%d\n", CmiMyPe(), CmiMyNode(), mycore);
if (mycore >= CmiNumCores()) {
CmiPrintf("Error> Invalid core number %d, only have %d cores (0-%d) on the node. \n", mycore, CmiNumCores(), CmiNumCores()-1);
CmiAbort("Invalid core number");
}
if (CmiSetCPUAffinity(mycore) == -1) CmiAbort("set_cpu_affinity abort!");
CmiNodeAllBarrier();
CmiNodeAllBarrier();
/* if (show_affinity_flag) CmiPrintCPUAffinity(); */
return;
}
#if CMK_CRAYXT || CMK_CRAYXE || CMK_CRAYXC
{
int numCores = CmiNumCores();
int myid = getXTNodeID(CmiMyNodeGlobal(), CmiNumNodesGlobal());
int myrank;
int pe, mype = CmiMyPeGlobal();
int node = CmiMyNodeGlobal();
int nnodes = 0;
#if CMK_SMP
if (CmiMyPe() >= CmiNumPes()) { /* this is comm thread */
int node = CmiMyPe() - CmiNumPes();
mype = CmiGetPeGlobal(CmiNodeFirst(node) + CmiMyNodeSize() - 1, CmiMyPartition()); /* last pe on SMP node */
node = CmiGetNodeGlobal(node, CmiMyPartition());
}
#endif
pe = mype - 1;
while (pe >= 0) {
int n = CmiNodeOf(pe);
if (n != node) { nnodes++; node = n; }
if (getXTNodeID(n, CmiNumNodesGlobal()) != myid) break;
pe --;
}
CmiAssert(numCores > 0);
myrank = (mype - pe - 1 + nnodes)%numCores;
#if CMK_SMP
if (CmiMyPe() >= CmiNumPes())
myrank = (myrank + 1)%numCores;
#endif
if (-1 != CmiSetCPUAffinity(myrank)) {
DEBUGP(("Processor %d is bound to core #%d on node #%d\n", CmiMyPe(), myrank, mynode));
}
else{
CmiPrintf("Processor %d set affinity failed!\n", CmiMyPe());
CmiAbort("set cpu affinity abort!\n");
}
}
if (CmiMyPe() < CmiNumPes())
CmiNodeAllBarrier();
CmiNodeAllBarrier();
#else
/* get my ip address */
if (CmiMyRank() == 0)
{
#if CMK_HAS_GETHOSTNAME
myip = skt_my_ip(); /* not thread safe, so only calls on rank 0 */
#else
CmiAbort("Can not get unique name for the compute nodes. \n");
#endif
}
CmiNodeAllBarrier();
/* prepare a msg to send */
msg = (hostnameMsg *)CmiAlloc(sizeof(hostnameMsg));
CmiSetHandler((char *)msg, cpuAffinityHandlerIdx);
msg->pe = CmiMyPe();
msg->ip = myip;
msg->ncores = CmiNumCores();
DEBUGP(("PE %d's node has %d number of cores. \n", CmiMyPe(), msg->ncores));
msg->rank = 0;
CmiSyncSendAndFree(0, sizeof(hostnameMsg), (void *)msg);
if (CmiMyPe() == 0) {
int i;
hostTable = CmmNew();
rankmsg = (rankMsg *)CmiAlloc(sizeof(rankMsg)+CmiNumPes()*sizeof(int)*2);
CmiSetHandler((char *)rankmsg, cpuAffinityRecvHandlerIdx);
rankmsg->ranks = (int *)((char*)rankmsg + sizeof(rankMsg));
rankmsg->nodes = (int *)((char*)rankmsg + sizeof(rankMsg) + CmiNumPes()*sizeof(int));
for (i=0; i<CmiNumPes(); i++) {
rankmsg->ranks[i] = 0;
rankmsg->nodes[i] = -1;
}
for (i=0; i<CmiNumPes(); i++) CmiDeliverSpecificMsg(cpuAffinityHandlerIdx);
}
/* receive broadcast from PE 0 */
CmiDeliverSpecificMsg(cpuAffinityRecvHandlerIdx);
CmiLock(affLock);
affinity_doneflag++;
CmiUnlock(affLock);
CmiNodeAllBarrier();
#endif
if (show_affinity_flag) CmiPrintCPUAffinity();
}
void persist_machine_init()
{
persistentSendMsgHandlerIdx =
CmiRegisterHandler((CmiHandler)sendPerMsgHandler);
}
void immediatering_initcall(void) {
// Register converse handlers
immediatering_startHandlerIdx=CmiRegisterHandler(immediatering_startHandler);
immediatering_finishHandlerIdx=CmiRegisterHandler(immediatering_finishHandler);
}
void ringsimple_moduleinit()
{
CpvInitialize(int, ringsimple_hop_index);
CpvAccess(ringsimple_hop_index) = CmiRegisterHandler((CmiHandler)ringsimple_hop);
}
void pingpong_moduleinit(void)
{
int i,j;
pvi(int, numRecv);
pva(numRecv) = 0;
pvi(int, nextIter);
pva(nextIter) = -1;
pvi(int, nextSize);
pva(nextSize) = -1;
pvi(int, nextNbr);
pva(nextNbr) = -1;
pvi(double, starttime);
pva(starttime) = 0.0;
pvi(double, endtime);
pva(endtime) = 0.0;
pvi(int, numSizes);
for(i=0; sizes[i].size != (-1); i++);
pva(numSizes) = i;
pvi(double **, times);
pva(times) = (double **) malloc(CmiNumNodes()*sizeof(double *));
for(i=0;i<CmiNumNodes();i++)
pva(times)[i] = (double *) malloc(pva(numSizes)*sizeof(double));
for(i=0;i<CmiNumNodes();i++)
for(j=0;j<pva(numSizes);j++)
pva(times)[i][j] = 0.0;
pvi(int *, nodeList);
pva(nodeList) = (int *) malloc(CmiNumNodes()*sizeof(int));
for(i=0;i<CmiNumNodes();i++)
pva(nodeList)[i] = CmiNodeFirst(i);
pvi(double *, gavg);
pva(gavg) = (double *) malloc(sizeof(double)*pva(numSizes));
pvi(double *, gmax);
pva(gmax) = (double *) malloc(sizeof(double)*pva(numSizes));
pvi(double *, gmin);
pva(gmin) = (double *) malloc(sizeof(double)*pva(numSizes));
pvi(int *, gmaxSrc);
pva(gmaxSrc) = (int *) malloc(sizeof(int)*pva(numSizes));
pvi(int *, gmaxDest);
pva(gmaxDest) = (int *) malloc(sizeof(int)*pva(numSizes));
pvi(int *, gminSrc);
pva(gminSrc) = (int *) malloc(sizeof(int)*pva(numSizes));
pvi(int *, gminDest);
pva(gminDest) = (int *) malloc(sizeof(int)*pva(numSizes));
for(i=0;i<pva(numSizes);i++) {
pva(gavg)[i] = 0.0;
pva(gmax)[i] = 0.0;
pva(gmin)[i] = 1000000000.0;
pva(gmaxSrc)[i] = 0;
pva(gmaxDest)[i] = 0;
pva(gminSrc)[i] = 0;
pva(gminDest)[i] = 0;
}
pvi(int, timeHandler);
pva(timeHandler) = CmiRegisterHandler((CmiHandler)recvTime);
pvi(int, nodeHandler);
pva(nodeHandler) = CmiRegisterHandler((CmiHandler)startNextNode);
pvi(int, nbrHandler);
pva(nbrHandler) = CmiRegisterHandler((CmiHandler)startNextNbr);
pvi(int, sizeHandler);
pva(sizeHandler) = CmiRegisterHandler((CmiHandler)startNextSize);
pvi(int, iterHandler);
pva(iterHandler) = CmiRegisterHandler((CmiHandler)startNextIter);
pvi(int, bounceHandler);
pva(bounceHandler) = CmiRegisterHandler((CmiHandler)bounceMessage);
pvi(int, setupHandler);
pva(setupHandler) = CmiRegisterHandler((CmiHandler)setupMessage);
pvi(int, startHandler);
pva(startHandler) = CmiRegisterHandler((CmiHandler)startMessage);
}
