Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members

ComputeMgr Class Reference

#include <ComputeMgr.h>

Inheritance diagram for ComputeMgr:

BOCclass List of all members.

Public Member Functions

 ComputeMgr ()
 ~ComputeMgr ()
void createComputes (ComputeMap *map)
void updateComputes (int, CkGroupID)
void updateComputes2 (CkQdMsg *)
void updateComputes3 ()
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 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 *)

Public Attributes

ComputeGlobal * computeGlobalObject

Constructor & Destructor Documentation

ComputeMgr::ComputeMgr (   ) 
 

Definition at line 75 of file ComputeMgr.C.

References computeGlobalObject.

00076 {
00077     CpvAccess(BOCclass_group).computeMgr = thisgroup;
00078     computeGlobalObject = 0;
00079     computeDPMEObject = 0;
00080     computeEwaldObject = 0;
00081     computeNonbondedWorkArrays = new ComputeNonbondedWorkArrays;
00082 }

ComputeMgr::~ComputeMgr (   ) 
 

Definition at line 84 of file ComputeMgr.C.

00085 {
00086     delete computeNonbondedWorkArrays;
00087 }

Member Function Documentation

void ComputeMgr::createComputes (  ComputeMap *  map  ) 
 

Definition at line 581 of file ComputeMgr.C.

References GlobalMasterServer::addClient(), ComputeMap::computeData, DebugM, SimParameters::firstTimestep, SimParameters::freeEnergyOn, SimParameters::globalForcesOn, SimParameters::IMDon, SimParameters::miscForcesOn, Node::molecule, Node::myid(), ComputeMap::nComputes, Molecule::numAtoms, Node::Object(), ComputeNonbondedUtil::select(), Node::simParameters, simParams, SimParameters::SMDDir, SimParameters::SMDFile, SimParameters::SMDk, SimParameters::SMDk2, SimParameters::SMDOn, SimParameters::SMDOutputFreq, SimParameters::SMDVel, SimParameters::tclForcesOn, and SimParameters::TMDOn.

Referenced by Node::startup().

00582 {
00583     Node *node = Node::Object();
00584     SimParameters *simParams = node->simParameters;
00585     int myNode = node->myid();
00586 
00587     numNonbondedSelf = 0;
00588     numNonbondedPair = 0;
00589     ComputeNonbondedUtil::select();
00590 
00591     if ( simParams->globalForcesOn && !myNode )
00592     {
00593         DebugM(4,"Mgr running on Node "<<CkMyPe()<<"\n");
00594         /* create a master server to allow multiple masters */
00595         masterServerObject = new GlobalMasterServer(this,
00596                 PatchMap::Object()->numNodesWithPatches());
00597 
00598         /* create the individual global masters */
00599         // masterServerObject->addClient(new GlobalMasterTest());
00600         if (simParams->tclForcesOn)
00601             masterServerObject->addClient(new GlobalMasterTcl());
00602         if (simParams->IMDon)
00603             masterServerObject->addClient(new GlobalMasterIMD());
00604 
00605         if (simParams->SMDOn)
00606             masterServerObject->addClient(
00607                 new GlobalMasterSMD(simParams->SMDk, simParams->SMDk2,
00608                                     simParams->SMDVel,
00609                                     simParams->SMDDir, simParams->SMDOutputFreq,
00610                                     simParams->firstTimestep, simParams->SMDFile,
00611                                     node->molecule->numAtoms)
00612             );
00613         if (simParams->TMDOn)
00614             masterServerObject->addClient(new GlobalMasterTMD());
00615         if (simParams->miscForcesOn)
00616             masterServerObject->addClient(new GlobalMasterMisc());
00617         if ( simParams->freeEnergyOn )
00618             masterServerObject->addClient(new GlobalMasterFreeEnergy());
00619     }
00620 
00621     for (int i=0; i < map->nComputes; i++)
00622     {
00623         if ( ! ( i % 100 ) )
00624         {
00625         }
00626         if ( map->computeData[i].node != myNode ) continue;
00627         DebugM(1,"Compute " << i << '\n');
00628         DebugM(1,"  node = " << map->computeData[i].node << '\n');
00629         DebugM(1,"  type = " << map->computeData[i].type << '\n');
00630         DebugM(1,"  patchBased = " << map->computeData[i].patchBased << '\n');
00631         DebugM(1,"  numPids = " << map->computeData[i].numPids << '\n');
00632         DebugM(1,"  numPidsAllocated = " << map->computeData[i].numPidsAllocated << '\n');
00633         for (int j=0; j < map->computeData[i].numPids; j++)
00634         {
00635             //      DebugM(1,"  pid " << map->computeData[i].pids[j] << '\n');
00636             if (!((j+1) % 6))
00637                 DebugM(1,'\n');
00638         }
00639         DebugM(1,"\n---------------------------------------");
00640         DebugM(1,"---------------------------------------\n");
00641 
00642         createCompute(i, map);
00643 
00644     }
00645 
00646 }

void ComputeMgr::doneUpdateLocalComputes (   ) 
 

Definition at line 269 of file ComputeMgr.C.

References DebugM.

00270 {
00271 
00272 //  if (!--updateComputesCount) {
00273     DebugM(4, "doneUpdateLocalComputes on Pe("<<CkMyPe()<<")\n");
00274     void *msg = CkAllocMsg(0,0,0);
00275     CkSendMsgBranch(updateComputesReturnEP,msg,0,updateComputesReturnChareID);
00276 //  }
00277 }

void ComputeMgr::recvComputeConsForceMsg (  ComputeConsForceMsg *   ) 
 

Definition at line 789 of file ComputeMgr.C.

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

00790 {
00791     Molecule *m = Node::Object()->molecule;
00792     delete [] m->consForceIndexes;
00793     delete [] m->consForce;
00794     int n = msg->aid.size();
00795     if (n > 0)
00796     {
00797         m->consForceIndexes = new int32[m->numAtoms];
00798         m->consForce = new Vector[n];
00799         int i;
00800         for (i=0; i<m->numAtoms; i++) m->consForceIndexes[i] = -1;
00801         for (i=0; i<msg->aid.size(); i++)
00802         {
00803             m->consForceIndexes[msg->aid[i]] = i;
00804             m->consForce[i] = msg->f[i];
00805         }
00806     }
00807     else
00808     {
00809         m->consForceIndexes = NULL;
00810         m->consForce = NULL;
00811     }
00812     delete msg;
00813 }

void ComputeMgr::recvComputeDPMEData (  ComputeDPMEDataMsg *   ) 
 

Definition at line 755 of file ComputeMgr.C.

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

00756 {
00757     if ( computeDPMEObject )
00758     {
00759 #ifdef DPME
00760         computeDPMEObject->recvData(msg);
00761 #endif
00762     }
00763     else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
00764     else NAMD_die("ComputeMgr::computeDPMEObject is NULL!");
00765 }

void ComputeMgr::recvComputeDPMEResults (  ComputeDPMEResultsMsg *   ) 
 

Definition at line 777 of file ComputeMgr.C.

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

00778 {
00779     if ( computeDPMEObject )
00780     {
00781 #ifdef DPME
00782         computeDPMEObject->recvResults(msg);
00783 #endif
00784     }
00785     else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
00786     else NAMD_die("ComputeMgr::computeDPMEObject is NULL!");
00787 }

void ComputeMgr::recvComputeEwaldData (  ComputeEwaldMsg *   ) 
 

Definition at line 721 of file ComputeMgr.C.

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

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

void ComputeMgr::recvComputeEwaldResults (  ComputeEwaldMsg *   ) 
 

Definition at line 733 of file ComputeMgr.C.

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

00734 {
00735     if (computeEwaldObject)
00736         computeEwaldObject->recvResults(msg);
00737     else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
00738     else NAMD_die("ComputeMgr::computeEwaldObject in recvResults is NULL!");
00739 }

void ComputeMgr::recvComputeGlobalConfig (  ComputeGlobalConfigMsg *   ) 
 

Definition at line 654 of file ComputeMgr.C.

References computeGlobalObject, NAMD_die(), PatchMap::Object(), and ComputeGlobal::recvConfig().

00655 {
00656     if ( computeGlobalObject )
00657     {
00658         computeGlobalObject->recvConfig(msg);
00659     }
00660     else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
00661     else NAMD_die("ComputeMgr::computeGlobalObject is NULL!");
00662 }

void ComputeMgr::recvComputeGlobalData (  ComputeGlobalDataMsg *   ) 
 

Definition at line 674 of file ComputeMgr.C.

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

00675 {
00676     if (masterServerObject)  // make sure it has been initialized
00677     {
00678         masterServerObject->recvData(msg);
00679     }
00680     else NAMD_die("ComputeMgr::masterServerObject is NULL!");
00681 }

void ComputeMgr::recvComputeGlobalResults (  ComputeGlobalResultsMsg *   ) 
 

Definition at line 688 of file ComputeMgr.C.

References computeGlobalObject, NAMD_die(), PatchMap::Object(), and ComputeGlobal::recvResults().

00689 {
00690     if ( computeGlobalObject )
00691     {
00692         computeGlobalObject->recvResults(msg);
00693     }
00694     else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
00695     else NAMD_die("ComputeMgr::computeGlobalObject is NULL!");
00696 }

void ComputeMgr::sendComputeDPMEData (  ComputeDPMEDataMsg *   ) 
 

Definition at line 741 of file ComputeMgr.C.

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

00742 {
00743     if ( computeDPMEObject )
00744     {
00745 #ifdef DPME
00746         int node = computeDPMEObject->getMasterNode();
00747         CProxy_ComputeMgr cm(CpvAccess(BOCclass_group).computeMgr);
00748         cm.recvComputeDPMEData(msg,node);
00749 #endif
00750     }
00751     else if ( ! (PatchMap::Object())->numHomePatches() ) delete msg;
00752     else NAMD_die("ComputeMgr::computeDPMEObject is NULL!");
00753 }

void ComputeMgr::sendComputeDPMEResults (  ComputeDPMEResultsMsg *  ,
int 
) 
 

Definition at line 767 of file ComputeMgr.C.

00768 {
00769     CProxy_ComputeMgr cm(CpvAccess(BOCclass_group).computeMgr);
00770 #if CHARM_VERSION > 050402
00771     cm[node].recvComputeDPMEResults(msg);
00772 #else
00773     cm.recvComputeDPMEResults(msg, node);
00774 #endif
00775 }

void ComputeMgr::sendComputeEwaldData (  ComputeEwaldMsg *   ) 
 

Definition at line 701 of file ComputeMgr.C.

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

Referenced by ComputeEwald::doWork().

00702 {
00703     if (computeEwaldObject)
00704     {
00705         int node = computeEwaldObject->getMasterNode();
00706         CProxy_ComputeMgr cm(CpvAccess(BOCclass_group).computeMgr);
00707 #if CHARM_VERSION > 050402
00708         cm[node].recvComputeEwaldData(msg);
00709 #else
00710         cm.recvComputeEwaldData(msg, node);
00711 #endif
00712     }
00713     else if (!PatchMap::Object()->numHomePatches())
00714     {
00715         CkPrintf("skipping message on Pe(%d)\n", CkMyPe());
00716         delete msg;
00717     }
00718     else NAMD_die("ComputeMgr::computeEwaldObject is NULL!");
00719 }

void ComputeMgr::sendComputeEwaldResults (  ComputeEwaldMsg *   ) 
 

Definition at line 728 of file ComputeMgr.C.

Referenced by ComputeEwald::recvData().

00729 {
00730     (CProxy_ComputeMgr(CpvAccess(BOCclass_group).computeMgr)).recvComputeEwaldResults(msg);
00731 }

void ComputeMgr::sendComputeGlobalConfig (  ComputeGlobalConfigMsg *   ) 
 

Definition at line 649 of file ComputeMgr.C.

00650 {
00651     (CProxy_ComputeMgr(CpvAccess(BOCclass_group).computeMgr)).recvComputeGlobalConfig(msg);
00652 }

void ComputeMgr::sendComputeGlobalData (  ComputeGlobalDataMsg *   ) 
 

Definition at line 664 of file ComputeMgr.C.

Referenced by ComputeGlobal::doWork().

00665 {
00666     CProxy_ComputeMgr cm(CpvAccess(BOCclass_group).computeMgr);
00667 #if CHARM_VERSION > 050402
00668     cm[0].recvComputeGlobalData(msg);
00669 #else
00670     cm.recvComputeGlobalData(msg, 0);
00671 #endif
00672 }

void ComputeMgr::sendComputeGlobalResults (  ComputeGlobalResultsMsg *   ) 
 

Definition at line 683 of file ComputeMgr.C.

00684 {
00685     (CProxy_ComputeMgr(CpvAccess(BOCclass_group).computeMgr)).recvComputeGlobalResults(msg);
00686 }

void ComputeMgr::updateComputes (  int  ,
CkGroupID 
) 
 

Definition at line 89 of file ComputeMgr.C.

References iERRORF, iout, and iPE().

Referenced by LdbCoordinator::ExecuteMigrations().

00090 {
00091     updateComputesReturnEP = ep;
00092     updateComputesReturnChareID = chareID;
00093     updateComputesCount = CkNumPes();
00094 
00095     if (CkMyPe())
00096     {
00097         iout << iPE << iERRORF << "updateComputes signaled on wrong Pe!\n" << endi;
00098         CkExit();
00099         return;
00100     }
00101 
00102 #if CHARM_VERSION > 050402
00103     CkStartQD(CkIndex_ComputeMgr::updateComputes2((CkQdMsg*)0),&thishandle);
00104 #else
00105     CkStartQD(CProxy_ComputeMgr::ckIdx_updateComputes2((CkQdMsg*)0),&thishandle);
00106 #endif
00107 }

void ComputeMgr::updateComputes2 (  CkQdMsg *   ) 
 

Definition at line 109 of file ComputeMgr.C.

References WorkDistrib::saveComputeMapChanges().

00110 {
00111     delete msg;
00112 
00113     CProxy_WorkDistrib wd(CpvAccess(BOCclass_group).workDistrib);
00114     WorkDistrib  *workDistrib = wd.ckLocalBranch();
00115 #if CHARM_VERSION > 050402
00116     workDistrib->saveComputeMapChanges(CkIndex_ComputeMgr::updateComputes3(),thisgroup);
00117 #else
00118     workDistrib->saveComputeMapChanges(CProxy_ComputeMgr::ckIdx_updateComputes3(),thisgroup);
00119 #endif
00120 }

void ComputeMgr::updateComputes3 (   ) 
 

Definition at line 122 of file ComputeMgr.C.

00123 {
00124     CProxy_ComputeMgr(thisgroup).updateLocalComputes();
00125 }

void ComputeMgr::updateLocalComputes (   ) 
 

Definition at line 127 of file ComputeMgr.C.

References ProxyMgr::createProxy(), DebugM, ComputeMap::newNode(), ComputeMap::node(), ComputeMap::numComputes(), ComputeMap::numPids(), ComputeMap::Object(), ComputeMap::pid(), ComputeMap::setNewNode(), and ComputeMap::setNode().

00128 {
00129     ComputeMap *computeMap = ComputeMap::Object();
00130     CProxy_ProxyMgr pm(CpvAccess(BOCclass_group).proxyMgr);
00131     ProxyMgr *proxyMgr = pm.ckLocalBranch();
00132 
00133     computeFlag = new int[computeMap->numComputes()];
00134 
00135     for (int i=0; i<computeMap->numComputes(); i++)
00136     {
00137         DebugM(3, "updateLocalComputes("<<i<<") curnode="<<computeMap->node(i)
00138                <<" newnode="<<computeMap->newNode(i)<<"\n");
00139         computeFlag[i] = 0;
00140 
00141         if (computeMap->newNode(i) == CkMyPe() && computeMap->node(i) != CkMyPe())
00142         {
00143             DebugM(4, "updateLocal - creating new computeID("<<i<<")\n");
00144             computeFlag[i] = 1;
00145             computeMap->setNode(i,computeMap->newNode(i));
00146             for (int n=0; n < computeMap->numPids(i); n++)
00147             {
00148                 proxyMgr->createProxy(computeMap->pid(i,n));
00149             }
00150         }
00151         else if (computeMap->node(i) == CkMyPe() &&
00152                  (computeMap->newNode(i) != -1 && computeMap->newNode(i) != CkMyPe() ))
00153         {
00154             DebugM(4, "updateLocal - deleting computeID("<<i<<")\n");
00155             computeFlag[i] = -1;
00156             computeMap->setNode(i,computeMap->newNode(i));
00157         }
00158         else if (computeMap->newNode(i) != -1)
00159         {
00160             computeMap->setNode(i,computeMap->newNode(i));
00161         }
00162         computeMap->setNewNode(i,-1);
00163     }
00164 
00165     if (!CkMyPe())
00166     {
00167 #if CHARM_VERSION > 050402
00168         CkStartQD(CkIndex_ComputeMgr::updateLocalComputes2((CkQdMsg*)0), &thishandle);
00169 #else
00170         CkStartQD(CProxy_ComputeMgr::ckIdx_updateLocalComputes2((CkQdMsg*)0), &thishandle);
00171 #endif
00172     }
00173 }

void ComputeMgr::updateLocalComputes2 (  CkQdMsg *   ) 
 

Definition at line 176 of file ComputeMgr.C.

00177 {
00178     delete msg;
00179     CProxy_ComputeMgr(thisgroup).updateLocalComputes3();
00180 }

void ComputeMgr::updateLocalComputes3 (   ) 
 

Definition at line 183 of file ComputeMgr.C.

References PatchMap::checkMap(), ComputeMap::checkMap(), ComputeMap::compute(), DebugM, ComputeMap::numComputes(), PatchMap::Object(), ComputeMap::Object(), ComputeMap::registerCompute(), and ProxyMgr::removeUnusedProxies().

00184 {
00185     ComputeMap *computeMap = ComputeMap::Object();
00186     CProxy_ProxyMgr pm(CpvAccess(BOCclass_group).proxyMgr);
00187     ProxyMgr *proxyMgr = pm.ckLocalBranch();
00188 
00189     ProxyMgr::nodecount = 0;
00190 
00191     for (int i=0; i<computeMap->numComputes(); i++)
00192     {
00193         if (1 == computeFlag[i])
00194         {
00195             DebugM(4, "updateLocalCompute3() - create computeID(" << i << ")\n");
00196             createCompute(i, computeMap);
00197         }
00198         else if (-1 == computeFlag[i])
00199         {
00200             // remove this compute
00201             DebugM(4, "updateLocalCompute3() - delete computeID(" << i << ")\n");
00202             delete computeMap->compute(i);
00203             computeMap->registerCompute(i,NULL);
00204         }
00205     }
00206     delete[] computeFlag;
00207 
00208     proxyMgr->removeUnusedProxies();
00209 
00210     DebugM(4, "msg to doneUpdateLocalComputes on Pe("<<CkMyPe()<<")\n");
00211     ComputeMap::Object()->checkMap();
00212     PatchMap::Object()->checkMap();
00213 
00214     if (!CkMyPe())
00215     {
00216 #if CHARM_VERSION > 050402
00217         CkStartQD(CkIndex_ComputeMgr::updateLocalComputes4((CkQdMsg*)0), &thishandle);
00218 #else
00219         CkStartQD(CProxy_ComputeMgr::ckIdx_updateLocalComputes4((CkQdMsg*)0), &thishandle);
00220 #endif
00221 // added a new phase to build spanning tree after load balance
00222 // was
00223 //    CkStartQD(CProxy_ComputeMgr::ckIdx_doneUpdateLocalComputes(), &thishandle);
00224     }
00225     //CSendMsgBranch(ComputeMgr, doneUpdateLocalComputes, thisgroup, 0);
00226 }

void ComputeMgr::updateLocalComputes4 (  CkQdMsg *   ) 
 

Definition at line 229 of file ComputeMgr.C.

00230 {
00231     delete msg;
00232     CProxy_ComputeMgr(thisgroup).updateLocalComputes5();
00233 }

void ComputeMgr::updateLocalComputes5 (   ) 
 

Definition at line 238 of file ComputeMgr.C.

References ProxyMgr::buildProxySpanningTree2(), firstphase, ProxyMgr::Object(), proxySendSpanning, and ProxyMgr::sendSpanningTrees().

00239 {
00240     // we always use the centralized building of spanning tree
00241     // distributed building of ST called in Node.C only
00242     if (proxySendSpanning || proxyRecvSpanning)
00243         ProxyMgr::Object()->buildProxySpanningTree2();
00244 
00245     // this code needs to be turned on if we want to
00246     // shift the creation of ST to the load balancer
00247 
00248 #if 0
00249     if (proxySendSpanning || proxyRecvSpanning)
00250     {
00251         if (firstphase)
00252             ProxyMgr::Object()->buildProxySpanningTree2();
00253         else
00254             if (CkMyPe() == 0)
00255                 ProxyMgr::Object()->sendSpanningTrees();
00256 
00257         firstphase = 0;
00258     }
00259 #endif
00260 
00261     if (!CkMyPe())
00262 #if CHARM_VERSION > 050402
00263         CkStartQD(CkIndex_ComputeMgr::doneUpdateLocalComputes(), &thishandle);
00264 #else
00265         CkStartQD(CProxy_ComputeMgr::ckIdx_doneUpdateLocalComputes(), &thishandle);
00266 #endif
00267 }

Member Data Documentation

ComputeGlobal* ComputeMgr::computeGlobalObject
 

Definition at line 78 of file ComputeMgr.h.

Referenced by ComputeMgr(), Sequencer::integrate(), recvComputeGlobalConfig(), and recvComputeGlobalResults().

The documentation for this class was generated from the following files:
Generated on Thu Jul 3 04:08:14 2008 for NAMD by  doxygen 1.3.9.1