ComputePatchPair Class Reference

#include <ComputePatchPair.h>

Inheritance diagram for ComputePatchPair:

Public Member Functions
	ComputePatchPair (ComputeID c, PatchID pid[], int t[])
virtual	~ComputePatchPair ()
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[2], CompAtomExt *pExt[2], Results *r[2])
Protected Member Functions inherited from Compute
void	enqueueWork ()

Protected Attributes
int	numAtoms [2]
CompAtomExt *	pExt [2]
CompAtom *	p [2]
Results *	r [2]
Patch *	patch [2]
PatchID	patchID [2]
int	trans [2]
Box< Patch, CompAtom > *	positionBox [2]
Box< Patch, Results > *	forceBox [2]
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 25 of file ComputePatchPair.h.

Constructor & Destructor Documentation

ComputePatchPair::ComputePatchPair	(	ComputeID	c,
		PatchID	pid[],
		int	t[]
	)

Definition at line 20 of file ComputePatchPair.C.

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

    : Compute(c) {

  gbisPhase = 3;
  setNumPatches(2);

  for (int i=0; i<2; i++) {
      patchID[i] = p[i];
      trans[i] = t[i];
      patch[i] = NULL;
      positionBox[i] = NULL;
      forceBox[i] = NULL;
  }
}

ComputePatchPair::~ComputePatchPair ( )

virtual

Definition at line 35 of file ComputePatchPair.C.

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

                                    {
  DebugM(4, "~ComputePatchPair("<<cid<<") numAtoms("<<patchID[0]<<") = " 
    << numAtoms[0] 
    << " numAtoms("<<patchID[1]<<") = " << numAtoms[1] << "\n" );
  DebugM(4, "~ComputePatchPair("<<cid<<") addr("<<patchID[0]<<") = " 
    << PatchMap::Object()->patch(patchID[0]) << " addr("<<patchID[1]<<") = "
    << PatchMap::Object()->patch(patchID[1]) << "\n");
  for (int i=0; i<2; i++) {
    if (positionBox[i] != NULL) {
      PatchMap::Object()->patch(patchID[i])->unregisterPositionPickup(this,
         &positionBox[i]);
    }
    if (forceBox[i] != NULL) {
      PatchMap::Object()->patch(patchID[i])->unregisterForceDeposit(this,
                &forceBox[i]);
    }
  }

}

Member Function Documentation

void ComputePatchPair::atomUpdate ( void  )

virtual

Reimplemented from Compute.

Definition at line 116 of file ComputePatchPair.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?

    // DebugM(4,"atomUpdate() - positionBox[0] is " << positionBox[0] << "\n");
    for (int i=0; i<2; i++) {

        numAtoms[i] = patch[i]->getNumAtoms();

        // DMK - Atom Separation (water vs. non-water)
        #if NAMD_SeparateWaters != 0
          numWaterAtoms[i] = patch[i]->getNumWaterAtoms();
        #endif
    }



    // Compute::atomUpdate();
}

void ComputePatchPair::doForce ( CompAtom *  p[2], CompAtomExt *  pExt[2], Results *  r[2]  )

protectedvirtual

Reimplemented in ComputeNonbondedPair.

Definition at line 137 of file ComputePatchPair.C.

References numAtoms.

Referenced by doWork().

{
    CkPrintf("ComputePatchPair::doForce() - Dummy eval was sent\n");
    CkPrintf(" %d patch 1 atoms and %d patch 2 atoms\n", numAtoms[0], numAtoms[1] );
}

void ComputePatchPair::doWork ( void  )

virtual

Reimplemented from Compute.

Definition at line 147 of file ComputePatchPair.C.

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

                              {

#if !defined(NAMD_CUDA) && !defined(NAMD_HIP)
  LdbCoordinator::Object()->startWork(ldObjHandle);
#endif
  if ( ( computeType != computeNonbondedPairType ) ||
        (!patch[0]->flags.doGBIS || gbisPhase == 1) ) {
    // Open up positionBox, forceBox, and atomBox
    for (int i=0; i<2; i++) {
      p[i] = positionBox[i]->open();
      r[i] = forceBox[i]->open();
      pExt[i] = patch[i]->getCompAtomExtInfo();
    }
  }

  doForce(p, pExt, r);
 // Inform load balancer
#if !defined(NAMD_CUDA) && !defined(NAMD_HIP)
  if (patch[0]->flags.doGBIS && (gbisPhase == 1 || gbisPhase == 2)) {
    LdbCoordinator::Object()->pauseWork(ldObjHandle);
  } else {
    LdbCoordinator::Object()->endWork(ldObjHandle);
  }
#endif

  // Close up boxes
  if ( ( computeType != computeNonbondedPairType ) ||
      (!patch[0]->flags.doGBIS || gbisPhase == 3) ) {
    for (int i=0; i<2; i++) {
      positionBox[i]->close(&p[i]);
      forceBox[i]->close(&r[i]);
    }
  }

}

void ComputePatchPair::initialize ( void  )

virtual

Reimplemented from Compute.

Reimplemented in ComputeNonbondedPair.

Definition at line 55 of file ComputePatchPair.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(), Compute::initialize(), numAtoms, PatchMap::Object(), patch, PATCH_PRIORITY, patchID, positionBox, Patch::registerForceDeposit(), and Patch::registerPositionPickup().

Referenced by ComputeNonbondedPair::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?

    for (int i=0; i<2; i++) {
        if (positionBox[i] == NULL) { // We have yet to get boxes
            if (!(patch[i] = PatchMap::Object()->patch(patchID[i]))) {
              DebugM(5,"invalid patch(" << patchID[i] 
                   << ")  pointer!\n");
            }
            positionBox[i] = patch[i]->registerPositionPickup(this);
            forceBox[i] = patch[i]->registerForceDeposit(this);
        }
        numAtoms[i] = patch[i]->getNumAtoms();
    }

  DebugM(4, "initialize("<<cid<<") numAtoms("<<patchID[0]<<") = " 
    << numAtoms[0] 
    << " numAtoms(" <<patchID[1]<<") = " << numAtoms[1] << "\n" );

    Compute::initialize();

    // proxies are more urgent (lower priority) than patches
    int myNode = CkMyPe();
    int p0 = PATCH_PRIORITY(patchID[0]);
    if ( PatchMap::Object()->node(patchID[0]) == myNode ) {
      p0 += GB1_COMPUTE_HOME_PRIORITY;
    } else {
      p0 += GB1_COMPUTE_PROXY_PRIORITY;
    }
    int p1 = PATCH_PRIORITY(patchID[1]);
    if ( PatchMap::Object()->node(patchID[1]) == myNode ) {
      p1 += GB1_COMPUTE_HOME_PRIORITY;
    } else {
      p1 += GB1_COMPUTE_PROXY_PRIORITY;
    }
    if (p0<p1) { //base phase priorities off of p0
      if ( PatchMap::Object()->node(patchID[0]) == myNode ) {
        gbisPhasePriority[0] = 0;
        gbisPhasePriority[1] = GB2_COMPUTE_HOME_PRIORITY-GB1_COMPUTE_HOME_PRIORITY;
        gbisPhasePriority[2] = COMPUTE_HOME_PRIORITY-GB1_COMPUTE_HOME_PRIORITY;
      } else {
        gbisPhasePriority[0] = 0;
        gbisPhasePriority[1] = GB2_COMPUTE_PROXY_PRIORITY-GB1_COMPUTE_PROXY_PRIORITY;
        gbisPhasePriority[2] = COMPUTE_PROXY_PRIORITY-GB1_COMPUTE_PROXY_PRIORITY;
      }
    } else { //base phase priorities off of p1
      if ( PatchMap::Object()->node(patchID[1]) == myNode ) {
        gbisPhasePriority[0] = 0;
        gbisPhasePriority[1] = GB2_COMPUTE_HOME_PRIORITY-GB1_COMPUTE_HOME_PRIORITY;
        gbisPhasePriority[2] = COMPUTE_HOME_PRIORITY-GB1_COMPUTE_HOME_PRIORITY;
      } else {
        gbisPhasePriority[0] = 0;
        gbisPhasePriority[1] = GB2_COMPUTE_PROXY_PRIORITY-GB1_COMPUTE_PROXY_PRIORITY;
        gbisPhasePriority[2] = COMPUTE_PROXY_PRIORITY-GB1_COMPUTE_PROXY_PRIORITY;
      }
    }
    basePriority = ((p0<p1)?p0:p1);   // most urgent wins

}

Member Data Documentation

Box<Patch,Results>* ComputePatchPair::forceBox[2]

protected

Definition at line 53 of file ComputePatchPair.h.

Referenced by ComputePatchPair(), doWork(), initialize(), ComputeNonbondedPair::noWork(), and ~ComputePatchPair().

int ComputePatchPair::numAtoms[2]

protected

Definition at line 36 of file ComputePatchPair.h.

Referenced by atomUpdate(), ComputeNonbondedPair::doForce(), doForce(), initialize(), ComputeNonbondedPair::noWork(), and ~ComputePatchPair().

CompAtom* ComputePatchPair::p[2]

protected

Definition at line 38 of file ComputePatchPair.h.

Referenced by doWork().

Patch* ComputePatchPair::patch[2]

protected

Definition at line 47 of file ComputePatchPair.h.

Referenced by atomUpdate(), ComputePatchPair(), ComputeNonbondedPair::doForce(), doWork(), ComputeNonbondedPair::initialize(), initialize(), ComputeNonbondedPair::noWork(), ComputeNonbondedPair::~ComputeNonbondedPair(), and ~ComputePatchPair().

PatchID ComputePatchPair::patchID[2]

protected

Definition at line 50 of file ComputePatchPair.h.

Referenced by ComputePatchPair(), ComputeNonbondedPair::doForce(), ComputeNonbondedPair::initialize(), initialize(), and ~ComputePatchPair().

CompAtomExt* ComputePatchPair::pExt[2]

protected

Definition at line 37 of file ComputePatchPair.h.

Referenced by doWork().

Box<Patch,CompAtom>* ComputePatchPair::positionBox[2]

protected

Definition at line 52 of file ComputePatchPair.h.

Referenced by ComputePatchPair(), doWork(), initialize(), ComputeNonbondedPair::noWork(), and ~ComputePatchPair().

Results* ComputePatchPair::r[2]

protected

Definition at line 39 of file ComputePatchPair.h.

Referenced by doWork().

int ComputePatchPair::trans[2]

protected

Definition at line 51 of file ComputePatchPair.h.

Referenced by ComputePatchPair(), ComputeNonbondedPair::doForce(), and ComputeNonbondedPair::initialize().

---

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

• ComputePatchPair.h
• ComputePatchPair.C