#include <ComputePatch.h>

Inheritance diagram for ComputePatch:

Public Member Functions
	ComputePatch (ComputeID c, PatchID pid)

virtual	~ComputePatch ()

virtual void	initialize ()

virtual void	atomUpdate ()

virtual void	doWork ()

Public Member Functions inherited from Compute
	Compute (ComputeID)

int	type ()

virtual	~Compute ()

void	setNumPatches (int n)

int	getNumPatches ()

virtual void	patchReady (PatchID, int doneMigration, int seq)

virtual int	noWork ()

virtual void	finishPatch (int)

int	sequence (void)

int	priority (void)

int	getGBISPhase (void)

virtual void	gbisP2PatchReady (PatchID, int seq)

virtual void	gbisP3PatchReady (PatchID, int seq)

Protected Member Functions
virtual void	doForce (CompAtom p, CompAtomExt pExt, Results *r)=0

Protected Member Functions inherited from Compute
void	enqueueWork ()

Protected Attributes
int	numAtoms

CompAtomExt *	pExt

CompAtom *	p

Results *	r

Patch *	patch

PatchID	patchID

Box< Patch, CompAtom > *	positionBox

Box< Patch, Results > *	forceBox

Protected Attributes inherited from Compute
int	computeType

int	basePriority

int	gbisPhase

int	gbisPhasePriority [3]

Additional Inherited Members
Public Attributes inherited from Compute
const ComputeID	cid

LDObjHandle	ldObjHandle

LocalWorkMsg *const	localWorkMsg

Detailed Description

Definition at line 24 of file ComputePatch.h.

Constructor & Destructor Documentation

ComputePatch::ComputePatch	(	ComputeID	c,
		PatchID	pid
	)

Definition at line 24 of file ComputePatch.C.

References forceBox, Compute::gbisPhase, p, patch, patchID, positionBox, and Compute::setNumPatches().

                                                  : Compute(c) {
     setNumPatches(1);
     patchID = p;
     patch = NULL;
     positionBox = NULL;
     forceBox = NULL;
     gbisPhase = 3;
 }

ComputePatch::~ComputePatch ( )

virtual

Definition at line 33 of file ComputePatch.C.

References Compute::cid, DebugM, forceBox, numAtoms, PatchMap::Object(), PatchMap::patch(), patchID, positionBox, Patch::unregisterForceDeposit(), and Patch::unregisterPositionPickup().

                             {
   DebugM(4, "~ComputePatch("<<cid<<") numAtoms("<<patchID<<") = " 
     << numAtoms << "\n");
     if (positionBox != NULL) {
       PatchMap::Object()->patch(patchID)->unregisterPositionPickup(this,
          &positionBox);
     }
     if (forceBox != NULL) {
       PatchMap::Object()->patch(patchID)->unregisterForceDeposit(this,
                 &forceBox);
     }
 }

Member Function Documentation

void ComputePatch::atomUpdate ( void )

virtual

Reimplemented from Compute.

Definition at line 78 of file ComputePatch.C.

References Patch::getNumAtoms(), numAtoms, and patch.

                               {
     // How can we tell if BoxOwner has packed up and left?  Need a mechanism
     // to handle this or do we assume the Boxes have been dumped?
     numAtoms = patch->getNumAtoms();
 
     // DMK - Atom Separation (water vs. non-water)
     #if NAMD_SeparateWaters != 0
       numWaterAtoms = patch->getNumWaterAtoms();
     #endif
 }

virtual void ComputePatch::doForce	(	CompAtom *	p,
		CompAtomExt *	pExt,
		Results *	r
	)

protectedpure virtual

Implemented in ComputeNonbondedSelf.

Referenced by doWork().

void ComputePatch::doWork ( void )

virtual

Reimplemented from Compute.

Definition at line 89 of file ComputePatch.C.

References Box< Owner, Data >::close(), computeNonbondedSelfType, Compute::computeType, DebugM, doForce(), Flags::doGBIS, LdbCoordinator::endWork(), Patch::flags, forceBox, Compute::gbisPhase, Patch::getCompAtomExtInfo(), Compute::ldObjHandle, LdbCoordinator::Object(), Box< Owner, Data >::open(), p, patch, patchID, LdbCoordinator::pauseWork(), pExt, positionBox, r, and LdbCoordinator::startWork().

                           {
   DebugM(3,patchID << ": doWork() called.\n");
 
 #if !defined(NAMD_CUDA) && !defined(NAMD_HIP)
   // Inform load balancer. 
   // I assume no threads will suspend until endWork is called
   LdbCoordinator::Object()->startWork(ldObjHandle);
 #endif
   if ( (computeType != computeNonbondedSelfType ) ||
        (!patch->flags.doGBIS || gbisPhase == 1) ) {
     // Open up positionBox, forceBox
     p = positionBox->open();
     r = forceBox->open();
     pExt = patch->getCompAtomExtInfo();
   }
 
   // Pass pointers to doForce
   doForce(p, pExt, r);
 // Inform load balancer
 #if !defined(NAMD_CUDA) && !defined(NAMD_HIP)
   if (patch->flags.doGBIS && (gbisPhase == 1 || gbisPhase == 2)) {
     LdbCoordinator::Object()->pauseWork(ldObjHandle);
   } else {
     LdbCoordinator::Object()->endWork(ldObjHandle);
   }
 #endif
   // Close up boxes
   if ( (computeType != computeNonbondedSelfType   ) ||
        (!patch->flags.doGBIS || gbisPhase == 3) ) {
     positionBox->close(&p);
     forceBox->close(&r);
   }
   DebugM(2,patchID << ": doWork() completed.\n");
 }

void ComputePatch::initialize ( void )

virtual

Reimplemented from Compute.

Reimplemented in ComputeNonbondedSelf.

Definition at line 46 of file ComputePatch.C.

References Compute::basePriority, Compute::cid, COMPUTE_HOME_PRIORITY, COMPUTE_PROXY_PRIORITY, DebugM, forceBox, GB1_COMPUTE_HOME_PRIORITY, GB1_COMPUTE_PROXY_PRIORITY, GB2_COMPUTE_HOME_PRIORITY, GB2_COMPUTE_PROXY_PRIORITY, Compute::gbisPhasePriority, Patch::getNumAtoms(), Patch::getPatchID(), Compute::initialize(), NAMD_bug(), numAtoms, PatchMap::Object(), patch, PATCH_PRIORITY, patchID, positionBox, Patch::registerForceDeposit(), and Patch::registerPositionPickup().

Referenced by ComputeNonbondedSelf::initialize().

                               {
     // How can we tell if BoxOwner has packed up and left?  Need a mechanism
     // to handle this or do we assume the Boxes have been dumped?
 
         if (positionBox == NULL) { // We have yet to get boxes
             if (!(patch = PatchMap::Object()->patch(patchID))) {
               NAMD_bug("ComputePatch used with unknown patch.");
             }
             DebugM(3, "initialize(" << cid <<")  patchid = "<<patch->getPatchID()<<"\n");
             positionBox = patch->registerPositionPickup(this);
             forceBox = patch->registerForceDeposit(this);
         }
         numAtoms = patch->getNumAtoms();
 
   DebugM(3, "initialize("<<cid<<") numAtoms("<<patchID<<") = " 
     << numAtoms  << " patchAddr=" << patch << "\n");
     Compute::initialize();
 
     int myNode = CkMyPe();
     if ( PatchMap::Object()->node(patchID) != myNode ) {
       basePriority = GB1_COMPUTE_PROXY_PRIORITY + PATCH_PRIORITY(patchID);
       gbisPhasePriority[0] = 0;
       gbisPhasePriority[1] = GB2_COMPUTE_PROXY_PRIORITY-GB1_COMPUTE_PROXY_PRIORITY;//sub GB1_PRIOR
       gbisPhasePriority[2] = COMPUTE_PROXY_PRIORITY-GB1_COMPUTE_PROXY_PRIORITY;
     } else {
       basePriority = GB1_COMPUTE_HOME_PRIORITY + PATCH_PRIORITY(patchID);
       gbisPhasePriority[0] = 0;
       gbisPhasePriority[1] = GB2_COMPUTE_HOME_PRIORITY-GB1_COMPUTE_HOME_PRIORITY;
       gbisPhasePriority[2] = COMPUTE_HOME_PRIORITY-GB1_COMPUTE_HOME_PRIORITY;
     }
 }