OpenAtom  Version1.5a
IntMap.h
Go to the documentation of this file.
1 /** \file IntMap.h
2  * Author: Eric J Bohm
3  * Date Created: June 4th, 2006
4  *
5  * Simple abstraction to replace CkHashtable with a straight array of
6  * integers when we know we can perfectly hash the keys into an int
7  * and only want an int back. Meaning storage is just int
8  * map[numKeys] and lookup is a constant time array offset. Array
9  * offset is an int multiply and int add. Should be significantly
10  * speedier than CkHashtable for the conditions under which it is
11  * appropriate.
12  *
13  *
14  * IntMap4 is for 4D paircalc
15  *
16  * IntMap2 is the more standard 2D
17  *
18  * This is a much less flexible object than CkHashtable and probably
19  * only suitable for use within procmaps.
20  */
21 
22 #ifndef _INTMAP_H_
23 #define _INTMAP_H_
24 extern int numPes;
25 
26 class IntMap4 {
27  private:
28  int ****Map;
29  int keyWmax;
30  int keyXmax;
31  int keyYmax;
32  int keyZmax;
33  int keyStep;
34  int *stepTable;
35  public:
36 
37  IntMap4(int keyW, int keyX, int keyY, int keyZ, int step)
38  : keyWmax(keyW), keyXmax(keyX), keyYmax(keyY), keyZmax(keyZ), keyStep(step)
39  {
40  Map=new int***[keyWmax];
41  int ***mappointpointbuf = new int**[keyWmax*keyXmax];
42  int **mappointbuf = new int*[keyWmax*keyXmax*keyYmax];
43  int *mapbuf= new int[keyWmax*keyXmax*keyYmax*keyZmax];
44 
45  for(int w=0;w<keyWmax;w++)
46  {
47  Map[w]= mappointpointbuf + (w*keyXmax);
48  for(int x=0;x<keyXmax;x++)
49  {
50  Map[w][x]= mappointbuf + (w*keyXmax+x)*keyYmax;
51  for(int y=0;y<keyYmax;y++)
52  {
53  Map[w][x][y]= mapbuf + ((w*keyXmax+x)*keyYmax+y)*keyZmax;
54  }
55  }
56 
57  }
58  stepTable= new int [keyXmax*keyStep];
59  for(int s=0;s<keyXmax*keyStep;s++)
60  stepTable[s]=s/keyStep;
61  }
62 
63  IntMap4(const IntMap4 &obj)
64  : keyWmax(obj.keyWmax), keyXmax(obj.keyXmax), keyYmax(obj.keyYmax), keyZmax(obj.keyZmax),
65  keyStep(obj.keyStep), Map(0), stepTable(0)
66  {
67  if (keyWmax > 0 && keyXmax > 0 && keyYmax > 0 && keyZmax > 0)
68  {
69  Map = new int***[keyWmax];
70  int ***mappointpointbuf = new int** [keyWmax*keyXmax];
71  int **mappointbuf = new int* [keyWmax*keyXmax*keyYmax];
72  int *mapbuf = new int [keyWmax*keyXmax*keyYmax*keyZmax];
73 
74  for(int w=0; w<keyWmax; w++)
75  {
76  Map[w] = mappointpointbuf + (w*keyXmax);
77  for(int x=0; x<keyXmax; x++)
78  {
79  Map[w][x] = mappointbuf + (w*keyXmax+x) * keyYmax;
80  for(int y=0; y<keyYmax; y++)
81  {
82  Map[w][x][y] = mapbuf + ((w*keyXmax+x)*keyYmax+y) * keyZmax;
83  for (int z=0; z<keyZmax; z++)
84  Map[w][x][y][z] = obj.Map[w][x][y][z];
85  }
86  }
87  }
88  }
89  if (keyXmax > 0 && keyStep > 0)
90  {
91  stepTable= new int [keyXmax*keyStep];
92  for(int s=0; s<keyXmax*keyStep; s++)
93  stepTable[s] = s/keyStep;
94  }
95  }
96 
97 
98 
99  ~IntMap4(){
100  if(Map!=NULL)
101  {
102  delete [] Map[0][0][0];
103  delete [] Map[0][0];
104  delete [] Map[0];
105  delete [] Map;
106  Map=NULL;
107  }
108  if (stepTable)
109  delete [] stepTable;
110  }
111 
112  void buildMap(int keyW=1, int keyX=1, int keyY=1, int keyZ=1, int step=1)
113  {
114  CkAssert(keyW>0);
115  CkAssert(keyX>0);
116  CkAssert(keyY>0);
117  CkAssert(keyZ>0);
118  keyWmax=keyW;
119  keyXmax=keyX;
120  keyYmax=keyY;
121  keyZmax=keyZ;
122  keyStep=step;
123  Map=new int***[keyWmax];
124  int ***mappointpointbuf = new int**[keyWmax*keyXmax];
125  int **mappointbuf = new int*[keyWmax*keyXmax*keyYmax];
126  int *mapbuf= new int[keyWmax*keyXmax*keyYmax*keyZmax];
127  for(int w=0;w<keyWmax;w++)
128  {
129  Map[w]= mappointpointbuf + (w*keyXmax);
130  for(int x=0;x<keyXmax;x++)
131  {
132  Map[w][x]= mappointbuf + (w*keyXmax+x)*keyYmax;
133  for(int y=0;y<keyYmax;y++)
134  Map[w][x][y]= mapbuf + ((w*keyXmax+x)*keyYmax+y)*keyZmax;
135  }
136  }
137  if (stepTable == 0)
138  {
139  stepTable= new int [keyXmax*keyStep];
140  for(int s=0;s<keyXmax*keyStep;s++)
141  stepTable[s]=s/keyStep;
142  }
143  }
144  void pup(PUP::er &p)
145  {
146  p|keyWmax;
147  p|keyXmax;
148  p|keyYmax;
149  p|keyZmax;
150  p|keyStep;
151  int ***mappointpointbuf = NULL;
152  int **mappointbuf = NULL;
153  int *mapbuf= NULL;
154  if(keyWmax>0)
155  {
156  CkAssert(keyXmax>0);
157  CkAssert(keyYmax>0);
158  CkAssert(keyZmax>0);
159  if(p.isUnpacking())
160  {
161  Map=new int***[keyWmax];
162  mappointpointbuf = new int**[keyWmax*keyXmax];
163  mappointbuf = new int*[keyWmax*keyXmax*keyYmax];
164  mapbuf= new int[keyWmax*keyXmax*keyYmax*keyZmax];
165  }
166  for(int w=0;w<keyWmax;w++)
167  {
168  if(keyXmax>0)
169  {
170  if(p.isUnpacking())
171  Map[w]= mappointpointbuf + (w*keyXmax);
172  for(int x=0;x<keyXmax;x++)
173  {
174  if(keyYmax>0)
175  {
176  if(p.isUnpacking())
177  Map[w][x]= mappointbuf + (w*keyXmax+x)*keyYmax;
178  for(int y=0;y<keyYmax;y++)
179  {
180  if(keyZmax>0)
181  {
182  if(p.isUnpacking())
183  Map[w][x][y]= mapbuf + ((w*keyXmax+x)*keyYmax+y)*keyZmax;
184  PUParray(p,Map[w][x][y],keyZmax);
185  }
186  }
187  }
188  }
189  if( p.isUnpacking() && (stepTable == 0) )
190  stepTable= new int[keyXmax*keyStep];
191  PUParray(p,stepTable,keyXmax*keyStep);
192  }
193  }
194  }
195  }
196 
197 
198  inline int getWmax(){return(keyWmax);}
199  inline int getXmax(){return(keyXmax);}
200  inline int getYmax(){return(keyYmax);}
201  inline int getZmax(){return(keyZmax);}
202  inline int get(int W, int X, int Y, int Z) {
203  /*
204  CkAssert(W<keyWmax);
205  CkAssert(X/keyStep<keyXmax);
206  CkAssert(Y/keyStep<keyYmax);
207  CkAssert(Z<keyZmax);
208  */
209 #define USE_INT_MAP_MATH
210 #ifdef USE_INT_MAP_MATH
211  return(Map[W][X/keyStep][Y/keyStep][Z]);
212 #else
213  return(Map[W][stepTable[X]][stepTable[Y]][Z]);
214 #endif
215  }
216  // inline int &put(int W, int X, int Y, int Z){return(&(Map[W][X/keyStep][Y/keyStep][Z]));}
217  inline void set(int W, int X, int Y, int Z, int value){
218  CkAssert(W<keyWmax);
219  CkAssert(X/keyStep<keyXmax);
220  CkAssert(Y/keyStep<keyYmax);
221  CkAssert(Z<keyZmax);
222  CkAssert(numPes>value);
223  Map[W][X/keyStep][Y/keyStep][Z]=value;
224  }
225  void dump()
226  {
227  for(int w=0;w<keyWmax;w++)
228  for(int x=0;x<keyXmax;x++)
229  for(int y=0;y<keyYmax;y++)
230  for(int z=0;z<keyZmax;z++)
231  CkPrintf("%d %d %d %d %d \n",w,x,y,z, get(w,x*keyStep,y*keyStep,z));
232  }
233  IntMap4(){keyWmax=0;keyXmax=0; keyYmax=0, keyZmax=0; keyStep=1; Map=NULL; stepTable=0; }
234  IntMap4(IntMap4 *fromMap, int offsetX, int offsetY, int offsetZ, bool torus );
235  void translate(IntMap4 *fromMap,int offsetX, int offsetY, int offsetZ, bool torus );
236 
237 
238 };
239 
240 class IntMap3 {
241  private:
242  int ***Map;
243  int keyXmax;
244  int keyYmax;
245  int keyZmax;
246 
247  public:
248  IntMap3(int keyX, int keyY, int keyZ, int step)
249  : keyXmax(keyX), keyYmax(keyY), keyZmax(keyZ)
250  {
251  CkAssert(keyX>0);
252  CkAssert(keyY>0);
253  CkAssert(keyZ>0);
254  Map=new int**[keyXmax];
255  int **mappointbuf = new int*[keyXmax*keyYmax];
256  int *mapbuf= new int[keyXmax*keyYmax*keyZmax];
257  for(int x=0;x<keyXmax;x++)
258  {
259  Map[x]= mappointbuf + (x*keyYmax);
260  for(int y=0;y<keyYmax;y++)
261  {
262  Map[x][y]= mapbuf + (x*keyYmax+y)*keyZmax;
263  memset(Map[x][y],-1,keyZmax*sizeof(int));
264  }
265  }
266  }
267  ~IntMap3(){
268  if(Map!=NULL)
269  {
270  delete [] Map[0][0];
271  delete [] Map[0];
272  delete [] Map;
273  Map=NULL;
274  }
275 
276  }
277 
278  void buildMap(int keyX=1, int keyY=1, int keyZ=1, int step=1)
279  {
280  CkAssert(keyX>0);
281  CkAssert(keyY>0);
282  CkAssert(keyZ>0);
283  keyXmax=keyX;
284  keyYmax=keyY;
285  keyZmax=keyZ;
286  CkAssert(keyXmax<10000000);
287  CkAssert(keyYmax<10000000);
288  CkAssert(keyZmax<10000000);
289  Map=new int**[keyXmax];
290  int **mappointbuf = new int*[keyXmax*keyYmax];
291  int *mapbuf= new int[keyXmax*keyYmax*keyZmax];
292  for(int x=0;x<keyXmax;x++)
293  {
294  Map[x]= mappointbuf + (x*keyYmax);
295  for(int y=0;y<keyYmax;y++)
296  {
297  Map[x][y]= mapbuf + (x*keyYmax+y)*keyZmax;
298  memset(Map[x][y],-1,keyZmax*sizeof(int));
299  }
300  }
301  }
302  void pup(PUP::er &p)
303  {
304  p|keyXmax;
305  p|keyYmax;
306  p|keyZmax;
307  CkAssert(keyXmax<10000000);
308  CkAssert(keyYmax<10000000);
309  CkAssert(keyZmax<10000000);
310  CkAssert(keyXmax>=0);
311  CkAssert(keyYmax>=0);
312  CkAssert(keyZmax>=0);
313  int **mappointbuf = NULL;
314  int *mapbuf= NULL;
315  if(keyXmax>0)
316  {
317  CkAssert(keyYmax>0);
318  CkAssert(keyZmax>0);
319  if(p.isUnpacking())
320  {
321  Map=new int**[keyXmax];
322  mappointbuf = new int*[keyXmax*keyYmax];
323  mapbuf= new int[keyXmax*keyYmax*keyZmax];
324  }
325  for(int x=0;x<keyXmax;x++)
326  {
327  if(keyYmax>0)
328  {
329  if(p.isUnpacking())
330  Map[x]= mappointbuf + (x*keyYmax);
331  for(int y=0;y<keyYmax;y++)
332  {
333  if(keyZmax>0){
334  if(p.isUnpacking())
335  Map[x][y]= mapbuf + (x*keyYmax+y)*keyZmax;
336  PUParray(p,Map[x][y],keyZmax);
337  }
338  }
339  }
340  }
341  }
342  }
343  inline int getXmax(){return(keyXmax);}
344  inline int getYmax(){return(keyYmax);}
345  inline int getZmax(){return(keyZmax);}
346  inline int get(int X, int Y, int Z) {
347  return(Map[X][Y][Z]);
348  }
349  // inline int &put(int W, int X, int Y, int Z){return(&(Map[W][X/keyStep][Y/keyStep][Z]));}
350  inline void set(int X, int Y, int Z, int value){
351  CkAssert(X<keyXmax);
352  CkAssert(Y<keyYmax);
353  CkAssert(Z<keyZmax);
354  CkAssert(numPes>value);
355  Map[X][Y][Z]=value;
356  }
357  int getCentroid(int torusMap);
358  void dump()
359  {
360  for(int x=0;x<keyXmax;x++)
361  for(int y=0;y<keyYmax;y++)
362  for(int z=0;z<keyZmax;z++)
363  CkPrintf("%d %d %d %d \n",x,y,z, get(x,y,z));
364  }
365  IntMap3(){keyXmax=0; keyYmax=0, keyZmax=0; Map=NULL;}
366  void translate(IntMap3 *fromMap,int offsetX, int offsetY, int offsetZ, bool torus );
367 };
368 
369 class IntMap2on2 {
370  private:
371  int **Map;
372  int keyXmax;
373  int keyYmax;
374  public:
375  IntMap2on2(){keyXmax=0; keyYmax=0; Map=NULL;}
376  /// Copy constructor
377  IntMap2on2(const IntMap2on2 &obj): keyXmax(obj.keyXmax), keyYmax(obj.keyYmax), Map(0)
378  {
379  if (obj.keyXmax >= 0 && obj.keyYmax >= 0)
380  {
381  int *mapbuf=new int[keyXmax*keyYmax];
382  if (obj.Map != NULL)
383  memcpy(mapbuf, obj.Map[0], keyXmax * keyYmax * sizeof(int));
384  else
385  memset(mapbuf, -1, keyXmax * keyYmax * sizeof(int));
386  Map = new int*[keyXmax];
387  for(int x=0;x<keyXmax;x++)
388  Map[x] = mapbuf + keyYmax * x;
389  }
390  }
391 
392 
393  ~IntMap2on2(){
394  if(Map!=NULL)
395  {
396  delete [] Map[0];
397  delete [] Map;
398  Map=NULL;
399  }
400  }
401  IntMap2on2(int keyX, int keyY): keyXmax(keyX), keyYmax(keyY)
402  {
403  CkAssert(keyXmax>=0);
404  CkAssert(keyYmax>=0);
405  CkAssert(keyXmax<10000000);
406  CkAssert(keyYmax<10000000);
407  Map= new int*[keyXmax];
408  int *mapbuf=new int[keyXmax*keyYmax];
409  for(int x=0;x<keyXmax;x++)
410  {
411  Map[x] = mapbuf + keyYmax * x;
412  memset(Map[x],-1,keyYmax*sizeof(int));
413  }
414 
415  }
416  void buildMap(int keyX=1, int keyY=1)
417  {
418 
419  CkAssert(keyX>0);
420  CkAssert(keyY>0);
421  keyXmax=keyX;
422  keyYmax=keyY;
423  CkAssert(keyXmax>0);
424  CkAssert(keyYmax>0);
425  CkAssert(keyXmax<10000000);
426  CkAssert(keyYmax<10000000);
427 
428  Map= new int*[keyXmax];
429  int *mapbuf=new int[keyXmax*keyYmax];
430  for(int x=0;x<keyXmax;x++)
431  {
432  Map[x] = mapbuf + keyYmax * x;
433  memset(Map[x],-1,keyYmax*sizeof(int));
434  }
435 
436  }
437  void pup(PUP::er &p)
438  {
439  p|keyXmax;
440  p|keyYmax;
441  CkAssert(keyXmax>=0);
442  CkAssert(keyYmax>=0);
443  CkAssert(keyXmax<10000000);
444  CkAssert(keyYmax<10000000);
445  int *mapbuf=NULL;
446  if(keyXmax>0)
447  {
448  CkAssert(keyYmax>0);
449  if(p.isUnpacking())
450  {
451  Map=new int*[keyXmax];
452  mapbuf=new int[keyXmax*keyYmax];
453  }
454  for(int x=0;x<keyXmax;x++)
455  {
456  if(keyYmax>0)
457  {
458  if(p.isUnpacking())
459  Map[x] = mapbuf + keyYmax * x;
460  PUParray(p,Map[x], keyYmax);
461  }
462  }
463  }
464  }
465 
466  inline int getXmax(){return(keyXmax);}
467  inline int getYmax(){return(keyYmax);}
468  int getCentroid(int torusMap);
469  inline int get(int X, int Y) {
470  /*
471  CkAssert(X<keyXmax);
472  CkAssert(Y<keyYmax);
473  */
474  return(Map[X][Y]);
475  }
476  // inline &int put(int X, int Y){&(Map[X][Y]);}
477  inline void set(int X, int Y, int value){
478  CkAssert(numPes>value);
479  CkAssert(X<keyXmax);
480  CkAssert(Y<keyYmax);
481  Map[X][Y]=value;
482  }
483  void dump()
484  {
485  for(int x=0;x<keyXmax;x++)
486  for(int y=0;y<keyYmax;y++)
487  CkPrintf("%d %d %d \n",x,y, get(x,y));
488  }
489  void translate(IntMap2on2 *fromMap, int offsetX, int offsetY, int offsetZ, bool torus );
490 };
491 
492 
493 class IntMap2on1 {
494  private:
495  int *Map;
496  int keyXmax;
497  int keyYmax;
498  int keymax;
499  public:
500  ~IntMap2on1(){
501  if(keymax>0 && Map!=NULL)
502  {
503  delete [] Map;
504  Map=NULL;
505  }
506  }
507  IntMap2on1(){keyXmax=0; keyYmax=0; keymax=0;Map=NULL;}
508  IntMap2on1(int keyX, int keyY): keyXmax(keyX), keyYmax(keyY)
509  {
510  CkAssert(keyXmax>0);
511  CkAssert(keyYmax>0);
512  CkAssert(keyXmax>keyYmax);
513  keymax=keyXmax*keyYmax;
514  Map= new int[keymax];
515  }
516  void buildMap(int keyX=1, int keyY=1)
517  {
518  CkAssert(keyX>0);
519  CkAssert(keyY>0);
520  keyXmax=keyX;
521  keyYmax=keyY;
522  CkAssert(keyXmax>keyYmax);
523  keymax=keyXmax*keyYmax;
524  Map= new int[keyXmax];
525  }
526  void pup(PUP::er &p)
527  {
528  p|keyXmax;
529  p|keyYmax;
530  p|keymax;
531  if(p.isUnpacking())
532  Map=new int[keymax];
533  PUParray(p,Map,keymax);
534 
535  }
536  inline int getXmax(){return(keyXmax);}
537  inline int getYmax(){return(keyYmax);}
538  inline int getmax(){return(keymax);}
539  inline int get(int X, int Y) {
540  /*
541  CkAssert(X<keyXmax);
542  CkAssert(Y<keyYmax);
543  */
544  return(Map[Y*keyXmax +X]);
545  }
546  // inline &int put(int X, int Y){&(Map[X][Y]);}
547  inline void set(int X, int Y, int value){
548  CkAssert(numPes>value);
549  CkAssert(X<keyXmax);
550  CkAssert(Y<keyYmax);
551  Map[Y*keyXmax +X]=value;
552  }
553  void dump()
554  {
555  for(int x=0;x<keyXmax;x++)
556  for(int y=0;y<keyYmax;y++)
557  CkPrintf("%d %d %d \n",x,y, get(x,y));
558  }
559  void translate(IntMap2on1 *fromMap, int offsetX, int offsetY, int offsetZ, bool torus );
560 };
561 
562 class IntMap1 {
563  private:
564  int *Map;
565  int keyXmax;
566  public:
567  ~IntMap1(){
568  if(keyXmax>0 && Map!=NULL)
569  {
570  delete [] Map;
571  Map=NULL;
572  }
573  }
574  IntMap1(){keyXmax=0; Map=NULL;}
575  IntMap1(int keyX): keyXmax(keyX)
576  {
577  CkAssert(keyXmax>0);
578  Map= new int[keyXmax];
579  }
580  void buildMap(int keyX=1, int keyY=1)
581  {
582  CkAssert(keyX>0);
583  keyXmax=keyX;
584  Map= new int[keyXmax];
585  }
586  void pup(PUP::er &p)
587  {
588  p|keyXmax;
589  if(p.isUnpacking())
590  Map=new int[keyXmax];
591  PUParray(p,Map,keyXmax);
592 
593  }
594  inline int getXmax(){return(keyXmax);}
595  inline int getmax(){return(keyXmax);}
596  inline int get(int X) {
597  /*
598  CkAssert(X<keyXmax);
599  */
600  return(Map[X]);
601  }
602  // inline &int put(int X, int Y){&(Map[X][Y]);}
603  inline void set(int X, int value){
604  CkAssert(numPes>value);
605  CkAssert(X<keyXmax);
606  Map[X]=value;
607  }
608  int getCentroid(int torusMap);
609  void dump()
610  {
611  for(int x=0;x<keyXmax;x++)
612  CkPrintf("%d %d \n",x,get(x));
613  }
614  void translate(IntMap1 *fromMap, int offsetX, int offsetY, int offsetZ, bool torus );
615 };
616 
617 
618 /*class MapType2 : public IntMap2on2 {
619  public:
620  int getCentroid (int);
621  void pup(PUP::er &p) { IntMap2on2::pup(p); }
622 };
623 */
624 typedef IntMap1 MapType1;
625 typedef IntMap2on2 MapType2;
626 typedef IntMap4 MapType4;
627 typedef IntMap3 MapType3;
628 
629 #endif
630 
IntMap2on2::IntMap2on2
IntMap2on2(const IntMap2on2 &obj)
Copy constructor.
Definition: IntMap.h:377
IntMap4
Definition: IntMap.h:26