Merge nodehelper lib and example codes into charm
[charm.git] / src / ck-com / ComlibStats.h
1 #ifndef COMLIB_STATS_H
2 #define COMLIB_STATS_H
3
4 /**
5    @addtogroup CharmComlib
6    @{
7    @file
8    
9    @brief Classes for storing simple statistics about messages send and received.
10 */
11
12 #include "charm++.h"
13 #include "convcomlibmanager.h"
14
15 class ComlibLocalStats;
16
17 /**
18    Old class that is no longer used.
19 */
20 class ComlibComRec {
21     int nmessages_sent;
22     int totalbytes_sent;
23     int nmessages_received;
24     int totalbytes_received;
25     
26     unsigned char *procMap; // Map of which processors have communicated
27     int npes;               // Total number of processors participating 
28                             // in the communication operation
29     int degree;             // Number of processors messages are sent 
30                             // to or received from
31     CmiBool recorded;
32
33     friend class ComlibLocalStats;
34  public:
35     ComlibComRec() {
36         npes = CkNumPes();
37         procMap = 0;
38         totalbytes_sent = 0;
39         totalbytes_received = 0;
40         nmessages_sent = 0;
41         nmessages_received = 0;
42         degree = 0;
43         recorded = CmiFalse;
44     }
45
46     ComlibComRec(int _npes) {
47         npes = _npes;
48         procMap = 0;
49         totalbytes_sent = 0;
50         totalbytes_received = 0;
51         nmessages_sent = 0;
52         nmessages_received = 0;
53         degree = 0;
54         recorded = CmiFalse;
55     }
56
57     ~ComlibComRec() {
58         if(recorded && procMap)
59             CmiFree(procMap);
60
61         procMap = 0;
62     }
63
64     void setNpes(int _npes) {npes = _npes;}
65     CmiBool isRecorded() { return recorded;}
66
67     int getTotalBytes() { return  totalbytes_sent + totalbytes_received; }
68     int getTotalMessages() { return nmessages_sent + nmessages_received;}
69     int getDegree() { return degree;}
70
71     inline void recordSend(int size, int dest) {
72         if(!recorded) {
73             recorded = CmiTrue;
74             int mapsize = (npes / (sizeof(char)*8) + 1) * sizeof(char); 
75             procMap = (unsigned char*) CmiAlloc(mapsize);
76             memset(procMap, 0, mapsize);
77         }
78
79         nmessages_sent ++;
80         totalbytes_sent += size;
81         int pos = dest / (sizeof(char)*8);
82         int off = dest % (sizeof(char)*8);
83
84         if((procMap[pos] & (1 << off)) == 0) {
85             degree ++;
86             procMap[pos] |= 1 << off;    //mark a processor as being sent to
87         }
88     }
89
90     inline void recordSendM(int size, int *dest_m, int ndest) {
91         
92         if(!recorded) {
93             recorded = CmiTrue;
94             int mapsize = (npes / (sizeof(char)*8) + 1) * sizeof(char); 
95             procMap = (unsigned char*) CmiAlloc(mapsize);
96             memset(procMap, 0, mapsize);
97         }
98         
99         nmessages_sent += ndest;
100         totalbytes_sent += size * ndest;
101         
102         for(int count = 0; count < ndest; count ++) {
103             int pos = dest_m[count] / (sizeof(char)*8);
104             int off = dest_m[count] % (sizeof(char)*8);
105             
106             if((procMap[pos] & (1 << off)) == 0) {
107                 degree ++;
108                 //mark a processor as being sent to
109                 procMap[pos] |= 1 << off;    
110             }
111         }
112     }
113
114     inline void recordRecv(int size, int src) {
115         if(!recorded) {
116             recorded = CmiTrue;
117             int mapsize = (npes / (sizeof(char)*8) + 1) * sizeof(char); 
118             procMap = (unsigned char*) CmiAlloc(mapsize);
119             memset(procMap, 0, mapsize);
120         }
121
122         nmessages_received ++;
123         totalbytes_received += size;
124         int pos = src / (sizeof(char) * 8);
125         int off = src % (sizeof(char) * 8);
126
127         if((procMap[pos] & (1 << off)) == 0) {
128             degree ++;
129             procMap[pos] |= 1 << off;    //mark a processor as being sent to
130         }
131     }
132     
133     inline void recordRecvM(int size, int *src_m, int nsrc) {
134         if(!recorded) {
135             recorded = CmiTrue;
136             int mapsize = (npes / (sizeof(char)*8) + 1) * sizeof(char); 
137             procMap = (unsigned char*) CmiAlloc(mapsize);
138             memset(procMap, 0, mapsize);
139         }
140
141         nmessages_received += nsrc;
142         totalbytes_received += size * nsrc;
143
144         for(int count = 0; count < nsrc; count++) {
145             int pos = src_m[count] / (sizeof(char) * 8);
146             int off = src_m[count] % (sizeof(char) * 8);
147             
148             if((procMap[pos] & (1 << off)) == 0) {
149                 degree ++;
150                 //mark a processor as being sent to
151                 procMap[pos] |= 1 << off;    
152             }
153         }
154     }
155     
156     void reset () {
157         if(procMap)
158             CmiFree(procMap);
159         procMap = 0;
160         totalbytes_sent = 0;
161         totalbytes_received = 0;
162         nmessages_sent = 0;
163         nmessages_received = 0;
164         degree = 0;
165         recorded = CmiFalse;
166     }
167
168     void pup(PUP::er &p) {
169         p | nmessages_sent;
170         p | totalbytes_sent;
171         p | nmessages_received;
172         p | totalbytes_received;
173         p | npes;
174         p | degree;
175         p | recorded;
176
177
178         int mapsize = (npes / (sizeof(char)*8) + 1) * sizeof(char); 
179         if(p.isUnpacking()) {
180             if(recorded) 
181                 procMap = (unsigned char*) CmiAlloc(mapsize);
182         }
183         
184         if(recorded)
185             p(procMap, mapsize);
186     }
187 };
188
189
190 /**
191    Old class that is no longer used.
192 */
193 class ComlibLocalStats {
194  public:
195     CkVec<ComlibComRec> cdata;
196     int nstrats;
197
198     ComlibLocalStats(int _strats) : cdata(_strats) {
199       nstrats = _strats;
200     }
201     
202     ComlibLocalStats() : cdata(1) {
203       nstrats = 1;
204     }
205
206     void setNstrats(int nst) {
207         nstrats = nst;
208         cdata.resize(nstrats);
209     }
210
211     inline void recordSend(int sid, int size, int dest) {
212       if(sid >= nstrats) {
213         nstrats = sid + 1;
214         cdata.resize(nstrats);
215       }
216
217       cdata[sid].recordSend(size, dest);
218
219     }
220
221     inline void recordRecv(int sid, int size, int src) {
222       if(sid >= nstrats) {
223         nstrats = sid + 1;
224         cdata.resize(nstrats);
225       }
226
227       cdata[sid].recordRecv(size, src);
228     }
229
230     inline void recordSendM(int sid, int size, int *dest_m, int ndest) {
231       if(sid >= nstrats) {
232         nstrats = sid + 1;
233         cdata.resize(nstrats);
234       }
235
236       cdata[sid].recordSendM(size, dest_m, ndest);
237     }
238
239     inline void recordRecvM(int sid, int size, int *src_m, int nsrc) {
240       if(sid >= nstrats) {
241         nstrats = sid + 1;
242         cdata.resize(nstrats);
243       }
244
245       cdata[sid].recordRecvM(size, src_m, nsrc);
246     }
247     
248     inline void reset() {
249       for(int count = 0; count < nstrats; count++)
250         cdata[count].reset();
251     }
252
253     void pup(PUP::er &p) {
254       p | nstrats;
255       p | cdata;
256     }
257
258     ComlibLocalStats & operator=(ComlibLocalStats &in) {
259       nstrats = in.nstrats;
260
261       cdata.resize(in.cdata.size());
262       for(int count = 0; count < in.nstrats; count++) {
263         if(in.cdata[count].isRecorded()) {
264           memcpy(&cdata[count],&in.cdata[count], sizeof(ComlibComRec));
265           
266           int npes = in.cdata[count].npes;
267           int mapsize = (npes / (sizeof(char)*8) + 1) * sizeof(char); 
268           cdata[count].procMap = (unsigned char*) CmiAlloc(mapsize);
269           memcpy(cdata[count].procMap, in.cdata[count].procMap, mapsize);
270         }
271         else
272           cdata[count].reset();
273       }
274       
275       return *this;
276     }
277 };
278
279 class ComlibGlobalStats {
280  
281   ComlibLocalStats *statsArr;
282   
283  public:
284   
285   ComlibGlobalStats();
286   ~ComlibGlobalStats() {}
287   
288   void updateStats(ComlibLocalStats &stats, int pe); 
289   
290   //The average amount of data communicated
291   void getAverageStats(int sid, double &, double &, double &, double &);
292 };
293
294 /*@}*/
295 #endif