#include <ComputeMgr.h>

Inheritance diagram for ComputeMgr:

Public Member Functions
	ComputeMgr ()

	~ComputeMgr ()

void	createComputes (ComputeMap *map)

void	updateComputes (int, CkGroupID)

void	updateComputes2 (CkQdMsg *)

void	updateComputes3 ()

void	splitComputes ()

void	splitComputes2 (CkQdMsg *)

void	updateLocalComputes ()

void	updateLocalComputes2 (CkQdMsg *)

void	updateLocalComputes3 ()

void	updateLocalComputes4 (CkQdMsg *)

void	updateLocalComputes5 ()

void	doneUpdateLocalComputes ()

void	sendComputeGlobalConfig (ComputeGlobalConfigMsg *)

void	recvComputeGlobalConfig (ComputeGlobalConfigMsg *)

void	sendComputeGlobalData (ComputeGlobalDataMsg *)

void	recvComputeGlobalData (ComputeGlobalDataMsg *)

void	sendComputeGlobalResults (ComputeGlobalResultsMsg *)

void	recvComputeGlobalResults (ComputeGlobalResultsMsg *)

void	enableComputeGlobalResults ()

void	sendComputeDPMEData (ComputeDPMEDataMsg *)

void	recvComputeDPMEData (ComputeDPMEDataMsg *)

void	sendComputeDPMEResults (ComputeDPMEResultsMsg *, int)

void	recvComputeDPMEResults (ComputeDPMEResultsMsg *)

void	sendComputeEwaldData (ComputeEwaldMsg *)

void	recvComputeEwaldData (ComputeEwaldMsg *)

void	sendComputeEwaldResults (ComputeEwaldMsg *)

void	recvComputeEwaldResults (ComputeEwaldMsg *)

void	recvComputeConsForceMsg (ComputeConsForceMsg *)

void	sendYieldDevice (int pe)

void	recvYieldDevice (int pe)

void	sendBuildCudaExclusions ()

void	recvBuildCudaExclusions ()

void	sendBuildCudaForceTable ()

void	recvBuildCudaForceTable ()

void	sendBuildMICForceTable ()

void	recvBuildMICForceTable ()

void	sendCreateNonbondedCUDASlave (int, int)

void	recvCreateNonbondedCUDASlave (NonbondedCUDASlaveMsg *)

void	sendNonbondedCUDASlaveReady (int, int, int, int)

void	recvNonbondedCUDASlaveReady (int, int, int)

void	sendNonbondedCUDASlaveSkip (ComputeNonbondedCUDA *c, int)

void	recvNonbondedCUDASlaveSkip (NonbondedCUDASkipMsg *)

void	sendNonbondedCUDASlaveEnqueue (ComputeNonbondedCUDA *c, int, int, int, int)

void	sendNonbondedCUDASlaveEnqueuePatch (ComputeNonbondedCUDA c, int, int, int, int, FinishWorkMsg )

void	sendAssignPatchesOnPe (std::vector< int > &pes, CudaComputeNonbonded *c)

void	recvAssignPatchesOnPe (CudaComputeNonbondedMsg *msg)

void	sendSkipPatchesOnPe (std::vector< int > &pes, CudaComputeNonbonded *c)

void	recvSkipPatchesOnPe (CudaComputeNonbondedMsg *msg)

void	sendFinishPatchesOnPe (std::vector< int > &pes, CudaComputeNonbonded *c)

void	recvFinishPatchesOnPe (CudaComputeNonbondedMsg *msg)

void	sendFinishPatchOnPe (int pe, CudaComputeNonbonded *c, int i, PatchID patchID)

void	recvFinishPatchOnPe (CudaComputeNonbondedMsg *msg)

void	sendOpenBoxesOnPe (std::vector< int > &pes, CudaComputeNonbonded *c)

void	recvOpenBoxesOnPe (CudaComputeNonbondedMsg *msg)

void	sendFinishReductions (int pe, CudaComputeNonbonded *c)

void	recvFinishReductions (CudaComputeNonbondedMsg *msg)

void	sendMessageEnqueueWork (int pe, CudaComputeNonbonded *c)

void	recvMessageEnqueueWork (CudaComputeNonbondedMsg *msg)

void	sendLaunchWork (int pe, CudaComputeNonbonded *c)

void	recvLaunchWork (CudaComputeNonbondedMsg *msg)

void	sendUnregisterBoxesOnPe (std::vector< int > &pes, CudaComputeNonbonded *c)

void	recvUnregisterBoxesOnPe (CudaComputeNonbondedMsg *msg)

void	sendCreateNonbondedMICSlave (int, int)

void	recvCreateNonbondedMICSlave (NonbondedMICSlaveMsg *)

void	sendNonbondedMICSlaveReady (int, int, int, int)

void	recvNonbondedMICSlaveReady (int, int, int)

void	sendNonbondedMICSlaveSkip (ComputeNonbondedMIC *c, int)

void	recvNonbondedMICSlaveSkip (NonbondedMICSkipMsg *)

void	sendNonbondedMICSlaveEnqueue (ComputeNonbondedMIC *c, int, int, int, int)

void	sendMICPEData (int, int)

void	recvMICPEData (int, int)

int	isMICProcessor (int)

Public Attributes
ComputeGlobal *	computeGlobalObject

ResizeArray < ComputeGlobalResultsMsg * >	computeGlobalResultsMsgs

int	computeGlobalResultsMsgSeq

int	computeGlobalResultsMsgMasterSeq

Detailed Description

Definition at line 57 of file ComputeMgr.h.

Constructor & Destructor Documentation

ComputeMgr::ComputeMgr ( )

Definition at line 109 of file ComputeMgr.C.

References computeGlobalObject, computeGlobalResultsMsgMasterSeq, computeGlobalResultsMsgSeq, and NAMD_die().

 {
     CkpvAccess(BOCclass_group).computeMgr = thisgroup;
     computeGlobalObject = 0;
     computeGlobalResultsMsgSeq = -1;
     computeGlobalResultsMsgMasterSeq = -1;
     computeDPMEObject = 0;
     computeEwaldObject = 0;
     computeNonbondedCUDAObject = 0;
     computeNonbondedMICObject = 0;
     computeNonbondedWorkArrays = new ComputeNonbondedWorkArrays;
     skipSplitting = 0;
     masterServerObject = NULL;
 
     #if defined(NAMD_MIC)
       // Create the micPEData flag array (1 bit per PE) and initially set each PE as "not driving
       //   a MIC card" (unset).  PEs that are driving MIC card will identify themselves during startup.
       int numPEs = CkNumPes();
       int numInts = ((numPEs + (sizeof(int)*8-1)) & (~(sizeof(int)*8-1))) / (sizeof(int)*8);  // Round up to sizeof(int) then divide by the size of an int
       micPEData = new int[numInts];
       if (micPEData == NULL) { NAMD_die("Unable to allocate memory for micPEData"); }
       memset(micPEData, 0, sizeof(int) * numInts);
     #else
       micPEData = NULL;
     #endif
 }

ComputeMgr::~ComputeMgr ( void )

Definition at line 136 of file ComputeMgr.C.

 {
     delete computeNonbondedWorkArrays;
     if (masterServerObject != NULL) delete masterServerObject;
 }

Member Function Documentation

void ComputeMgr::createComputes ( ComputeMap * map )

Definition at line 1009 of file ComputeMgr.C.

References GlobalMasterServer::addClient(), ComputeNonbondedMIC::assignPatches(), ComputeNonbondedCUDA::assignPatches(), CudaComputeNonbonded::assignPatches(), SimParameters::bondedCUDA, SimParameters::colvarsOn, computeAnglesType, computeBondsType, computeCrosstermsType, computeDihedralsType, computeExclsType, computeImpropersType, computeNonbondedCUDA2Type, computeNonbondedCUDAType, computeNonbondedMICType, computeNonbondedPairType, computeNonbondedSelfType, computeSelfAnglesType, computeSelfBondsType, computeSelfCrosstermsType, computeSelfDihedralsType, computeSelfExclsType, computeSelfImpropersType, DebugM, DeviceCUDA::device_shared_with_pe(), deviceCUDA, SimParameters::firstTimestep, SimParameters::freeEnergyOn, getCudaComputeNonbonded(), DeviceCUDA::getMasterPe(), SimParameters::globalForcesOn, SimParameters::IMDignore, SimParameters::IMDignoreForces, SimParameters::IMDon, CudaComputeNonbonded::initialize(), mic_device_pe(), mic_device_shared_with_pe(), SimParameters::miscForcesOn, Node::molecule, Node::myid(), Molecule::numAtoms, PatchMap::Object(), Node::Object(), Node::simParameters, SimParameters::SMDDir, SimParameters::SMDFile, SimParameters::SMDk, SimParameters::SMDk2, SimParameters::SMDOn, SimParameters::SMDOutputFreq, SimParameters::SMDVel, SimParameters::symmetryLastStep, SimParameters::symmetryOn, SimParameters::tclForcesOn, SimParameters::TMDOn, ComputeMap::type(), and SimParameters::useCUDA2.

Referenced by Node::startup().

 {
 // #ifdef NAMD_CUDA
 //     int ComputePmeCUDACounter = 0;
 // #endif
     Node *node = Node::Object();
     SimParameters *simParams = node->simParameters;
     int myNode = node->myid();
 
     if ( simParams->globalForcesOn && !myNode )
     {
         DebugM(4,"Mgr running on Node "<<CkMyPe()<<"\n");
         /* create a master server to allow multiple masters */
         masterServerObject = new GlobalMasterServer(this,
                 PatchMap::Object()->numNodesWithPatches());
 
         /* create the individual global masters */
         // masterServerObject->addClient(new GlobalMasterTest());
         if (simParams->tclForcesOn)
             masterServerObject->addClient(new GlobalMasterTcl());
         if (simParams->IMDon && ! (simParams->IMDignore || simParams->IMDignoreForces) )
             masterServerObject->addClient(new GlobalMasterIMD());
 
         if (simParams->SMDOn)
             masterServerObject->addClient(
                 new GlobalMasterSMD(simParams->SMDk, simParams->SMDk2,
                                     simParams->SMDVel,
                                     simParams->SMDDir, simParams->SMDOutputFreq,
                                     simParams->firstTimestep, simParams->SMDFile,
                                     node->molecule->numAtoms)
             );
             
         if (simParams->symmetryOn && 
           (simParams->firstTimestep < simParams->symmetryLastStep || 
           simParams->symmetryLastStep == -1))
             masterServerObject->addClient(new GlobalMasterSymmetry());    
         if (simParams->TMDOn)
             masterServerObject->addClient(new GlobalMasterTMD());
         if (simParams->miscForcesOn)
             masterServerObject->addClient(new GlobalMasterMisc());
         if ( simParams->freeEnergyOn )
             masterServerObject->addClient(new GlobalMasterFreeEnergy());
                 if ( simParams->colvarsOn )
                         masterServerObject->addClient(new GlobalMasterColvars());
 
     }
 
     if ( !myNode && simParams->IMDon && (simParams->IMDignore || simParams->IMDignoreForces) ) {
       // GlobalMasterIMD constructor saves pointer to node->IMDOutput object
       new GlobalMasterIMD();
     }
 
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
     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
 
     #ifdef NAMD_MIC
       bool deviceIsMine = ( mic_device_pe() == CkMyPe() );
     #endif
 
     for (int i=0; i < map->nComputes; i++)
     {
         if ( ! ( i % 100 ) )
         {
         }
 
 #if defined(NAMD_CUDA) || defined(NAMD_HIP) || defined(NAMD_MIC)
         switch ( map->type(i) )
         {
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
           // case computePmeCUDAType:
           //   // Only create single ComputePmeCUDA object per Pe
           //  if ( map->computeData[i].node != myNode ) continue;
           //  if (ComputePmeCUDACounter > 0) continue;
           //  ComputePmeCUDACounter++;
           //  break;
           case computeNonbondedSelfType:
             if ( ! deviceIsMine ) continue;
             if ( ! deviceCUDA->device_shared_with_pe(map->computeData[i].node) ) continue;
           break;
 
           case computeNonbondedPairType:
             if ( ! deviceIsMine ) continue;
             if ( ! deviceCUDA->device_shared_with_pe(map->computeData[i].node) ) continue;
           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
 #ifdef NAMD_MIC
 
           case computeNonbondedSelfType:
             if (map->directToDevice(i) != 0) { // If should be directed to the device...
               if ( ! deviceIsMine ) continue;
               if ( ! mic_device_shared_with_pe(map->computeData[i].node) ) continue;
             } else { // ... otherwise, direct to host...
               if (map->computeData[i].node != myNode) { continue; }
             }
             break;
 
           case computeNonbondedPairType:
             if (map->directToDevice(i)) { // If should be directed to the device...
               if ( ! deviceIsMine ) continue;
               if ( ! mic_device_shared_with_pe(map->computeData[i].node) ) continue;
             } else { // ... otherwise, direct to host...
               if (map->computeData[i].node != myNode) { continue; }
             }
             break;
 
 #endif
           case computeNonbondedCUDAType:
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
           case computeNonbondedCUDA2Type:
 // #ifdef BONDED_CUDA
 //           case computeBondedCUDAType:
 // #endif
 #endif
           case computeNonbondedMICType:
             if ( ! deviceIsMine ) continue;
           default:
             if ( map->computeData[i].node != myNode ) continue;
         }
 #else // defined(NAMD_CUDA) || defined(NAMD_MIC)
         if ( map->computeData[i].node != myNode ) continue;
 #endif
         DebugM(1,"Compute " << i << '\n');
         DebugM(1,"  node = " << map->computeData[i].node << '\n');
         DebugM(1,"  type = " << map->computeData[i].type << '\n');
         DebugM(1,"  numPids = " << map->computeData[i].numPids << '\n');
 //         DebugM(1,"  numPidsAllocated = " << map->computeData[i].numPidsAllocated << '\n');
         for (int j=0; j < map->computeData[i].numPids; j++)
         {
             DebugM(1,"  pid " << map->computeData[i].pids[j].pid << '\n');
             if (!((j+1) % 6))
                 DebugM(1,'\n');
         }
         DebugM(1,"\n---------------------------------------");
         DebugM(1,"---------------------------------------\n");
 
         createCompute(i, map);
 
     }
 
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
     if (simParams->useCUDA2) {
       if (deviceIsMine) {
         getCudaComputeNonbonded()->assignPatches(this);
         getCudaComputeNonbonded()->initialize();
       }
     } else {
       if ( computeNonbondedCUDAObject ) {
         computeNonbondedCUDAObject->assignPatches();
       }      
     }
 #ifdef BONDED_CUDA
     if (simParams->bondedCUDA) {
       if (deviceIsMineBonded) {
         getComputeBondedCUDA()->initialize();
       }
     }
 #endif
 #endif
 #ifdef NAMD_MIC
     if ( computeNonbondedMICObject ) {
       computeNonbondedMICObject->assignPatches();
     }
 #endif
 
 }

void ComputeMgr::doneUpdateLocalComputes ( )

Definition at line 348 of file ComputeMgr.C.

References DebugM.

 {
 
 //  if (!--updateComputesCount) {
     DebugM(4, "doneUpdateLocalComputes on Pe("<<CkMyPe()<<")\n");
     void *msg = CkAllocMsg(0,0,0);
     CkSendMsgBranch(updateComputesReturnEP,msg,0,updateComputesReturnChareID);
 //  }
 }

void ComputeMgr::enableComputeGlobalResults ( )

Definition at line 1293 of file ComputeMgr.C.

References computeGlobalResultsMsgs, computeGlobalResultsMsgSeq, ResizeArray< T >::del(), recvComputeGlobalResults(), and ResizeArray< T >::size().

Referenced by ComputeGlobal::doWork().

 {
     ++computeGlobalResultsMsgSeq;
     for ( int i=0; i<computeGlobalResultsMsgs.size(); ++i ) {
       if ( computeGlobalResultsMsgs[i]->seq == computeGlobalResultsMsgSeq ) {
         ComputeGlobalResultsMsg *msg = computeGlobalResultsMsgs[i];
         computeGlobalResultsMsgs.del(i);
         recvComputeGlobalResults(msg);
         break;
       }
     }
 }

int ComputeMgr::isMICProcessor ( int pe )

Definition at line 1885 of file ComputeMgr.C.

                                      {
   if (pe < 0 || pe >= CkNumPes() || micPEData == NULL) { return 0; }
   int majorIndex = pe / (sizeof(int)*8);
   int minorIndex = pe % (sizeof(int)*8);
   return ((micPEData[majorIndex] >> minorIndex) & 0x01);
 }

void ComputeMgr::recvAssignPatchesOnPe ( CudaComputeNonbondedMsg * msg )

Definition at line 1594 of file ComputeMgr.C.

References CudaComputeNonbonded::assignPatchesOnPe(), and CudaComputeNonbondedMsg::c.

                                                                    {
   msg->c->assignPatchesOnPe();
   delete msg;
 }

void ComputeMgr::recvBuildCudaExclusions ( )

Definition at line 1461 of file ComputeMgr.C.

References build_cuda_exclusions().

                                          {
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
     build_cuda_exclusions();
 #endif
 }

void ComputeMgr::recvBuildCudaForceTable ( )

Definition at line 1480 of file ComputeMgr.C.

References build_cuda_force_table().

                                          {
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
     build_cuda_force_table();
 #endif
 }

void ComputeMgr::recvBuildMICForceTable ( )

Definition at line 1499 of file ComputeMgr.C.

                                         {
   #ifdef NAMD_MIC
     build_mic_force_table();
   #endif
 }

void ComputeMgr::recvComputeConsForceMsg ( ComputeConsForceMsg * msg )

Definition at line 1408 of file ComputeMgr.C.

References ComputeConsForceMsg::aid, Molecule::consForce, Molecule::consForceIndexes, ComputeConsForceMsg::f, for(), Node::molecule, Molecule::numAtoms, Node::Object(), and ResizeArray< T >::size().

 {
     Molecule *m = Node::Object()->molecule;
     delete [] m->consForceIndexes;
     delete [] m->consForce;
     int n = msg->aid.size();
     if (n > 0)
     {
         m->consForceIndexes = new int32[m->numAtoms];
         m->consForce = new Vector[n];
         int i;
         for (i=0; i<m->numAtoms; i++) m->consForceIndexes[i] = -1;
         for (i=0; i<msg->aid.size(); i++)
         {
             m->consForceIndexes[msg->aid[i]] = i;
             m->consForce[i] = msg->f[i];
         }
     }
     else
     {
         m->consForceIndexes = NULL;
         m->consForce = NULL;
     }
     delete msg;
 }

void ComputeMgr::recvComputeDPMEData ( ComputeDPMEDataMsg * msg )

Definition at line 1378 of file ComputeMgr.C.

References NAMD_die(), and PatchMap::Object().

 {
     if ( computeDPMEObject )
     {
 #ifdef DPME
         computeDPMEObject->recvData(msg);
 #endif
     }
     else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
     else NAMD_die("ComputeMgr::computeDPMEObject is NULL!");
 }

void ComputeMgr::recvComputeDPMEResults ( ComputeDPMEResultsMsg * msg )

Definition at line 1396 of file ComputeMgr.C.

References NAMD_die(), and PatchMap::Object().

 {
     if ( computeDPMEObject )
     {
 #ifdef DPME
         computeDPMEObject->recvResults(msg);
 #endif
     }
     else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
     else NAMD_die("ComputeMgr::computeDPMEObject is NULL!");
 }

void ComputeMgr::recvComputeEwaldData ( ComputeEwaldMsg * msg )

Definition at line 1341 of file ComputeMgr.C.

References NAMD_die(), and ComputeEwald::recvData().

 {
     if (computeEwaldObject)
         computeEwaldObject->recvData(msg);
     else NAMD_die("ComputeMgr::computeEwaldObject in recvData is NULL!");
 }

void ComputeMgr::recvComputeEwaldResults ( ComputeEwaldMsg * msg )

Definition at line 1353 of file ComputeMgr.C.

References NAMD_die(), PatchMap::Object(), and ComputeEwald::recvResults().

Referenced by sendComputeEwaldResults().

 {
     if (computeEwaldObject) {
         CmiEnableUrgentSend(1);
         computeEwaldObject->recvResults(msg);
         CmiEnableUrgentSend(0);
     }
     else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
     else NAMD_die("ComputeMgr::computeEwaldObject in recvResults is NULL!");
 }

void ComputeMgr::recvComputeGlobalConfig ( ComputeGlobalConfigMsg * )

void ComputeMgr::recvComputeGlobalData ( ComputeGlobalDataMsg * msg )

Definition at line 1278 of file ComputeMgr.C.

References NAMD_die(), and GlobalMasterServer::recvData().

 {
     if (masterServerObject)  // make sure it has been initialized
     {
         masterServerObject->recvData(msg);
     }
     else NAMD_die("ComputeMgr::masterServerObject is NULL!");
 }

void ComputeMgr::recvComputeGlobalResults ( ComputeGlobalResultsMsg * msg )

Definition at line 1306 of file ComputeMgr.C.

References ResizeArray< T >::add(), computeGlobalObject, computeGlobalResultsMsgs, computeGlobalResultsMsgSeq, NAMD_die(), PatchMap::Object(), ComputeGlobal::recvResults(), and ComputeGlobalResultsMsg::seq.

Referenced by enableComputeGlobalResults().

 {
     if ( computeGlobalObject )
     {
       if ( msg->seq == computeGlobalResultsMsgSeq ) {
         CmiEnableUrgentSend(1);
         computeGlobalObject->recvResults(msg);
         CmiEnableUrgentSend(0);
       } else {
         computeGlobalResultsMsgs.add(msg);
       }
     }
     else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
     else NAMD_die("ComputeMgr::computeGlobalObject is NULL!");
 }

void ComputeMgr::recvCreateNonbondedCUDASlave ( NonbondedCUDASlaveMsg * msg )

Definition at line 1519 of file ComputeMgr.C.

References Compute::cid, NonbondedCUDASlaveMsg::index, and NonbondedCUDASlaveMsg::master.

                                                                         {
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
   new ComputeNonbondedCUDA(msg->master->cid,this,msg->master,msg->index);
 #endif
 }

void ComputeMgr::recvCreateNonbondedMICSlave ( NonbondedMICSlaveMsg * msg )

Definition at line 1819 of file ComputeMgr.C.

References Compute::cid, NonbondedMICSlaveMsg::index, and NonbondedMICSlaveMsg::master.

                                                                       {
 #ifdef NAMD_MIC
   ComputeNonbondedMIC *c = new ComputeNonbondedMIC(msg->master->cid,this,msg->master,msg->index);
 #endif
 }

void ComputeMgr::recvFinishPatchesOnPe ( CudaComputeNonbondedMsg * msg )

Definition at line 1621 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c, and CudaComputeNonbonded::finishPatchesOnPe().

                                                                    {
   msg->c->finishPatchesOnPe();
   delete msg;
 }

void ComputeMgr::recvFinishPatchOnPe ( CudaComputeNonbondedMsg * msg )

Definition at line 1634 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c, CudaComputeNonbonded::finishPatchOnPe(), and CudaComputeNonbondedMsg::i.

                                                                  {
   msg->c->finishPatchOnPe(msg->i);
   delete msg;
 }

void ComputeMgr::recvFinishReductions ( CudaComputeNonbondedMsg * msg )

Definition at line 1659 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c, and CudaComputeNonbonded::finishReductions().

                                                                   {
   msg->c->finishReductions();
   delete msg;
 }

void ComputeMgr::recvLaunchWork ( CudaComputeNonbondedMsg * msg )

Definition at line 1681 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c, and CudaComputeNonbonded::launchWork().

                                                             {
   msg->c->launchWork();
   delete msg;
 }

void ComputeMgr::recvMessageEnqueueWork ( CudaComputeNonbondedMsg * msg )

Definition at line 1670 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c, and CudaComputeNonbonded::messageEnqueueWork().

                                                                     {
   msg->c->messageEnqueueWork();
   delete msg;
 }

void ComputeMgr::recvMICPEData	(	int	pe,
		int	data
	)

Definition at line 1870 of file ComputeMgr.C.

                                                {
   if (pe < 0 || pe >= CkNumPes() || micPEData == NULL) { return; }
   int majorIndex = pe / (sizeof(int)*8);
   int minorIndex = pe % (sizeof(int)*8);
   if (data != 0) {
     micPEData[majorIndex] |= (0x01 << minorIndex);
   } else {
     micPEData[majorIndex] &= ((~0x01) << minorIndex);
   }
 }

void ComputeMgr::recvNonbondedCUDASlaveReady	(	int	np,
		int	ac,
		int	seq
	)

Definition at line 1530 of file ComputeMgr.C.

References Compute::patchReady().

                                                                     {
   for ( int i=0; i<np; ++i ) {
     computeNonbondedCUDAObject->patchReady(-1,ac,seq);
   }
 }

void ComputeMgr::recvNonbondedCUDASlaveSkip ( NonbondedCUDASkipMsg * msg )

Definition at line 1547 of file ComputeMgr.C.

References NonbondedCUDASkipMsg::compute, and ComputeNonbondedCUDA::skip().

                                                                      {
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
   msg->compute->skip();
 #endif
   delete msg;
 }

void ComputeMgr::recvNonbondedMICSlaveReady	(	int	np,
		int	ac,
		int	seq
	)

Definition at line 1830 of file ComputeMgr.C.

References Compute::patchReady().

                                                                    {
   for ( int i=0; i<np; ++i ) {
     computeNonbondedMICObject->patchReady(-1,ac,seq);
   }
 }

void ComputeMgr::recvNonbondedMICSlaveSkip ( NonbondedMICSkipMsg * msg )

Definition at line 1847 of file ComputeMgr.C.

References NonbondedMICSkipMsg::compute, and ComputeNonbondedMIC::skip().

                                                                    {
 #ifdef NAMD_MIC
   msg->compute->skip();
 #endif
   delete msg;
 }

void ComputeMgr::recvOpenBoxesOnPe ( CudaComputeNonbondedMsg * msg )

Definition at line 1648 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c, and CudaComputeNonbonded::openBoxesOnPe().

                                                                {
   msg->c->openBoxesOnPe();
   delete msg;
 }

void ComputeMgr::recvSkipPatchesOnPe ( CudaComputeNonbondedMsg * msg )

Definition at line 1607 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c, and CudaComputeNonbonded::skipPatchesOnPe().

                                                                  {
   msg->c->skipPatchesOnPe();
   delete msg;
 }

void ComputeMgr::recvUnregisterBoxesOnPe ( CudaComputeNonbondedMsg * msg )

Definition at line 1694 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c, and CudaComputeNonbonded::unregisterBoxesOnPe().

                                                                      {
   msg->c->unregisterBoxesOnPe();
   delete msg;
 }

void ComputeMgr::recvYieldDevice ( int pe )

Definition at line 1439 of file ComputeMgr.C.

References ComputeNonbondedMIC::recvYieldDevice(), and ComputeNonbondedCUDA::recvYieldDevice().

                                        {
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
     computeNonbondedCUDAObject->recvYieldDevice(pe);
 #endif
 #ifdef NAMD_MIC
     computeNonbondedMICObject->recvYieldDevice(pe);
 #endif
 }

void ComputeMgr::sendAssignPatchesOnPe	(	std::vector< int > &	pes,
		CudaComputeNonbonded *	c
	)

Definition at line 1586 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c.

Referenced by CudaComputeNonbonded::assignPatches().

                                                                                    {
   for (int i=0;i < pes.size();i++) {
     CudaComputeNonbondedMsg *msg = new CudaComputeNonbondedMsg;
     msg->c = c;
     thisProxy[pes[i]].recvAssignPatchesOnPe(msg);
   }
 }

void ComputeMgr::sendBuildCudaExclusions ( )

Definition at line 1448 of file ComputeMgr.C.

Referenced by Node::resendMolecule().

                                          {
     CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
     int pe = CkNodeFirst(CkMyNode());
     int end = pe + CkNodeSize(CkMyNode());
     for( ; pe != end; ++pe ) {
       cm[pe].recvBuildCudaExclusions();
     }
 }

void ComputeMgr::sendBuildCudaForceTable ( )

Definition at line 1467 of file ComputeMgr.C.

Referenced by send_build_cuda_force_table().

                                          {
     CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
     int pe = CkNodeFirst(CkMyNode());
     int end = pe + CkNodeSize(CkMyNode());
     for( ; pe != end; ++pe ) {
       cm[pe].recvBuildCudaForceTable();
     }
 }

void ComputeMgr::sendBuildMICForceTable ( )

Definition at line 1486 of file ComputeMgr.C.

                                         {
   CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
   int pe = CkNodeFirst(CkMyNode());
   int end = pe + CkNodeSize(CkMyNode());
   for( ; pe != end; ++pe ) {
     cm[pe].recvBuildMICForceTable();
   }
 }

void ComputeMgr::sendComputeDPMEData ( ComputeDPMEDataMsg * msg )

Definition at line 1364 of file ComputeMgr.C.

References NAMD_die(), and PatchMap::Object().

 {
     if ( computeDPMEObject )
     {
 #ifdef DPME
         int node = computeDPMEObject->getMasterNode();
         CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
         cm.recvComputeDPMEData(msg,node);
 #endif
     }
     else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
     else NAMD_die("ComputeMgr::computeDPMEObject is NULL!");
 }

void ComputeMgr::sendComputeDPMEResults	(	ComputeDPMEResultsMsg *	msg,
		int	node
	)

Definition at line 1390 of file ComputeMgr.C.

 {
     CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
     cm[node].recvComputeDPMEResults(msg);
 }

void ComputeMgr::sendComputeEwaldData ( ComputeEwaldMsg * msg )

Definition at line 1325 of file ComputeMgr.C.

References ComputeEwald::getMasterNode(), NAMD_die(), and PatchMap::Object().

Referenced by ComputeEwald::doWork().

 {
     if (computeEwaldObject)
     {
         int node = computeEwaldObject->getMasterNode();
         CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
         cm[node].recvComputeEwaldData(msg);
     }
     else if (!PatchMap::Object()->numHomePatches())
     {
         CkPrintf("skipping message on Pe(%d)\n", CkMyPe());
         delete msg;
     }
     else NAMD_die("ComputeMgr::computeEwaldObject is NULL!");
 }

void ComputeMgr::sendComputeEwaldResults ( ComputeEwaldMsg * msg )

Definition at line 1348 of file ComputeMgr.C.

References recvComputeEwaldResults().

Referenced by ComputeEwald::recvData().

 {
     (CProxy_ComputeMgr(CkpvAccess(BOCclass_group).computeMgr)).recvComputeEwaldResults(msg);
 }

void ComputeMgr::sendComputeGlobalConfig ( ComputeGlobalConfigMsg * )

void ComputeMgr::sendComputeGlobalData ( ComputeGlobalDataMsg * msg )

Definition at line 1272 of file ComputeMgr.C.

Referenced by ComputeGlobal::doWork().

 {
     CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
     cm[0].recvComputeGlobalData(msg);
 }

void ComputeMgr::sendComputeGlobalResults ( ComputeGlobalResultsMsg * msg )

Definition at line 1287 of file ComputeMgr.C.

References computeGlobalResultsMsgMasterSeq, and ComputeGlobalResultsMsg::seq.

 {
     msg->seq = ++computeGlobalResultsMsgMasterSeq;
     thisProxy.recvComputeGlobalResults(msg);
 }

void ComputeMgr::sendCreateNonbondedCUDASlave	(	int	pe,
		int	index
	)

Definition at line 1511 of file ComputeMgr.C.

References NonbondedCUDASlaveMsg::index, and NonbondedCUDASlaveMsg::master.

Referenced by ComputeNonbondedCUDA::assignPatches().

                                                                {
   NonbondedCUDASlaveMsg *msg = new NonbondedCUDASlaveMsg;
   msg->master = computeNonbondedCUDAObject;
   msg->index = index;
   CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
   cm[pe].recvCreateNonbondedCUDASlave(msg);
 }

void ComputeMgr::sendCreateNonbondedMICSlave	(	int	pe,
		int	index
	)

Definition at line 1811 of file ComputeMgr.C.

References NonbondedMICSlaveMsg::index, and NonbondedMICSlaveMsg::master.

                                                               {
   NonbondedMICSlaveMsg *msg = new NonbondedMICSlaveMsg;
   msg->master = computeNonbondedMICObject;
   msg->index = index;
   CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
   cm[pe].recvCreateNonbondedMICSlave(msg);
 }

void ComputeMgr::sendFinishPatchesOnPe	(	std::vector< int > &	pes,
		CudaComputeNonbonded *	c
	)

Definition at line 1612 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c, COMPUTE_PROXY_PRIORITY, PRIORITY_SIZE, Compute::sequence(), and SET_PRIORITY.

                                                                                    {
   for (int i=0;i < pes.size();i++) {
     CudaComputeNonbondedMsg *msg = new (PRIORITY_SIZE) CudaComputeNonbondedMsg;
     SET_PRIORITY(msg, c->sequence(), COMPUTE_PROXY_PRIORITY);
     msg->c = c;
     thisProxy[pes[i]].recvFinishPatchesOnPe(msg);
   }
 }

void ComputeMgr::sendFinishPatchOnPe	(	int	pe,
		CudaComputeNonbonded *	c,
		int	i,
		PatchID	patchID
	)

Definition at line 1626 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c, COMPUTE_PROXY_PRIORITY, CudaComputeNonbondedMsg::i, PATCH_PRIORITY, PRIORITY_SIZE, Compute::sequence(), and SET_PRIORITY.

                                                                                             {
   CudaComputeNonbondedMsg *msg = new (PRIORITY_SIZE) CudaComputeNonbondedMsg;
   SET_PRIORITY(msg, c->sequence(), COMPUTE_PROXY_PRIORITY + PATCH_PRIORITY(patchID));
   msg->c = c;
   msg->i = i;
   thisProxy[pe].recvFinishPatchOnPe(msg);
 }

void ComputeMgr::sendFinishReductions	(	int	pe,
		CudaComputeNonbonded *	c
	)

Definition at line 1653 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c.

Referenced by CudaComputeNonbonded::skipPatchesOnPe().

                                                                      {
   CudaComputeNonbondedMsg *msg = new CudaComputeNonbondedMsg;
   msg->c = c;
   thisProxy[pe].recvFinishReductions(msg);
 }

void ComputeMgr::sendLaunchWork	(	int	pe,
		CudaComputeNonbonded *	c
	)

Definition at line 1675 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c.

Referenced by CudaComputeNonbonded::openBoxesOnPe().

                                                                {
   CudaComputeNonbondedMsg *msg = new CudaComputeNonbondedMsg;
   msg->c = c;
   thisProxy[pe].recvLaunchWork(msg);
 }

void ComputeMgr::sendMessageEnqueueWork	(	int	pe,
		CudaComputeNonbonded *	c
	)

Definition at line 1664 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c.

Referenced by CudaComputeNonbonded::noWork().

                                                                        {
   CudaComputeNonbondedMsg *msg = new CudaComputeNonbondedMsg;
   msg->c = c;
   thisProxy[pe].recvMessageEnqueueWork(msg);
 }

void ComputeMgr::sendMICPEData	(	int	pe,
		int	data
	)

Definition at line 1865 of file ComputeMgr.C.

                                                {
   CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
   cm.recvMICPEData(pe, data);
 }

void ComputeMgr::sendNonbondedCUDASlaveEnqueue	(	ComputeNonbondedCUDA *	c,
		int	pe,
		int	seq,
		int	prio,
		int	ws
	)

Definition at line 1554 of file ComputeMgr.C.

References Compute::cid, LocalWorkMsg::compute, ComputeNonbondedCUDA::localHostedPatches, Compute::localWorkMsg, ComputeNonbondedCUDA::localWorkMsg2, SET_PRIORITY, ResizeArray< T >::size(), and Compute::type().

Referenced by ComputeNonbondedCUDA::finishWork().

                                                                                                          {
   if ( ws == 2 && c->localHostedPatches.size() == 0 ) return;
   LocalWorkMsg *msg = ( ws == 1 ? c->localWorkMsg : c->localWorkMsg2 );
   msg->compute = c;
   int type = c->type();
   int cid = c->cid;
   SET_PRIORITY(msg,seq,prio);
   CProxy_WorkDistrib wdProxy(CkpvAccess(BOCclass_group).workDistrib);
   wdProxy[pe].enqueueCUDA(msg);
 }

void ComputeMgr::sendNonbondedCUDASlaveEnqueuePatch	(	ComputeNonbondedCUDA *	c,
		int	pe,
		int	seq,
		int	prio,
		int	data,
		FinishWorkMsg *	msg
	)

Definition at line 1565 of file ComputeMgr.C.

References FinishWorkMsg::compute, FinishWorkMsg::data, and SET_PRIORITY.

Referenced by ComputeNonbondedCUDA::messageFinishPatch().

                                                                                                                                     {
   msg->compute = c;
   msg->data = data;
   SET_PRIORITY(msg,seq,prio);
   CProxy_WorkDistrib wdProxy(CkpvAccess(BOCclass_group).workDistrib);
   wdProxy[pe].finishCUDAPatch(msg);
 }

void ComputeMgr::sendNonbondedCUDASlaveReady	(	int	pe,
		int	np,
		int	ac,
		int	seq
	)

Definition at line 1525 of file ComputeMgr.C.

Referenced by ComputeNonbondedCUDA::noWork().

                                                                             {
   CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
   cm[pe].recvNonbondedCUDASlaveReady(np,ac,seq);
 }

void ComputeMgr::sendNonbondedCUDASlaveSkip	(	ComputeNonbondedCUDA *	c,
		int	pe
	)

Definition at line 1541 of file ComputeMgr.C.

References NonbondedCUDASkipMsg::compute.

Referenced by ComputeNonbondedCUDA::noWork().

                                                                            {
   NonbondedCUDASkipMsg *msg = new NonbondedCUDASkipMsg;
   msg->compute = c;
   thisProxy[pe].recvNonbondedCUDASlaveSkip(msg);
 }

void ComputeMgr::sendNonbondedMICSlaveEnqueue	(	ComputeNonbondedMIC *	c,
		int	pe,
		int	seq,
		int	prio,
		int	ws
	)

Definition at line 1854 of file ComputeMgr.C.

References Compute::cid, LocalWorkMsg::compute, ComputeNonbondedMIC::localHostedPatches, Compute::localWorkMsg, ComputeNonbondedMIC::localWorkMsg2, SET_PRIORITY, ResizeArray< T >::size(), and Compute::type().

                                                                                                        {
   if ( ws == 2 && c->localHostedPatches.size() == 0 ) return;
   LocalWorkMsg *msg = ( ws == 1 ? c->localWorkMsg : c->localWorkMsg2 );
   msg->compute = c;
   int type = c->type();
   int cid = c->cid;
   SET_PRIORITY(msg,seq,prio);
   CProxy_WorkDistrib wdProxy(CkpvAccess(BOCclass_group).workDistrib);
   wdProxy[pe].enqueueMIC(msg);
 }

void ComputeMgr::sendNonbondedMICSlaveReady	(	int	pe,
		int	np,
		int	ac,
		int	seq
	)

Definition at line 1825 of file ComputeMgr.C.

                                                                            {
   CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
   cm[pe].recvNonbondedMICSlaveReady(np,ac,seq);
 }

void ComputeMgr::sendNonbondedMICSlaveSkip	(	ComputeNonbondedMIC *	c,
		int	pe
	)

Definition at line 1841 of file ComputeMgr.C.

References NonbondedMICSkipMsg::compute.

                                                                          {
   NonbondedMICSkipMsg *msg = new NonbondedMICSkipMsg;
   msg->compute = c;
   thisProxy[pe].recvNonbondedMICSlaveSkip(msg);
 }

void ComputeMgr::sendOpenBoxesOnPe	(	std::vector< int > &	pes,
		CudaComputeNonbonded *	c
	)

Definition at line 1639 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c, PRIORITY_SIZE, PROXY_DATA_PRIORITY, Compute::sequence(), and SET_PRIORITY.

Referenced by CudaComputeNonbonded::doWork().

                                                                                {
   for (int i=0;i < pes.size();i++) {
     CudaComputeNonbondedMsg *msg = new (PRIORITY_SIZE) CudaComputeNonbondedMsg;
     SET_PRIORITY(msg, c->sequence(), PROXY_DATA_PRIORITY+1); // after bonded
     msg->c = c;
     thisProxy[pes[i]].recvOpenBoxesOnPe(msg);
   }
 }

void ComputeMgr::sendSkipPatchesOnPe	(	std::vector< int > &	pes,
		CudaComputeNonbonded *	c
	)

Definition at line 1599 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c.

                                                                                  {
   for (int i=0;i < pes.size();i++) {
     CudaComputeNonbondedMsg *msg = new CudaComputeNonbondedMsg;
     msg->c = c;
     thisProxy[pes[i]].recvSkipPatchesOnPe(msg);
   }
 }

void ComputeMgr::sendUnregisterBoxesOnPe	(	std::vector< int > &	pes,
		CudaComputeNonbonded *	c
	)

Definition at line 1686 of file ComputeMgr.C.

References CudaComputeNonbondedMsg::c.

Referenced by CudaComputeNonbonded::~CudaComputeNonbonded().

                                                                                      {
   for (int i=0;i < pes.size();i++) {
     CudaComputeNonbondedMsg *msg = new CudaComputeNonbondedMsg;
     msg->c = c;
     thisProxy[pes[i]].recvUnregisterBoxesOnPe(msg);
   }
 }

void ComputeMgr::sendYieldDevice ( int pe )

Definition at line 1434 of file ComputeMgr.C.

Referenced by cuda_check_local_calc(), and cuda_check_remote_calc().

                                        {
     CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
     cm[pe].recvYieldDevice(CkMyPe());
 }

void ComputeMgr::splitComputes ( )

Definition at line 175 of file ComputeMgr.C.

References ComputeMap::cloneCompute(), ComputeMap::extendPtrs(), ComputeMap::newNode(), ComputeMap::newNumPartitions(), ComputeMap::node(), ComputeMap::numComputes(), ComputeMap::numPartitions(), ComputeMap::Object(), ComputeMap::setNewNode(), ComputeMap::setNewNumPartitions(), and ComputeMap::setNumPartitions().

 {
   if ( ! CkMyRank() ) {
     ComputeMap *computeMap = ComputeMap::Object();
     const int nc = computeMap->numComputes();
 
     for (int i=0; i<nc; i++) {
       int nnp = computeMap->newNumPartitions(i);
       if ( nnp > 0 ) {
         if ( computeMap->numPartitions(i) != 1 ) {
           CkPrintf("Warning: unable to partition compute %d\n", i);
           computeMap->setNewNumPartitions(i,0);
           continue;
         }
         //CkPrintf("splitting compute %d by %d\n",i,nnp);
         computeMap->setNumPartitions(i,nnp);
         if (computeMap->newNode(i) == -1) {
           computeMap->setNewNode(i,computeMap->node(i));
         }
         for ( int j=1; j<nnp; ++j ) {
           int newcid = computeMap->cloneCompute(i,j);
           //CkPrintf("compute %d partition %d is %d\n",i,j,newcid);
         }
       }
     }
     computeMap->extendPtrs();
   }
 
   if (!CkMyPe())
   {
     CkStartQD(CkIndex_ComputeMgr::splitComputes2((CkQdMsg*)0), &thishandle);
   }
 }

void ComputeMgr::splitComputes2 ( CkQdMsg * msg )

Definition at line 209 of file ComputeMgr.C.

 {
     delete msg;
     CProxy_ComputeMgr(thisgroup).updateLocalComputes();
 }

void ComputeMgr::updateComputes	(	int	ep,
		CkGroupID	chareID
	)

Definition at line 142 of file ComputeMgr.C.

References NAMD_bug().

Referenced by LdbCoordinator::ExecuteMigrations().

 {
     updateComputesReturnEP = ep;
     updateComputesReturnChareID = chareID;
     updateComputesCount = CkNumPes();
 
     if (CkMyPe())
     {
         NAMD_bug("updateComputes signaled on wrong Pe!");
     }
 
     CkStartQD(CkIndex_ComputeMgr::updateComputes2((CkQdMsg*)0),&thishandle);
 }

void ComputeMgr::updateComputes2 ( CkQdMsg * msg )

Definition at line 156 of file ComputeMgr.C.

References WorkDistrib::saveComputeMapChanges().

 {
     delete msg;
 
     CProxy_WorkDistrib wd(CkpvAccess(BOCclass_group).workDistrib);
     WorkDistrib  *workDistrib = wd.ckLocalBranch();
     workDistrib->saveComputeMapChanges(CkIndex_ComputeMgr::updateComputes3(),thisgroup);
 }

void ComputeMgr::updateComputes3 ( )

Definition at line 165 of file ComputeMgr.C.

 {
     if ( skipSplitting ) {
       CProxy_ComputeMgr(thisgroup).updateLocalComputes();
     } else {
       CProxy_ComputeMgr(thisgroup).splitComputes();
       skipSplitting = 1;
     }
 }

void ComputeMgr::updateLocalComputes ( )

Definition at line 215 of file ComputeMgr.C.

References ResizeArray< T >::add(), ComputeMap::compute(), ProxyMgr::createProxy(), Compute::ldObjHandle, LdbCoordinator::Migrate(), ComputeMap::newNode(), ComputeMap::newNumPartitions(), ComputeMap::node(), ComputeMap::numComputes(), ComputeMap::numPids(), ComputeMap::Object(), LdbCoordinator::Object(), ComputeMap::pid(), ComputeMap::registerCompute(), and ResizeArray< T >::resize().

 {
     ComputeMap *computeMap = ComputeMap::Object();
     CProxy_ProxyMgr pm(CkpvAccess(BOCclass_group).proxyMgr);
     ProxyMgr *proxyMgr = pm.ckLocalBranch();
     LdbCoordinator *ldbCoordinator = LdbCoordinator::Object();
 
      computeFlag.resize(0);
 
     const int nc = computeMap->numComputes();
     for (int i=0; i<nc; i++) {
 
         if ( computeMap->node(i) == CkMyPe() &&
              computeMap->newNumPartitions(i) > 1 ) {
            Compute *c = computeMap->compute(i);
            ldbCoordinator->Migrate(c->ldObjHandle,CkMyPe());
            delete c;
            computeMap->registerCompute(i,NULL);
            if ( computeMap->newNode(i) == CkMyPe() ) computeFlag.add(i); 
         } else
         if (computeMap->newNode(i) == CkMyPe() && computeMap->node(i) != CkMyPe())
         {
             computeFlag.add(i);
             for (int n=0; n < computeMap->numPids(i); n++)
             {
                 proxyMgr->createProxy(computeMap->pid(i,n));
             }
         }
         else if (computeMap->node(i) == CkMyPe() &&
                  (computeMap->newNode(i) != -1 && computeMap->newNode(i) != CkMyPe() ))
         {
             // CkPrintf("delete compute %d on pe %d\n",i,CkMyPe());
             delete computeMap->compute(i);
             computeMap->registerCompute(i,NULL);
         }
     }
 
     if (!CkMyPe())
     {
         CkStartQD(CkIndex_ComputeMgr::updateLocalComputes2((CkQdMsg*)0), &thishandle);
     }
 }

void ComputeMgr::updateLocalComputes2 ( CkQdMsg * msg )

Definition at line 259 of file ComputeMgr.C.

 {
     delete msg;
     CProxy_ComputeMgr(thisgroup).updateLocalComputes3();
 }

void ComputeMgr::updateLocalComputes3 ( )

Definition at line 266 of file ComputeMgr.C.

References ResizeArray< T >::clear(), ComputeMap::newNode(), ProxyMgr::nodecount, ComputeMap::numComputes(), ComputeMap::Object(), ProxyMgr::removeUnusedProxies(), ComputeMap::setNewNode(), ComputeMap::setNewNumPartitions(), ComputeMap::setNode(), and ResizeArray< T >::size().

 {
     ComputeMap *computeMap = ComputeMap::Object();
     CProxy_ProxyMgr pm(CkpvAccess(BOCclass_group).proxyMgr);
     ProxyMgr *proxyMgr = pm.ckLocalBranch();
 
     ProxyMgr::nodecount = 0;
 
     const int nc = computeMap->numComputes();
 
     if ( ! CkMyRank() ) {
       for (int i=0; i<nc; i++) {
         computeMap->setNewNumPartitions(i,0);
         if (computeMap->newNode(i) != -1) {
           computeMap->setNode(i,computeMap->newNode(i));
           computeMap->setNewNode(i,-1);
         }
       }
     }
  
     for(int i=0; i<computeFlag.size(); i++) createCompute(computeFlag[i], computeMap);
     computeFlag.clear();
 
     proxyMgr->removeUnusedProxies();
 
     if (!CkMyPe())
     {
         CkStartQD(CkIndex_ComputeMgr::updateLocalComputes4((CkQdMsg*)0), &thishandle);
     }
 }

void ComputeMgr::updateLocalComputes4 ( CkQdMsg * msg )

Definition at line 298 of file ComputeMgr.C.

References SimParameters::computeMapFilename, Node::Object(), ComputeMap::Object(), ComputeMap::saveComputeMap(), Node::simParameters, simParams, and SimParameters::storeComputeMap.

 {
     delete msg;
     CProxy_ComputeMgr(thisgroup).updateLocalComputes5();
 
     // store the latest compute map
            SimParameters *simParams = Node::Object()->simParameters;
     if (simParams->storeComputeMap) {
       ComputeMap *computeMap = ComputeMap::Object();
       computeMap->saveComputeMap(simParams->computeMapFilename);
     }
 }

void ComputeMgr::updateLocalComputes5 ( )

Definition at line 316 of file ComputeMgr.C.

References ProxyMgr::buildProxySpanningTree2(), PatchMap::checkMap(), ComputeMap::checkMap(), PatchMap::Object(), ComputeMap::Object(), ProxyMgr::Object(), proxyRecvSpanning, proxySendSpanning, and ProxyMgr::sendSpanningTrees().

 {
     if ( ! CkMyRank() ) {
       ComputeMap::Object()->checkMap();
       PatchMap::Object()->checkMap();
     }
 
     // we always use the centralized building of spanning tree
     // distributed building of ST called in Node.C only
     if (proxySendSpanning || proxyRecvSpanning)
         ProxyMgr::Object()->buildProxySpanningTree2();
 
     // this code needs to be turned on if we want to
     // shift the creation of ST to the load balancer
 
 #if 0
     if (proxySendSpanning || proxyRecvSpanning)
     {
         if (firstphase)
             ProxyMgr::Object()->buildProxySpanningTree2();
         else
             if (CkMyPe() == 0)
                 ProxyMgr::Object()->sendSpanningTrees();
 
         firstphase = 0;
     }
 #endif
 
     if (!CkMyPe())
         CkStartQD(CkIndex_ComputeMgr::doneUpdateLocalComputes(), &thishandle);
 }