ProxyPatch Class Reference

#include <ProxyPatch.h>

Inheritance diagram for ProxyPatch:

Public Member Functions
	ProxyPatch (PatchID pd)
virtual	~ProxyPatch (void)
void	receiveData (ProxyDataMsg *)
void	receiveAll (ProxyDataMsg *)
void	receiveData (ProxyGBISP2DataMsg *)
void	receiveData (ProxyGBISP3DataMsg *)
void	setSpanningTree (int, int *, int)
int	getSpanningTreeParent ()
int	getSpanningTreeChild (int *)
const int *	getSpanningTreeChildPtr ()
int	getSpanningTreeNChild (void)
ProxyCombinedResultMsg *	depositCombinedResultMsg (ProxyCombinedResultMsg *)
ProxyCombinedResultMsg *	depositCombinedResultRawMsg (ProxyCombinedResultRawMsg *)
Public Member Functions inherited from Patch
	Patch (PatchID pd)
int	hasNewAtoms ()
virtual	~Patch ()
Box< Patch, CompAtom > *	registerPositionPickup (Compute *cid)
void	unregisterPositionPickup (Compute *cid, Box< Patch, CompAtom > **const box)
Box< Patch, CompAtom > *	registerAvgPositionPickup (Compute *cid)
void	unregisterAvgPositionPickup (Compute *cid, Box< Patch, CompAtom > **const box)
Box< Patch, CompAtom > *	registerVelocityPickup (Compute *cid)
void	unregisterVelocityPickup (Compute *cid, Box< Patch, CompAtom > **const box)
Box< Patch, Real > *	registerIntRadPickup (Compute *cid)
void	unregisterIntRadPickup (Compute *cid, Box< Patch, Real > **const box)
Box< Patch, GBReal > *	registerPsiSumDeposit (Compute *cid)
void	unregisterPsiSumDeposit (Compute *cid, Box< Patch, GBReal > **const box)
Box< Patch, Real > *	registerBornRadPickup (Compute *cid)
void	unregisterBornRadPickup (Compute *cid, Box< Patch, Real > **const box)
Box< Patch, GBReal > *	registerDEdaSumDeposit (Compute *cid)
void	unregisterDEdaSumDeposit (Compute *cid, Box< Patch, GBReal > **const box)
Box< Patch, Real > *	registerDHdrPrefixPickup (Compute *cid)
void	unregisterDHdrPrefixPickup (Compute *cid, Box< Patch, Real > **const box)
Box< Patch, int > *	registerLcpoTypePickup (Compute *cid)
void	unregisterLcpoTypePickup (Compute *cid, Box< Patch, int > **const box)
Box< Patch, Results > *	registerForceDeposit (Compute *cid)
void	unregisterForceDeposit (Compute *cid, Box< Patch, Results > **const box)
void	positionsReady (int n=0, int startup=1)
void	positionBoxClosed (void)
void	forceBoxClosed (void)
void	avgPositionBoxClosed (void)
void	velocityBoxClosed (void)
void	intRadBoxClosed (void)
void	psiSumBoxClosed (void)
void	bornRadBoxClosed (void)
void	dEdaSumBoxClosed (void)
void	dHdrPrefixBoxClosed (void)
void	gbisP2Ready ()
void	gbisP3Ready ()
void	lcpoTypeBoxClosed (void)
int	getNumAtoms () const
int	getNumFixedAtoms () const
void	setNumFixedAtoms (int numFixed)
PatchID	getPatchID () const
int	getNumComputes () const
CompAtomExt *	getCompAtomExtInfo ()
CompAtom *	getCompAtomInfo ()
CudaAtom *	getCudaAtomList ()

Protected Member Functions
virtual void	boxClosed (int)

Additional Inherited Members
Public Attributes inherited from Patch
Lattice &	lattice
Flags	flags
Protected Attributes inherited from Patch
const PatchID	patchID
int	numAtoms
int	numFixedAtoms
CompAtomList	p
CompAtomList	p_avg
CompAtomList	v
AtomMapper *	atomMapper
RealList	intRad
GBRealList	psiSum
GBRealList	psiFin
RealList	bornRad
RealList	dHdrPrefix
GBRealList	dEdaSum
IntList	lcpoType
CompAtomExtList	pExt
CompAtom *	avgPositionPtrBegin
CompAtom *	avgPositionPtrEnd
CompAtom *	velocityPtrBegin
CompAtom *	velocityPtrEnd
CudaAtom *	cudaAtomPtr
ForceList	f [Results::maxNumForces]
Results	results
int	computesSortedByPriority
int	firstHoldableCompute
OwnerBox< Patch, CompAtom >	positionBox
ComputePtrList	positionComputeList
OwnerBox< Patch, CompAtom >	avgPositionBox
ComputePtrList	avgPositionComputeList
OwnerBox< Patch, CompAtom >	velocityBox
ComputePtrList	velocityComputeList
OwnerBox< Patch, Real >	intRadBox
ComputePtrList	intRadComputeList
OwnerBox< Patch, GBReal >	psiSumBox
ComputePtrList	psiSumComputeList
OwnerBox< Patch, Real >	bornRadBox
ComputePtrList	bornRadComputeList
OwnerBox< Patch, GBReal >	dEdaSumBox
ComputePtrList	dEdaSumComputeList
OwnerBox< Patch, Real >	dHdrPrefixBox
ComputePtrList	dHdrPrefixComputeList
OwnerBox< Patch, int >	lcpoTypeBox
ComputePtrList	lcpoTypeComputeList
OwnerBox< Patch, Results >	forceBox
ComputePtrList	forceComputeList
int	boxesOpen
int	_hasNewAtoms
int *	child
int	nChild

Detailed Description

Definition at line 19 of file ProxyPatch.h.

Constructor & Destructor Documentation

ProxyPatch()

ProxyPatch::ProxyPatch

(

PatchID

pd

)

Definition at line 26 of file ProxyPatch.C.

References Patch::child, DebugM, Patch::nChild, Patch::numAtoms, PatchMap::Object(), ProxyMgr::Object(), Patch::patchID, proxySpanDim, and ProxyMgr::registerProxy().

                                 : 
  Patch(pd), proxyMsgBufferStatus(PROXYMSGNOTBUFFERED), 
  curProxyMsg(NULL), prevProxyMsg(NULL)
{
  DebugM(4, "ProxyPatch(" << pd << ") at " << this << "\n");
  ProxyMgr::Object()->registerProxy(patchID);
  numAtoms = -1;
  parent = -1;

#ifndef NODEAWARE_PROXY_SPANNINGTREE
  nChild = 0;
  child = new int[proxySpanDim];
#endif

#if CMK_PERSISTENT_COMM && USE_PERSISTENT_TREE
  localphs = 0;
#ifdef REMOVE_PROXYRESULTMSG_EXTRACOPY
  int msgstart = sizeof(envelope)+sizeof(ProxyResultVarsizeMsg);
#else
  int msgstart = sizeof(envelope)+sizeof(ProxyResultMsg);
#endif
  localphs = CmiCreatePersistent(PatchMap::Object()->node(patchID), 30000, msgstart);
  ntreephs = 0;
#ifdef NODEAWARE_PROXY_SPANNINGTREE
  treephs = NULL;
#else
  treephs = new PersistentHandle[proxySpanDim];
#endif
#endif

  // DMK - Atom Separation (water vs. non-water)
  #if NAMD_SeparateWaters != 0
    numWaterAtoms = -1;
  #endif
  
  #if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
    depositLock = CmiCreateLock();
  #endif
}

~ProxyPatch()

ProxyPatch::~ProxyPatch ( void  )

virtual

Definition at line 66 of file ProxyPatch.C.

References Patch::atomMapper, ResizeArray< Elem >::begin(), Patch::child, DebugM, ResizeArray< Elem >::end(), Patch::lcpoType, ProxyMgr::Object(), Patch::p, Patch::patchID, Patch::pExt, ResizeArray< Elem >::resize(), AtomMapper::unregisterIDsCompAtomExt(), and ProxyMgr::unregisterProxy().

{
  DebugM(4, "ProxyPatch(" << patchID << ") deleted at " << this << "\n");
  ProxyMgr::Object()->unregisterProxy(patchID);

  // ProxyPatch may be freed because of load balancing if the compute object
  // it corresponds to no longer exist on this specific processor.
  CmiAssert(prevProxyMsg!=NULL);
  if(prevProxyMsg!=NULL) {
// #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
//       AtomMap::Object()->unregisterIDs(patchID,positionPtrBegin, positionPtrEnd);
// #else
      atomMapper->unregisterIDsCompAtomExt(pExt.begin(),pExt.end());
// #endif      
#if ! CMK_PERSISTENT_COMM || ! USE_PERSISTENT_TREE
      delete prevProxyMsg;
#endif
      prevProxyMsg = NULL;
  }


#ifdef NODEAWARE_PROXY_SPANNINGTREE
  #ifdef USE_NODEPATCHMGR
  delete [] nodeChildren;  
  #endif
#endif
  delete [] child;

  p.resize(0);
  pExt.resize(0);

  lcpoType.resize(0);

#if CMK_PERSISTENT_COMM && USE_PERSISTENT_TREE
  CmiDestoryPersistent(localphs);
  localphs = 0;
  for (int i=0; i<ntreephs; i++)  CmiDestoryPersistent(treephs[i]);
  delete [] treephs;
#endif
}

Member Function Documentation

boxClosed()

void ProxyPatch::boxClosed ( int  box )

protectedvirtual

Implements Patch.

Definition at line 107 of file ProxyPatch.C.

References Patch::boxesOpen, DebugM, ProxyGBISP2ResultMsg::dEdaSum, Patch::dEdaSum, ProxyGBISP2ResultMsg::dEdaSumLen, Flags::doFullElectrostatics, Flags::doNonbonded, Patch::flags, GB1_PROXY_RESULTS_PRIORITY, GB2_PROXY_RESULTS_PRIORITY, Patch::numAtoms, ProxyMgr::Object(), ProxyGBISP1ResultMsg::origPe, ProxyGBISP2ResultMsg::origPe, ProxyGBISP1ResultMsg::patch, ProxyGBISP2ResultMsg::patch, PATCH_PRIORITY, Patch::patchID, PRIORITY_SIZE, PROXYALLMSGBUFFERED, PROXYDATAMSGBUFFERED, ProxyGBISP1ResultMsg::psiSum, Patch::psiSum, ProxyGBISP1ResultMsg::psiSumLen, receiveAll(), receiveData(), ProxyMgr::sendResult(), Flags::sequence, and SET_PRIORITY.

                                  {
  ProxyGBISP1ResultMsg *msg1;
  ProxyGBISP2ResultMsg *msg2;
 
  if (box == 1) { // force Box
    // Note: delay the deletion of proxyDataMsg (of the 
    // current step) until the next step. This is done 
    // for the sake of atom migration (ProxyDataMsg) 
    // as the ProxyPatch has to  unregister the atoms 
    // of the previous step in the AtomMap data structure 
    // also denotes end of gbis phase 3
    sendResults();
  } else if ( box == 5) {//end phase 1
    //this msg should only have nonzero atoms if flags.doNonbonded
    int msgAtoms = (flags.doNonbonded) ? numAtoms : 0;
    msg1 = new (msgAtoms,PRIORITY_SIZE) ProxyGBISP1ResultMsg;
    for (int i = 0; i < msgAtoms; i++) {
      msg1->psiSum[i] = psiSum[i];
    }
    msg1->patch = patchID;
    msg1->psiSumLen = msgAtoms;
    msg1->origPe = CkMyPe();
    SET_PRIORITY(msg1,flags.sequence,GB1_PROXY_RESULTS_PRIORITY + PATCH_PRIORITY(patchID));
    ProxyMgr::Object()->sendResult(msg1);
  } else if ( box == 8) {//end phase 2
    //this msg should only have nonzero atoms if flags.doFullElectrostatics
    int msgAtoms = (flags.doFullElectrostatics) ? numAtoms : 0;
    msg2 = new (msgAtoms,PRIORITY_SIZE) ProxyGBISP2ResultMsg;
    for (int i = 0; i < msgAtoms; i++) {
      msg2->dEdaSum[i] = dEdaSum[i];
    }
    msg2->patch = patchID;
    msg2->dEdaSumLen = msgAtoms;
    msg2->origPe = CkMyPe();
    SET_PRIORITY(msg2,flags.sequence,GB2_PROXY_RESULTS_PRIORITY + PATCH_PRIORITY(patchID));
    ProxyMgr::Object()->sendResult(msg2);
  } else if (box == 9) {
    //nothing
  } else if (box == 10) {
    // LCPO do nothing
  }


  if ( ! --boxesOpen ) {
    DebugM(2,patchID << ": " << "Checking message buffer.\n");    
    
    if(proxyMsgBufferStatus == PROXYALLMSGBUFFERED) {
          CmiAssert(curProxyMsg != NULL);
          DebugM(3,"Patch " << patchID << " processing buffered proxy ALL data.\n");
          receiveAll(curProxyMsg);          
    }else if(proxyMsgBufferStatus == PROXYDATAMSGBUFFERED) {
          CmiAssert(curProxyMsg != NULL);
          DebugM(3,"Patch " << patchID << " processing buffered proxy data.\n");
          receiveData(curProxyMsg);
    }
  } else {
       DebugM(3,"ProxyPatch " << patchID << ": " << boxesOpen << " boxes left to close.\n");
  }
}

depositCombinedResultMsg()

ProxyCombinedResultMsg * ProxyPatch::depositCombinedResultMsg

(

ProxyCombinedResultMsg *

msg

)

Definition at line 476 of file ProxyPatch.C.

References ResizeArray< Elem >::add(), ResizeArray< Elem >::begin(), ResizeArray< Elem >::end(), ProxyCombinedResultMsg::forceList, Results::maxNumForces, Patch::nChild, ProxyCombinedResultMsg::nodes, Vector::x, Vector::y, and Vector::z.

Referenced by ProxyMgr::sendResults().

                                                                                        {
#if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
  CmiLock(depositLock);
#endif
  nWait++;
  if (nWait == 1) msgCBuffer = msg;
  else {
    NodeIDList::iterator n_i, n_e;
    n_i = msg->nodes.begin();
    n_e = msg->nodes.end();
    for (; n_i!=n_e; ++n_i) msgCBuffer->nodes.add(*n_i);
    for ( int k = 0; k < Results::maxNumForces; ++k )
    {
    register ForceList::iterator r_i;
    r_i = msgCBuffer->forceList[k]->begin();
    register ForceList::iterator f_i, f_e;
    f_i = msg->forceList[k]->begin();
    f_e = msg->forceList[k]->end();
    //    for ( ; f_i != f_e; ++f_i, ++r_i ) *r_i += *f_i;

    int nf = f_e - f_i;
#ifdef ARCH_POWERPC
#pragma disjoint (*f_i, *r_i)
#pragma unroll(4)
#endif
    for (int count = 0; count < nf; count++) {
      r_i[count].x += f_i[count].x;      
      r_i[count].y += f_i[count].y;      
      r_i[count].z += f_i[count].z;
    }

    }
    delete msg;
  }
//CkPrintf("[%d:%d] wait: %d of %d (%d %d %d)\n", CkMyPe(), patchID, nWait, nChild+1, parent, child[0],child[1]);
  if (nWait == nChild + 1) {
    nWait = 0;
#if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
    CmiUnlock(depositLock);
#endif
    
    return msgCBuffer;
  }

#if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
  CmiUnlock(depositLock);
#endif

  return NULL;
}

depositCombinedResultRawMsg()

ProxyCombinedResultMsg * ProxyPatch::depositCombinedResultRawMsg

(

ProxyCombinedResultRawMsg *

msg

)

Definition at line 540 of file ProxyPatch.C.

References ResizeArray< Elem >::add(), ResizeArray< Elem >::begin(), ProxyCombinedResultRawMsg::flLen, ProxyCombinedResultRawMsg::forceArr, ProxyCombinedResultMsg::forceList, ProxyCombinedResultMsg::fromRaw(), ProxyCombinedResultRawMsg::isForceNonZero, Results::maxNumForces, Patch::nChild, ProxyCombinedResultRawMsg::nodes, ProxyCombinedResultMsg::nodes, ProxyCombinedResultRawMsg::nodeSize, Vector::x, Vector::y, and Vector::z.

Referenced by ProxyMgr::recvImmediateResults(), and NodeProxyMgr::recvImmediateResults().

                                                                                              {
#if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
  CmiLock(depositLock);
#endif
  nWait++;
  if (nWait == 1) msgCBuffer = ProxyCombinedResultMsg::fromRaw(msg);
  else {
    for (int i=0; i<msg->nodeSize; i++) msgCBuffer->nodes.add(msg->nodes[i]);

    register char* isNonZero = msg->isForceNonZero;
        register Force* f_i = msg->forceArr;
        for ( int k = 0; k < Results::maxNumForces; ++k )
    {
                register ForceList::iterator r_i;
                r_i = msgCBuffer->forceList[k]->begin();
        int nf = msg->flLen[k];

#ifdef ARCH_POWERPC
#pragma disjoint (*f_i, *r_i)
#endif
                for (int count = 0; count < nf; count++) {
                        if(*isNonZero){
                                r_i[count].x += f_i->x;
                                r_i[count].y += f_i->y;
                                r_i[count].z += f_i->z;
                                f_i++;
                        }
                        isNonZero++;
                }
    }
    delete msg;
  }
//CkPrintf("[%d:%d] wait: %d of %d (%d %d %d)\n", CkMyPe(), patchID, nWait, nChild+1, parent, child[0],child[1]);
  if (nWait == nChild + 1) {
    nWait = 0;
#if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
    CmiUnlock(depositLock);
#endif

    return msgCBuffer;
  }

#if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
  CmiUnlock(depositLock);
#endif

  return NULL;
}

getSpanningTreeChild()

int ProxyPatch::getSpanningTreeChild

(

int *

c

)

Definition at line 471 of file ProxyPatch.C.

References Patch::child, and Patch::nChild.

                                           { 
  for (int i=0; i<nChild; i++) c[i] = child[i];
  return nChild;
}

getSpanningTreeChildPtr()

const int* ProxyPatch::getSpanningTreeChildPtr ( )

inline

Definition at line 35 of file ProxyPatch.h.

References Patch::child.

Referenced by ProxyMgr::recvImmediateProxyAll(), and ProxyMgr::recvImmediateProxyData().

{ return child; }

getSpanningTreeNChild()

int ProxyPatch::getSpanningTreeNChild ( void  )

inline

Definition at line 36 of file ProxyPatch.h.

References Patch::nChild.

Referenced by ProxyMgr::recvImmediateProxyAll(), and ProxyMgr::recvImmediateProxyData().

{ return nChild; }

getSpanningTreeParent()

int ProxyPatch::getSpanningTreeParent ( )

inline

Definition at line 33 of file ProxyPatch.h.

Referenced by ProxyMgr::recvImmediateResults(), NodeProxyMgr::recvImmediateResults(), and ProxyMgr::sendResults().

{ return parent; }

receiveAll()

void ProxyPatch::receiveAll

(

ProxyDataMsg *

msg

)

Definition at line 245 of file ProxyPatch.C.

References Patch::atomMapper, ProxyDataMsg::avgPlLen, ProxyDataMsg::avgPositionList, Patch::avgPositionPtrBegin, Patch::avgPositionPtrEnd, ResizeArray< Elem >::begin(), Patch::boxesOpen, ProxyDataMsg::cudaAtomList, Patch::cudaAtomPtr, DebugM, Flags::doGBIS, Flags::doLCPO, ResizeArray< Elem >::end(), ProxyDataMsg::flags, Patch::flags, Patch::intRad, ProxyDataMsg::intRadList, Patch::lcpoType, ProxyDataMsg::lcpoTypeList, NAMD_bug(), Patch::numAtoms, Node::Object(), Patch::p, Patch::patchID, Patch::pExt, ProxyDataMsg::plExtLen, ProxyDataMsg::plLen, ProxyDataMsg::positionExtList, ProxyDataMsg::positionList, Patch::positionsReady(), PROXYALLMSGBUFFERED, ResizeArray< Elem >::resize(), Node::simParameters, AtomMapper::unregisterIDsCompAtomExt(), SimParameters::useAVXTiles, ProxyDataMsg::velocityList, Patch::velocityPtrBegin, Patch::velocityPtrEnd, and ProxyDataMsg::vlLen.

Referenced by boxClosed(), and ProxyMgr::recvProxyAll().

{
  DebugM(3, "receiveAll(" << patchID << ")\n");

  if ( boxesOpen )
  {
    proxyMsgBufferStatus = PROXYALLMSGBUFFERED;    
    curProxyMsg = msg;
    return;
  }  

  //The prevProxyMsg has to be deleted after this if-statement because
  // positionPtrBegin points to the space inside the prevProxyMsg
  if(prevProxyMsg!=NULL) {
// #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
//       AtomMap::Object()->unregisterIDs(patchID,positionPtrBegin,positionPtrEnd);
// #else
      atomMapper->unregisterIDsCompAtomExt(pExt.begin(), pExt.end());
// #endif
  }
  //Now delete the ProxyDataMsg of the previous step
#if ! CMK_PERSISTENT_COMM || ! USE_PERSISTENT_TREE
  delete prevProxyMsg;
#endif
  curProxyMsg = msg;
  prevProxyMsg = curProxyMsg;

  flags = msg->flags;

#ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
  if ( ((int64)msg->positionList) % 32 ) { // not aligned
    p.resize(msg->plLen);
    positionPtrBegin = p.begin();
    memcpy(positionPtrBegin, msg->positionList, sizeof(CompAtom)*(msg->plLen));
  } else { // aligned
    positionPtrBegin = msg->positionList;
  }
  positionPtrEnd = positionPtrBegin + msg->plLen;
  if ( ((int64)positionPtrBegin) % 32 ) NAMD_bug("ProxyPatch::receiveAll positionPtrBegin not 32-byte aligned");
#else
  p.resize(msg->plLen);
  memcpy(p.begin(), msg->positionList, sizeof(CompAtom)*(msg->plLen));
#endif

// DMK
#if defined(NAMD_CUDA) || defined(NAMD_HIP) || defined(NAMD_MIC)
  cudaAtomPtr = msg->cudaAtomList;
#endif

#if defined(NAMD_AVXTILES)
  if (Node::Object()->simParameters->useAVXTiles) {
    cudaAtomPtr = msg->cudaAtomList;
    tiles.realloc(msg->plLen, cudaAtomPtr);
  }
#endif
  numAtoms = msg->plLen;
  //numAtoms = p.size();
  
  avgPositionPtrBegin = msg->avgPositionList;
  avgPositionPtrEnd = msg->avgPositionList + msg->avgPlLen;
  
  // BEGIN LA
  velocityPtrBegin = msg->velocityList;
  velocityPtrEnd = msg->velocityList + msg->vlLen;
  // END LA

  if (flags.doGBIS) {
    intRad.resize(numAtoms*2);
    for (int i = 0; i < numAtoms*2;i++) {
      intRad[i] = msg->intRadList[i];
    }
  }

  if (flags.doLCPO) {
    lcpoType.resize(numAtoms);
    for (int i = 0; i < numAtoms; i++) {
      lcpoType[i] = msg->lcpoTypeList[i];
    }
  }

  //We cannot reuse the CompAtomExt list inside the msg because
  //the information is needed at every step. In the current implementation
  //scheme, the ProxyDataMsg msg will be deleted for every step.
  //In order to keep this information, we have to do the extra copy. But
  //this overhead is amortized among the steps that atoms don't migrate
  // --Chao Mei
  pExt.resize(msg->plExtLen);
  memcpy(pExt.begin(), msg->positionExtList, sizeof(CompAtomExt)*(msg->plExtLen));

  // DMK - Atom Separation (water vs. non-water)
  #if NAMD_SeparateWaters != 0
    numWaterAtoms = msg->numWaterAtoms;
  #endif

  positionsReady(1);
}

receiveData() [1/3]

void ProxyPatch::receiveData

(

ProxyDataMsg *

msg

)

Definition at line 168 of file ProxyPatch.C.

References ProxyDataMsg::avgPlLen, ProxyDataMsg::avgPositionList, Patch::avgPositionPtrBegin, Patch::avgPositionPtrEnd, ResizeArray< Elem >::begin(), Patch::boxesOpen, ProxyDataMsg::cudaAtomList, Patch::cudaAtomPtr, DebugM, ProxyDataMsg::flags, Patch::flags, NAMD_bug(), Patch::numAtoms, Node::Object(), Patch::p, Patch::patchID, Patch::pExt, ProxyDataMsg::plExtLen, ProxyDataMsg::plLen, ProxyDataMsg::positionExtList, ProxyDataMsg::positionList, Patch::positionsReady(), PROXYDATAMSGBUFFERED, ResizeArray< Elem >::resize(), Node::simParameters, SimParameters::useAVXTiles, ProxyDataMsg::velocityList, Patch::velocityPtrBegin, Patch::velocityPtrEnd, and ProxyDataMsg::vlLen.

Referenced by boxClosed(), ProxyMgr::recvData(), and ProxyMgr::recvProxyData().

{
  DebugM(3, "receiveData(" << patchID << ")\n");

  //delete the ProxyDataMsg of the previous step
  delete prevProxyMsg;
  prevProxyMsg = NULL;

  if ( boxesOpen )
  {
      proxyMsgBufferStatus = PROXYDATAMSGBUFFERED;
    // store message in queue (only need one element, though)
    curProxyMsg = msg;
    return;
  }

  //Reuse position arrays inside proxyDataMsg --Chao Mei
  curProxyMsg = msg;
  prevProxyMsg = curProxyMsg;
  flags = msg->flags;

#ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
  if ( ((int64)msg->positionList) % 32 ) { // not aligned
    p.resize(msg->plLen);
    positionPtrBegin = p.begin();
    memcpy(positionPtrBegin, msg->positionList, sizeof(CompAtom)*(msg->plLen));
  } else { // aligned
    positionPtrBegin = msg->positionList;
  }
  positionPtrEnd = positionPtrBegin + msg->plLen;
  if ( ((int64)positionPtrBegin) % 32 ) NAMD_bug("ProxyPatch::receiveData positionPtrBegin not 32-byte aligned");
#else
  p.resize(msg->plLen);
  memcpy(p.begin(), msg->positionList, sizeof(CompAtom)*(msg->plLen));
#endif

// DMK
#if defined(NAMD_CUDA) || defined(NAMD_HIP) || defined(NAMD_MIC)
  cudaAtomPtr = msg->cudaAtomList;
#endif
  
#if defined(NAMD_AVXTILES)
  if (Node::Object()->simParameters->useAVXTiles) {
    cudaAtomPtr = msg->cudaAtomList;
    tiles.realloc(msg->plLen, cudaAtomPtr);
  }
#endif
  avgPositionPtrBegin = msg->avgPositionList;
  avgPositionPtrEnd = msg->avgPositionList + msg->avgPlLen;
  
  // BEGIN LA
  velocityPtrBegin = msg->velocityList;
  velocityPtrEnd = msg->velocityList + msg->vlLen;
  // END LA

  if ( numAtoms == -1 ) { // for new proxies since receiveAtoms is not called
      //numAtoms = p.size();
      numAtoms = msg->plLen;

      //Retrieve the CompAtomExt list
      CmiAssert(msg->plExtLen!=0);
      pExt.resize(msg->plExtLen);
      memcpy(pExt.begin(), msg->positionExtList, sizeof(CompAtomExt)*(msg->plExtLen));


    // DMK - Atom Separation (water vs. non-water)
    #if NAMD_SeparateWaters != 0
      numWaterAtoms = msg->numWaterAtoms;
    #endif

    positionsReady(1);
  } else {
    positionsReady(0);
  }
}

receiveData() [2/3]

void ProxyPatch::receiveData

(

ProxyGBISP2DataMsg *

msg

)

Definition at line 528 of file ProxyPatch.C.

References ResizeArray< Elem >::begin(), ProxyGBISP2DataMsg::bornRad, Patch::bornRad, Patch::gbisP2Ready(), and Patch::numAtoms.

                                                    {
  memcpy(bornRad.begin(), msg->bornRad, sizeof(Real)*numAtoms);
  delete msg;
  Patch::gbisP2Ready();
}

receiveData() [3/3]

void ProxyPatch::receiveData

(

ProxyGBISP3DataMsg *

msg

)

Definition at line 534 of file ProxyPatch.C.

References ResizeArray< Elem >::begin(), ProxyGBISP3DataMsg::dHdrPrefix, Patch::dHdrPrefix, ProxyGBISP3DataMsg::dHdrPrefixLen, and Patch::gbisP3Ready().

                                                    {
  memcpy(dHdrPrefix.begin(), msg->dHdrPrefix, sizeof(Real)*msg->dHdrPrefixLen);
  delete msg;
  Patch::gbisP3Ready();
}

setSpanningTree()

void ProxyPatch::setSpanningTree	(	int	p,
		int *	c,
		int	n
	)

Definition at line 455 of file ProxyPatch.C.

References Patch::child, Patch::nChild, and Patch::p.

Referenced by ProxyMgr::recvNodeAwareSpanningTree(), ProxyMgr::recvNodeAwareSTParent(), and ProxyMgr::recvSpanningTree().

                                                     { 
#if CMK_PERSISTENT_COMM && USE_PERSISTENT_TREE
  if (ntreephs!=0) {
      for (int i=0; i<ntreephs; i++)  CmiDestoryPersistent(treephs[i]);
  }
  for (int i=0; i<n; i++) {
       treephs[i] = CmiCreatePersistent(c[i], 27000, sizeof(envelope)+sizeof(ProxyDataMsg));
  }
  ntreephs = n;
#endif
  parent=p; nChild = n; nWait = 0;
  for (int i=0; i<n; i++) child[i] = c[i];
//CkPrintf("setSpanningTree: [%d:%d] %d %d:%d %d\n", CkMyPe(), patchID, parent, nChild, child[0], child[1]);
}

---

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

• ProxyPatch.h
• ProxyPatch.C