NAMD
ProxyPatch.C
Go to the documentation of this file.
1 
7 #include "InfoStream.h"
8 #include "Lattice.h"
9 #include "ComputeMsmMsa.h" // needed for MsmMsaData definition
10 #include "main.decl.h"
11 #include "main.h"
12 #include "ProxyPatch.h"
13 #include "ProxyMgr.decl.h"
14 #include "ProxyMgr.h"
15 #include "AtomMap.h"
16 #include "PatchMap.h"
17 #include "Priorities.h"
18 
19 #include "Node.h"
20 #include "SimParameters.h"
21 
22 #define MIN_DEBUG_LEVEL 2
23 //#define DEBUGM
24 #include "Debug.h"
25 
27  Patch(pd), proxyMsgBufferStatus(PROXYMSGNOTBUFFERED),
28  curProxyMsg(NULL), prevProxyMsg(NULL)
29 {
30  DebugM(4, "ProxyPatch(" << pd << ") at " << this << "\n");
32  numAtoms = -1;
33  parent = -1;
34 
35 #ifndef NODEAWARE_PROXY_SPANNINGTREE
36  nChild = 0;
37  child = new int[proxySpanDim];
38 #endif
39 
40 #if CMK_PERSISTENT_COMM && USE_PERSISTENT_TREE
41  localphs = 0;
42 #ifdef REMOVE_PROXYRESULTMSG_EXTRACOPY
43  int msgstart = sizeof(envelope)+sizeof(ProxyResultVarsizeMsg);
44 #else
45  int msgstart = sizeof(envelope)+sizeof(ProxyResultMsg);
46 #endif
47  localphs = CmiCreatePersistent(PatchMap::Object()->node(patchID), 30000, msgstart);
48  ntreephs = 0;
49 #ifdef NODEAWARE_PROXY_SPANNINGTREE
50  treephs = NULL;
51 #else
52  treephs = new PersistentHandle[proxySpanDim];
53 #endif
54 #endif
55 
56  // DMK - Atom Separation (water vs. non-water)
57  #if NAMD_SeparateWaters != 0
58  numWaterAtoms = -1;
59  #endif
60 
61  #if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
62  depositLock = CmiCreateLock();
63  #endif
64 }
65 
67 {
68  DebugM(4, "ProxyPatch(" << patchID << ") deleted at " << this << "\n");
70 
71  // ProxyPatch may be freed because of load balancing if the compute object
72  // it corresponds to no longer exist on this specific processor.
73  CmiAssert(prevProxyMsg!=NULL);
74  if(prevProxyMsg!=NULL) {
75 // #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
76 // AtomMap::Object()->unregisterIDs(patchID,positionPtrBegin, positionPtrEnd);
77 // #else
79 // #endif
80 #if ! CMK_PERSISTENT_COMM || ! USE_PERSISTENT_TREE
81  delete prevProxyMsg;
82 #endif
83  prevProxyMsg = NULL;
84  }
85 
86 
87 #ifdef NODEAWARE_PROXY_SPANNINGTREE
88  #ifdef USE_NODEPATCHMGR
89  delete [] nodeChildren;
90  #endif
91 #endif
92  delete [] child;
93 
94  p.resize(0);
95  pExt.resize(0);
96 
97  lcpoType.resize(0);
98 
99 #if CMK_PERSISTENT_COMM && USE_PERSISTENT_TREE
100  CmiDestoryPersistent(localphs);
101  localphs = 0;
102  for (int i=0; i<ntreephs; i++) CmiDestoryPersistent(treephs[i]);
103  delete [] treephs;
104 #endif
105 }
106 
107 void ProxyPatch::boxClosed(int box) {
108  ProxyGBISP1ResultMsg *msg1;
109  ProxyGBISP2ResultMsg *msg2;
110 
111  if (box == 1) { // force Box
112  // Note: delay the deletion of proxyDataMsg (of the
113  // current step) until the next step. This is done
114  // for the sake of atom migration (ProxyDataMsg)
115  // as the ProxyPatch has to unregister the atoms
116  // of the previous step in the AtomMap data structure
117  // also denotes end of gbis phase 3
118  sendResults();
119  } else if ( box == 5) {//end phase 1
120  //this msg should only have nonzero atoms if flags.doNonbonded
121  int msgAtoms = (flags.doNonbonded) ? numAtoms : 0;
122  msg1 = new (msgAtoms,PRIORITY_SIZE) ProxyGBISP1ResultMsg;
123  for (int i = 0; i < msgAtoms; i++) {
124  msg1->psiSum[i] = psiSum[i];
125  }
126  msg1->patch = patchID;
127  msg1->psiSumLen = msgAtoms;
128  msg1->origPe = CkMyPe();
130  ProxyMgr::Object()->sendResult(msg1);
131  } else if ( box == 8) {//end phase 2
132  //this msg should only have nonzero atoms if flags.doFullElectrostatics
133  int msgAtoms = (flags.doFullElectrostatics) ? numAtoms : 0;
134  msg2 = new (msgAtoms,PRIORITY_SIZE) ProxyGBISP2ResultMsg;
135  for (int i = 0; i < msgAtoms; i++) {
136  msg2->dEdaSum[i] = dEdaSum[i];
137  }
138  msg2->patch = patchID;
139  msg2->dEdaSumLen = msgAtoms;
140  msg2->origPe = CkMyPe();
142  ProxyMgr::Object()->sendResult(msg2);
143  } else if (box == 9) {
144  //nothing
145  } else if (box == 10) {
146  // LCPO do nothing
147  }
148 
149 
150  if ( ! --boxesOpen ) {
151  DebugM(2,patchID << ": " << "Checking message buffer.\n");
152 
153  if(proxyMsgBufferStatus == PROXYALLMSGBUFFERED) {
154  CmiAssert(curProxyMsg != NULL);
155  DebugM(3,"Patch " << patchID << " processing buffered proxy ALL data.\n");
156  receiveAll(curProxyMsg);
157  }else if(proxyMsgBufferStatus == PROXYDATAMSGBUFFERED) {
158  CmiAssert(curProxyMsg != NULL);
159  DebugM(3,"Patch " << patchID << " processing buffered proxy data.\n");
160  receiveData(curProxyMsg);
161  }
162  } else {
163  DebugM(3,"ProxyPatch " << patchID << ": " << boxesOpen << " boxes left to close.\n");
164  }
165 }
166 
167 //each timestep
169 {
170  DebugM(3, "receiveData(" << patchID << ")\n");
171 
172  //delete the ProxyDataMsg of the previous step
173  delete prevProxyMsg;
174  prevProxyMsg = NULL;
175 
176  if ( boxesOpen )
177  {
178  proxyMsgBufferStatus = PROXYDATAMSGBUFFERED;
179  // store message in queue (only need one element, though)
180  curProxyMsg = msg;
181  return;
182  }
183 
184  //Reuse position arrays inside proxyDataMsg --Chao Mei
185  curProxyMsg = msg;
186  prevProxyMsg = curProxyMsg;
187  flags = msg->flags;
188 
189 #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
190  if ( ((int64)msg->positionList) % 32 ) { // not aligned
191  p.resize(msg->plLen);
192  positionPtrBegin = p.begin();
193  memcpy(positionPtrBegin, msg->positionList, sizeof(CompAtom)*(msg->plLen));
194  } else { // aligned
195  positionPtrBegin = msg->positionList;
196  }
197  positionPtrEnd = positionPtrBegin + msg->plLen;
198  if ( ((int64)positionPtrBegin) % 32 ) NAMD_bug("ProxyPatch::receiveData positionPtrBegin not 32-byte aligned");
199 #else
200  p.resize(msg->plLen);
201  memcpy(p.begin(), msg->positionList, sizeof(CompAtom)*(msg->plLen));
202 #endif
203 
204 // DMK
205 #if defined(NAMD_CUDA) || defined(NAMD_HIP) || defined(NAMD_MIC)
206  cudaAtomPtr = msg->cudaAtomList;
207 #endif
208 
209 #if defined(NAMD_AVXTILES)
211  cudaAtomPtr = msg->cudaAtomList;
212  tiles.realloc(msg->plLen, cudaAtomPtr);
213  }
214 #endif
217 
218  // BEGIN LA
220  velocityPtrEnd = msg->velocityList + msg->vlLen;
221  // END LA
222 
223  if ( numAtoms == -1 ) { // for new proxies since receiveAtoms is not called
224  //numAtoms = p.size();
225  numAtoms = msg->plLen;
226 
227  //Retrieve the CompAtomExt list
228  CmiAssert(msg->plExtLen!=0);
229  pExt.resize(msg->plExtLen);
230  memcpy(pExt.begin(), msg->positionExtList, sizeof(CompAtomExt)*(msg->plExtLen));
231 
232 
233  // DMK - Atom Separation (water vs. non-water)
234  #if NAMD_SeparateWaters != 0
235  numWaterAtoms = msg->numWaterAtoms;
236  #endif
237 
238  positionsReady(1);
239  } else {
240  positionsReady(0);
241  }
242 }
243 
244 //every doMigration
246 {
247  DebugM(3, "receiveAll(" << patchID << ")\n");
248 
249  if ( boxesOpen )
250  {
251  proxyMsgBufferStatus = PROXYALLMSGBUFFERED;
252  curProxyMsg = msg;
253  return;
254  }
255 
256  //The prevProxyMsg has to be deleted after this if-statement because
257  // positionPtrBegin points to the space inside the prevProxyMsg
258  if(prevProxyMsg!=NULL) {
259 // #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
260 // AtomMap::Object()->unregisterIDs(patchID,positionPtrBegin,positionPtrEnd);
261 // #else
263 // #endif
264  }
265  //Now delete the ProxyDataMsg of the previous step
266 #if ! CMK_PERSISTENT_COMM || ! USE_PERSISTENT_TREE
267  delete prevProxyMsg;
268 #endif
269  curProxyMsg = msg;
270  prevProxyMsg = curProxyMsg;
271 
272  flags = msg->flags;
273 
274 #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
275  if ( ((int64)msg->positionList) % 32 ) { // not aligned
276  p.resize(msg->plLen);
277  positionPtrBegin = p.begin();
278  memcpy(positionPtrBegin, msg->positionList, sizeof(CompAtom)*(msg->plLen));
279  } else { // aligned
280  positionPtrBegin = msg->positionList;
281  }
282  positionPtrEnd = positionPtrBegin + msg->plLen;
283  if ( ((int64)positionPtrBegin) % 32 ) NAMD_bug("ProxyPatch::receiveAll positionPtrBegin not 32-byte aligned");
284 #else
285  p.resize(msg->plLen);
286  memcpy(p.begin(), msg->positionList, sizeof(CompAtom)*(msg->plLen));
287 #endif
288 
289 // DMK
290 #if defined(NAMD_CUDA) || defined(NAMD_HIP) || defined(NAMD_MIC)
291  cudaAtomPtr = msg->cudaAtomList;
292 #endif
293 
294 #if defined(NAMD_AVXTILES)
296  cudaAtomPtr = msg->cudaAtomList;
297  tiles.realloc(msg->plLen, cudaAtomPtr);
298  }
299 #endif
300  numAtoms = msg->plLen;
301  //numAtoms = p.size();
302 
305 
306  // BEGIN LA
308  velocityPtrEnd = msg->velocityList + msg->vlLen;
309  // END LA
310 
311  if (flags.doGBIS) {
313  for (int i = 0; i < numAtoms*2;i++) {
314  intRad[i] = msg->intRadList[i];
315  }
316  }
317 
318  if (flags.doLCPO) {
320  for (int i = 0; i < numAtoms; i++) {
321  lcpoType[i] = msg->lcpoTypeList[i];
322  }
323  }
324 
325  //We cannot reuse the CompAtomExt list inside the msg because
326  //the information is needed at every step. In the current implementation
327  //scheme, the ProxyDataMsg msg will be deleted for every step.
328  //In order to keep this information, we have to do the extra copy. But
329  //this overhead is amortized among the steps that atoms don't migrate
330  // --Chao Mei
331  pExt.resize(msg->plExtLen);
332  memcpy(pExt.begin(), msg->positionExtList, sizeof(CompAtomExt)*(msg->plExtLen));
333 
334  // DMK - Atom Separation (water vs. non-water)
335  #if NAMD_SeparateWaters != 0
336  numWaterAtoms = msg->numWaterAtoms;
337  #endif
338 
339  positionsReady(1);
340 }
341 
342 void ProxyPatch::sendResults(void)
343 {
344  DebugM(3, "sendResults(" << patchID << ")\n");
345  register int i = 0;
346  register ForceList::iterator f_i, f_e, f2_i;
347  for ( i = Results::normal + 1 ; i <= flags.maxForceMerged; ++i ) {
348  f_i = f[Results::normal].begin(); f_e = f[Results::normal].end();
349  f2_i = f[i].begin();
350  for ( ; f_i != f_e; ++f_i, ++f2_i ) *f_i += *f2_i;
351  f[i].resize(0);
352  }
353  for ( i = flags.maxForceUsed + 1; i < Results::maxNumForces; ++i )
354  f[i].resize(0);
355 
356 #if CMK_PERSISTENT_COMM && USE_PERSISTENT_TREE
357  CmiUsePersistentHandle(&localphs, 1);
358 #endif
359 
360  if (proxyRecvSpanning == 0) {
361 #ifdef REMOVE_PROXYRESULTMSG_EXTRACOPY
363 #else
365  msg->node = CkMyPe();
366  msg->patch = patchID;
367  for ( i = 0; i < Results::maxNumForces; ++i )
368  msg->forceList[i] = &(f[i]);
369 #endif
371  //sending results to HomePatch
373  }
374  else {
378  msg->nodes.add(CkMyPe());
379  msg->patch = patchID;
380  for ( i = 0; i < Results::maxNumForces; ++i )
381  msg->forceList[i] = &(f[i]);
382  //sending results to HomePatch
384  }
385 #if CMK_PERSISTENT_COMM && USE_PERSISTENT_TREE
386  CmiUsePersistentHandle(NULL, 0);
387 #endif
388 }
389 
390 #ifdef NODEAWARE_PROXY_SPANNINGTREE
391 void ProxyPatch::setSpanningTree(int p, int *c, int n) {
392 #if CMK_PERSISTENT_COMM && USE_PERSISTENT_TREE && ! defined(USE_NODEPATCHMGR)
393  if (ntreephs!=0) {
394  for (int i=0; i<ntreephs; i++) CmiDestoryPersistent(treephs[i]);
395  delete [] treephs;
396  }
397  treephs = NULL;
398  if (n) {
399  treephs = new PersistentHandle[n];
400  for (int i=0; i<n; i++) {
401  treephs[i] = CmiCreatePersistent(c[i], 27000, sizeof(envelope)+sizeof(ProxyDataMsg));
402  }
403  }
404  ntreephs = n;
405 #endif
406  parent=p; nChild = n; nWait = 0;
407  delete [] child;
408  if(n==0) {
409  child = NULL;
410  return;
411  }
412  child = new int[n];
413  for (int i=0; i<n; i++) child[i] = c[i];
414 
415  #if defined(PROCTRACE_DEBUG) && defined(NAST_DEBUG)
416  DebugFileTrace *dft = DebugFileTrace::Object();
417  dft->openTrace();
418  dft->writeTrace("ProxyPatch[%d] has %d children: ", patchID, nChild);
419  for(int i=0; i<nChild; i++)
420  dft->writeTrace("%d ", child[i]);
421  dft->writeTrace("\n");
422  dft->closeTrace();
423  #endif
424 //CkPrintf("setSpanningTree: [%d:%d] %d %d:%d %d\n", CkMyPe(), patchID, parent, nChild, child[0], child[1]);
425 }
426 
427 #ifdef USE_NODEPATCHMGR
428 void ProxyPatch::setSTNodeChildren(int numNids, int *nids){
429 #if CMK_PERSISTENT_COMM && USE_PERSISTENT_TREE
430  if (numNodeChild!=0) {
431  for (int i=0; i<numNodeChild; i++) CmiDestoryPersistent(treephs[i]);
432  delete [] treephs;
433  }
434  treephs = NULL;
435  if (numNids) {
436  treephs = new PersistentHandle[numNids];
437  for (int i=0; i<numNids; i++) {
438  treephs[i] = CmiCreateNodePersistent(nids[i], 27000, sizeof(envelope)+sizeof(ProxyDataMsg));
439  }
440  }
441  ntreephs = numNids;
442 #endif
443  numNodeChild = numNids;
444  delete [] nodeChildren;
445  if(numNids==0) {
446  nodeChildren = NULL;
447  return;
448  }
449  nodeChildren = new int[numNids];
450  for(int i=0; i<numNids; i++) nodeChildren[i] = nids[i];
451 }
452 #endif
453 
454 #else //branch for NODEAWARE_PROXY_SPANNINGTREE not defined
455 void ProxyPatch::setSpanningTree(int p, int *c, int n) {
456 #if CMK_PERSISTENT_COMM && USE_PERSISTENT_TREE
457  if (ntreephs!=0) {
458  for (int i=0; i<ntreephs; i++) CmiDestoryPersistent(treephs[i]);
459  }
460  for (int i=0; i<n; i++) {
461  treephs[i] = CmiCreatePersistent(c[i], 27000, sizeof(envelope)+sizeof(ProxyDataMsg));
462  }
463  ntreephs = n;
464 #endif
465  parent=p; nChild = n; nWait = 0;
466  for (int i=0; i<n; i++) child[i] = c[i];
467 //CkPrintf("setSpanningTree: [%d:%d] %d %d:%d %d\n", CkMyPe(), patchID, parent, nChild, child[0], child[1]);
468 }
469 #endif
470 
472  for (int i=0; i<nChild; i++) c[i] = child[i];
473  return nChild;
474 }
475 
477 #if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
478  CmiLock(depositLock);
479 #endif
480  nWait++;
481  if (nWait == 1) msgCBuffer = msg;
482  else {
483  NodeIDList::iterator n_i, n_e;
484  n_i = msg->nodes.begin();
485  n_e = msg->nodes.end();
486  for (; n_i!=n_e; ++n_i) msgCBuffer->nodes.add(*n_i);
487  for ( int k = 0; k < Results::maxNumForces; ++k )
488  {
489  register ForceList::iterator r_i;
490  r_i = msgCBuffer->forceList[k]->begin();
491  register ForceList::iterator f_i, f_e;
492  f_i = msg->forceList[k]->begin();
493  f_e = msg->forceList[k]->end();
494  // for ( ; f_i != f_e; ++f_i, ++r_i ) *r_i += *f_i;
495 
496  int nf = f_e - f_i;
497 #ifdef ARCH_POWERPC
498 #pragma disjoint (*f_i, *r_i)
499 #pragma unroll(4)
500 #endif
501  for (int count = 0; count < nf; count++) {
502  r_i[count].x += f_i[count].x;
503  r_i[count].y += f_i[count].y;
504  r_i[count].z += f_i[count].z;
505  }
506 
507  }
508  delete msg;
509  }
510 //CkPrintf("[%d:%d] wait: %d of %d (%d %d %d)\n", CkMyPe(), patchID, nWait, nChild+1, parent, child[0],child[1]);
511  if (nWait == nChild + 1) {
512  nWait = 0;
513 #if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
514  CmiUnlock(depositLock);
515 #endif
516 
517  return msgCBuffer;
518  }
519 
520 #if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
521  CmiUnlock(depositLock);
522 #endif
523 
524  return NULL;
525 }
526 
527 //receive data after phase 1 to begin phase 2
529  memcpy(bornRad.begin(), msg->bornRad, sizeof(Real)*numAtoms);
530  delete msg;
532 }
533 
535  memcpy(dHdrPrefix.begin(), msg->dHdrPrefix, sizeof(Real)*msg->dHdrPrefixLen);
536  delete msg;
538 }
539 
541 #if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
542  CmiLock(depositLock);
543 #endif
544  nWait++;
545  if (nWait == 1) msgCBuffer = ProxyCombinedResultMsg::fromRaw(msg);
546  else {
547  for (int i=0; i<msg->nodeSize; i++) msgCBuffer->nodes.add(msg->nodes[i]);
548 
549  register char* isNonZero = msg->isForceNonZero;
550  register Force* f_i = msg->forceArr;
551  for ( int k = 0; k < Results::maxNumForces; ++k )
552  {
553  register ForceList::iterator r_i;
554  r_i = msgCBuffer->forceList[k]->begin();
555  int nf = msg->flLen[k];
556 
557 #ifdef ARCH_POWERPC
558 #pragma disjoint (*f_i, *r_i)
559 #endif
560  for (int count = 0; count < nf; count++) {
561  if(*isNonZero){
562  r_i[count].x += f_i->x;
563  r_i[count].y += f_i->y;
564  r_i[count].z += f_i->z;
565  f_i++;
566  }
567  isNonZero++;
568  }
569  }
570  delete msg;
571  }
572 //CkPrintf("[%d:%d] wait: %d of %d (%d %d %d)\n", CkMyPe(), patchID, nWait, nChild+1, parent, child[0],child[1]);
573  if (nWait == nChild + 1) {
574  nWait = 0;
575 #if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
576  CmiUnlock(depositLock);
577 #endif
578 
579  return msgCBuffer;
580  }
581 
582 #if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
583  CmiUnlock(depositLock);
584 #endif
585 
586  return NULL;
587 }
588 
589 
590 
static Node * Object()
Definition: Node.h:86
#define PROXYMSGNOTBUFFERED
Definition: ProxyPatch.h:15
int * lcpoTypeList
Definition: ProxyMgr.h:112
#define PROXY_RESULTS_PRIORITY
Definition: Priorities.h:73
static ProxyResultVarsizeMsg * getANewMsg(NodeID nid, PatchID pid, int prioSize, ForceList *fls)
Definition: ProxyMgr.C:150
RealList intRad
Definition: Patch.h:155
int proxyRecvSpanning
Definition: ProxyMgr.C:46
static ProxyMgr * Object()
Definition: ProxyMgr.h:394
static PatchMap * Object()
Definition: PatchMap.h:27
#define GB1_PROXY_RESULTS_PRIORITY
Definition: Priorities.h:54
CompAtom * velocityPtrEnd
Definition: Patch.h:202
Definition: Vector.h:64
SimParameters * simParameters
Definition: Node.h:178
float Real
Definition: common.h:109
#define DebugM(x, y)
Definition: Debug.h:59
static ProxyCombinedResultMsg * fromRaw(ProxyCombinedResultRawMsg *msg)
Definition: ProxyMgr.C:303
BigReal z
Definition: Vector.h:66
void receiveAll(ProxyDataMsg *)
Definition: ProxyPatch.C:245
CompAtom * avgPositionPtrEnd
Definition: Patch.h:198
RealList dHdrPrefix
Definition: Patch.h:159
void positionsReady(int n=0)
Definition: Patch.C:403
CompAtom * avgPositionList
Definition: ProxyMgr.h:104
CompAtom * velocityList
Definition: ProxyMgr.h:107
CudaAtom * cudaAtomPtr
Definition: Patch.h:205
AtomMapper * atomMapper
Definition: Patch.h:152
GBRealList dEdaSum
Definition: Patch.h:160
Definition: Patch.h:35
Flags flags
Definition: Patch.h:127
void unregisterProxy(PatchID pid)
Definition: ProxyMgr.C:539
#define PRIORITY_SIZE
Definition: Priorities.h:13
int boxesOpen
Definition: Patch.h:243
IntList lcpoType
Definition: Patch.h:164
ProxyCombinedResultMsg * depositCombinedResultRawMsg(ProxyCombinedResultRawMsg *)
Definition: ProxyPatch.C:540
GBRealList psiSum
Definition: Patch.h:156
GBReal * dEdaSum
Definition: ProxyMgr.h:51
CudaAtom * cudaAtomList
Definition: ProxyMgr.h:123
void NAMD_bug(const char *err_msg)
Definition: common.C:123
void gbisP2Ready()
Definition: Patch.C:570
int doFullElectrostatics
Definition: PatchTypes.h:23
iterator end(void)
Definition: ResizeArray.h:37
void receiveData(ProxyDataMsg *)
Definition: ProxyPatch.C:168
int getSpanningTreeChild(int *)
Definition: ProxyPatch.C:471
#define GB2_PROXY_RESULTS_PRIORITY
Definition: Priorities.h:62
PatchID patch
Definition: ProxyMgr.h:167
int plExtLen
Definition: ProxyMgr.h:121
CompAtomList p
Definition: Patch.h:146
int numAtoms
Definition: Patch.h:144
BigReal x
Definition: Vector.h:66
int maxForceUsed
Definition: PatchTypes.h:31
int sequence
Definition: PatchTypes.h:18
int PatchID
Definition: NamdTypes.h:182
int doNonbonded
Definition: PatchTypes.h:22
CompAtom * avgPositionPtrBegin
Definition: Patch.h:197
#define PROXYALLMSGBUFFERED
Definition: ProxyPatch.h:17
void gbisP3Ready()
Definition: Patch.C:587
ForceList * forceList[Results::maxNumForces]
Definition: ProxyMgr.h:254
ProxyPatch(PatchID pd)
Definition: ProxyPatch.C:26
Flags flags
Definition: ProxyMgr.h:98
int add(const Elem &elem)
Definition: ResizeArray.h:97
void setSpanningTree(int, int *, int)
Definition: ProxyPatch.C:455
Real * intRadList
Definition: ProxyMgr.h:110
ProxyCombinedResultMsg * depositCombinedResultMsg(ProxyCombinedResultMsg *)
Definition: ProxyPatch.C:476
CompAtom * positionList
Definition: ProxyMgr.h:102
#define PROXYDATAMSGBUFFERED
Definition: ProxyPatch.h:16
long long int64
Definition: common.h:34
RealList bornRad
Definition: Patch.h:158
void resize(int i)
Definition: ResizeArray.h:84
ForceList * forceList[Results::maxNumForces]
Definition: ProxyMgr.h:168
NodeID node
Definition: ProxyMgr.h:166
const PatchID patchID
Definition: Patch.h:143
void registerProxy(PatchID pid)
Definition: ProxyMgr.C:519
void sendResults(ProxyResultVarsizeMsg *)
Definition: ProxyMgr.C:1428
BigReal y
Definition: Vector.h:66
int flLen[Results::maxNumForces]
Definition: ProxyMgr.h:233
Real * dHdrPrefix
Definition: ProxyMgr.h:59
int doLCPO
Definition: PatchTypes.h:29
int * child
Definition: Patch.h:262
CompAtomExt * positionExtList
Definition: ProxyMgr.h:122
int doGBIS
Definition: PatchTypes.h:28
#define SET_PRIORITY(MSG, SEQ, PRIO)
Definition: Priorities.h:18
void sendResult(ProxyGBISP1ResultMsg *)
Definition: ProxyMgr.C:1851
int avgPlLen
Definition: ProxyMgr.h:103
int maxForceMerged
Definition: PatchTypes.h:32
ForceList f[Results::maxNumForces]
Definition: Patch.h:207
int proxySpanDim
Definition: ProxyMgr.C:48
virtual ~ProxyPatch(void)
Definition: ProxyPatch.C:66
virtual void boxClosed(int)
Definition: ProxyPatch.C:107
int nChild
Definition: Patch.h:263
CompAtomExtList pExt
Definition: Patch.h:174
#define PATCH_PRIORITY(PID)
Definition: Priorities.h:25
CompAtom * velocityPtrBegin
Definition: Patch.h:201
void unregisterIDsCompAtomExt(const CompAtomExt *begin, const CompAtomExt *end)
Definition: AtomMap.C:76
iterator begin(void)
Definition: ResizeArray.h:36