msgQ test: Adjust test parameters (num priorities, numiters)
[charm.git] / tests / charm++ / startupTest / startupTest.h
1 extern double WasteUnits;
2 extern CProxy_main mainProxy;
3 extern CProxy_ReadArrFour fourProxy;            
4 extern CProxy_ReadArrSix sixProxy;              
5 extern double dOne;
6 extern double dTwo;
7 extern CkVec<int> IntArrFour;
8 extern CkVec<int> IntArrFive;
9 extern CkVec<CProxy_groupTest> groupProxy;
10 extern CkVec<CProxy_groupTestX> groupProxyX;
11
12 bool CheckAllReadOnly();
13 void WasteTime(double);
14 class intdual {
15  private:
16     int x, y;
17  public:
18     intdual(){x=y=0;}
19
20     intdual(int _x,int _y) : x(_x), y(_y){}
21     void pup(PUP::er &p)
22       {
23           p|x;
24           p|y;
25       }
26     inline int getx(){return x;};
27     inline int gety(){return y;};
28     inline CkHashCode hash() const {
29         return (CkHashCode)((x<<10)+y);
30     }
31     static CkHashCode staticHash(const void *k,size_t){
32         return ((intdual *)k)->hash();
33     }
34     inline int compare(intdual &t) const{
35         return (t.getx() == x && t.gety() == y);
36     }
37     static int staticCompare(const void *a,const void *b,size_t){
38         return ((intdual *)a)->compare((*(intdual *)b));
39     }
40    
41 };
42
43
44 class main : public CBase_main
45 {
46  public:
47   int doneCount;
48   main(CkArgMsg *msg);
49   void createReport(CkReductionMsg *msg);
50   void doneReport(CkReductionMsg *msg);
51 };
52
53 class groupTest : public CBase_groupTest
54 {
55  public:
56   int order;
57   groupTest(int order): order(order) 
58     {
59       // test that all lower order ids were created first
60       for(int i=order-1;i>0;i--)
61         {
62           //make a proxy
63           //get a branch
64           //test the order value in it
65           //      CkPrintf("[%d] test group id %d looking at %d\n",CkMyPe(),order,i);
66           CkAssert(groupProxy[i].ckLocalBranch()->order==i);
67
68         }
69     }
70 };
71
72 class groupTestX : public CBase_groupTestX
73 {
74  public:
75   int order;
76   groupTestX(int order): order(order) 
77     {
78       // test that all lower order ids were created first
79       for(int i=order-1;i>0;i--)
80         {
81           //make a proxy
82           //get a branch
83           //test the order value in it
84           //      CkPrintf("[%d] test group id %d looking at %d\n",CkMyPe(),order,i);
85           CkAssert(groupProxy[i].ckLocalBranch()->order==i);
86           CkAssert(groupProxyX[i].ckLocalBranch()->order==i);
87
88         }
89     }
90 };
91
92 class ReadArrZero : public CBase_ReadArrZero
93 {
94  private:
95  public:
96   int size;
97   double units;
98   bool workdone;
99   bool reddone;
100   ReadArrZero(int arrSize, double WasteUnits) :size(arrSize), units(WasteUnits)
101     {
102       int a=1;
103       workdone=false;
104       reddone=false;
105       contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::createReport(NULL),mainProxy),0);
106     }
107
108   ReadArrZero()
109     {
110       workdone=false;
111       reddone=false;
112     }
113
114   ReadArrZero(CkMigrateMessage *m) {};
115
116   void receiveRed(CkReductionMsg *msg)
117     {
118
119       int *data   = (int *)msg->getData();
120       int sender      = msg->getUserFlag();  
121
122       CkPrintf("{%d} on [%d] gets reduction from %d, recv %d\n",thisIndex, CkMyPe(), sender, data[0]);
123       CkAssert(sender==thisIndex+1);
124       reddone=true;
125       if(workdone)
126         {
127           contribute(sizeof(int),data,CkReduction::sum_int,CkCallback(CkIndex_main::doneReport(NULL),mainProxy),0);
128         }
129       delete msg;
130     }
131   
132   void dowork()
133   {
134     WasteTime(WasteUnits);
135     int a=1;
136     workdone=true;
137     if(reddone || thisIndex>6)
138       {
139         contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::doneReport(NULL),mainProxy),0);
140       }
141
142   }
143
144 };
145
146 class ReadArrOne : public CBase_ReadArrOne
147 {
148  private:
149  public:
150   int size;
151   double units;
152   CkCallback callbacktoZero;  
153   
154   ReadArrOne(int arrSize, double WasteUnits, CkCallback _cb) :size(arrSize), units(WasteUnits), callbacktoZero(_cb)
155     {
156       int a=1;
157       contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::createReport(NULL),mainProxy),1);
158     }
159
160   ReadArrOne(CkMigrateMessage *m) {};
161   
162   void dowork(){
163     WasteTime(WasteUnits);
164     int a=1;
165     contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::doneReport(NULL),mainProxy),1);
166     contribute(sizeof(int), &a, CkReduction::sum_int,  callbacktoZero,1);
167
168   }
169
170 };
171
172 class ReadArrTwo : public CBase_ReadArrTwo
173 {
174  private:
175  public:
176   int size;
177   double units;
178   CkCallback callbacktoZero;
179
180   ReadArrTwo(int arrSize, double WasteUnits, CkCallback _cb) :size(arrSize), units(WasteUnits), callbacktoZero(_cb)
181     {
182       int a=1;
183       contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::createReport(NULL),mainProxy),2);
184     }
185
186   ReadArrTwo(CkMigrateMessage *m) {};
187
188   
189   void dowork(){
190     WasteTime(WasteUnits);
191     int a=1;
192     contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::doneReport(NULL),mainProxy),2);
193     contribute(sizeof(int), &a, CkReduction::sum_int,  callbacktoZero,2);
194   }
195
196
197 };
198
199 class ReadArrThree : public CBase_ReadArrThree
200 {
201  private:
202  public:
203   int size;
204   double units;
205   CkCallback callbacktoZero;
206   ReadArrThree(int arrSize, double WasteUnits, CkCallback _cb) :size(arrSize), units(WasteUnits), callbacktoZero(_cb)
207     {
208       int a=1;
209       if(CkMyPe()%2)
210         WasteTime(WasteUnits);
211       contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::createReport(NULL),mainProxy),3);
212     }
213
214   ReadArrThree(CkMigrateMessage *m) {};
215   
216   void dowork(){
217     WasteTime(WasteUnits);
218     int a=1;
219     contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::doneReport(NULL),mainProxy),3);
220     contribute(sizeof(int), &a, CkReduction::sum_int,  callbacktoZero,3);
221   }
222
223
224   
225 };
226
227 class ReadArrFour : public CBase_ReadArrFour
228 {
229  private:
230  public:
231   int size;
232   double units;
233   int *data;
234   CkCallback callbacktoZero;
235   
236   ReadArrFour(int arrSize, double WasteUnits, CkCallback _cb) :size(arrSize), units(WasteUnits), callbacktoZero(_cb) 
237     {
238       int a=1;
239       data=new int[arrSize];
240       memcpy(data,&(IntArrFour[0]),sizeof(int)*arrSize);
241       contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::createReport(NULL),mainProxy),4);
242     }
243
244   ReadArrFour(CkMigrateMessage *m) {};
245
246   
247   void dowork()
248   {
249     WasteTime(WasteUnits);
250     int a=1;
251     contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::doneReport(NULL),mainProxy),4);
252     contribute(sizeof(int), &a, CkReduction::sum_int,  callbacktoZero,4);
253   }
254
255
256   
257 };
258
259 class ReadArrFive : public CBase_ReadArrFive
260 {
261  private:
262   int *data;
263  public:
264   int size;
265   double units;
266   bool validate; 
267   CkCallback callbacktoZero;
268   ReadArrFive(int arrSize, double WasteUnits, bool validate, CkCallback _cb) :size(arrSize), units(WasteUnits), validate(validate), callbacktoZero(_cb) 
269     {
270       int a=1;
271       // we shadow four, use its data member
272       if(validate)
273         {
274           data=fourProxy(thisIndex).ckLocal()->data;
275           CkAssert(data!=NULL);
276           for(int i=0;i<arrSize;i++)
277             CkAssert(data[i]==i);
278         }
279       contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::createReport(NULL),mainProxy),5);
280     }
281   
282   ReadArrFive(CkMigrateMessage *m) {};
283
284   void dowork(){
285     WasteTime(WasteUnits);
286     int a=1;
287     contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::doneReport(NULL),mainProxy),5);
288     contribute(sizeof(int), &a, CkReduction::sum_int,  callbacktoZero,5);
289
290   }
291
292 };
293
294
295 class ReadArrSix : public CBase_ReadArrSix
296 {
297  private:
298  public:
299   int *data;
300   int size;
301   int size2;
302   double units;
303   CkCallback callbacktoZero;
304   ReadArrSix(int arrSize, int arrSize2, double WasteUnits, CkCallback _cb) :size(arrSize), size2(arrSize2), units(WasteUnits), callbacktoZero(_cb) 
305     {
306       int a=1;
307       data=new int[arrSize];
308       memcpy(data,&(IntArrFive[0]),sizeof(int)*arrSize);
309       contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::createReport(NULL),mainProxy),6);
310     }
311   
312   ReadArrSix(CkMigrateMessage *m) {};
313
314   void dowork(){
315     WasteTime(WasteUnits);
316     int a=1;
317     contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::doneReport(NULL),mainProxy),6);
318     contribute(sizeof(int), &a, CkReduction::sum_int,  callbacktoZero,6);
319
320   }
321
322 };
323
324 class ReadArrSeven : public CBase_ReadArrSeven
325 {
326  private:
327  public:
328   int *data;
329   int size;
330   int size2;
331   double units;
332   bool validate;
333   CkCallback callbacktoZero;
334
335   ReadArrSeven(int arrSize, int arrSize2, double WasteUnits, bool validate, CkCallback _cb) :size(arrSize), size2(arrSize2), units(WasteUnits), validate(validate), callbacktoZero(_cb) 
336     {
337       int a=1;
338       // we shadow six, use its data member
339       if(validate)
340         {
341           data=sixProxy(thisIndex.x,thisIndex.y).ckLocal()->data;
342           CkAssert(data!=NULL);
343           bool pass=true;
344           for(int i=0;i<arrSize;i++)
345             if(data[i]!=i)
346               {
347                 CkPrintf("[%d,%d] i %d != data[%d]\n",thisIndex.x, thisIndex.y,i,data[i]);
348                 pass=false;
349               }
350           CkAssert(pass);
351         }
352
353       contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::createReport(NULL),mainProxy),7);
354     }
355   
356   ReadArrSeven(CkMigrateMessage *m) {};
357
358   void dowork(){
359     WasteTime(WasteUnits);
360     int a=1;
361     contribute(sizeof(int),&a,CkReduction::sum_int,CkCallback(CkIndex_main::doneReport(NULL),mainProxy),7);
362     contribute(sizeof(int), &a, CkReduction::sum_int,  callbacktoZero,7);
363
364   }
365
366 };
367
368
369
370 class OneMap: public CkArrayMap { 
371  public:
372   double howmuch;
373   OneMap(double _howmuch): howmuch(_howmuch)
374     {
375       CheckAllReadOnly();
376       WasteTime(howmuch);
377     }
378   int procNum(int, const CkArrayIndex &);
379 };
380
381 class TwoMap: public CkArrayMap { 
382  public:
383   double howmuch;
384   TwoMap(double _howmuch): howmuch(_howmuch)
385     {
386       CheckAllReadOnly();
387       WasteTime(howmuch);
388     }
389     int procNum(int, const CkArrayIndex &);
390 };
391
392 class ThreeMap: public CkArrayMap { 
393  public:
394   double howmuch;
395   ThreeMap(double _howmuch) : howmuch(_howmuch)
396     {
397       CheckAllReadOnly();
398       WasteTime(howmuch);
399     }
400     int procNum(int, const CkArrayIndex &);
401 };
402
403 class FourMap: public CkArrayMap { 
404  public:
405   double howmuch;
406   FourMap(double _howmuch) : howmuch(_howmuch)
407     {
408       CheckAllReadOnly();
409       WasteTime(howmuch);
410     }
411     int procNum(int, const CkArrayIndex &);
412 };
413
414 class FiveMap: public CkArrayMap { 
415  public:
416   double howmuch;
417   FiveMap(double _howmuch) : howmuch(_howmuch)
418     {
419       CheckAllReadOnly();
420       WasteTime(howmuch);
421     }
422     int procNum(int, const CkArrayIndex &);
423 };
424
425
426 class SixMap: public CkArrayMap { 
427  public:
428   double howmuch;
429   SixMap(double _howmuch) : howmuch(_howmuch)
430     {
431       CheckAllReadOnly();
432       WasteTime(howmuch);
433     }
434   int procNum(int, const CkArrayIndex &);
435 };