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