71d5bd5a6b1c20d9d3ee57ee6a50e50acf7c8964
[charm.git] / tests / charm++ / commtest / comlib / benchmulti.C
1
2 #include <stdio.h>
3 #include <string.h>
4
5 #include <sys/time.h>
6 #include <sys/resource.h>
7 #include <unistd.h>
8
9 #include "ComlibManager.h"
10 #include "EachToManyMulticastStrategy.h"
11 #include "RingMulticastStrategy.h"
12 #include "BroadcastStrategy.h"
13 #include "bench.decl.h"
14
15 #define USELIB
16 #define MAXPASS 100
17
18 int MESSAGESIZE=128;
19 int fraction = 1;
20 /*readonly*/ CkChareID mid;
21 /*readonly*/ CProxy_Bench arr;
22 /*readonly*/ int nElements;
23
24 void callbackhandler(void *message){
25     //CkPrintf("[%d]In callback function\n", CkMyPe());
26     
27     BenchMessage *bm = (BenchMessage *)EnvToUsr((envelope *)message);
28     arr[CkMyPe()].receiveMessage(bm);
29 }
30
31 class BenchMessage : public CkMcastBaseMsg, public CMessage_BenchMessage {
32 public:
33     int size;
34     char *data;
35     int src;
36     
37     static void *alloc(int mnum, size_t size, int *sizes, int priobits){
38         int total_size = size + sizeof(char) * sizes[0];
39         BenchMessage *dmsg = (BenchMessage *)CkAllocMsg(mnum, total_size, 
40                                                         priobits);
41         dmsg->size = sizes[0];        
42         return (void *)dmsg;
43     }
44     
45     static void *pack(BenchMessage *msg){
46         return (void *)msg;
47     }
48     
49     static BenchMessage *unpack(void *buf){
50         BenchMessage *bmsg = (BenchMessage *)buf;
51         return bmsg;
52     }
53 };
54
55 void reductionClient(void *param, int dataSize, void *data){
56     arr.sendMessage();
57 }
58
59 /*mainchare*/
60 class Main : public Chare
61 {
62     int pass, superpass;
63     double curTime;
64 public:
65     Main(CkArgMsg* m)
66     {
67         //Process command-line arguments
68         pass = 0;
69         superpass = 0;
70         nElements= CkNumPes();
71
72         if(m->argc > 1 ) MESSAGESIZE=atoi(m->argv[1]);
73         //if(m->argc > 2 ) fraction=atoi(m->argv[2]);
74
75         if(m->argc > 2 ) nElements=atoi(m->argv[2]);
76
77         delete m;
78         
79         CkPrintf("Running Bench on %d processors for %d elements with %d byte messages\n", CkNumPes(), nElements, MESSAGESIZE);
80         
81         mid = thishandle;        
82
83         arr = CProxy_Bench::ckNew();
84         arr.setReductionClient(reductionClient, NULL);
85                 
86         int count = 0;
87         CkArrayIndexMax *elem_array = new CkArrayIndexMax[nElements/fraction];
88         for(count = 0; count < nElements/fraction; count ++) {
89             elem_array[count] = CkArrayIndex1D(count);
90         }
91
92         EachToManyMulticastStrategy *strat = new 
93             EachToManyMulticastStrategy(USE_MESH, arr.ckGetArrayID(), 
94                                         arr.ckGetArrayID(), 
95                                         nElements/fraction, elem_array,
96                                         nElements/fraction, elem_array); 
97         
98         DirectMulticastStrategy *dstrat = new DirectMulticastStrategy
99             (arr.ckGetArrayID());
100
101         RingMulticastStrategy *rstrat = new RingMulticastStrategy
102             (arr.ckGetArrayID(), arr.ckGetArrayID());
103
104         BroadcastStrategy *bstrat = new BroadcastStrategy(arr.ckGetArrayID(),
105                                                           USE_HYPERCUBE);
106         
107         CkPrintf("After creating array\n");
108         CkArrayID aid = arr.ckGetArrayID();
109
110         ComlibInstanceHandle cinst = CkGetComlibInstance();        
111         cinst.setStrategy(bstrat);
112         ComlibPrintf("After register strategy\n");
113
114         for(count = 0; count < nElements; count++)
115             arr[count].insert(cinst);
116         arr.doneInserting();
117         
118         curTime = CkWallTimer();
119         arr.sendMessage();
120         CkPrintf("After Main\n");
121     };
122     
123     void send(void) {
124         
125         static int count = 0;
126         count ++;
127
128         if (count == nElements){
129             pass ++;
130             count = 0;
131             arr.sendMessage();
132         }
133     }
134     
135     void done()
136     {
137         static int count = 0;
138         
139         count ++;
140         
141         if(count == nElements) {
142             CkPrintf("%d %5.4lf\n", MESSAGESIZE, (CmiWallTimer() - curTime)*1000/MAXPASS);
143
144             curTime = CkWallTimer();
145             superpass ++;
146             pass = 0;
147             count = 0;
148
149             if(superpass == 50)
150                 CkExit();
151             else {
152               if(superpass < 20)
153                   MESSAGESIZE += 50;
154               else if(superpass < 30)
155                   MESSAGESIZE += 100;
156               else if(superpass < 40)
157                   MESSAGESIZE += 200;
158               else if(superpass < 50)
159                   MESSAGESIZE += 500;
160               
161               arr.start(MESSAGESIZE);
162             }
163         }
164     }
165 };
166
167 /*array [1D]*/
168 class Bench : public CBase_Bench //ArrayElement1D
169 {
170     int pass;
171     int mcount;
172     double time, startTime;
173     int firstEntryFlag, sendFinishedFlag;
174     CProxySection_Bench sproxy;
175     CProxy_Bench arrd;
176     ComlibInstanceHandle myinst;
177
178 public:
179
180     void pup(PUP::er &p) {
181         if(p.isPacking())
182             CkPrintf("Migrating from %d\n", CkMyPe());
183
184         ArrayElement1D::pup(p);
185         p | pass ;
186         p | mcount ;
187         p | time;
188         p | startTime;
189         p | firstEntryFlag ;
190         p | sendFinishedFlag ;
191         p | sproxy ;
192         p | myinst;
193         p | arrd;
194     }
195   
196     Bench(ComlibInstanceHandle cinst)
197     {   
198         pass = 0;
199         mcount = 0;
200         time = 0.0;
201         
202         firstEntryFlag = 0;
203         sendFinishedFlag = 0;
204
205         arrd = thisProxy;
206         ComlibDelegateProxy(&arrd);
207
208         CkArrayIndexMax *elem_array = new CkArrayIndexMax[nElements/fraction];
209         for(int count = 0; count < nElements/fraction; count ++) 
210             elem_array[count] = CkArrayIndex1D(count);
211         
212         sproxy = CProxySection_Bench::ckNew
213             (thisProxy.ckGetArrayID(), elem_array, nElements/fraction); 
214         //ComlibInitSection(sproxy.ckGetSectionInfo());
215         ComlibDelegateProxy(&sproxy);
216
217         usesAtSync = CmiTrue;
218         setMigratable(true);
219         myinst = cinst;
220     }
221     
222     Bench(CkMigrateMessage *m) {
223         CkPrintf(" Migrated to %d\n", CkMyPe());
224     }
225     
226     void sendMessage()
227     {
228         if(thisIndex >= nElements/fraction) {
229             finishPass();
230             return;
231         }
232         
233 #ifdef USELIB
234         myinst.beginIteration();
235 #endif
236
237         int count = 0;
238         int size = MESSAGESIZE;
239         
240 #ifdef USELIB
241         //ComlibDelegateProxy(&arrd);
242         arrd.receiveMessage(new(&size, 0) BenchMessage);
243         //sproxy.receiveMessage(new(&size, 0) BenchMessage);
244 #else
245         arr[count].receiveMessage(new (&size, 0) BenchMessage);
246 #endif
247
248 #ifdef USELIB
249         myinst.endIteration();
250 #endif
251
252         sendFinishedFlag = 1;   
253     }
254     
255     void receiveMessage(BenchMessage *bmsg){
256         
257         ComlibPrintf("[%d][%d] In Receive Message \n", CkMyPe(), thisIndex);
258         
259         if(!firstEntryFlag) {
260             startTime = CkWallTimer();
261             firstEntryFlag = 1;
262         }
263         
264         delete bmsg;
265         
266         mcount ++;
267
268         if((mcount == nElements/fraction) /*&& (sendFinishedFlag)*/){
269             finishPass();
270         }
271     }
272
273     void start(int messagesize){
274         //CkPrintf("In Start\n");
275         MESSAGESIZE = 128;  //messagesize;
276         
277         //if(firstEntryFlag) {
278         //  CkPrintf("Calling AtSync\n");
279         //  AtSync();
280         //}
281         //else
282         sendMessage();
283     }
284
285     void ResumeFromSync() {
286         ComlibResetSectionProxy(&sproxy);
287         myinst.setSourcePe();
288         sendMessage();
289     }
290
291     void finishPass(){
292         mcount = 0;            
293         pass ++;        
294         time += CkWallTimer() - startTime;
295
296         CProxy_Main mainProxy(mid);
297         if(pass == MAXPASS){
298             pass = 0;
299             mainProxy.done();
300         }
301         else {
302             sendMessage();
303             int x = 0;
304             //contribute(sizeof(int), (void *)&x, CkReduction::sum_int);
305         }
306         
307         sendFinishedFlag = 0;
308     }
309 };
310
311 #include "bench.def.h"