#include <PatchMgr.h>

Inheritance diagram for PatchMgr:

Public Member Functions
	PatchMgr ()

	~PatchMgr ()

void	createHomePatch (PatchID pid, FullAtomList &a)

void	movePatch (PatchID, NodeID)

void	sendMovePatches ()

void	recvMovePatches (MovePatchesMsg *msg)

void	sendAtoms (PatchID pid, FullAtomList &a)

void	recvAtoms (MovePatchesMsg *msg)

HomePatch *	homePatch (PatchID pid)

void	sendMigrationMsgs (PatchID, MigrationInfo *, int)

void	recvMigrateAtomsCombined (MigrateAtomsCombinedMsg *)

void	moveAtom (MoveAtomMsg *msg)

void	moveAllBy (MoveAllByMsg *msg)

void	setLattice (SetLatticeMsg *msg)

void	sendCheckpointReq (int pid, int remote, const char *key, int task)

void	recvCheckpointReq (CheckpointAtomsReqMsg *msg)

void	sendCheckpointLoad (CheckpointAtomsMsg *msg, int dst, int dstpe)

void	recvCheckpointLoad (CheckpointAtomsMsg *msg)

void	sendCheckpointStore (CheckpointAtomsMsg *msg, int dst, int dstpe)

void	recvCheckpointStore (CheckpointAtomsMsg *msg)

void	sendCheckpointAck (int pid, int dst, int dstpe)

void	recvCheckpointAck (CheckpointAtomsReqMsg *msg)

void	sendExchangeReq (int pid, int src)

void	recvExchangeReq (ExchangeAtomsReqMsg *msg)

void	sendExchangeMsg (ExchangeAtomsMsg *msg, int dst, int dstpe)

void	recvExchangeMsg (ExchangeAtomsMsg *msg)

void	setHomePatchFixedAtomNum (int patchId, int numFixed)

void	sendOneHomePatch (int patchId, int nodeId)

Static Public Member Functions
static PatchMgr *	Object ()

Friends
class	PatchMap

Detailed Description

Definition at line 145 of file PatchMgr.h.

Constructor & Destructor Documentation

PatchMgr::PatchMgr ( )

Definition at line 34 of file PatchMgr.C.

References PatchMap::Instance(), NAMD_bug(), recvCheckpointAck_handler(), recvCheckpointLoad_handler(), recvCheckpointReq_handler(), recvCheckpointStore_handler(), recvExchangeMsg_handler(), recvExchangeReq_handler(), and PatchMap::registerPatchMgr().

 {
     // CkPrintf("[%d] PatchMgr Created\n", CkMyPe());
 
     // Singleton pattern
     if (CkpvAccess(PatchMgr_instance) == NULL) {
         CkpvAccess(PatchMgr_instance) = this;
     } else {
         NAMD_bug("PatchMgr instanced twice on same processor!");
     }
 
     // Get PatchMap singleton started
     patchMap = PatchMap::Instance();
     patchMap->registerPatchMgr(this);
 
     recvCheckpointReq_index = CmiRegisterHandler((CmiHandler)recvCheckpointReq_handler);
     recvCheckpointLoad_index = CmiRegisterHandler((CmiHandler)recvCheckpointLoad_handler);
     recvCheckpointStore_index = CmiRegisterHandler((CmiHandler)recvCheckpointStore_handler);
     recvCheckpointAck_index = CmiRegisterHandler((CmiHandler)recvCheckpointAck_handler);
 
     recvExchangeReq_index = CmiRegisterHandler((CmiHandler)recvExchangeReq_handler);
     recvExchangeMsg_index = CmiRegisterHandler((CmiHandler)recvExchangeMsg_handler);
 
     // Message combining initialization
     migrationCountdown = 0;
     combineMigrationMsgs = new MigrateAtomsCombinedMsg*[CkNumPes()];
     int numPes = CkNumPes();
     for ( int i = 0; i < numPes; ++i ) combineMigrationMsgs[i] = 0;
 }

PatchMgr::~PatchMgr ( )

Definition at line 64 of file PatchMgr.C.

References ResizeArrayIter< Type >::begin(), ResizeArrayIter< Type >::end(), SortedArray< Type >::find(), and HomePatchElem::patch.

 {
     HomePatchListIter hi(homePatches);
     for ( hi = hi.begin(); hi != hi.end(); hi++) {
       HomePatchElem* elem = homePatches.find(HomePatchElem(hi->pid));
       delete elem->patch;
     }
     delete [] combineMigrationMsgs;
 }

Member Function Documentation

void PatchMgr::createHomePatch	(	PatchID	pid,
		FullAtomList &	a
	)

Definition at line 74 of file PatchMgr.C.

References SortedArray< Type >::load(), and PatchMap::registerPatch().

Referenced by WorkDistrib::createHomePatches(), ParallelIOMgr::createHomePatches(), and recvMovePatches().

 {
     HomePatch *patch = new HomePatch(pid, a);
     homePatches.load(HomePatchElem(pid, patch));
     patchMap->registerPatch(pid, patch);
 }

HomePatch* PatchMgr::homePatch ( PatchID pid )

inline

Definition at line 165 of file PatchMgr.h.

References SortedArray< Type >::find().

Referenced by sendMovePatches(), and sendOneHomePatch().

                                     {
      return homePatches.find(HomePatchElem(pid))->patch;
   } 

void PatchMgr::moveAllBy ( MoveAllByMsg * msg )

Definition at line 244 of file PatchMgr.C.

References Lattice::apply_transform(), ResizeArray< T >::begin(), ResizeArray< T >::end(), FullAtom::fixedPosition, Patch::getNumAtoms(), Patch::lattice, MoveAllByMsg::offset, CompAtom::position, Lattice::reverse_transform(), and FullAtom::transform.

                                           {
   // loop over homePatches, moving every atom
   for (HomePatchElem *elem = homePatches.begin(); elem != homePatches.end(); elem++) {
     HomePatch *hp = elem->patch;
     for (int i=0; i<hp->getNumAtoms(); i++) {
       FullAtom &a = hp->atom[i];
       a.fixedPosition = hp->lattice.reverse_transform(a.position,a.transform);
       a.fixedPosition += msg->offset;
       a.position = hp->lattice.apply_transform(a.fixedPosition,a.transform);
     }
   }
   delete msg;
 }

void PatchMgr::moveAtom ( MoveAtomMsg * msg )

Definition at line 226 of file PatchMgr.C.

References Lattice::apply_transform(), MoveAtomMsg::atomid, MoveAtomMsg::coord, FullAtom::fixedPosition, PatchMap::homePatch(), LocalID::index, Patch::lattice, AtomMap::localID(), MoveAtomMsg::moveto, notUsed, AtomMap::Object(), LocalID::pid, CompAtom::position, Lattice::reverse_transform(), and FullAtom::transform.

                                         {
   LocalID lid = AtomMap::Object()->localID(msg->atomid);
   if ( lid.pid != notUsed ) {
     HomePatch *hp = patchMap->homePatch(lid.pid);
     if ( hp ) {
       FullAtom &a = hp->atom[lid.index];
       if ( msg->moveto ) {
         a.fixedPosition = msg->coord;
       } else {
         a.fixedPosition = hp->lattice.reverse_transform(a.position,a.transform);
         a.fixedPosition += msg->coord;
       }
       a.position = hp->lattice.apply_transform(a.fixedPosition,a.transform);
     }
   }
   delete msg;
 }

void PatchMgr::movePatch	(	PatchID	pid,
		NodeID	nodeID
	)

Definition at line 84 of file PatchMgr.C.

References SortedArray< Type >::load().

Referenced by WorkDistrib::distributeHomePatches().

 {
     move.load(MovePatch(pid,nodeID));
 }

static PatchMgr* PatchMgr::Object ( )

inlinestatic

Definition at line 152 of file PatchMgr.h.

Referenced by HomePatch::doAtomMigration(), HomePatch::exchangeAtoms(), HomePatch::exchangeCheckpoint(), recvCheckpointAck_handler(), HomePatch::recvCheckpointLoad(), recvCheckpointLoad_handler(), HomePatch::recvCheckpointReq(), recvCheckpointReq_handler(), HomePatch::recvCheckpointStore(), recvCheckpointStore_handler(), recvExchangeMsg_handler(), HomePatch::recvExchangeReq(), and recvExchangeReq_handler().

152 { return CkpvAccess(PatchMgr_instance); }

void PatchMgr::recvAtoms ( MovePatchesMsg * msg )

Definition at line 168 of file PatchMgr.C.

References MovePatchesMsg::atom, PatchMap::homePatch(), and MovePatchesMsg::pid.

                                             {
     patchMap->homePatch(msg->pid)->reinitAtoms(msg->atom);
     delete msg;
 }

void PatchMgr::recvCheckpointAck ( CheckpointAtomsReqMsg * msg )

Definition at line 378 of file PatchMgr.C.

References PatchMap::homePatch(), NAMD_bug(), CheckpointAtomsReqMsg::pid, and HomePatch::recvCheckpointAck().

Referenced by recvCheckpointAck_handler().

                                                            {
   HomePatch *hp = patchMap->homePatch(msg->pid);
   if ( ! hp ) NAMD_bug("null HomePatch pointer in PatchMgr::recvCheckpointAck");
   hp->recvCheckpointAck();
   delete msg;
 }

void PatchMgr::recvCheckpointLoad ( CheckpointAtomsMsg * msg )

Definition at line 326 of file PatchMgr.C.

References PatchMap::homePatch(), CheckpointAtomsMsg::pid, and HomePatch::recvCheckpointLoad().

Referenced by recvCheckpointLoad_handler().

                                                          {
   HomePatch *hp = patchMap->homePatch(msg->pid);
   hp->recvCheckpointLoad(msg);
 }

void PatchMgr::recvCheckpointReq ( CheckpointAtomsReqMsg * msg )

Definition at line 294 of file PatchMgr.C.

References PatchMap::homePatch(), CheckpointAtomsReqMsg::key, NAMD_bug(), PatchMap::node(), CheckpointAtomsReqMsg::pe, CheckpointAtomsReqMsg::pid, HomePatch::recvCheckpointReq(), CheckpointAtomsReqMsg::replica, and CheckpointAtomsReqMsg::task.

Referenced by recvCheckpointReq_handler().

                                                            {
   int patchnode = patchMap->node(msg->pid);
   if ( CkMyPe() != patchnode ) {
     thisProxy[patchnode].recvCheckpointReq(msg);
   } else {
     HomePatch *hp = patchMap->homePatch(msg->pid);
     if ( ! hp ) NAMD_bug("null HomePatch pointer in PatchMgr::recvCheckpointReq");
     hp->recvCheckpointReq(msg->task, msg->key, msg->replica, msg->pe);
     delete msg;
   }
 }

void PatchMgr::recvCheckpointStore ( CheckpointAtomsMsg * msg )

Definition at line 351 of file PatchMgr.C.

References PatchMap::homePatch(), CheckpointAtomsMsg::pid, and HomePatch::recvCheckpointStore().

Referenced by recvCheckpointStore_handler().

                                                           {
   HomePatch *hp = patchMap->homePatch(msg->pid);
   hp->recvCheckpointStore(msg);
 }

void PatchMgr::recvExchangeMsg ( ExchangeAtomsMsg * msg )

Definition at line 433 of file PatchMgr.C.

References PatchMap::homePatch(), ExchangeAtomsMsg::pid, and HomePatch::recvExchangeMsg().

Referenced by recvExchangeMsg_handler().

                                                     {
   HomePatch *hp = patchMap->homePatch(msg->pid);
   hp->recvExchangeMsg(msg);
 }

void PatchMgr::recvExchangeReq ( ExchangeAtomsReqMsg * msg )

Definition at line 405 of file PatchMgr.C.

References ExchangeAtomsReqMsg::dstpe, PatchMap::homePatch(), NAMD_bug(), PatchMap::node(), ExchangeAtomsReqMsg::pid, and HomePatch::recvExchangeReq().

Referenced by recvExchangeReq_handler().

                                                        {
   int patchnode = patchMap->node(msg->pid);
   if ( CkMyPe() != patchnode ) {
     thisProxy[patchnode].recvExchangeReq(msg);
   } else {
     HomePatch *hp = patchMap->homePatch(msg->pid);
     if ( ! hp ) NAMD_bug("null HomePatch pointer in PatchMgr::recvExchangeReq");
     hp->recvExchangeReq(msg->dstpe);
     delete msg;
   }
 }

void PatchMgr::recvMigrateAtomsCombined ( MigrateAtomsCombinedMsg * msg )

Definition at line 219 of file PatchMgr.C.

References DebugM, MigrateAtomsCombinedMsg::distribute(), ResizeArray< T >::size(), and MigrateAtomsCombinedMsg::srcPatchID.

 {
   DebugM(3,"Received MigrateAtomsCombinedMsg with " << msg->srcPatchID.size() << " messages.\n");
   msg->distribute();
   delete msg;
 }

void PatchMgr::recvMovePatches ( MovePatchesMsg * msg )

Definition at line 137 of file PatchMgr.C.

References MovePatchesMsg::atom, createHomePatch(), and MovePatchesMsg::pid.

                                                   {
     // Make a new HomePatch
     createHomePatch(msg->pid, msg->atom);
     delete msg;
 
     // Tell sending PatchMgr we received MovePatchMsg
 //    AckMovePatchesMsg *ackmsg = 
 //      new AckMovePatchesMsg;
 //    CSendMsgBranch(PatchMgr,ackMovePatches, ackmsg, thisgroup, msg->fromNodeID);
 }

void PatchMgr::sendAtoms	(	PatchID	pid,
		FullAtomList &	a
	)

Definition at line 157 of file PatchMgr.C.

References MovePatchesMsg::atom, NAMD_bug(), PatchMap::node(), and ResizeArray< T >::shared().

Referenced by WorkDistrib::reinitAtoms().

                                                      {
 
       MovePatchesMsg *msg = new MovePatchesMsg(pid, a);
 
       if ( msg->atom.shared() ) NAMD_bug("shared message array in PatchMgr::sendAtoms");
 
       CProxy_PatchMgr cp(thisgroup);
       cp[patchMap->node(pid)].recvAtoms(msg);
 
 }

void PatchMgr::sendCheckpointAck	(	int	pid,
		int	dst,
		int	dstpe
	)

Definition at line 358 of file PatchMgr.C.

References CheckpointAtomsReqMsg::pid.

Referenced by HomePatch::recvCheckpointReq(), and HomePatch::recvCheckpointStore().

                                                             {
   CheckpointAtomsReqMsg *msg = new CheckpointAtomsReqMsg;
   msg->pid = pid;
   envelope *env = UsrToEnv(CheckpointAtomsReqMsg::pack(msg));
   CmiSetHandler(env,recvCheckpointAck_index);
 #if CMK_HAS_PARTITION
   CmiInterSyncSendAndFree(dstpe,dst,env->getTotalsize(),(char*)env);
 #else
   CmiSyncSendAndFree(dstpe,env->getTotalsize(),(char*)env);
 #endif
 }

void PatchMgr::sendCheckpointLoad	(	CheckpointAtomsMsg *	msg,
		int	dst,
		int	dstpe
	)

Definition at line 308 of file PatchMgr.C.

Referenced by HomePatch::recvCheckpointReq().

                                                                              {
   envelope *env = UsrToEnv(CheckpointAtomsMsg::pack(msg));
   CmiSetHandler(env,recvCheckpointLoad_index);
 #if CMK_HAS_PARTITION
   CmiInterSyncSendAndFree(dstpe,dst,env->getTotalsize(),(char*)env);
 #else
   CmiSyncSendAndFree(dstpe,env->getTotalsize(),(char*)env);
 #endif
 }

void PatchMgr::sendCheckpointReq	(	int	pid,
		int	remote,
		const char *	key,
		int	task
	)

Definition at line 270 of file PatchMgr.C.

References CheckpointAtomsReqMsg::key, CheckpointAtomsReqMsg::pe, CheckpointAtomsReqMsg::pid, CheckpointAtomsReqMsg::replica, and CheckpointAtomsReqMsg::task.

Referenced by HomePatch::exchangeCheckpoint().

                                                                                {
   CheckpointAtomsReqMsg *msg = new (1+strlen(key),0) CheckpointAtomsReqMsg;
   msg->pid = pid;
   msg->pe = CkMyPe();
   msg->replica = CmiMyPartition();
   msg->task = task;
   strcpy(msg->key,key);
   envelope *env = UsrToEnv(CheckpointAtomsReqMsg::pack(msg));
   CmiSetHandler(env,recvCheckpointReq_index);
 #if CMK_HAS_PARTITION
   CmiInterSyncSendAndFree(CkMyPe(),remote,env->getTotalsize(),(char*)env);
 #else
   CmiSyncSendAndFree(CkMyPe(),env->getTotalsize(),(char*)env);
 #endif
 }

void PatchMgr::sendCheckpointStore	(	CheckpointAtomsMsg *	msg,
		int	dst,
		int	dstpe
	)

Definition at line 333 of file PatchMgr.C.

Referenced by HomePatch::recvCheckpointLoad().

                                                                               {
   envelope *env = UsrToEnv(CheckpointAtomsMsg::pack(msg));
   CmiSetHandler(env,recvCheckpointStore_index);
 #if CMK_HAS_PARTITION
   CmiInterSyncSendAndFree(dstpe,dst,env->getTotalsize(),(char*)env);
 #else
   CmiSyncSendAndFree(dstpe,env->getTotalsize(),(char*)env);
 #endif
 }

void PatchMgr::sendExchangeMsg	(	ExchangeAtomsMsg *	msg,
		int	dst,
		int	dstpe
	)

Definition at line 417 of file PatchMgr.C.

Referenced by HomePatch::recvExchangeReq().

                                                                         {
   envelope *env = UsrToEnv(ExchangeAtomsMsg::pack(msg));
   CmiSetHandler(env,recvExchangeMsg_index);
 #if CMK_HAS_PARTITION
   CmiInterSyncSendAndFree(dstpe,dst,env->getTotalsize(),(char*)env);
 #else
   CmiSyncSendAndFree(dstpe,env->getTotalsize(),(char*)env);
 #endif
 }

void PatchMgr::sendExchangeReq	(	int	pid,
		int	src
	)

Definition at line 386 of file PatchMgr.C.

References ExchangeAtomsReqMsg::dstpe, and ExchangeAtomsReqMsg::pid.

Referenced by HomePatch::exchangeAtoms().

                                                {
   ExchangeAtomsReqMsg *msg = new ExchangeAtomsReqMsg;
   msg->pid = pid;
   msg->dstpe = CkMyPe();
   envelope *env = UsrToEnv(ExchangeAtomsReqMsg::pack(msg));
   CmiSetHandler(env,recvExchangeReq_index);
 #if CMK_HAS_PARTITION
   CmiInterSyncSendAndFree(CkMyPe(),src,env->getTotalsize(),(char*)env);
 #else
   CmiSyncSendAndFree(CkMyPe(),env->getTotalsize(),(char*)env);
 #endif
 }

void PatchMgr::sendMigrationMsgs	(	PatchID	src,
		MigrationInfo *	m,
		int	numMsgs
	)

Definition at line 175 of file PatchMgr.C.

References MigrateAtomsCombinedMsg::add(), ResizeArray< T >::add(), DebugM, MigrationInfo::destNodeID, PatchMap::numHomePatches(), ResizeArray< T >::resize(), and ResizeArray< T >::size().

Referenced by HomePatch::doAtomMigration().

                                                                            {
 /*
   for (int i=0; i < numMsgs; i++) {
     PatchMgr::Object()->sendMigrationMsg(src, m[i]);
   }
 */
   if ( ! migrationCountdown )  // (re)initialize
   {
     // DebugM(3,"migrationCountdown (re)initialize\n");
     numHomePatches = patchMap->numHomePatches();
     migrationCountdown = numHomePatches;
     combineMigrationDestPes.resize(0);
   }
   for (int i=0; i < numMsgs; i++) {  // buffer messages
     int destNodeID = m[i].destNodeID;
     if ( 1 ) // destNodeID != CkMyPe() )
     {
       if ( ! combineMigrationMsgs[destNodeID] )
       {
         combineMigrationMsgs[destNodeID] = new MigrateAtomsCombinedMsg();
         combineMigrationDestPes.add(destNodeID);
       }
       combineMigrationMsgs[destNodeID]->add(src,m[i].destPatchID,m[i].mList);
     }
     else
     {
         // for now buffer local messages too
     }
   }
   migrationCountdown -= 1;
   // DebugM(3,"migrationCountdown = " << migrationCountdown << "\n");
   if ( ! migrationCountdown )  // send out combined messages
   {
     int n = combineMigrationDestPes.size();
     for ( int i = 0; i < n; ++i ) {
         int destNodeID = combineMigrationDestPes[i];
         DebugM(3,"Sending MigrateAtomsCombinedMsg to node " << destNodeID << "\n");
         CProxy_PatchMgr cp(thisgroup);
         cp[destNodeID].recvMigrateAtomsCombined(combineMigrationMsgs[destNodeID]);
         combineMigrationMsgs[destNodeID] = 0;
     }
   }
 }

void PatchMgr::sendMovePatches ( )

Definition at line 110 of file PatchMgr.C.

References MovePatchesMsg::atom, ResizeArrayIter< Type >::begin(), SortedArray< Type >::del(), ResizeArrayIter< Type >::end(), homePatch(), NAMD_bug(), ResizeArray< T >::resize(), ResizeArray< T >::shared(), ResizeArray< T >::size(), and PatchMap::unregisterPatch().

Referenced by WorkDistrib::distributeHomePatches().

 {
     if (! move.size())
         return;
 
     MovePatchListIter m(move);
     for ( m = m.begin(); m != m.end(); m++) {
       HomePatch *p = homePatch(m->pid);
       patchMap->unregisterPatch(m->pid, p);
 
       MovePatchesMsg *msg = new MovePatchesMsg(m->pid, p->atom);
 
       // Deleting the HomePatchElem will call a destructor for clean up
       // but the msg elements are safe since they use a container template
       // that uses ref counting.
       delete p;
       homePatches.del(HomePatchElem(m->pid)); 
 
       if ( msg->atom.shared() ) NAMD_bug("shared message array in PatchMgr::sendMovePatches");
 
       // Sending to PatchMgr::recvMovePatches on remote node
       CProxy_PatchMgr cp(thisgroup);
       cp[m->nodeID].recvMovePatches(msg);
     }
     move.resize(0);
 }

void PatchMgr::sendOneHomePatch	(	int	patchId,
		int	nodeId
	)

Definition at line 89 of file PatchMgr.C.

References MovePatchesMsg::atom, SortedArray< Type >::del(), homePatch(), NAMD_bug(), ResizeArray< T >::shared(), and PatchMap::unregisterPatch().

                                                       {
     HomePatch *p = homePatch(patchId);
     patchMap->unregisterPatch(patchId, p);
 
     MovePatchesMsg *msg = new MovePatchesMsg(patchId, p->atom);
 
     // Deleting the HomePatchElem will call a destructor for clean up
     // but the msg elements are safe since they use a container template
     // that uses ref counting.
     delete p;
     homePatches.del(HomePatchElem(patchId)); 
 
     if ( msg->atom.shared() ) NAMD_bug("shared message array in PatchMgr::sendOneHomePatch");
 
     // Sending to PatchMgr::recvMovePatches on remote node
     CProxy_PatchMgr cp(thisgroup);
     cp[nodeId].recvMovePatches(msg);
 }

void PatchMgr::setHomePatchFixedAtomNum	(	int	patchId,
		int	numFixed
	)

inline

Definition at line 220 of file PatchMgr.h.

References PatchMap::homePatch(), and Patch::setNumFixedAtoms().

                                                           {
       HomePatch *thisHomePatch = patchMap->homePatch(patchId);
       thisHomePatch->setNumFixedAtoms(numFixed);
   }

void PatchMgr::setLattice ( SetLatticeMsg * msg )

Definition at line 258 of file PatchMgr.C.

References ResizeArray< T >::begin(), ResizeArray< T >::end(), SetLatticeMsg::lattice, Patch::lattice, SimParameters::lattice, Node::Object(), and Node::simParameters.

                                             {
   // loop over homePatches, setting the lattice to the new value.
   for (HomePatchElem *elem = homePatches.begin(); elem != homePatches.end(); elem++) {
     HomePatch *hp = elem->patch;
     hp->lattice = msg->lattice;
   }
   // Must also do this for SimParameters in order for pressure profile to work!
   Node::Object()->simParameters->lattice = msg->lattice;
 }

Friends And Related Function Documentation

friend class PatchMap

friend

Definition at line 193 of file PatchMgr.h.

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation