static void startNextNbr(EmptyMsg *msg)
{
EmptyMsg m;
TimeMessage *tm;
int i, size;
//CmiAssert(CmiMyPe()==0);
CmiFree(msg);
pva(nextNbr)++;
if(pva(nextNbr) == CmiMyNode()) {
CmiSetHandler(&m, pva(nbrHandler));
CmiSyncSend(CmiMyPe(), sizeof(EmptyMsg), &m);
return;
}
if(pva(nextNbr) == CmiNumNodes()) {
pva(nextNbr) = -1;
CmiSetHandler(&m, pva(nodeHandler));
CmiSyncSend(CmiMyPe(), sizeof(EmptyMsg), &m);
size = sizeof(TimeMessage)+pva(numSizes)*CmiNumNodes()*sizeof(double);
tm = (TimeMessage *) CmiAlloc(size);
for(i=0;i<CmiNumNodes();i++)
memcpy(tm->data+i*pva(numSizes),pva(times)[i],
sizeof(double)*pva(numSizes));
tm->srcNode = CmiMyNode();
CmiSetHandler(tm, pva(timeHandler));
CmiSyncSendAndFree(0, size, tm);
} else {
CmiSetHandler(&m, pva(sizeHandler));
CmiSyncSend(CmiMyPe(), sizeof(EmptyMsg), &m);
}
}
static void SendSpanningChildren(int size, char *msg, int rankToAssign, int startNode) {
#if CMK_BROADCAST_SPANNING_TREE
int i, oldRank;
char *newmsg;
oldRank = CMI_DEST_RANK(msg);
/* doing this is to avoid the multiple assignment in the following for loop */
CMI_DEST_RANK(msg) = rankToAssign;
/* first send msgs to other nodes */
CmiAssert(startNode >=0 && startNode<CmiNumNodes());
for (i=1; i<=BROADCAST_SPANNING_FACTOR; i++) {
int nd = CmiMyNode()-startNode;
if (nd<0) nd+=CmiNumNodes();
nd = BROADCAST_SPANNING_FACTOR*nd + i;
if (nd > CmiNumNodes() - 1) break;
nd += startNode;
nd = nd%CmiNumNodes();
CmiAssert(nd>=0 && nd!=CmiMyNode());
#if CMK_BROADCAST_USE_CMIREFERENCE
CmiReference(msg);
CmiSendNetworkFunc(CmiNodeFirst(nd), size, msg, BCAST_SYNC);
#else
newmsg = CopyMsg(msg, size);
CmiSendNetworkFunc(CmiNodeFirst(nd), size, newmsg, BCAST_SYNC);
#endif
}
CMI_DEST_RANK(msg) = oldRank;
#endif
}
void Communicate::sendMessage(int PE, void *msg, int size)
{
if ( CmiMyPe() ) NAMD_bug("Communicate::sendMessage not from Pe 0");
while ( CkpvAccess(CsmAcks) < nchildren ) {
CmiDeliverMsgs(0);
}
CkpvAccess(CsmAcks) = 0;
CmiSetHandler(msg, CsmHandlerIndex);
switch(PE) {
case ALL:
NAMD_bug("Unexpected Communicate::sendMessage(ALL,...)");
//CmiSyncBroadcastAll(size, (char *)msg);
break;
case ALLBUTME:
//CmiSyncBroadcast(size, (char *)msg);
if ( CmiNumNodes() > 2 ) {
CmiSyncSend(CmiNodeFirst(2),size,(char*)msg);
}
if ( CmiNumNodes() > 1 ) {
CmiSyncSend(CmiNodeFirst(1),size,(char*)msg);
}
break;
default:
NAMD_bug("Unexpected Communicate::sendMessage(PEL,...)");
//CmiSyncSend(PE, size, (char *)msg);
break;
}
}
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;
}
void *Communicate::getMessage(int PE, int tag)
{
if ( CmiMyRank() ) NAMD_bug("Communicate::getMessage called on non-rank-zero Pe\n");
int itag[2], rtag[2];
void *msg;
itag[0] = (PE==(-1)) ? (CmmWildCard) : PE;
itag[1] = (tag==(-1)) ? (CmmWildCard) : tag;
while((msg=CmmGet(CkpvAccess(CsmMessages),2,itag,rtag))==0) {
CmiDeliverMsgs(0);
}
char *ackmsg = (char *) CmiAlloc(CmiMsgHeaderSizeBytes);
CmiSetHandler(ackmsg, CsmAckHandlerIndex);
CmiSyncSend(CmiNodeFirst((CmiMyNode()-1)/2), CmiMsgHeaderSizeBytes, ackmsg);
while ( CkpvAccess(CsmAcks) < nchildren ) {
CmiDeliverMsgs(0);
}
CkpvAccess(CsmAcks) = 0;
int size = SIZEFIELD(msg);
for ( int i = 2; i >= 1; --i ) {
int node = CmiMyNode() * 2 + i;
if ( node < CmiNumNodes() ) {
CmiSyncSend(CmiNodeFirst(node),size,(char*)msg);
}
}
return msg;
}
void BGQTorusManager::populateLocalNodes() {
if(CmiNumPartitions() == 1) return;
CmiLock(bgq_lock);
if(bgq_isLocalSet) {
CmiUnlock(bgq_lock);
return;
}
if(bgq_localNodes == NULL)
bgq_localNodes = (int *)malloc(CmiNumNodesGlobal()*sizeof(int));
CmiAssert(bgq_localNodes != NULL);
for(int i = 0; i < CmiNumNodesGlobal(); i++)
bgq_localNodes[i] = -1;
for(int i = 0; i < CmiNumNodes(); i++) {
int a, b, c, d, e, t;
int global;
rankToCoordinates(CmiNodeFirst(i), a, b, c, d, e, t);
global = CmiNodeOf(coordinatesToRank(a, b, c, d, e, t));
bgq_localNodes[global] = i;
}
bgq_isLocalSet = 1;
CmiUnlock(bgq_lock);
}
static void SendHyperCube(int size, char *msg, int rankToAssign, int startNode) {
#if CMK_BROADCAST_HYPERCUBE
int i, cnt, tmp, relDist, oldRank;
const int dims=CmiNodesDim;
oldRank = CMI_DEST_RANK(msg);
/* doing this is to avoid the multiple assignment in the following for loop */
CMI_DEST_RANK(msg) = rankToAssign;
/* first send msgs to other nodes */
relDist = CmiMyNode()-startNode;
if (relDist < 0) relDist += CmiNumNodes();
/* Sending scheme example: say we have 9 nodes, and the msg is sent from 0
* The overall sending steps will be as follows:
* 0-->8, 0-->4, 0-->2, 0-->1
* 4-->6, 4-->5
* 2-->3
* 6-->7
* So for node id as N=A+2^B, it will forward the broadcast (B-1) msg to in
* the order as: N+2^(B-1), N+2^(B-2),..., N+1 except node 0, where B is
* the first position of bit 1 in the binary format of the number of N
* counting from the right with count starting from 0.
* On node 0, the value "B" should be CmiNodesDim
*/
/* Calculate 2^B */
if(relDist==0) cnt = 1<<dims;
else cnt = relDist & ((~relDist)+1);
/*CmiPrintf("ND[%d]: send bcast msg with cnt=%d\n", CmiMyNode(), cnt);*/
/* Begin to send msgs */
for(cnt>>=1; cnt>0; cnt>>=1){
int nd = relDist + cnt;
if (nd >= CmiNumNodes()) continue;
nd = (nd+startNode)%CmiNumNodes();
/*CmiPrintf("ND[%d]: send to node %d\n", CmiMyNode(), nd);*/
CmiAssert(nd>=0 && nd!=CmiMyNode());
#if CMK_BROADCAST_USE_CMIREFERENCE
CmiReference(msg);
CmiSendNetworkFunc(CmiNodeFirst(nd), size, msg, BCAST_SYNC);
#else
char *newmsg = CopyMsg(msg, size);
CmiSendNetworkFunc(CmiNodeFirst(nd), size, newmsg, BCAST_SYNC);
#endif
}
CMI_DEST_RANK(msg) = oldRank;
#endif
}
void CmiSyncNodeBroadcastFn(int size, char *msg) {
int mynode = CmiMyNode();
int i;
CQdCreate(CpvAccess(cQdState), CmiNumNodes()-1);
#if CMK_BROADCAST_SPANNING_TREE
CMI_SET_BROADCAST_ROOT(msg, -CmiMyNode()-1);
SendSpanningChildrenNode(size, msg);
#elif CMK_BROADCAST_HYPERCUBE
CMI_SET_BROADCAST_ROOT(msg, -CmiMyNode()-1);
SendHyperCubeNode(size, msg);
#else
for (i=mynode+1; i<CmiNumNodes(); i++)
CmiSyncNodeSendFn(i, size, msg);
for (i=0; i<mynode; i++)
CmiSyncNodeSendFn(i, size, msg);
#endif
}
static void startNextNode(EmptyMsg *msg)
{
EmptyMsg m;
CmiFree(msg);
if((CmiMyNode()+1) != CmiNumNodes()) {
CmiSetHandler(&m, pva(nbrHandler));
CmiSyncSend(pva(nodeList)[CmiMyNode()+1], sizeof(EmptyMsg), &m);
}
}
static void recvTime(TimeMessage *msg)
{
EmptyMsg m;
int i, j;
double time;
pva(numRecv)++;
for(i=0;i<CmiNumNodes();i++) {
if(i==msg->srcNode)
continue;
for(j=0;j<pva(numSizes);j++) {
time = *(msg->data+i*pva(numSizes)+j);
pva(gavg)[j] += time;
if(time > pva(gmax)[j]) {
pva(gmax)[j] = time;
pva(gmaxSrc)[j] = msg->srcNode;
pva(gmaxDest)[j] = i;
}
if(time < pva(gmin)[j]) {
pva(gmin)[j] = time;
pva(gminSrc)[j] = msg->srcNode;
pva(gminDest)[j] = i;
}
}
}
if(pva(numRecv)==CmiNumNodes()){
for(j=0;j<pva(numSizes);j++)
pva(gavg)[j] /= (CmiNumNodes()*(CmiNumNodes()-1));
for(j=0;j<pva(numSizes);j++) {
CmiPrintf("%d\t\t%le\n",
sizes[j].size, pva(gavg)[j]);
//CmiPrintf("[pingpong] size=%d\tmaxTime=%le seconds\t[%d->%d]\n",
// sizes[j].size, pva(gmax)[j],pva(gmaxSrc)[j],pva(gmaxDest)[j]);
//CmiPrintf("[pingpong] size=%d\tminTime=%le seconds\t[%d->%d]\n",
// sizes[j].size, pva(gmin)[j],pva(gminSrc)[j],pva(gminDest)[j]);
}
CmiSetHandler(&m, pva(ack_handler));
CmiSyncSend(0, sizeof(EmptyMsg), &m);
}
CmiFree(msg);
}
void CmiSyncBroadcastFn(int size, char *msg) {
void *newmsg = msg;
#if CMK_BROADCAST_SPANNING_TREE && CMK_BROADCAST_USE_CMIREFERENCE
/* need to copy the msg in case the msg is on the stack */
/* and we only need to copy when sending out network */
if (CmiNumNodes()>1) newmsg = CopyMsg(msg, size);
#endif
CmiSyncBroadcastFn1(size, newmsg);
#if CMK_BROADCAST_SPANNING_TREE && CMK_BROADCAST_USE_CMIREFERENCE
if (newmsg != msg) CmiFree(newmsg);
#endif
}
void ccs_getinfo(char *msg)
{
int nNode=CmiNumNodes();
int len=(1+nNode)*sizeof(ChMessageInt_t);
ChMessageInt_t *table=(ChMessageInt_t *)malloc(len);
int n;
table[0]=ChMessageInt_new(nNode);
for (n=0;n<nNode;n++)
table[1+n]=ChMessageInt_new(CmiNodeSize(n));
CcsSendReply(len,(const char *)table);
free(table);
CmiFree(msg);
}
CmiCommHandle CmiAsyncNodeBroadcastFn(int size, char *msg) {
int i;
#if ENABLE_CONVERSE_QD
CQdCreate(CpvAccess(cQdState), CmiNumNodes()-1);
#endif
MACHSTATE1(3,"[%d] Sending async node broadcast message from {",CmiMyNode());
CMI_BROADCAST_ROOT(msg) = 0;
CMI_DEST_RANK(msg) =DGRAM_NODEMESSAGE;
void *handle = malloc(sizeof(int));
*((int *)handle) = CmiNumNodes()-1;
for (i=CmiMyNode()+1; i<CmiNumNodes(); i++) {
lapiSendFn(i, size, msg, DeliveredMsg, handle);
}
for (i=0; i<CmiMyNode(); i++) {
lapiSendFn(i, size, msg, DeliveredMsg, handle);
}
MACHSTATE(3,"} Sending async broadcast message end");
return handle;
}
void CmiFreeBroadcastAllFn(int size, char *msg) {
CmiSyncBroadcastFn1(size, msg);
#if CMK_BROADCAST_SPANNING_TREE && CMK_BROADCAST_USE_CMIREFERENCE
/* need to copy the msg in case the msg is on the stack */
/* and we only need to copy when sending out network */
if (CmiNumNodes()>1 && CmiGetReference(msg)>1) {
void *newmsg = CopyMsg(msg, size);
CmiFree(msg);
msg = newmsg;
}
#endif
CmiSendSelf(msg);
}
void pingpong_init(void)
{
EmptyMsg m;
if(CmiNumNodes()==1) {
CmiPrintf("[pingpong] This benchmark requires > 1 nodes.\n");
CmiSetHandler(&m, pva(ack_handler));
CmiSyncSend(0, sizeof(EmptyMsg), &m);
return;
}
CmiSetHandler(&m, pva(nbrHandler));
CmiSyncSend(0, sizeof(EmptyMsg), &m);
}
void printNetStatistics(void)
{
char tmpstr[1024];
OtherNode myNode;
int i;
unsigned int send_pkt=0, resend_pkt=0, recv_pkt=0, send_ack=0;
unsigned int recv_ack=0, ack_pkts=0;
myNode = nodes+CmiMyNode();
sprintf(tmpstr, "***********************************\n");
strcpy(statstr, tmpstr);
sprintf(tmpstr, "Net Statistics For Node %u\n", CmiMyNode());
strcat(statstr, tmpstr);
sprintf(tmpstr, "Interrupts: %u \tProcessed: %u\n",
myNode->stat_total_intr, myNode->stat_proc_intr);
strcat(statstr, tmpstr);
sprintf(tmpstr, "Total Msgs Sent: %u \tTotal Bytes Sent: %u\n",
myNode->sent_msgs, myNode->sent_bytes);
strcat(statstr, tmpstr);
sprintf(tmpstr, "Total Msgs Recv: %u \tTotal Bytes Recv: %u\n",
myNode->recd_msgs, myNode->recd_bytes);
strcat(statstr, tmpstr);
sprintf(tmpstr, "***********************************\n");
strcat(statstr, tmpstr);
sprintf(tmpstr, "[Num]\tSENDTO\tRESEND\tRECV\tACKSTO\tACKSFRM\tPKTACK\n");
strcat(statstr,tmpstr);
sprintf(tmpstr, "=====\t======\t======\t====\t======\t=======\t======\n");
strcat(statstr,tmpstr);
for(i=0;i<CmiNumNodes();i++) {
OtherNode node = nodes+i;
sprintf(tmpstr, "[%u]\t%u\t%u\t%u\t%u\t%u\t%u\n",
i, node->stat_send_pkt, node->stat_resend_pkt,
node->stat_recv_pkt, node->stat_send_ack,
node->stat_recv_ack, node->stat_ack_pkts);
strcat(statstr, tmpstr);
send_pkt += node->stat_send_pkt;
recv_pkt += node->stat_recv_pkt;
resend_pkt += node->stat_resend_pkt;
send_ack += node->stat_send_ack;
recv_ack += node->stat_recv_ack;
ack_pkts += node->stat_ack_pkts;
}
sprintf(tmpstr, "[TOTAL]\t%u\t%u\t%u\t%u\t%u\t%u\n",
send_pkt, resend_pkt,
recv_pkt, send_ack,
recv_ack, ack_pkts);
strcat(statstr, tmpstr);
sprintf(tmpstr, "***********************************\n");
strcat(statstr, tmpstr);
CmiPrintf(statstr);
}
static void initMsgOrderInfo(MsgOrderInfo *info) {
int i;
int totalPEs = CmiNumPes();
#if CMK_SMP && CMK_OFFLOAD_BCAST_PROCESS
/* the comm thread will also access such info */
totalPEs += CmiNumNodes();
#endif
info->nextMsgSeqNo = malloc(totalPEs*sizeof(int));
memset(info->nextMsgSeqNo, 0, totalPEs*sizeof(int));
info->expectedMsgSeqNo = malloc(totalPEs*sizeof(int));
memset(info->expectedMsgSeqNo, 0, totalPEs*sizeof(int));
info->oooMsgBuffer = malloc(totalPEs*sizeof(void **));
memset(info->oooMsgBuffer, 0, totalPEs*sizeof(void **));
info->oooMaxOffset = malloc(totalPEs*sizeof(unsigned char));
memset(info->oooMaxOffset, 0, totalPEs*sizeof(unsigned char));
info->CUR_WINDOW_SIZE = malloc(totalPEs*sizeof(unsigned char));
for (i=0; i<totalPEs; i++) info->CUR_WINDOW_SIZE[i] = INIT_WINDOW_SIZE;
}
static INLINE_KEYWORD void processProcBcastMsg(int size, char *msg) {
/* Since this function is only called on intermediate nodes,
* the rank of this msg should be 0.
*/
CmiAssert(CMI_DEST_RANK(msg)==0);
/*CmiPushPE(CMI_DEST_RANK(msg), msg);*/
#if CMK_BROADCAST_SPANNING_TREE
SendSpanningChildrenProc(size, msg);
#elif CMK_BROADCAST_HYPERCUBE
SendHyperCubeProc(size, msg);
#endif
#if CMK_BROADCAST_SPANNING_TREE && CMK_BROADCAST_USE_CMIREFERENCE
/* same message may be sent out, make a copy of it */
if (CmiNumNodes()>1 && CmiGetReference(msg)>1) {
void *newmsg;
newmsg = CopyMsg(msg, size);
CmiFree(msg);
msg = newmsg;
}
#endif
CmiPushPE(0, msg);
}
void TorusLB::strategy() {
int index;
// compute the average load by (compute load + background load) / numPesAvailable
computeAverage();
// two heaps of self and pair computes
makeTwoHeaps();
const int beginGroup = processors[0].Id;
const int endGroup = beginGroup + P;
#define INGROUP(PROC) ((PROC) >= beginGroup && (PROC) < endGroup)
computeInfo *c;
processorInfo *p, *minp;
Iterator nextP;
overLoad = 1.2;
for(int I=0; I<numComputes; I++) {
c = (computeInfo *) computePairHeap->deleteMax();
if ( ! c ) c = (computeInfo *) computeSelfHeap->deleteMax();
if(c->processor != -1) continue; // go to the next compute
if(!c) CkAbort("TorusLB: Compute Heap empty!\n");
for(int j=0; j<6; j++) {
bestPe[j] = 0;
goodPe[j] = 0;
badPe[j] = 0;
}
// Look at pes which have the compute's patches
// HYBRID check if processor is in local group
#define SELECT_REALPE(X) if INGROUP((X)) { \
selectPes(&processors[(X) - beginGroup], c); \
}
const int realPe1 = patches[c->patch1].processor;
SELECT_REALPE(realPe1)
const int realPe2 = patches[c->patch2].processor;
if ( realPe2 != realPe1 ) {
SELECT_REALPE(realPe2)
}
// Try the processors which have the patches' proxies
p = (processorInfo *)(patches[c->patch1].proxiesOn.iterator((Iterator *)&nextP));
while(p) { // patch 1
if INGROUP(p->Id) selectPes(p, c);
p = (processorInfo *)(patches[c->patch1].proxiesOn.next((Iterator *)&nextP));
}
p = (processorInfo *)(patches[c->patch2].proxiesOn.iterator((Iterator *)&nextP));
while(p) { // patch 2
if INGROUP(p->Id) selectPes(p, c);
p = (processorInfo *)(patches[c->patch2].proxiesOn.next((Iterator *)&nextP));
}
// see if we have found a processor to place the compute on
p = 0;
if((p = bestPe[5])
#if USE_TOPOMAP
|| (p = goodPe[5])
#endif
|| (p = bestPe[4])
#if USE_TOPOMAP
|| (p = goodPe[4])
#endif
|| (p = bestPe[3])
#if USE_TOPOMAP
|| (p = goodPe[3])
#endif
|| (p = bestPe[1])
#if USE_TOPOMAP
|| (p = goodPe[1])
#endif
|| (p = bestPe[2])
#if USE_TOPOMAP
|| (p = goodPe[2])
#endif
|| (p = bestPe[0])
#if USE_TOPOMAP
|| (p = goodPe[0])
#endif
) {
assign(c, p);
continue;
}
// Try all pes on the nodes of the home patches
if ( CmiNumNodes() > 1 ) { // else not useful
double minLoad = overLoad * averageLoad;
minp = 0;
int realNode1 = CmiNodeOf(realPe1);
int nodeSize = CmiNodeSize(realNode1);
if ( nodeSize > 1 ) { // else did it already
int firstpe = CmiNodeFirst(realNode1);
for ( int rpe = firstpe; rpe < firstpe+nodeSize; ++rpe ) {
if INGROUP(rpe) {
p = &processors[rpe - beginGroup];
if ( p->available && ( p->load + c->load < minLoad ) ) {
minLoad = p->load + c->load;
minp = p;
}
}
}
}
if ( realPe2 != realPe1 ) {
int realNode2 = CmiNodeOf(realPe2);
if ( realNode2 != realNode1 ) { // else did it already
nodeSize = CmiNodeSize(realNode2);
if ( nodeSize > 1 ) {
int firstpe = CmiNodeFirst(realNode2);
for ( int rpe = firstpe; rpe < firstpe+nodeSize; ++rpe ) {
if INGROUP(rpe) {
p = &processors[rpe - beginGroup];
if ( p->available && ( p->load + c->load < minLoad ) ) {
minLoad = p->load + c->load;
minp = p;
}
}
}
}
main(CkArgMsg *)
{
// print banner
iout << iINFO << "NAMD " << NAMD_VERSION << " for " << NAMD_PLATFORM
<< "\n"
#ifdef MEM_OPT_VERSION
<< iWARN << "\n"
<< iWARN << " *** EXPERIMENTAL MEMORY OPTIMIZED VERSION ***\n"
<< iWARN << "\n"
#endif
#if 0
<< iWARN << "\n"
<< iWARN << " *** UNRELEASED EXPERIMENTAL VERSION ***\n"
<< iWARN << "\n"
#endif
#ifdef SPEC_DISABLED_VERSION
<< iINFO << "\n"
<< iINFO << "NAMD is a parallel, object-oriented molecular dynamics\n"
<< iINFO << "code designed for high-performance simulation of large\n"
<< iINFO << "biomolecular systems. NAMD is distributed free of\n"
<< iINFO << "charge and includes source code. For more information\n"
<< iINFO << "please visit http://www.ks.uiuc.edu/Research/namd/\n"
<< iINFO << "\n"
<< iINFO << "*********************************************************\n"
<< iINFO << "This version of NAMD may be distributed only as a part of\n"
<< iINFO << "the SPEC Workstation Benchmark and all other distribution\n"
<< iINFO << "is prohibited. Any use of this software is bound by\n"
<< iINFO << "the terms of the NAMD License, which is available at\n"
<< iINFO << "http://www.ks.uiuc.edu/Research/namd/license.html\n"
<< iINFO << "The NAMD development team will not provide support for\n"
<< iINFO << "any version of NAMD unless you have first registered\n"
<< iINFO << "and downloaded the latest version of NAMD available at\n"
<< iINFO << "http://www.ks.uiuc.edu/Research/namd/\n"
<< iINFO << "*********************************************************\n"
#else
<< iINFO << "\n"
<< iINFO << "Please visit http://www.ks.uiuc.edu/Research/namd/\n"
<< iINFO << "for updates, documentation, and support information.\n"
#endif
<< iINFO << "\n"
<< iINFO << "Please cite Phillips et al., J. Comp. Chem. 26:1781-1802 (2005)\n"
<< iINFO << "in all publications reporting results obtained with NAMD.\n"
<< iINFO << "\n"
<< endi;
char charm_version[64];
sprintf(charm_version,"%d",CHARM_VERSION);
#if CHARM_VERSION < 60500
#error "Charm++ 6.5.1 or later is required to build NAMD"
#endif
iout << iINFO << "Based on Charm++/Converse " << charm_version
<< " for " << CMK_MACHINE_NAME << "\n" << endi;
iout << iINFO << "Built " << namd_build_date << " by "
<< namd_build_user << " on " << namd_build_machine << "\n"
<< endi;
#ifndef NO_SOCKET
char numcpus[512];
sprintf(numcpus,"%d",CkNumPes());
tbsoft_sendusage("NAMD",NAMD_VERSION,NAMD_PLATFORM,numcpus,"");
#endif
#if CMK_BLUEGENE_CHARM
iout << iINFO << "Running on BigSim using " << CmiNumPes() << " real processors.\n" << endi;
#endif
iout << iINFO << "Running on " << CkNumPes() << " processors, "
<< CmiNumNodes() << " nodes, "
<< CmiNumPhysicalNodes() << " physical nodes.\n" << endi;
iout << iINFO << "CPU topology information " << (CmiCpuTopologyEnabled()?"available":"unavailable") << ".\n" << endi;
iout << iINFO << "Charm++/Converse parallel runtime startup completed at "
<< CmiWallTimer() << " s\n"<< endi;
const char* memsource;
memusage(&memsource);
iout << iINFO << memusage_MB() << " MB of memory in use"
<< " based on " << memsource << "\n";
}
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);
}
