00001
00007 #include "InfoStream.h"
00008 #include "ProcessorPrivate.h"
00009
00010
00011 #define MIN_DEBUG_LEVEL 1
00012 #include "Debug.h"
00013
00014 #include "BOCgroup.h"
00015 #include "ComputeMgr.decl.h"
00016 #include "ComputeMgr.h"
00017 #include "ProxyMgr.decl.h"
00018 #include "ProxyMgr.h"
00019
00020 #include "Node.h"
00021 #include "ComputeMap.h"
00022 #include "PatchMap.h"
00023 #include "PatchMap.inl"
00024
00025 #include "Compute.h"
00026 #include "ComputeNonbondedUtil.h"
00027 #include "ComputeNonbondedSelf.h"
00028 #include "ComputeNonbondedPair.h"
00029 #include "ComputeNonbondedCUDA.h"
00030 #include "ComputeAngles.h"
00031 #include "ComputeDihedrals.h"
00032 #include "ComputeImpropers.h"
00033 #include "ComputeCrossterms.h"
00034 #include "ComputeBonds.h"
00035 #include "ComputeNonbondedCUDAExcl.h"
00036 #include "ComputeFullDirect.h"
00037 #include "ComputeGlobal.h"
00038 #include "ComputeGlobalMsgs.h"
00039 #include "ComputeExt.h"
00040 #include "ComputeDPMTA.h"
00041 #include "ComputeDPME.h"
00042 #include "ComputeDPMEMsgs.h"
00043 #include "ComputePme.h"
00044 #include "OptPme.h"
00045 #include "ComputeEwald.h"
00046 #include "ComputeEField.h"
00047
00048 #include "ComputeGridForce.h"
00049
00050 #include "ComputeStir.h"
00051 #include "ComputeSphericalBC.h"
00052 #include "ComputeCylindricalBC.h"
00053 #include "ComputeTclBC.h"
00054 #include "ComputeRestraints.h"
00055 #include "ComputeConsForce.h"
00056 #include "ComputeConsForceMsgs.h"
00057 #include "WorkDistrib.h"
00058
00059
00060 #include "FreeEnergyEnums.h"
00061 #include "FreeEnergyAssert.h"
00062 #include "FreeEnergyGroup.h"
00063 #include "FreeEnergyVector.h"
00064 #include "FreeEnergyRestrain.h"
00065 #include "FreeEnergyRMgr.h"
00066 #include "FreeEnergyLambda.h"
00067 #include "FreeEnergyLambdMgr.h"
00068
00069 #include "GlobalMasterTest.h"
00070 #include "GlobalMasterIMD.h"
00071 #include "GlobalMasterTcl.h"
00072 #include "GlobalMasterSMD.h"
00073 #include "GlobalMasterTMD.h"
00074 #include "GlobalMasterEasy.h"
00075 #include "GlobalMasterMisc.h"
00076 #include "GlobalMasterFreeEnergy.h"
00077 #include "GlobalMasterColvars.h"
00078
00079 ComputeMgr::ComputeMgr()
00080 {
00081 CkpvAccess(BOCclass_group).computeMgr = thisgroup;
00082 computeGlobalObject = 0;
00083 computeDPMEObject = 0;
00084 computeEwaldObject = 0;
00085 computeNonbondedCUDAObject = 0;
00086 computeNonbondedWorkArrays = new ComputeNonbondedWorkArrays;
00087 }
00088
00089 ComputeMgr::~ComputeMgr(void)
00090 {
00091 delete computeNonbondedWorkArrays;
00092 }
00093
00094 void ComputeMgr::updateComputes(int ep, CkGroupID chareID)
00095 {
00096 updateComputesReturnEP = ep;
00097 updateComputesReturnChareID = chareID;
00098 updateComputesCount = CkNumPes();
00099
00100 if (CkMyPe())
00101 {
00102 iout << iPE << iERRORF << "updateComputes signaled on wrong Pe!\n" << endi;
00103 CkExit();
00104 return;
00105 }
00106
00107 CkStartQD(CkIndex_ComputeMgr::updateComputes2((CkQdMsg*)0),&thishandle);
00108 }
00109
00110 void ComputeMgr::updateComputes2(CkQdMsg *msg)
00111 {
00112 delete msg;
00113
00114 CProxy_WorkDistrib wd(CkpvAccess(BOCclass_group).workDistrib);
00115 WorkDistrib *workDistrib = wd.ckLocalBranch();
00116 workDistrib->saveComputeMapChanges(CkIndex_ComputeMgr::updateComputes3(),thisgroup);
00117 }
00118
00119 void ComputeMgr::updateComputes3()
00120 {
00121 CProxy_ComputeMgr(thisgroup).updateLocalComputes();
00122 }
00123
00124 void ComputeMgr::updateLocalComputes()
00125 {
00126 ComputeMap *computeMap = ComputeMap::Object();
00127 CProxy_ProxyMgr pm(CkpvAccess(BOCclass_group).proxyMgr);
00128 ProxyMgr *proxyMgr = pm.ckLocalBranch();
00129
00130 computeFlag = new int[computeMap->numComputes()];
00131
00132 for (int i=0; i<computeMap->numComputes(); i++)
00133 {
00134 DebugM(3, "updateLocalComputes("<<i<<") curnode="<<computeMap->node(i)
00135 <<" newnode="<<computeMap->newNode(i)<<"\n");
00136 computeFlag[i] = 0;
00137
00138 if (computeMap->newNode(i) == CkMyPe() && computeMap->node(i) != CkMyPe())
00139 {
00140 DebugM(4, "updateLocal - creating new computeID("<<i<<")\n");
00141 computeFlag[i] = 1;
00142 computeMap->setNode(i,computeMap->newNode(i));
00143 for (int n=0; n < computeMap->numPids(i); n++)
00144 {
00145 proxyMgr->createProxy(computeMap->pid(i,n));
00146 }
00147 }
00148 else if (computeMap->node(i) == CkMyPe() &&
00149 (computeMap->newNode(i) != -1 && computeMap->newNode(i) != CkMyPe() ))
00150 {
00151 DebugM(4, "updateLocal - deleting computeID("<<i<<")\n");
00152 computeFlag[i] = -1;
00153 computeMap->setNode(i,computeMap->newNode(i));
00154 }
00155 else if (computeMap->newNode(i) != -1)
00156 {
00157 computeMap->setNode(i,computeMap->newNode(i));
00158 }
00159 computeMap->setNewNode(i,-1);
00160 }
00161
00162 if (!CkMyPe())
00163 {
00164 CkStartQD(CkIndex_ComputeMgr::updateLocalComputes2((CkQdMsg*)0), &thishandle);
00165 }
00166 }
00167
00168 void
00169 ComputeMgr::updateLocalComputes2(CkQdMsg *msg)
00170 {
00171 delete msg;
00172 CProxy_ComputeMgr(thisgroup).updateLocalComputes3();
00173 }
00174
00175 void
00176 ComputeMgr::updateLocalComputes3()
00177 {
00178 ComputeMap *computeMap = ComputeMap::Object();
00179 CProxy_ProxyMgr pm(CkpvAccess(BOCclass_group).proxyMgr);
00180 ProxyMgr *proxyMgr = pm.ckLocalBranch();
00181
00182 ProxyMgr::nodecount = 0;
00183
00184 for (int i=0; i<computeMap->numComputes(); i++)
00185 {
00186 if (1 == computeFlag[i])
00187 {
00188 DebugM(4, "updateLocalCompute3() - create computeID(" << i << ")\n");
00189 createCompute(i, computeMap);
00190 }
00191 else if (-1 == computeFlag[i])
00192 {
00193
00194 DebugM(4, "updateLocalCompute3() - delete computeID(" << i << ")\n");
00195 delete computeMap->compute(i);
00196 computeMap->registerCompute(i,NULL);
00197 }
00198 }
00199 delete[] computeFlag;
00200
00201 proxyMgr->removeUnusedProxies();
00202
00203 DebugM(4, "msg to doneUpdateLocalComputes on Pe("<<CkMyPe()<<")\n");
00204 ComputeMap::Object()->checkMap();
00205 PatchMap::Object()->checkMap();
00206
00207 if (!CkMyPe())
00208 {
00209 CkStartQD(CkIndex_ComputeMgr::updateLocalComputes4((CkQdMsg*)0), &thishandle);
00210
00211
00212
00213 }
00214
00215 }
00216
00217 void
00218 ComputeMgr::updateLocalComputes4(CkQdMsg *msg)
00219 {
00220 delete msg;
00221 CProxy_ComputeMgr(thisgroup).updateLocalComputes5();
00222 }
00223
00224 int firstphase = 1;
00225
00226 void
00227 ComputeMgr::updateLocalComputes5()
00228 {
00229
00230
00231 if (proxySendSpanning || proxyRecvSpanning)
00232 ProxyMgr::Object()->buildProxySpanningTree2();
00233
00234
00235
00236
00237 #if 0
00238 if (proxySendSpanning || proxyRecvSpanning)
00239 {
00240 if (firstphase)
00241 ProxyMgr::Object()->buildProxySpanningTree2();
00242 else
00243 if (CkMyPe() == 0)
00244 ProxyMgr::Object()->sendSpanningTrees();
00245
00246 firstphase = 0;
00247 }
00248 #endif
00249
00250 if (!CkMyPe())
00251 CkStartQD(CkIndex_ComputeMgr::doneUpdateLocalComputes(), &thishandle);
00252 }
00253
00254 void ComputeMgr::doneUpdateLocalComputes()
00255 {
00256
00257
00258 DebugM(4, "doneUpdateLocalComputes on Pe("<<CkMyPe()<<")\n");
00259 void *msg = CkAllocMsg(0,0,0);
00260 CkSendMsgBranch(updateComputesReturnEP,msg,0,updateComputesReturnChareID);
00261
00262 }
00263
00264
00265 void
00266 ComputeMgr::createCompute(ComputeID i, ComputeMap *map)
00267 {
00268 Compute *c;
00269 PatchID pid2[2];
00270 PatchIDList pids;
00271 int trans2[2];
00272 SimParameters *simParams = Node::Object()->simParameters;
00273
00274 switch ( map->type(i) )
00275 {
00276 case computeNonbondedSelfType:
00277 c = new ComputeNonbondedSelf(i,map->computeData[i].pids[0].pid,
00278 computeNonbondedWorkArrays,
00279 map->partition(i),map->partition(i)+1,
00280 map->numPartitions(i));
00281 ++numNonbondedSelf;
00282 map->registerCompute(i,c);
00283 c->initialize();
00284 break;
00285 case computeNonbondedPairType:
00286 pid2[0] = map->computeData[i].pids[0].pid;
00287 trans2[0] = map->computeData[i].pids[0].trans;
00288 pid2[1] = map->computeData[i].pids[1].pid;
00289 trans2[1] = map->computeData[i].pids[1].trans;
00290 c = new ComputeNonbondedPair(i,pid2,trans2,
00291 computeNonbondedWorkArrays,
00292 map->partition(i),map->partition(i)+1,
00293 map->numPartitions(i));
00294 ++numNonbondedPair;
00295 map->registerCompute(i,c);
00296 c->initialize();
00297 break;
00298 #ifdef NAMD_CUDA
00299 case computeNonbondedCUDAType:
00300 c = computeNonbondedCUDAObject = new ComputeNonbondedCUDA(i,this);
00301 map->registerCompute(i,c);
00302 c->initialize();
00303 break;
00304 #endif
00305 case computeExclsType:
00306 PatchMap::Object()->basePatchIDList(CkMyPe(),pids);
00307 c = new ComputeExcls(i,pids);
00308 map->registerCompute(i,c);
00309 c->initialize();
00310 break;
00311 case computeBondsType:
00312 PatchMap::Object()->basePatchIDList(CkMyPe(),pids);
00313 c = new ComputeBonds(i,pids);
00314 map->registerCompute(i,c);
00315 c->initialize();
00316 break;
00317 case computeAnglesType:
00318 PatchMap::Object()->basePatchIDList(CkMyPe(),pids);
00319 c = new ComputeAngles(i,pids);
00320 map->registerCompute(i,c);
00321 c->initialize();
00322 break;
00323 case computeDihedralsType:
00324 PatchMap::Object()->basePatchIDList(CkMyPe(),pids);
00325 c = new ComputeDihedrals(i,pids);
00326 map->registerCompute(i,c);
00327 c->initialize();
00328 break;
00329 case computeImpropersType:
00330 PatchMap::Object()->basePatchIDList(CkMyPe(),pids);
00331 c = new ComputeImpropers(i,pids);
00332 map->registerCompute(i,c);
00333 c->initialize();
00334 break;
00335 case computeCrosstermsType:
00336 PatchMap::Object()->basePatchIDList(CkMyPe(),pids);
00337 c = new ComputeCrossterms(i,pids);
00338 map->registerCompute(i,c);
00339 c->initialize();
00340 break;
00341 case computeSelfExclsType:
00342 c = new ComputeSelfExcls(i,map->computeData[i].pids[0].pid);
00343 map->registerCompute(i,c);
00344 c->initialize();
00345 break;
00346 case computeSelfBondsType:
00347 c = new ComputeSelfBonds(i,map->computeData[i].pids[0].pid);
00348 map->registerCompute(i,c);
00349 c->initialize();
00350 break;
00351 case computeSelfAnglesType:
00352 c = new ComputeSelfAngles(i,map->computeData[i].pids[0].pid);
00353 map->registerCompute(i,c);
00354 c->initialize();
00355 break;
00356 case computeSelfDihedralsType:
00357 c = new ComputeSelfDihedrals(i,map->computeData[i].pids[0].pid);
00358 map->registerCompute(i,c);
00359 c->initialize();
00360 break;
00361 case computeSelfImpropersType:
00362 c = new ComputeSelfImpropers(i,map->computeData[i].pids[0].pid);
00363 map->registerCompute(i,c);
00364 c->initialize();
00365 break;
00366 case computeSelfCrosstermsType:
00367 c = new ComputeSelfCrossterms(i,map->computeData[i].pids[0].pid);
00368 map->registerCompute(i,c);
00369 c->initialize();
00370 break;
00371 #ifdef DPMTA
00372 case computeDPMTAType:
00373 c = new ComputeDPMTA(i);
00374 map->registerCompute(i,c);
00375 c->initialize();
00376 break;
00377 #endif
00378 #ifdef DPME
00379 case computeDPMEType:
00380 c = computeDPMEObject = new ComputeDPME(i,this);
00381 map->registerCompute(i,c);
00382 c->initialize();
00383 break;
00384 #endif
00385 case optPmeType:
00386 c = new OptPmeCompute(i);
00387 map->registerCompute(i,c);
00388 c->initialize();
00389 break;
00390 case computePmeType:
00391 c = new ComputePme(i);
00392 map->registerCompute(i,c);
00393 c->initialize();
00394 break;
00395 case computeEwaldType:
00396 c = computeEwaldObject = new ComputeEwald(i,this);
00397 map->registerCompute(i,c);
00398 c->initialize();
00399 break;
00400 case computeFullDirectType:
00401 c = new ComputeFullDirect(i);
00402 map->registerCompute(i,c);
00403 c->initialize();
00404 break;
00405 case computeGlobalType:
00406 c = computeGlobalObject = new ComputeGlobal(i,this);
00407 map->registerCompute(i,c);
00408 c->initialize();
00409 break;
00410 case computeStirType:
00411 c = new ComputeStir(i,map->computeData[i].pids[0].pid);
00412 map->registerCompute(i,c);
00413 c->initialize();
00414 break;
00415 case computeExtType:
00416 c = new ComputeExt(i);
00417 map->registerCompute(i,c);
00418 c->initialize();
00419 break;
00420 case computeEFieldType:
00421 c = new ComputeEField(i,map->computeData[i].pids[0].pid);
00422 map->registerCompute(i,c);
00423 c->initialize();
00424 break;
00425
00426 case computeGridForceType:
00427 c = new ComputeGridForce(i);
00428 map->registerCompute(i,c);
00429 c->initialize();
00430 break;
00431
00432 case computeSphericalBCType:
00433 c = new ComputeSphericalBC(i,map->computeData[i].pids[0].pid);
00434 map->registerCompute(i,c);
00435 c->initialize();
00436 break;
00437 case computeCylindricalBCType:
00438 c = new ComputeCylindricalBC(i,map->computeData[i].pids[0].pid);
00439 map->registerCompute(i,c);
00440 c->initialize();
00441 break;
00442 case computeTclBCType:
00443 c = new ComputeTclBC(i);
00444 map->registerCompute(i,c);
00445 c->initialize();
00446 break;
00447 case computeRestraintsType:
00448 c = new ComputeRestraints(i,map->computeData[i].pids[0].pid);
00449 map->registerCompute(i,c);
00450 c->initialize();
00451 break;
00452 case computeConsForceType:
00453 c = new ComputeConsForce(i,map->computeData[i].pids[0].pid);
00454 map->registerCompute(i,c);
00455 c->initialize();
00456 break;
00457 case computeConsTorqueType:
00458 c = new ComputeConsTorque(i,map->computeData[i].pids[0].pid);
00459 map->registerCompute(i,c);
00460 c->initialize();
00461 break;
00462 default:
00463 NAMD_bug("Unknown compute type in ComputeMgr::createCompute().");
00464 break;
00465 }
00466 }
00467
00468 void registerUserEventsForAllComputeObjs()
00469 {
00470 #ifdef TRACE_COMPUTE_OBJECTS
00471 ComputeMap *map = ComputeMap::Object();
00472 char user_des[50];
00473 for (int i=0; i<map->numComputes(); i++)
00474 {
00475 memset(user_des, 0, 50);
00476 switch ( map->type(i) )
00477 {
00478 case computeNonbondedSelfType:
00479 sprintf(user_des, "computeNonBondedSelfType_%d", i);
00480 break;
00481 case computeNonbondedPairType:
00482 sprintf(user_des, "computeNonBondedPairType_%d", i);
00483 break;
00484 case computeExclsType:
00485 sprintf(user_des, "computeExclsType_%d", i);
00486 break;
00487 case computeBondsType:
00488 sprintf(user_des, "computeBondsType_%d", i);
00489 break;
00490 case computeAnglesType:
00491 sprintf(user_des, "computeAnglesType_%d", i);
00492 break;
00493 case computeDihedralsType:
00494 sprintf(user_des, "computeDihedralsType_%d", i);
00495 break;
00496 case computeImpropersType:
00497 sprintf(user_des, "computeImpropersType_%d", i);
00498 break;
00499 case computeCrosstermsType:
00500 sprintf(user_des, "computeCrosstermsType_%d", i);
00501 break;
00502 case computeSelfExclsType:
00503 sprintf(user_des, "computeSelfExclsType_%d", i);
00504 break;
00505 case computeSelfBondsType:
00506 sprintf(user_des, "computeSelfBondsType_%d", i);
00507 break;
00508 case computeSelfAnglesType:
00509 sprintf(user_des, "computeSelfAnglesType_%d", i);
00510 break;
00511 case computeSelfDihedralsType:
00512 sprintf(user_des, "computeSelfDihedralsType_%d", i);
00513 break;
00514 case computeSelfImpropersType:
00515 sprintf(user_des, "computeSelfImpropersType_%d", i);
00516 break;
00517 case computeSelfCrosstermsType:
00518 sprintf(user_des, "computeSelfCrosstermsType_%d", i);
00519 break;
00520 #ifdef DPMTA
00521 case computeDPMTAType:
00522 sprintf(user_des, "computeDPMTAType_%d", i);
00523 break;
00524 #endif
00525 #ifdef DPME
00526 case computeDPMEType:
00527 sprintf(user_des, "computeDPMEType_%d", i);
00528 break;
00529 #endif
00530 case computePmeType:
00531 sprintf(user_des, "computePMEType_%d", i);
00532 break;
00533 case computeEwaldType:
00534 sprintf(user_des, "computeEwaldType_%d", i);
00535 break;
00536 case computeFullDirectType:
00537 sprintf(user_des, "computeFullDirectType_%d", i);
00538 break;
00539 case computeGlobalType:
00540 sprintf(user_des, "computeGlobalType_%d", i);
00541 break;
00542 case computeStirType:
00543 sprintf(user_des, "computeStirType_%d", i);
00544 break;
00545 case computeExtType:
00546 sprintf(user_des, "computeExtType_%d", i);
00547 break;
00548 case computeEFieldType:
00549 sprintf(user_des, "computeEFieldType_%d", i);
00550 break;
00551
00552 case computeGridForceType:
00553 sprintf(user_des, "computeGridForceType_%d", i);
00554 break;
00555
00556 case computeSphericalBCType:
00557 sprintf(user_des, "computeSphericalBCType_%d", i);
00558 break;
00559 case computeCylindricalBCType:
00560 sprintf(user_des, "computeCylindricalBCType_%d", i);
00561 break;
00562 case computeTclBCType:
00563 sprintf(user_des, "computeTclBCType_%d", i);
00564 break;
00565 case computeRestraintsType:
00566 sprintf(user_des, "computeRestraintsType_%d", i);
00567 break;
00568 case computeConsForceType:
00569 sprintf(user_des, "computeConsForceType_%d", i);
00570 break;
00571 case computeConsTorqueType:
00572 sprintf(user_des, "computeConsTorqueType_%d", i);
00573 break;
00574 default:
00575 NAMD_bug("Unknown compute type in ComputeMgr::registerUserEventForAllComputeObjs().");
00576 break;
00577 }
00578 int user_des_len = strlen(user_des);
00579 char *user_des_cst = new char[user_des_len+1];
00580 memcpy(user_des_cst, user_des, user_des_len);
00581 user_des_cst[user_des_len] = 0;
00582
00583
00584
00585
00586 int reEvenId = traceRegisterUserEvent(user_des_cst, TRACE_COMPOBJ_IDOFFSET+i);
00587
00588 }
00589 #else
00590 return;
00591 #endif
00592 }
00593
00594 void
00595 ComputeMgr::createComputes(ComputeMap *map)
00596 {
00597 Node *node = Node::Object();
00598 SimParameters *simParams = node->simParameters;
00599 int myNode = node->myid();
00600
00601 numNonbondedSelf = 0;
00602 numNonbondedPair = 0;
00603 ComputeNonbondedUtil::select();
00604
00605 if ( simParams->globalForcesOn && !myNode )
00606 {
00607 DebugM(4,"Mgr running on Node "<<CkMyPe()<<"\n");
00608
00609 masterServerObject = new GlobalMasterServer(this,
00610 PatchMap::Object()->numNodesWithPatches());
00611
00612
00613
00614 if (simParams->tclForcesOn)
00615 masterServerObject->addClient(new GlobalMasterTcl());
00616 if (simParams->IMDon)
00617 masterServerObject->addClient(new GlobalMasterIMD());
00618
00619 if (simParams->SMDOn)
00620 masterServerObject->addClient(
00621 new GlobalMasterSMD(simParams->SMDk, simParams->SMDk2,
00622 simParams->SMDVel,
00623 simParams->SMDDir, simParams->SMDOutputFreq,
00624 simParams->firstTimestep, simParams->SMDFile,
00625 node->molecule->numAtoms)
00626 );
00627 if (simParams->TMDOn)
00628 masterServerObject->addClient(new GlobalMasterTMD());
00629 if (simParams->miscForcesOn)
00630 masterServerObject->addClient(new GlobalMasterMisc());
00631 if ( simParams->freeEnergyOn )
00632 masterServerObject->addClient(new GlobalMasterFreeEnergy());
00633 if ( simParams->colvarsOn )
00634 masterServerObject->addClient(new GlobalMasterColvars());
00635
00636 }
00637
00638 for (int i=0; i < map->nComputes; i++)
00639 {
00640 if ( ! ( i % 100 ) )
00641 {
00642 }
00643 if ( map->computeData[i].node != myNode ) continue;
00644 DebugM(1,"Compute " << i << '\n');
00645 DebugM(1," node = " << map->computeData[i].node << '\n');
00646 DebugM(1," type = " << map->computeData[i].type << '\n');
00647 DebugM(1," patchBased = " << map->computeData[i].patchBased << '\n');
00648 DebugM(1," numPids = " << map->computeData[i].numPids << '\n');
00649 DebugM(1," numPidsAllocated = " << map->computeData[i].numPidsAllocated << '\n');
00650 for (int j=0; j < map->computeData[i].numPids; j++)
00651 {
00652
00653 if (!((j+1) % 6))
00654 DebugM(1,'\n');
00655 }
00656 DebugM(1,"\n---------------------------------------");
00657 DebugM(1,"---------------------------------------\n");
00658
00659 createCompute(i, map);
00660
00661 }
00662
00663 }
00664
00665
00666 void ComputeMgr:: sendComputeGlobalConfig(ComputeGlobalConfigMsg *msg)
00667 {
00668 (CProxy_ComputeMgr(CkpvAccess(BOCclass_group).computeMgr)).recvComputeGlobalConfig(msg);
00669 }
00670
00671 void ComputeMgr:: recvComputeGlobalConfig(ComputeGlobalConfigMsg *msg)
00672 {
00673 if ( computeGlobalObject )
00674 {
00675 computeGlobalObject->recvConfig(msg);
00676 }
00677 else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
00678 else NAMD_die("ComputeMgr::computeGlobalObject is NULL!");
00679 }
00680
00681 void ComputeMgr:: sendComputeGlobalData(ComputeGlobalDataMsg *msg)
00682 {
00683 CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
00684 cm[0].recvComputeGlobalData(msg);
00685 }
00686
00687 void ComputeMgr:: recvComputeGlobalData(ComputeGlobalDataMsg *msg)
00688 {
00689 if (masterServerObject)
00690 {
00691 masterServerObject->recvData(msg);
00692 }
00693 else NAMD_die("ComputeMgr::masterServerObject is NULL!");
00694 }
00695
00696 void ComputeMgr:: sendComputeGlobalResults(ComputeGlobalResultsMsg *msg)
00697 {
00698 (CProxy_ComputeMgr(CkpvAccess(BOCclass_group).computeMgr)).recvComputeGlobalResults(msg);
00699 }
00700
00701 void ComputeMgr:: recvComputeGlobalResults(ComputeGlobalResultsMsg *msg)
00702 {
00703 if ( computeGlobalObject )
00704 {
00705 computeGlobalObject->recvResults(msg);
00706 }
00707 else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
00708 else NAMD_die("ComputeMgr::computeGlobalObject is NULL!");
00709 }
00710
00711
00712
00713
00714 void ComputeMgr:: sendComputeEwaldData(ComputeEwaldMsg *msg)
00715 {
00716 if (computeEwaldObject)
00717 {
00718 int node = computeEwaldObject->getMasterNode();
00719 CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
00720 cm[node].recvComputeEwaldData(msg);
00721 }
00722 else if (!PatchMap::Object()->numHomePatches())
00723 {
00724 CkPrintf("skipping message on Pe(%d)\n", CkMyPe());
00725 delete msg;
00726 }
00727 else NAMD_die("ComputeMgr::computeEwaldObject is NULL!");
00728 }
00729
00730 void ComputeMgr:: recvComputeEwaldData(ComputeEwaldMsg *msg)
00731 {
00732 if (computeEwaldObject)
00733 computeEwaldObject->recvData(msg);
00734 else NAMD_die("ComputeMgr::computeEwaldObject in recvData is NULL!");
00735 }
00736
00737 void ComputeMgr:: sendComputeEwaldResults(ComputeEwaldMsg *msg)
00738 {
00739 (CProxy_ComputeMgr(CkpvAccess(BOCclass_group).computeMgr)).recvComputeEwaldResults(msg);
00740 }
00741
00742 void ComputeMgr::recvComputeEwaldResults(ComputeEwaldMsg *msg)
00743 {
00744 if (computeEwaldObject)
00745 computeEwaldObject->recvResults(msg);
00746 else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
00747 else NAMD_die("ComputeMgr::computeEwaldObject in recvResults is NULL!");
00748 }
00749
00750 void ComputeMgr:: sendComputeDPMEData(ComputeDPMEDataMsg *msg)
00751 {
00752 if ( computeDPMEObject )
00753 {
00754 #ifdef DPME
00755 int node = computeDPMEObject->getMasterNode();
00756 CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
00757 cm.recvComputeDPMEData(msg,node);
00758 #endif
00759 }
00760 else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
00761 else NAMD_die("ComputeMgr::computeDPMEObject is NULL!");
00762 }
00763
00764 void ComputeMgr:: recvComputeDPMEData(ComputeDPMEDataMsg *msg)
00765 {
00766 if ( computeDPMEObject )
00767 {
00768 #ifdef DPME
00769 computeDPMEObject->recvData(msg);
00770 #endif
00771 }
00772 else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
00773 else NAMD_die("ComputeMgr::computeDPMEObject is NULL!");
00774 }
00775
00776 void ComputeMgr:: sendComputeDPMEResults(ComputeDPMEResultsMsg *msg, int node)
00777 {
00778 CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
00779 cm[node].recvComputeDPMEResults(msg);
00780 }
00781
00782 void ComputeMgr:: recvComputeDPMEResults(ComputeDPMEResultsMsg *msg)
00783 {
00784 if ( computeDPMEObject )
00785 {
00786 #ifdef DPME
00787 computeDPMEObject->recvResults(msg);
00788 #endif
00789 }
00790 else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
00791 else NAMD_die("ComputeMgr::computeDPMEObject is NULL!");
00792 }
00793
00794 void ComputeMgr::recvComputeConsForceMsg(ComputeConsForceMsg *msg)
00795 {
00796 Molecule *m = Node::Object()->molecule;
00797 delete [] m->consForceIndexes;
00798 delete [] m->consForce;
00799 int n = msg->aid.size();
00800 if (n > 0)
00801 {
00802 m->consForceIndexes = new int32[m->numAtoms];
00803 m->consForce = new Vector[n];
00804 int i;
00805 for (i=0; i<m->numAtoms; i++) m->consForceIndexes[i] = -1;
00806 for (i=0; i<msg->aid.size(); i++)
00807 {
00808 m->consForceIndexes[msg->aid[i]] = i;
00809 m->consForce[i] = msg->f[i];
00810 }
00811 }
00812 else
00813 {
00814 m->consForceIndexes = NULL;
00815 m->consForce = NULL;
00816 }
00817 delete msg;
00818 }
00819
00820 void ComputeMgr::sendYieldDevice(int pe) {
00821 CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
00822 cm[pe].recvYieldDevice(CkMyPe());
00823 }
00824
00825 void ComputeMgr::recvYieldDevice(int pe) {
00826 #ifdef NAMD_CUDA
00827 computeNonbondedCUDAObject->recvYieldDevice(pe);
00828 #endif
00829 }
00830
00831 #include "ComputeMgr.def.h"
00832