OpenAtom  Version1.5a
StructFactorCache.C
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////////////=
2 /** \file StructFactorCache.C
3  *
4  */
5 ///////////////////////////////////////////////////////////////////////////////=
6 
7 #include "utility/util.h"
8 #include "fft_slab_ctrl/fftCacheSlab.h"
9 
10 #include "StructFactorCache.h"
11 #include "gParticlePlane.decl.h"
12 #include "src_piny_physics_v1.0/include/class_defs/CP_OPERATIONS/class_cpnonlocal.h"
13 extern CkVec <CProxy_CP_State_ParticlePlane> UparticlePlaneProxy;
14 extern Config config;
15 
16 ///////////////////////////////////////////////////////////////////////////////=
17 ///////////////////////////////////////////////////////////////////////////////c
18 ///////////////////////////////////////////////////////////////////////////////=
19 int StructFactCache::existStructFact(int planeIndex) {
20  for(int i=0; i<planeCountList.length(); i++){
21  PlaneCount thisCount = planeCountList[i];
22  if(thisCount.plane == planeIndex) {
23  return i;
24  }
25  }
26 #ifdef _CP_DEBUG_SF_CACHE_
27  CkPrintf("[%d] lacks plane %d\n",CkMyPe(),planeIndex);
28 #endif
29 
30  return -1;
31 }
32 ///////////////////////////////////////////////////////////////////////////////=
33 
34 ///////////////////////////////////////////////////////////////////////////////=
35 ///////////////////////////////////////////////////////////////////////////////c
36 ///////////////////////////////////////////////////////////////////////////////=
37 int StructFactCache::existStructFactGrp(int planeIndex, int atmGrp) {
38  for(int i=0; i<planeCountList.length(); i++){
39  PlaneCount thisCount = planeCountList[i];
40  if(thisCount.plane == planeIndex) {
41  if(structFactorAtmGrps[i][atmGrp]==1)
42  {
43 #ifdef _CP_DEBUG_SF_CACHE_
44  CkPrintf("[%d] has plane %d atom %d\n",CkMyPe(),planeIndex,atmGrp);
45 #endif
46  return i;
47  }
48  }
49  }
50 #ifdef _CP_DEBUG_SF_CACHE_
51  CkPrintf("[%d] lacks plane %d atom %d\n",CkMyPe(),planeIndex,atmGrp);
52 #endif
53  return -1;
54 }
55 ///////////////////////////////////////////////////////////////////////////////=
56 
57 
58 ///////////////////////////////////////////////////////////////////////////////=
59 ///////////////////////////////////////////////////////////////////////////////c
60 ///////////////////////////////////////////////////////////////////////////////=
61 int StructFactCache::incCountStructFact(int planeIndex) {
62 
63  for(int i=0; i<planeCountList.length(); i++){
64  PlaneCount* thisCount = &(planeCountList[i]);
65  if(thisCount->plane == planeIndex) {
66  thisCount->count ++;
67  return thisCount->count;
68  }
69  }
70 
71  planeCountList.insert(planeCountList.length(), PlaneCount(planeIndex, 1, 1));
72  return 1;
73 }
74 ///////////////////////////////////////////////////////////////////////////////=
75 
76 
77 ///////////////////////////////////////////////////////////////////////////////=
78 ///////////////////////////////////////////////////////////////////////////////c
79 ///////////////////////////////////////////////////////////////////////////////=
80 int StructFactCache::decCountStructFact(int planeIndex) {
81  for(int i=0; i<planeCountList.length(); i++){
82  PlaneCount* thisCount = &(planeCountList[i]);
83  if(thisCount->plane == planeIndex) {
84  thisCount->count--;
85  if(thisCount->count < 0) {
86  thisCount->count = 0;
87  CkPrintf("Over Decrementing counters!!!\n");
88  }
89  return thisCount->count;
90  }
91  }
92  CkPrintf("Trying to Decrement non-existing counters!!!\n");
93  return -1;
94 }
95 ///////////////////////////////////////////////////////////////////////////////=
96 
97 
98 ///////////////////////////////////////////////////////////////////////////////=
99 ///////////////////////////////////////////////////////////////////////////////c
100 ///////////////////////////////////////////////////////////////////////////////=
101 void StructFactCache::printCountStructFact() {
102  CkPrintf("/////////////////////////////////////\n");
103  for(int i=0; i<planeCountList.length(); i++){
104  PlaneCount thisCount = planeCountList[i];
105  CkPrintf(" plane -- %d, count -- %d\n", thisCount.plane, thisCount.count);
106  }
107  CkPrintf("/////////////////////////////////////\n");
108 }
109 ///////////////////////////////////////////////////////////////////////////////=
110 
111 
112 ///////////////////////////////////////////////////////////////////////////////=
113 ///////////////////////////////////////////////////////////////////////////////c
114 ///////////////////////////////////////////////////////////////////////////////=
115 void StructFactCache::setZero(int planeIndex) {
116  int i = existStructFact(planeIndex);
117  if(i>=0)
118  {
119 #ifdef _CP_DEBUG_SF_CACHE_
120  CkPrintf("[%d] zeros plane %d\n",CkMyPe(),planeIndex);
121 #endif
122  planeCountList[i].updated = 0;
123  for(int j=0;j<numSfGrps;j++)
124  structFactorAtmGrps[i][j]=0;
125  }
126 }
127 ///////////////////////////////////////////////////////////////////////////////=
128 
129 
130 
131 ///////////////////////////////////////////////////////////////////////////////=
132 ///////////////////////////////////////////////////////////////////////////////c
133 ///////////////////////////////////////////////////////////////////////////////=
134 int StructFactCache::getStructFact(int planeIndex, int atmGrpIndex, complex** sf,
135  complex** sf_x, complex** sf_y, complex** sf_z) {
136  int i = existStructFact(planeIndex);
137  if(i < 0) return -1;
138  int arroffset=structFactorSize[i]*atmGrpIndex*natm_nl_grp_max;
139  *sf = structFactorList[i]+arroffset;
140  *sf_x = structFactorfxList[i]+arroffset;
141  *sf_y = structFactorfyList[i]+arroffset;
142  *sf_z = structFactorfzList[i]+arroffset;
143  return i;
144 }
145 ///////////////////////////////////////////////////////////////////////////////=
146 
147 ///////////////////////////////////////////////////////////////////////////////=
148 ///////////////////////////////////////////////////////////////////////////////c
149 ///////////////////////////////////////////////////////////////////////////////=
150 void StructFactCache::getStructFactIdx(int sfindex, int atmGrpIndex, complex** sf,
151  complex** sf_x, complex** sf_y, complex** sf_z) {
152  int arroffset=structFactorSize[sfindex]*atmGrpIndex*natm_nl_grp_max;
153  *sf = structFactorList[sfindex]+arroffset;
154  *sf_x = structFactorfxList[sfindex]+arroffset;
155  *sf_y = structFactorfyList[sfindex]+arroffset;
156  *sf_z = structFactorfzList[sfindex]+arroffset;
157 }
158 ///////////////////////////////////////////////////////////////////////////////=
159 
160 
161 void StructFactCache::acceptStructFact(StructFactorMsg *msg)
162 {
163  // check if we have the plane
164 
165  int atmIndex=msg->atmGrpIndex;
166  int planeIndex=msg->planeIndex;
167  int arroffset=msg->gsSize*atmIndex*natm_nl_grp_max;
168  int sfindex=existStructFact(planeIndex);
169 #ifdef _CP_DEBUG_SF_CACHE_
170  CkPrintf("[%d] received SF for plane %d atom %d\n",CkMyPe(),planeIndex, atmIndex);
171 #endif
172 
173  if(sfindex<0)
174  { // create the entry
175  //allocate the arrays
176  incCountStructFact(planeIndex);
177  int structSize=msg->gsSize*numSfGrps*natm_nl_grp_max;
178  complex *structFactor = (complex *)fftw_malloc(structSize*sizeof(complex));
179  complex *structFactor_fx = (complex *)fftw_malloc(structSize*sizeof(complex));
180  complex *structFactor_fy = (complex *)fftw_malloc(structSize*sizeof(complex));
181  complex *structFactor_fz = (complex *)fftw_malloc(structSize*sizeof(complex));
182  int *atmGrpArrive = new int[numSfGrps];
183  bzero(atmGrpArrive, numSfGrps*sizeof(int));
184  structFactorAtmGrps.insert(structFactorAtmGrps.length(),atmGrpArrive);
185  structFactorList.insert(structFactorList.length(),structFactor);
186  structFactorfxList.insert(structFactorfxList.length(), structFactor_fx);
187  structFactorfyList.insert(structFactorfyList.length(), structFactor_fy);
188  structFactorfzList.insert(structFactorfzList.length(), structFactor_fz);
189  structFactorSize.insert(structFactorSize.length(), msg->gsSize);
190  //set list index
191  sfindex=existStructFact(planeIndex);
192 #ifdef _CP_DEBUG_SF_CACHE_
193  CkPrintf("[%d] created SF entry %d for plane %d atom %d\n",CkMyPe(),sfindex, planeIndex, atmIndex);
194 #endif
195  }
196  CkAssert(sfindex>=0);
197  planeCountList[sfindex].updated = 1; // possible semantic misuse here
198  structFactorAtmGrps[sfindex][atmIndex] = 1;
199  CmiMemcpy(structFactorList[sfindex]+arroffset,msg->structFactor,msg->datalen*sizeof(complex));
200  CmiMemcpy(structFactorfxList[sfindex]+arroffset,msg->structFactor_fx,msg->datalen*sizeof(complex));
201  CmiMemcpy(structFactorfyList[sfindex]+arroffset,msg->structFactor_fy,msg->datalen*sizeof(complex));
202  CmiMemcpy(structFactorfzList[sfindex]+arroffset,msg->structFactor_fz,msg->datalen*sizeof(complex));
203 
204  // launch the computeZ's registered for this atom index
205  int ppregindex;
206  if((ppregindex=existsPP(planeIndex,atmIndex))>=0)
207  {
208  PlaneAtom regPPs=ppList[ppregindex];
209  CkArrayIndex2D idx2d;
210  for(int i=0;i<regPPs.particles.length();i++)
211  {
212 
213  // we could set up a section multicast for this, but they're
214  // all processor local so it would only save us some copies
215  // of a tiny message. precious little savings
216 
217  // these are of course not made as cklocal branch calls
218  // because we want to lower the priority of this work so it
219  // happens when the system is otherwise idle
220 
221  idx2d=regPPs.particles[i];
222  // call up computeZ
223  PPDummyMsg *pmsg = new (8*sizeof(int)) PPDummyMsg;
224  pmsg->atmGrp=atmIndex;
225  pmsg->sfindex=sfindex;
226  CkSetQueueing(pmsg, CK_QUEUEING_IFIFO);
227  *(int*)CkPriorityPtr(pmsg) = config.sfpriority+atmIndex+numSfGrps; //lower than sf and sfcache
228  UparticlePlaneProxy[thisInstance.proxyOffset](idx2d.index[0], idx2d.index[1]).computeZ(pmsg);
229  // CkPrintf("triggering computeZ for %d on %d %d\n", pmsg->atmGrp, idx2d.index[0], idx2d.index[1]);
230  }
231  }
232  else
233  {
234  char out[100];
235  snprintf(out, 100, "[%d] accepted SF for %d %d without any registered particles",CkMyPe(), planeIndex, atmIndex);
236  CkAbort(out);
237  }
238  delete msg; //do not delete nokeep
239 }
240 ///////////////////////////////////////////////////////////////////////////////=
241 
242 ///////////////////////////////////////////////////////////////////////////////=
243 ///////////////////////////////////////////////////////////////////////////////c
244 ///////////////////////////////////////////////////////////////////////////////=
245 /** local particle planes register themselves with the cache so they can be launched by the arrival of
246  * an update for the (plane, atom)
247  */
248 int StructFactCache::registerPP(int state, int plane, int atom) {
249  // check for existing entry
250  PlaneAtom pa(plane,atom);
251  CkArrayIndex2D idx2d(state,plane);
252  for(int i=0; i<ppList.length(); i++){
253  if(ppList[i]==pa)
254  {
255  ppList[i].particles.push_back(idx2d);
256 #ifdef _CP_DEBUG_SF_CACHE_
257  CkPrintf("[%d] registers PP[%d,%d] atom %d at %d\n",CkMyPe(),state,plane,atom, ppList[i].particles.length()-1);
258 #endif
259  return i;
260  }
261  }
262  // no entry add new one
263  ppList.push_back(pa);
264  ppList[ppList.length()-1].particles.push_back(idx2d);
265 #ifdef _CP_DEBUG_SF_CACHE_
266  CkPrintf("SFC [%d] registers PP[%d,%d] atom %d at %d\n",CkMyPe(),state,plane,atom,ppList[ppList.length()-1].particles.length()-1);
267 #endif
268  return ppList.length()-1;
269 }
270 ///////////////////////////////////////////////////////////////////////////////=
271 
272 int StructFactCache::existsPP(int plane, int atom) {
273  // find existing entry
274  PlaneAtom pa(plane,atom);
275  for(int i=0; i<ppList.length(); i++)
276  if(ppList[i]==pa)
277  return i;
278  return -1;
279 }
280 
281 ///////////////////////////////////////////////////////////////////////////////=
282 ///////////////////////////////////////////////////////////////////////////////c
283 ///////////////////////////////////////////////////////////////////////////////=
284 void StructFactCache::removeAll() {
285 
286  for(int i=structFactorList.length()-1; i>=0; i--){
287  fftw_free(structFactorList[i]);
288  fftw_free(structFactorfxList[i]);
289  fftw_free(structFactorfyList[i]);
290  fftw_free(structFactorfzList[i]);
291  delete []structFactorAtmGrps[i];
292  }
293 
294  structFactorList.removeAll();
295  structFactorfxList.removeAll();
296  structFactorfyList.removeAll();
297  structFactorfzList.removeAll();
298  structFactorSize.removeAll();
299  gSpaceSlabs.removeAll();
300 }
301 ///////////////////////////////////////////////////////////////////////////////=
302 
303 #include "structureFactorCache.def.h"
304 
fftCacheSlab.h
Add type declarations for simulationConstants class (readonly vars) and once class for each type of o...
StructFactCache::registerPP
int registerPP(int state, int plane, int atmGrp)
local particle planes register themselves with the cache so they can be launched by the arrival of an...
Definition: StructFactorCache.C:248