NAMD: Patch.C Source File

00001 
00007 #include "InfoStream.h"
00008 #include "Patch.h"
00009 #include "PatchMap.h"
00010 #include "Compute.h"
00011 
00012 #include "AtomMap.h"
00013 #include "ComputeMap.h"
00014 #include "Node.h"
00015 #include "Molecule.h"
00016 #include "SimParameters.h"
00017 #include "ResizeArrayPrimIter.h"
00018 #include "ComputeNonbondedMICKernel.h"
00019 #include "Priorities.h"
00020 #include "ReductionMgr.h"
00021 
00022 #include "Sync.h"
00023 
00024 #include <algorithm>
00025 
00026 typedef ResizeArrayPrimIter<Compute*> ComputePtrListIter;
00027 
00028 struct cptr_sortop_priority {
00029   bool operator() (Compute *i, Compute *j) const {
00030     return ( i->priority() < j->priority() );
00031   }
00032 };
00033 
00034 //#define  DEBUGM
00035 #define MIN_DEBUG_LEVEL 4
00036 #include "Debug.h"
00037 
00038 Patch::~Patch() {
00039   delete atomMapper;
00040 #ifndef NAMD_CUDA
00041   delete reduction;
00042 #endif
00043 }
00044 
00045 Patch::Patch(PatchID pd) :
00046    lattice(flags.lattice),
00047    patchID(pd), numAtoms(0), numFixedAtoms(0),
00048    avgPositionPtrBegin(0), avgPositionPtrEnd(0),
00049    velocityPtrBegin(0), velocityPtrEnd(0),      // BEGIN LA, END LA
00050    positionBox(this,&Patch::positionBoxClosed,pd,0),
00051    avgPositionBox(this,&Patch::avgPositionBoxClosed,pd,3),
00052    velocityBox(this,&Patch::velocityBoxClosed,pd,4), // BEGIN LA, END LA
00053    psiSumBox(this,&Patch::psiSumBoxClosed,pd,5), // begin gbis
00054    intRadBox(this,&Patch::intRadBoxClosed,pd,6),
00055    bornRadBox(this,&Patch::bornRadBoxClosed,pd,7),
00056    dEdaSumBox(this,&Patch::dEdaSumBoxClosed,pd,8),
00057    dHdrPrefixBox(this,&Patch::dHdrPrefixBoxClosed,pd,9), //end gbis
00058    lcpoTypeBox(this,&Patch::lcpoTypeBoxClosed,pd,10),
00059    forceBox(this,&Patch::forceBoxClosed,pd,1),
00060    boxesOpen(0), _hasNewAtoms(0),
00061    computesSortedByPriority(0), firstHoldableCompute(0)
00062 
00063    // DMK - Atom Separation (water vs. non-water)
00064    #if NAMD_SeparateWaters != 0
00065      ,numWaterAtoms(-1)
00066    #endif
00067 {
00068   //CkPrintf("GBIS: PatchCreated\n");
00069 #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
00070     positionPtrBegin = 0;
00071     positionPtrEnd = 0;
00072 #endif
00073 
00074         nChild = 0;
00075         child = NULL;
00076 #ifdef NODEAWARE_PROXY_SPANNINGTREE
00077   #ifdef USE_NODEPATCHMGR
00078   nodeChildren = NULL;
00079   numNodeChild = 0;
00080   #endif
00081 #endif
00082 
00083   lattice = Node::Object()->simParameters->lattice;
00084   atomMapper = new AtomMapper(pd);
00085 #ifndef NAMD_CUDA
00086   reduction = ReductionMgr::Object()->willSubmit(REDUCTIONS_BASIC);
00087 #endif
00088 
00089   // DMK
00090   #if defined(NAMD_MIC)
00091     cudaAtomPtr = NULL;
00092     #if MIC_SUBMIT_ATOMS_ON_ARRIVAL != 0
00093       pthread_mutex_init(&mic_atomData_mutex, NULL);
00094       mic_atomData = NULL;
00095       mic_atomData_seq = -1;
00096       mic_atomData_allocSize_host = 0;
00097       for (int i = 0; i < MIC_MAX_DEVICES_PER_NODE; i++) {
00098         mic_atomData_prev[i] = NULL;
00099         mic_atomData_deviceSeq[i] = -1;
00100         mic_atomData_devicePtr[i] = 0;
00101         mic_atomData_allocSize_device[i] = 0;
00102       }
00103     #endif
00104   #endif
00105 }
00106 
00107 Box<Patch,CompAtom>* Patch::registerPositionPickup(Compute *cid)
00108 {
00109    if ( computesSortedByPriority ) {
00110      positionComputeList.sort();
00111      computesSortedByPriority = 0;
00112    }
00113    //DebugM(4, "registerPositionPickupa("<<patchID<<") from " << cid->cid << "\n");
00114    if (positionComputeList.add(cid) < 0)
00115    {
00116      DebugM(7, "registerPositionPickup() failed for cid " << cid->cid << std::endl);
00117      return NULL;
00118    }
00119    return positionBox.checkOut(cid->cid);
00120 }
00121 
00122 void Patch::unregisterPositionPickup(Compute *cid, Box<Patch,CompAtom> **const box)
00123 {
00124    if ( computesSortedByPriority ) {
00125      positionComputeList.sort();
00126      computesSortedByPriority = 0;
00127    }
00128    DebugM(4, "UnregisterPositionPickup from " << cid->cid << "\n");
00129    positionComputeList.del(cid);
00130    positionBox.checkIn(*box);
00131    *box = 0;
00132 }
00133 
00134 Box<Patch,CompAtom>* Patch::registerAvgPositionPickup(Compute *cid)
00135 {
00136    //DebugM(4, "registerAvgPositionPickup("<<patchID<<") from " << cid->cid << "\n");
00137    return avgPositionBox.checkOut(cid->cid);
00138 }
00139 
00140 void Patch::unregisterAvgPositionPickup(Compute *cid, Box<Patch,CompAtom> **const box)
00141 {
00142    DebugM(4, "UnregisterAvgPositionPickup from " << cid->cid << "\n");
00143    avgPositionBox.checkIn(*box);
00144    *box = 0;
00145 }
00146 
00147 // BEGIN LA
00148 Box<Patch,CompAtom>* Patch::registerVelocityPickup(Compute *cid)
00149 {
00150    //DebugM(4, "registerVelocityPickup("<<patchID<<") from " << cid->cid << "\n");
00151    return velocityBox.checkOut(cid->cid);
00152 }
00153 
00154 void Patch::unregisterVelocityPickup(Compute *cid, Box<Patch,CompAtom> **const box)
00155 {
00156    DebugM(4, "UnregisterVelocityPickup from " << cid->cid << "\n");
00157    velocityBox.checkIn(*box);
00158    *box = 0;
00159 }
00160 // END LA
00161 
00162 //begin gbis
00163 //deposit, not pickup
00164 Box<Patch,GBReal>* Patch::registerPsiSumDeposit(Compute *cid) {
00165 
00166   if (psiSumComputeList.add(cid) < 0) {
00167     DebugM(7, "registerPsiSumDeposit() failed for cid " << cid->cid << std::endl);
00168     DebugM(7, "  size of psiSumCompueList " << psiSumComputeList.size() << std::endl);
00169      return NULL;
00170   }
00171   return psiSumBox.checkOut(cid->cid);
00172 }
00173 
00174 void Patch::unregisterPsiSumDeposit(Compute *cid,Box<Patch,GBReal> **const box) {
00175   psiSumComputeList.del(cid);
00176   psiSumBox.checkIn(*box);
00177   *box = 0;
00178 }
00179 Box<Patch,Real>* Patch::registerIntRadPickup(Compute *cid) {
00180   return intRadBox.checkOut(cid->cid);
00181 }
00182 void Patch::unregisterIntRadPickup(Compute *cid,Box<Patch,Real> **const box) {
00183   intRadBox.checkIn(*box);
00184   *box = 0;
00185 }
00186 
00187 //LCPO
00188 Box<Patch,int>* Patch::registerLcpoTypePickup(Compute *cid) {
00189   return lcpoTypeBox.checkOut(cid->cid);
00190 }
00191 void Patch::unregisterLcpoTypePickup(Compute *cid,Box<Patch,int> **const box) {
00192   lcpoTypeBox.checkIn(*box);
00193   *box = 0;
00194 }
00195 
00196 Box<Patch,Real>* Patch::registerBornRadPickup(Compute *cid) {
00197   return bornRadBox.checkOut(cid->cid);
00198 }
00199 void Patch::unregisterBornRadPickup(Compute *cid,Box<Patch,Real> **const box) {
00200   bornRadBox.checkIn(*box);
00201   *box = 0;
00202 }
00203 
00204 Box<Patch,GBReal>* Patch::registerDEdaSumDeposit(Compute *cid) {
00205   if (dEdaSumComputeList.add(cid) < 0) {
00206     DebugM(7, "registerDEdaSumDeposit() failed for cid " << cid->cid << std::endl);
00207     DebugM(7, "  size of dEdaSumCompueList " << dEdaSumComputeList.size() << std::endl);
00208      return NULL;
00209   }
00210   return dEdaSumBox.checkOut(cid->cid);
00211 }
00212 void Patch::unregisterDEdaSumDeposit(Compute *cid,Box<Patch,GBReal> **const box){
00213   dEdaSumComputeList.del(cid);
00214   dEdaSumBox.checkIn(*box);
00215   *box = 0;
00216 }
00217 
00218 Box<Patch,Real>* Patch::registerDHdrPrefixPickup(Compute *cid)
00219 {
00220   return dHdrPrefixBox.checkOut(cid->cid);
00221 }
00222 void Patch::unregisterDHdrPrefixPickup(Compute *cid,Box<Patch,Real> **const box) {
00223   dHdrPrefixBox.checkIn(*box);
00224   *box = 0;
00225 }
00226 //end gbis
00227 
00228 Box<Patch,Results>* Patch::registerForceDeposit(Compute *cid)
00229 {
00230    if (forceComputeList.add(cid) < 0)
00231    {
00232      DebugM(7, "registerForceDeposit() failed for cid " << cid->cid << std::endl);
00233      DebugM(7, "  size of forceCompueList " << forceComputeList.size() << std::endl);
00234      return NULL;
00235    }
00236    return forceBox.checkOut(cid->cid);
00237 }
00238 
00239 void Patch::unregisterForceDeposit(Compute *cid, Box<Patch,Results> **const box)
00240 {
00241    DebugM(4, "unregisterForceDeposit() computeID("<<cid<<")"<<std::endl);
00242    forceComputeList.del(cid);
00243    forceBox.checkIn(*box);
00244    *box = 0;
00245 }
00246 
00247 void Patch::positionBoxClosed(void)
00248 {
00249    //positionPtrBegin = 0;
00250    this->boxClosed(0);
00251 }
00252 
00253 void Patch::forceBoxClosed(void)
00254 {
00255    DebugM(4, "patchID("<<patchID<<") forceBoxClosed! call\n");
00256 
00257 #ifndef NAMD_CUDA
00258    // calculate direct nonbonded virial from segregated forces and aggregate forces
00259    const Vector center = lattice.unscale( PatchMap::Object()->center(patchID) );
00260 #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
00261    const CompAtom * const __restrict pd = positionPtrBegin;
00262 #else
00263    const CompAtom * const __restrict pd = p.begin();
00264 #endif
00265    const int n = numAtoms;
00266    int roff = 0;
00267 
00268 #ifdef NAMD_AVXTILES
00269    // If "Tiles" algorithm is active, perform same reduction and virial calc
00270    // in BigReal precision, but add in forces stored in tiles data structures
00271    // if they were touched on this patch.
00272    if (Node::Object()->simParameters->useAVXTiles) {
00273      double virialHold[6], virialSlowHold[6];
00274      tiles.nativeForceVirialUpdate(flags.doFullElectrostatics, flags.doVirial,
00275                                    pd, center, results.f[Results::nbond], 
00276                                    results.f[Results::slow],
00277                                    results.f[Results::nbond_virial],
00278                                    results.f[Results::slow_virial],
00279                                    virialHold, virialSlowHold);
00280      f[Results::nbond_virial].resize(0);
00281      f[Results::slow_virial].resize(0);
00282      reduction->item(roff + REDUCTION_VIRIAL_NBOND_XX) += virialHold[0];
00283      reduction->item(roff + REDUCTION_VIRIAL_NBOND_XY) += virialHold[1];
00284      reduction->item(roff + REDUCTION_VIRIAL_NBOND_XZ) += virialHold[2];
00285      reduction->item(roff + REDUCTION_VIRIAL_NBOND_YX) += virialHold[1];
00286      reduction->item(roff + REDUCTION_VIRIAL_NBOND_YY) += virialHold[3];
00287      reduction->item(roff + REDUCTION_VIRIAL_NBOND_YZ) += virialHold[4];
00288      reduction->item(roff + REDUCTION_VIRIAL_NBOND_ZX) += virialHold[2];
00289      reduction->item(roff + REDUCTION_VIRIAL_NBOND_ZY) += virialHold[4];
00290      reduction->item(roff + REDUCTION_VIRIAL_NBOND_ZZ) += virialHold[5];
00291      roff += REDUCTION_VIRIAL_SLOW_XX - REDUCTION_VIRIAL_NBOND_XX;
00292      reduction->item(roff + REDUCTION_VIRIAL_NBOND_XX) += virialSlowHold[0];
00293      reduction->item(roff + REDUCTION_VIRIAL_NBOND_XY) += virialSlowHold[1];
00294      reduction->item(roff + REDUCTION_VIRIAL_NBOND_XZ) += virialSlowHold[2];
00295      reduction->item(roff + REDUCTION_VIRIAL_NBOND_YX) += virialSlowHold[1];
00296      reduction->item(roff + REDUCTION_VIRIAL_NBOND_YY) += virialSlowHold[3];
00297      reduction->item(roff + REDUCTION_VIRIAL_NBOND_YZ) += virialSlowHold[4];
00298      reduction->item(roff + REDUCTION_VIRIAL_NBOND_ZX) += virialSlowHold[2];
00299      reduction->item(roff + REDUCTION_VIRIAL_NBOND_ZY) += virialSlowHold[4];
00300      reduction->item(roff + REDUCTION_VIRIAL_NBOND_ZZ) += virialSlowHold[5];
00301      reduction->submit();
00302      for (int j = 0; j < Results::maxNumForces; ++j ) results.f[j] = 0;
00303      this->boxClosed(1);
00304      return;
00305    }
00306 #endif
00307 
00308    for ( int j1 = Results::nbond; j1 <= Results::slow; ++j1, roff += REDUCTION_VIRIAL_SLOW_XX - REDUCTION_VIRIAL_NBOND_XX ) {
00309       int j2 = j1 + ( Results::nbond_virial - Results::nbond );
00310       Force * __restrict f1 = results.f[j1];
00311       Force * __restrict f2 = results.f[j2];
00312       BigReal virial_xx = 0.;
00313       BigReal virial_xy = 0.;
00314       BigReal virial_xz = 0.;
00315       BigReal virial_yy = 0.;
00316       BigReal virial_yz = 0.;
00317       BigReal virial_zz = 0.;
00318 #pragma omp simd reduction(+:virial_xx,virial_xy,virial_xz,virial_yy,virial_yz,virial_zz)
00319 #pragma ivdep
00320       for ( int i=0; i<n; ++i ) {
00321         BigReal p_x = pd[i].position.x - center.x;
00322         BigReal p_y = pd[i].position.y - center.y;
00323         BigReal p_z = pd[i].position.z - center.z;
00324         BigReal f_x = f2[i].x;
00325         BigReal f_y = f2[i].y;
00326         BigReal f_z = f2[i].z;
00327         virial_xx += f_x * p_x;
00328         virial_xy += f_x * p_y;
00329         virial_xz += f_x * p_z;
00330         virial_yy += f_y * p_y;
00331         virial_yz += f_y * p_z;
00332         virial_zz += f_z * p_z;
00333         f1[i].x += f_x;
00334         f1[i].y += f_y;
00335         f1[i].z += f_z;
00336       }
00337       f[j2].resize(0);
00338       reduction->item(roff + REDUCTION_VIRIAL_NBOND_XX) += virial_xx;
00339       reduction->item(roff + REDUCTION_VIRIAL_NBOND_XY) += virial_xy;
00340       reduction->item(roff + REDUCTION_VIRIAL_NBOND_XZ) += virial_xz;
00341       reduction->item(roff + REDUCTION_VIRIAL_NBOND_YX) += virial_xy;
00342       reduction->item(roff + REDUCTION_VIRIAL_NBOND_YY) += virial_yy;
00343       reduction->item(roff + REDUCTION_VIRIAL_NBOND_YZ) += virial_yz;
00344       reduction->item(roff + REDUCTION_VIRIAL_NBOND_ZX) += virial_xz;
00345       reduction->item(roff + REDUCTION_VIRIAL_NBOND_ZY) += virial_yz;
00346       reduction->item(roff + REDUCTION_VIRIAL_NBOND_ZZ) += virial_zz;
00347    }
00348    reduction->submit();
00349 #endif
00350 
00351    for (int j = 0; j < Results::maxNumForces; ++j )
00352    {
00353      results.f[j] = 0;
00354    }
00355    this->boxClosed(1);
00356 }
00357 
00358 void Patch::avgPositionBoxClosed(void)
00359 {
00360    avgPositionPtrBegin = 0;
00361    this->boxClosed(3);
00362 }
00363 
00364 // BEGIN LA
00365 void Patch::velocityBoxClosed(void)
00366 {
00367    DebugM(4, "patchID("<<patchID<<") velocityBoxClosed! call\n");
00368    velocityPtrBegin = 0;
00369    this->boxClosed(4);  // ?? Don't know about number
00370 }
00371 // END LA
00372 
00373 // void Patch::boxClosed(int box) is virtual
00374 
00375 // begin gbis
00376 void Patch::psiSumBoxClosed(void) {
00377   this->boxClosed(5);
00378 }
00379 void Patch::intRadBoxClosed(void) {
00380    //dHdrPrefixPtr = 0;
00381    this->boxClosed(6);
00382 }
00383 void Patch::bornRadBoxClosed(void) {
00384    //bornRadPtr = 0;
00385    this->boxClosed(7);
00386 }
00387 void Patch::dEdaSumBoxClosed(void) {
00388    //dEdaSumPtr = 0;
00389    this->boxClosed(8);
00390 }
00391 void Patch::dHdrPrefixBoxClosed(void) {
00392    //dHdrPrefixPtr = 0;
00393    this->boxClosed(9);
00394 }
00395 // end gbis
00396 
00397 //LCPO
00398 void Patch::lcpoTypeBoxClosed(void) {
00399    this->boxClosed(10);
00400 }
00401 
00402 void Patch::positionsReady(int doneMigration)
00403 {
00404    DebugM(4,"Patch::positionsReady() - patchID(" << patchID <<")"<<std::endl );
00405 
00406    if ( doneMigration ){
00407 // #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
00408 //       AtomMap::Object()->registerIDs(patchID,positionPtrBegin,positionPtrEnd);       
00409 // #else
00410        atomMapper->registerIDsCompAtomExt(pExt.begin(),pExt.end());
00411 // #endif
00412 
00413      #ifdef NAMD_AVXTILES
00414      if (Node::Object()->simParameters->useAVXTiles) {
00415        #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
00416        const CompAtom * const pd = positionPtrBegin;
00417        #else
00418        const CompAtom * const pd = p.begin();
00419        #endif
00420        tiles.atomUpdate(pd, getCompAtomExtInfo());
00421      }
00422      #endif
00423    }
00424 
00425 #ifdef NAMD_KNL
00426   #if defined(NAMD_AVXTILES)
00427   if (!Node::Object()->simParameters->useAVXTiles)
00428   #endif
00429    {
00430      const Vector center = lattice.unscale( PatchMap::Object()->center(patchID) );
00431      const int n = numAtoms;
00432      pFlt.resize(n);
00433      CompAtomFlt * const pf = pFlt.begin();
00434 #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
00435      const CompAtom * const pd = positionPtrBegin;
00436 #else
00437      const CompAtom * const pd = p.begin();
00438 #endif
00439      for ( int i=0; i<n; ++i ) {
00440        // need to subtract center in double precision, then assign to float
00441        pf[i].position.x = pd[i].position.x - center.x;
00442        pf[i].position.y = pd[i].position.y - center.y;
00443        pf[i].position.z = pd[i].position.z - center.z;
00444        pf[i].vdwType = pd[i].vdwType;
00445      }
00446    }
00447 #endif
00448    boxesOpen = 2;
00449    if ( flags.doMolly ) boxesOpen++;
00450    // BEGIN LA
00451    if (flags.doLoweAndersen) {
00452        DebugM(4, "Patch::positionsReady, flags.doMolly = " << flags.doMolly << "\n");
00453        boxesOpen++;
00454    }
00455    // END LA
00456    _hasNewAtoms = (doneMigration != 0);
00457 
00458 #if CMK_BLUEGENEL
00459    CmiNetworkProgressAfter (0);
00460 #endif
00461 
00462    // Give all position pickup boxes access to positions
00463    //positionPtrBegin = p.begin();
00464 #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
00465    positionBox.open(positionPtrBegin);
00466 #else
00467    positionBox.open(p.begin());
00468 #endif
00469    if ( flags.doMolly ) {
00470      //avgPositionPtrBegin = p_avg.begin();
00471      avgPositionBox.open(avgPositionPtrBegin);
00472    }
00473    
00474    // BEGIN LA
00475    if (flags.doLoweAndersen) {
00476        velocityBox.open(velocityPtrBegin);
00477    }
00478    // END LA
00479    // begin gbis
00480     if (flags.doGBIS) {
00481       boxesOpen += 5;
00482       //intRad should already be taken care of
00483       intRadBox.open(intRad.begin());
00484       psiSum.resize(numAtoms);//resize array
00485       psiSum.setall(0);
00486       psiSumBox.open(psiSum.begin());
00487       psiFin.resize(numAtoms);//has no box
00488       psiFin.setall(0);
00489       bornRad.resize(numAtoms);
00490       bornRad.setall(0);
00491       bornRadBox.open(bornRad.begin());
00492       dEdaSum.resize(numAtoms);//resize array
00493       dEdaSum.setall(0);
00494       dEdaSumBox.open(dEdaSum.begin());
00495       dHdrPrefix.resize(numAtoms);
00496       dHdrPrefix.setall(0);
00497       dHdrPrefixBox.open(dHdrPrefix.begin());
00498     }
00499    // end gbis
00500 
00501   //LCPO
00502   if (flags.doLCPO) {
00503     boxesOpen++;
00504     lcpoTypeBox.open(lcpoType.begin());
00505   }
00506 
00507 #if CMK_BLUEGENEL
00508    CmiNetworkProgressAfter (0);
00509 #endif
00510    
00511    // Give all force deposit boxes access to forces
00512    Force *forcePtr;
00513    for ( int j = 0; j < Results::maxNumForces; ++j )
00514     {
00515       f[j].resize(numAtoms);
00516       forcePtr = f[j].begin();
00517       memset (forcePtr, 0, sizeof (Force) * numAtoms);
00518       results.f[j] = forcePtr;
00519     }
00520    forceBox.open(&results);
00521 
00522    #ifdef NAMD_AVXTILES
00523    // Zero data in arrays in "Tiles" data structures if they have been touched
00524    if (Node::Object()->simParameters->useAVXTiles)
00525      tiles.zeroForces(flags.doFullElectrostatics);
00526    #endif
00527    
00528 
00529    if ( ! computesSortedByPriority ) {
00530      if (positionComputeList.size() == 0 && PatchMap::Object()->node(patchID) != CkMyPe()) {
00531        iout << iINFO << "PATCH_COUNT: Patch " << patchID 
00532             << " on PE " << CkMyPe() <<" home patch " 
00533             << PatchMap::Object()->node(patchID)
00534             << " does not have any computes\n" 
00535             << endi;
00536      }
00537 
00538      cptr_sortop_priority so;
00539      std::sort(positionComputeList.begin(), positionComputeList.end(), so);
00540      computesSortedByPriority = 1;
00541      int i;
00542      for ( i=0; i<positionComputeList.size(); ++i ) {
00543        if ( positionComputeList[i]->priority() > PME_PRIORITY ) break;
00544      }
00545      firstHoldableCompute = i;
00546    }
00547 
00548    int seq = flags.sequence;
00549 
00550    // Iterate over compute objects that need to be informed we are ready
00551    Compute **cid = positionComputeList.begin();
00552    for ( int i=0; i < firstHoldableCompute; ++i, ++cid ) {
00553      (*cid)->patchReady(patchID,doneMigration,seq);
00554    }
00555    Compute **cend = positionComputeList.end();
00556 
00557    // gzheng
00558    if (Sync::Object()->holdComputes(patchID, cid, cend, doneMigration, seq)) {
00559      return;
00560    }
00561 
00562    for( ; cid != cend; cid++ ) {
00563      (*cid)->patchReady(patchID,doneMigration,seq);
00564    }
00565 }
00566 
00567 // begin gbis
00568 
00569 void Patch::gbisP2Ready() {
00570  ComputePtrListIter cid(positionComputeList);
00571 
00572   int seq = flags.sequence;
00573   for(cid = cid.begin(); cid != cid.end(); cid++) {
00574     if ( (*cid)->type() == computeNonbondedSelfType ||
00575          (*cid)->type() == computeNonbondedPairType ||
00576          (*cid)->type() == computeNonbondedCUDAType
00577 #ifdef NAMD_CUDA
00578          || (*cid)->type() == computeNonbondedCUDA2Type
00579 #endif
00580          ) {
00581       (*cid)->gbisP2PatchReady(patchID,seq);
00582     }
00583   }
00584 }
00585 
00586 void Patch::gbisP3Ready() {
00587 
00588   ComputePtrListIter cid(positionComputeList);
00589 
00590   int seq = flags.sequence;
00591   for(cid = cid.begin(); cid != cid.end(); cid++) {
00592     if ( (*cid)->type() == computeNonbondedSelfType ||
00593          (*cid)->type() == computeNonbondedPairType ||
00594          (*cid)->type() == computeNonbondedCUDAType
00595 #ifdef NAMD_CUDA
00596          || (*cid)->type() == computeNonbondedCUDA2Type
00597 #endif
00598          ) {
00599       (*cid)->gbisP3PatchReady(patchID,seq);
00600     }
00601   }
00602 }
00603 
00604 //end gbis