version 1.1132 | version 1.1133 |
---|
| |
return ComputeCUDAMgr::getComputeCUDAMgr()->createCudaComputeNonbonded(c); | return ComputeCUDAMgr::getComputeCUDAMgr()->createCudaComputeNonbonded(c); |
} | } |
| |
| #ifdef BONDED_CUDA |
| ComputeBondedCUDA* getComputeBondedCUDA() { |
| return ComputeCUDAMgr::getComputeCUDAMgr()->getComputeBondedCUDA(); |
| } |
| |
| ComputeBondedCUDA* createComputeBondedCUDA(ComputeID c, ComputeMgr* computeMgr) { |
| return ComputeCUDAMgr::getComputeCUDAMgr()->createComputeBondedCUDA(c, computeMgr); |
| } |
| #endif |
#endif | #endif |
| |
// | // |
| |
c->initialize(); | c->initialize(); |
break; | break; |
#endif | #endif |
| #ifdef NAMD_CUDA |
| #ifdef BONDED_CUDA |
| case computeBondedCUDAType: |
| c = createComputeBondedCUDA(i, this); |
| map->registerCompute(i,c); |
| break; |
| #endif |
| #endif |
case computeExclsType: | case computeExclsType: |
| #if defined(BONDED_CUDA) && defined(NAMD_CUDA) |
| if (simParams->bondedCUDA & 16) |
| { |
| PatchMap::Object()->basePatchIDList(map->computeData[i].node, pids); |
| getComputeBondedCUDA()->registerCompute(map->computeData[i].node, map->type(i), pids); |
| } else |
| #endif |
| { |
PatchMap::Object()->basePatchIDList(CkMyPe(),pids); | PatchMap::Object()->basePatchIDList(CkMyPe(),pids); |
c = new ComputeExcls(i,pids); // unknown delete | c = new ComputeExcls(i,pids); // unknown delete |
map->registerCompute(i,c); | map->registerCompute(i,c); |
c->initialize(); | c->initialize(); |
| } |
break; | break; |
case computeBondsType: | case computeBondsType: |
| #if defined(BONDED_CUDA) && defined(NAMD_CUDA) |
| if (simParams->bondedCUDA & 1) |
| { |
| PatchMap::Object()->basePatchIDList(map->computeData[i].node, pids); |
| getComputeBondedCUDA()->registerCompute(map->computeData[i].node, map->type(i), pids); |
| } else |
| #endif |
| { |
PatchMap::Object()->basePatchIDList(CkMyPe(),pids); | PatchMap::Object()->basePatchIDList(CkMyPe(),pids); |
c = new ComputeBonds(i,pids); // unknown delete | c = new ComputeBonds(i,pids); // unknown delete |
map->registerCompute(i,c); | map->registerCompute(i,c); |
c->initialize(); | c->initialize(); |
| } |
break; | break; |
case computeAnglesType: | case computeAnglesType: |
| #if defined(BONDED_CUDA) && defined(NAMD_CUDA) |
| if (simParams->bondedCUDA & 2) |
| { |
| PatchMap::Object()->basePatchIDList(map->computeData[i].node, pids); |
| getComputeBondedCUDA()->registerCompute(map->computeData[i].node, map->type(i), pids); |
| } else |
| #endif |
| { |
PatchMap::Object()->basePatchIDList(CkMyPe(),pids); | PatchMap::Object()->basePatchIDList(CkMyPe(),pids); |
c = new ComputeAngles(i,pids); // unknown delete | c = new ComputeAngles(i,pids); // unknown delete |
map->registerCompute(i,c); | map->registerCompute(i,c); |
c->initialize(); | c->initialize(); |
| } |
break; | break; |
case computeDihedralsType: | case computeDihedralsType: |
| #if defined(BONDED_CUDA) && defined(NAMD_CUDA) |
| if (simParams->bondedCUDA & 4) |
| { |
| PatchMap::Object()->basePatchIDList(map->computeData[i].node, pids); |
| getComputeBondedCUDA()->registerCompute(map->computeData[i].node, map->type(i), pids); |
| } else |
| #endif |
| { |
PatchMap::Object()->basePatchIDList(CkMyPe(),pids); | PatchMap::Object()->basePatchIDList(CkMyPe(),pids); |
c = new ComputeDihedrals(i,pids); // unknown delete | c = new ComputeDihedrals(i,pids); // unknown delete |
map->registerCompute(i,c); | map->registerCompute(i,c); |
c->initialize(); | c->initialize(); |
| } |
break; | break; |
case computeImpropersType: | case computeImpropersType: |
| #if defined(BONDED_CUDA) && defined(NAMD_CUDA) |
| if (simParams->bondedCUDA & 8) |
| { |
| PatchMap::Object()->basePatchIDList(map->computeData[i].node, pids); |
| getComputeBondedCUDA()->registerCompute(map->computeData[i].node, map->type(i), pids); |
| } else |
| #endif |
| { |
PatchMap::Object()->basePatchIDList(CkMyPe(),pids); | PatchMap::Object()->basePatchIDList(CkMyPe(),pids); |
c = new ComputeImpropers(i,pids); // unknown delete | c = new ComputeImpropers(i,pids); // unknown delete |
map->registerCompute(i,c); | map->registerCompute(i,c); |
c->initialize(); | c->initialize(); |
| } |
break; | break; |
case computeTholeType: | case computeTholeType: |
PatchMap::Object()->basePatchIDList(CkMyPe(),pids); | PatchMap::Object()->basePatchIDList(CkMyPe(),pids); |
| |
c->initialize(); | c->initialize(); |
break; | break; |
case computeCrosstermsType: | case computeCrosstermsType: |
| #if defined(BONDED_CUDA) && defined(NAMD_CUDA) |
| if (simParams->bondedCUDA & 32) |
| { |
| PatchMap::Object()->basePatchIDList(map->computeData[i].node, pids); |
| getComputeBondedCUDA()->registerCompute(map->computeData[i].node, map->type(i), pids); |
| } else |
| #endif |
| { |
PatchMap::Object()->basePatchIDList(CkMyPe(),pids); | PatchMap::Object()->basePatchIDList(CkMyPe(),pids); |
c = new ComputeCrossterms(i,pids); // unknown delete | c = new ComputeCrossterms(i,pids); // unknown delete |
map->registerCompute(i,c); | map->registerCompute(i,c); |
c->initialize(); | c->initialize(); |
| } |
break; | break; |
// JLai | // JLai |
case computeGromacsPairType: | case computeGromacsPairType: |
| |
break; | break; |
// End of JLai | // End of JLai |
case computeSelfExclsType: | case computeSelfExclsType: |
| #if defined(BONDED_CUDA) && defined(NAMD_CUDA) |
| if (simParams->bondedCUDA & 16) |
| { |
| getComputeBondedCUDA()->registerSelfCompute(map->computeData[i].node, map->type(i), map->computeData[i].pids[0].pid); |
| } else |
| #endif |
| { |
c = new ComputeSelfExcls(i,map->computeData[i].pids[0].pid); | c = new ComputeSelfExcls(i,map->computeData[i].pids[0].pid); |
map->registerCompute(i,c); | map->registerCompute(i,c); |
c->initialize(); | c->initialize(); |
| } |
break; | break; |
case computeSelfBondsType: | case computeSelfBondsType: |
| #if defined(BONDED_CUDA) && defined(NAMD_CUDA) |
| if (simParams->bondedCUDA & 1) |
| { |
| getComputeBondedCUDA()->registerSelfCompute(map->computeData[i].node, map->type(i), map->computeData[i].pids[0].pid); |
| } else |
| #endif |
| { |
c = new ComputeSelfBonds(i,map->computeData[i].pids[0].pid); | c = new ComputeSelfBonds(i,map->computeData[i].pids[0].pid); |
map->registerCompute(i,c); | map->registerCompute(i,c); |
c->initialize(); | c->initialize(); |
| } |
break; | break; |
case computeSelfAnglesType: | case computeSelfAnglesType: |
| #if defined(BONDED_CUDA) && defined(NAMD_CUDA) |
| if (simParams->bondedCUDA & 2) |
| { |
| getComputeBondedCUDA()->registerSelfCompute(map->computeData[i].node, map->type(i), map->computeData[i].pids[0].pid); |
| } else |
| #endif |
| { |
c = new ComputeSelfAngles(i,map->computeData[i].pids[0].pid); | c = new ComputeSelfAngles(i,map->computeData[i].pids[0].pid); |
map->registerCompute(i,c); | map->registerCompute(i,c); |
c->initialize(); | c->initialize(); |
| } |
break; | break; |
case computeSelfDihedralsType: | case computeSelfDihedralsType: |
| #if defined(BONDED_CUDA) && defined(NAMD_CUDA) |
| if (simParams->bondedCUDA & 4) |
| { |
| getComputeBondedCUDA()->registerSelfCompute(map->computeData[i].node, map->type(i), map->computeData[i].pids[0].pid); |
| } else |
| #endif |
| { |
c = new ComputeSelfDihedrals(i,map->computeData[i].pids[0].pid); | c = new ComputeSelfDihedrals(i,map->computeData[i].pids[0].pid); |
map->registerCompute(i,c); | map->registerCompute(i,c); |
c->initialize(); | c->initialize(); |
| } |
break; | break; |
case computeSelfImpropersType: | case computeSelfImpropersType: |
| #if defined(BONDED_CUDA) && defined(NAMD_CUDA) |
| if (simParams->bondedCUDA & 8) |
| { |
| getComputeBondedCUDA()->registerSelfCompute(map->computeData[i].node, map->type(i), map->computeData[i].pids[0].pid); |
| } else |
| #endif |
| { |
c = new ComputeSelfImpropers(i,map->computeData[i].pids[0].pid); | c = new ComputeSelfImpropers(i,map->computeData[i].pids[0].pid); |
map->registerCompute(i,c); | map->registerCompute(i,c); |
c->initialize(); | c->initialize(); |
| } |
break; | break; |
case computeSelfTholeType: | case computeSelfTholeType: |
c = new ComputeSelfThole(i,map->computeData[i].pids[0].pid); | c = new ComputeSelfThole(i,map->computeData[i].pids[0].pid); |
| |
c->initialize(); | c->initialize(); |
break; | break; |
case computeSelfCrosstermsType: | case computeSelfCrosstermsType: |
| #if defined(BONDED_CUDA) && defined(NAMD_CUDA) |
| if (simParams->bondedCUDA & 32) |
| { |
| getComputeBondedCUDA()->registerSelfCompute(map->computeData[i].node, map->type(i), map->computeData[i].pids[0].pid); |
| } else |
| #endif |
| { |
c = new ComputeSelfCrossterms(i,map->computeData[i].pids[0].pid); | c = new ComputeSelfCrossterms(i,map->computeData[i].pids[0].pid); |
map->registerCompute(i,c); | map->registerCompute(i,c); |
c->initialize(); | c->initialize(); |
| } |
break; | break; |
#ifdef DPMTA | #ifdef DPMTA |
case computeDPMTAType: | case computeDPMTAType: |
| |
dz = abs(z1-z2); | dz = abs(z1-z2); |
sprintf(user_des, "computeNonBondedPairType_%d(%d,%d,%d)", i, dx,dy,dz); | sprintf(user_des, "computeNonBondedPairType_%d(%d,%d,%d)", i, dx,dy,dz); |
break; | break; |
| #ifdef NAMD_CUDA |
| #ifdef BONDED_CUDA |
| case computeBondedCUDAType: |
| sprintf(user_des, "computeBondedCUDAType_%d", i); |
| break; |
| #endif |
| #endif |
case computeExclsType: | case computeExclsType: |
sprintf(user_des, "computeExclsType_%d", i); | sprintf(user_des, "computeExclsType_%d", i); |
break; | break; |
| |
| |
#ifdef NAMD_CUDA | #ifdef NAMD_CUDA |
bool deviceIsMine = ( deviceCUDA->getMasterPe() == CkMyPe() ); | bool deviceIsMine = ( deviceCUDA->getMasterPe() == CkMyPe() ); |
| #ifdef BONDED_CUDA |
| // Place bonded forces on Pe different from non-bonded forces |
| int bondedMasterPe = deviceCUDA->getMasterPe(); |
| // for (int i=0;i < deviceCUDA->getNumPesSharingDevice();i++) { |
| // int pe = deviceCUDA->getPesSharingDevice(i); |
| // if (pe != deviceCUDA->getMasterPe()) { |
| // bondedMasterPe = pe; |
| // } |
| // } |
| bool deviceIsMineBonded = (CkMyPe() == bondedMasterPe); |
| #endif |
#endif | #endif |
| |
#ifdef NAMD_MIC | #ifdef NAMD_MIC |
| |
if ( ! ( i % 100 ) ) | if ( ! ( i % 100 ) ) |
{ | { |
} | } |
| |
#if defined(NAMD_CUDA) || defined(NAMD_MIC) | #if defined(NAMD_CUDA) || defined(NAMD_MIC) |
switch ( map->type(i) ) | switch ( map->type(i) ) |
{ | { |
| |
// ComputePmeCUDACounter++; | // ComputePmeCUDACounter++; |
// break; | // break; |
case computeNonbondedSelfType: | case computeNonbondedSelfType: |
| if ( ! deviceIsMine ) continue; |
| if ( ! deviceCUDA->device_shared_with_pe(map->computeData[i].node) ) continue; |
| break; |
| |
case computeNonbondedPairType: | case computeNonbondedPairType: |
if ( ! deviceIsMine ) continue; | if ( ! deviceIsMine ) continue; |
if ( ! deviceCUDA->device_shared_with_pe(map->computeData[i].node) ) continue; | if ( ! deviceCUDA->device_shared_with_pe(map->computeData[i].node) ) continue; |
break; | break; |
| |
| #ifdef BONDED_CUDA |
| case computeSelfBondsType: |
| case computeBondsType: |
| if (simParams->bondedCUDA & 1) { |
| if ( ! deviceIsMineBonded ) continue; |
| if ( ! deviceCUDA->device_shared_with_pe(map->computeData[i].node) ) continue; |
| } else { |
| if ( map->computeData[i].node != myNode ) continue; |
| } |
| break; |
| |
| case computeSelfAnglesType: |
| case computeAnglesType: |
| if (simParams->bondedCUDA & 2) { |
| if ( ! deviceIsMineBonded ) continue; |
| if ( ! deviceCUDA->device_shared_with_pe(map->computeData[i].node) ) continue; |
| } else { |
| if ( map->computeData[i].node != myNode ) continue; |
| } |
| break; |
| |
| case computeSelfDihedralsType: |
| case computeDihedralsType: |
| if (simParams->bondedCUDA & 4) { |
| if ( ! deviceIsMineBonded ) continue; |
| if ( ! deviceCUDA->device_shared_with_pe(map->computeData[i].node) ) continue; |
| } else { |
| if ( map->computeData[i].node != myNode ) continue; |
| } |
| break; |
| |
| case computeSelfImpropersType: |
| case computeImpropersType: |
| if (simParams->bondedCUDA & 8) { |
| if ( ! deviceIsMineBonded ) continue; |
| if ( ! deviceCUDA->device_shared_with_pe(map->computeData[i].node) ) continue; |
| } else { |
| if ( map->computeData[i].node != myNode ) continue; |
| } |
| break; |
| |
| case computeSelfExclsType: |
| case computeExclsType: |
| if (simParams->bondedCUDA & 16) { |
| if ( ! deviceIsMineBonded ) continue; |
| if ( ! deviceCUDA->device_shared_with_pe(map->computeData[i].node) ) continue; |
| } else { |
| if ( map->computeData[i].node != myNode ) continue; |
| } |
| break; |
| |
| case computeSelfCrosstermsType: |
| case computeCrosstermsType: |
| if (simParams->bondedCUDA & 32) { |
| if ( ! deviceIsMineBonded ) continue; |
| if ( ! deviceCUDA->device_shared_with_pe(map->computeData[i].node) ) continue; |
| } else { |
| if ( map->computeData[i].node != myNode ) continue; |
| } |
| break; |
| |
| case computeBondedCUDAType: |
| if ( ! deviceIsMineBonded ) continue; |
| if ( map->computeData[i].node != myNode ) continue; |
| break; |
| #endif |
| |
#endif | #endif |
#ifdef NAMD_MIC | #ifdef NAMD_MIC |
| |
| |
case computeNonbondedCUDAType: | case computeNonbondedCUDAType: |
#ifdef NAMD_CUDA | #ifdef NAMD_CUDA |
case computeNonbondedCUDA2Type: | case computeNonbondedCUDA2Type: |
| // #ifdef BONDED_CUDA |
| // case computeBondedCUDAType: |
| // #endif |
#endif | #endif |
case computeNonbondedMICType: | case computeNonbondedMICType: |
if ( ! deviceIsMine ) continue; | if ( ! deviceIsMine ) continue; |
| |
computeNonbondedCUDAObject->assignPatches(); | computeNonbondedCUDAObject->assignPatches(); |
} | } |
} | } |
| #ifdef BONDED_CUDA |
| if (simParams->bondedCUDA) { |
| if (deviceIsMineBonded) { |
| getComputeBondedCUDA()->initialize(); |
| } |
| } |
| #endif |
#endif | #endif |
#ifdef NAMD_MIC | #ifdef NAMD_MIC |
if ( computeNonbondedMICObject ) { | if ( computeNonbondedMICObject ) { |
| |
msg->c->unregisterBoxesOnPe(); | msg->c->unregisterBoxesOnPe(); |
delete msg; | delete msg; |
} | } |
| |
| #ifdef BONDED_CUDA |
| |
| class ComputeBondedCUDAMsg : public CMessage_ComputeBondedCUDAMsg { |
| public: |
| ComputeBondedCUDA* c; |
| int i; |
| }; |
| |
| void ComputeMgr::sendAssignPatchesOnPe(std::vector<int>& pes, ComputeBondedCUDA* c) { |
| for (int i=0;i < pes.size();i++) { |
| ComputeBondedCUDAMsg *msg = new ComputeBondedCUDAMsg; |
| msg->c = c; |
| thisProxy[pes[i]].recvAssignPatchesOnPe(msg); |
| } |
| } |
| |
| void ComputeMgr::recvAssignPatchesOnPe(ComputeBondedCUDAMsg *msg) { |
| msg->c->assignPatchesOnPe(); |
| delete msg; |
| } |
| |
| void ComputeMgr::sendMessageEnqueueWork(int pe, ComputeBondedCUDA* c) { |
| ComputeBondedCUDAMsg *msg = new ComputeBondedCUDAMsg; |
| msg->c = c; |
| thisProxy[pe].recvMessageEnqueueWork(msg); |
| } |
| |
| void ComputeMgr::recvMessageEnqueueWork(ComputeBondedCUDAMsg *msg) { |
| msg->c->messageEnqueueWork(); |
| delete msg; |
| } |
| |
| void ComputeMgr::sendOpenBoxesOnPe(std::vector<int>& pes, ComputeBondedCUDA* c) { |
| for (int i=0;i < pes.size();i++) { |
| ComputeBondedCUDAMsg *msg = new ComputeBondedCUDAMsg; |
| msg->c = c; |
| thisProxy[pes[i]].recvOpenBoxesOnPe(msg); |
| } |
| } |
| |
| void ComputeMgr::recvOpenBoxesOnPe(ComputeBondedCUDAMsg *msg) { |
| msg->c->openBoxesOnPe(); |
| delete msg; |
| } |
| |
| void ComputeMgr::sendLoadTuplesOnPe(std::vector<int>& pes, ComputeBondedCUDA* c) { |
| for (int i=0;i < pes.size();i++) { |
| ComputeBondedCUDAMsg *msg = new ComputeBondedCUDAMsg; |
| msg->c = c; |
| thisProxy[pes[i]].recvLoadTuplesOnPe(msg); |
| } |
| } |
| |
| void ComputeMgr::recvLoadTuplesOnPe(ComputeBondedCUDAMsg *msg) { |
| msg->c->loadTuplesOnPe(); |
| delete msg; |
| } |
| |
| void ComputeMgr::sendLaunchWork(int pe, ComputeBondedCUDA* c) { |
| ComputeBondedCUDAMsg *msg = new ComputeBondedCUDAMsg; |
| msg->c = c; |
| thisProxy[pe].recvLaunchWork(msg); |
| } |
| |
| void ComputeMgr::recvLaunchWork(ComputeBondedCUDAMsg *msg) { |
| msg->c->launchWork(); |
| delete msg; |
| } |
| |
| void ComputeMgr::sendFinishPatchesOnPe(std::vector<int>& pes, ComputeBondedCUDA* c) { |
| for (int i=0;i < pes.size();i++) { |
| ComputeBondedCUDAMsg *msg = new ComputeBondedCUDAMsg; |
| msg->c = c; |
| thisProxy[pes[i]].recvFinishPatchesOnPe(msg); |
| } |
| } |
| |
| void ComputeMgr::recvFinishPatchesOnPe(ComputeBondedCUDAMsg *msg) { |
| msg->c->finishPatchesOnPe(); |
| delete msg; |
| } |
| |
| void ComputeMgr::sendFinishReductions(int pe, ComputeBondedCUDA* c) { |
| ComputeBondedCUDAMsg *msg = new ComputeBondedCUDAMsg; |
| msg->c = c; |
| thisProxy[pe].recvFinishReductions(msg); |
| } |
| |
| void ComputeMgr::recvFinishReductions(ComputeBondedCUDAMsg *msg) { |
| msg->c->finishReductions(); |
| delete msg; |
| } |
| |
| void ComputeMgr::sendUnregisterBoxesOnPe(std::vector<int>& pes, ComputeBondedCUDA* c) { |
| for (int i=0;i < pes.size();i++) { |
| ComputeBondedCUDAMsg *msg = new ComputeBondedCUDAMsg; |
| msg->c = c; |
| thisProxy[pes[i]].recvUnregisterBoxesOnPe(msg); |
| } |
| } |
| |
| void ComputeMgr::recvUnregisterBoxesOnPe(ComputeBondedCUDAMsg *msg) { |
| msg->c->unregisterBoxesOnPe(); |
| delete msg; |
| } |
| |
| #endif // BONDED_CUDA |
| |
#endif // NAMD_CUDA | #endif // NAMD_CUDA |
| |
void ComputeMgr::sendCreateNonbondedMICSlave(int pe, int index) { | void ComputeMgr::sendCreateNonbondedMICSlave(int pe, int index) { |