Merge branch 'charm' of charmgit:charm into charm
[charm.git] / src / ck-perf / trace-controlPoints.C
1 #include "charm++.h"
2 #include "trace-controlPoints.h"
3 #include "trace-controlPointsBOC.h"
4
5
6 /**
7  *   \addtogroup ControlPointFramework
8  *   @{
9  */
10
11
12 // Charm++ "processor"(user thread)-private global variable
13 CkpvStaticDeclare(TraceControlPoints*, _trace);
14
15 // This global variable is required for any post-execution 
16 // parallel analysis or parallel activities the trace module 
17 // might wish to perform.
18 CkGroupID traceControlPointsGID;
19
20 /**
21   For each TraceFoo module, _createTraceFoo() must be defined.
22   This function is called in _createTraces() generated in moduleInit.C
23
24   This module is special in that it is always included in charm, but sometimes it does nothing.
25   This is called on all processors in SMP version.
26 */
27 void _createTracecontrolPoints(char **argv)
28 {
29   CkpvInitialize(TraceControlPoints*, _trace);
30   CkpvAccess(_trace) = new TraceControlPoints(argv);
31   CkpvAccess(_traces)->addTrace(CkpvAccess(_trace));
32 }
33
34 TraceControlPoints::TraceControlPoints(char **argv)
35 {
36   resetTimings();
37
38   nesting_level = 0;
39
40   whenStoppedTracing = 0;
41
42   b1=0;
43   b2=0;
44   b3=0;
45
46   if (CkpvAccess(traceOnPe) == 0) return;
47
48   // Process runtime arguments intended for the module
49   // CmiGetArgIntDesc(argv,"+ControlPointsPar0", &par0, "Fake integer parameter 0");
50 }
51
52
53 void TraceControlPoints::traceBegin(void){
54   if(whenStoppedTracing != 0)
55     totalUntracedTime += CmiWallTimer() - whenStoppedTracing;
56   whenStoppedTracing = 0;
57   CkPrintf("[%d] TraceControlPoints::traceBegin() totalUntracedTime=%f\n", CkMyPe(), totalUntracedTime);
58 }
59
60
61 void TraceControlPoints::traceEnd(void){
62   CkPrintf("[%d] TraceControlPoints::traceEnd()\n", CkMyPe());
63   CkAssert(whenStoppedTracing == 0); // can't support nested traceEnds on one processor yet...
64   whenStoppedTracing = CmiWallTimer();
65 }
66
67
68
69 void TraceControlPoints::userEvent(int eventID) 
70 {
71   //  CkPrintf("[%d] User Point Event id %d encountered\n", CkMyPe(), eventID);
72 }
73
74 void TraceControlPoints::userBracketEvent(int eventID, double bt, double et) {
75   //  CkPrintf("[%d] User Bracket Event id %d encountered\n", CkMyPe(), eventID);
76 }
77
78 void TraceControlPoints::creation(envelope *, int epIdx, int num) {
79   //  CkPrintf("[%d] Point-to-Point Message for Entry Method id %d sent\n",  CkMyPe(), epIdx);
80 }
81
82 void TraceControlPoints::creationMulticast(envelope *, int epIdx, int num, 
83                                     int *pelist) {
84   //  CkPrintf("[%d] Multicast Message for Entry Method id %d sent to %d pes\n", CkMyPe(), epIdx, num);
85 }
86
87 void TraceControlPoints::creationDone(int num) {
88   //  CkPrintf("[%d] Last initiated send completes\n", CkMyPe());
89 }
90   
91 void TraceControlPoints::messageRecv(char *env, int pe) {
92   // CkPrintf("[%d] Message from pe %d received by scheduler\n", CkMyPe(), pe);
93 }
94   
95 void TraceControlPoints::beginExecute(CmiObjId *tid)
96 {
97   nesting_level++;
98   if(nesting_level == 1){
99     // CmiObjId is a 4-integer tuple uniquely identifying a migratable
100     //   Charm++ object. Note that there are other non-migratable Charm++
101     //   objects that CmiObjId will not identify.
102     b1++;
103     lastBeginExecuteTime = CmiWallTimer();
104     lastbeginMessageSize = -1;
105   }
106 }
107
108
109
110 void TraceControlPoints::beginExecute(envelope *e)
111 {
112   nesting_level++;
113   if(nesting_level == 1){
114     lastBeginExecuteTime = CmiWallTimer();
115     lastbeginMessageSize = e->getTotalsize();
116     b2++;
117     b2mlen += lastbeginMessageSize;
118   }
119 }
120  
121 void TraceControlPoints::beginExecute(int event,int msgType,int ep,int srcPe, 
122                                int mlen, CmiObjId *idx)
123 {
124   nesting_level++;
125   if(nesting_level == 1){
126     b3++;
127     b3mlen += mlen;
128     lastBeginExecuteTime = CmiWallTimer();
129     lastbeginMessageSize = mlen;
130   }
131 }
132
133 void TraceControlPoints::endExecute(void)
134 {
135   //  CkPrintf("TraceControlPoints::endExecute\n");
136   nesting_level--;
137   if(nesting_level == 0){
138     
139     double executionTime = CmiWallTimer() - lastBeginExecuteTime;
140     totalEntryMethodTime += executionTime;
141     totalEntryMethodInvocations ++;
142     
143     double m = (double)CmiMemoryUsage();
144     if(memUsage < m){
145       memUsage = m;
146     }    
147   }
148 }
149
150 void TraceControlPoints::beginIdle(double curWallTime) {
151   lastBeginIdle = CmiWallTimer();
152   // CkPrintf("[%d] Scheduler has no useful user-work\n", CkMyPe());
153
154   double m = (double)CmiMemoryUsage();
155   if(memUsage < m){
156     memUsage = m;
157   }
158 }
159
160 void TraceControlPoints::endIdle(double curWallTime) {
161   totalIdleTime += CmiWallTimer() - lastBeginIdle;
162   //  CkPrintf("[%d] Scheduler now has useful user-work\n", CkMyPe());
163 }
164
165 void TraceControlPoints::beginComputation(void)
166 {
167   CkPrintf("[%d] TraceControlPoints::beginComputation\n", CkMyPe());
168   // Code Below shows what trace-summary would do.
169   // initialze arrays because now the number of entries is known.
170   // _logPool->initMem();
171 }
172
173 void TraceControlPoints::endComputation(void)
174 {
175   CkPrintf("[%d] TraceControlPoints::endComputationn", CkMyPe());
176 }
177
178 void TraceControlPoints::malloc(void *where, int size, void **stack, int stackSize)
179 {
180   // CkPrintf("[%d] Memory allocation of size %d occurred\n", CkMyPe(), size);
181   double m = (double)CmiMemoryUsage();
182   if(memUsage < m){
183     memUsage = m;
184   }
185 }
186
187 void TraceControlPoints::free(void *where, int size) {
188   //  CkPrintf("[%d] %d-byte Memory block freed\n", CkMyPe(), size);
189 }
190
191 void TraceControlPoints::traceClose(void)
192 {
193   // Print out some performance counters on BG/P
194   CProxy_TraceControlPointsBOC myProxy(traceControlPointsGID);
195
196     
197   CkpvAccess(_trace)->endComputation();
198   // remove myself from traceArray so that no tracing will be called.
199   CkpvAccess(_traces)->removeTrace(this);
200 }
201
202
203
204
205 void TraceControlPoints::resetTimings(){
206   totalIdleTime = 0.0;
207   totalEntryMethodTime = 0.0;
208   totalEntryMethodInvocations = 0;
209   lastResetTime = CmiWallTimer();
210   totalUntracedTime = 0;
211   if(whenStoppedTracing !=0){
212     whenStoppedTracing = CmiWallTimer();
213   }
214 }
215
216 void TraceControlPoints::resetAll(){
217   totalIdleTime = 0.0;
218   totalEntryMethodTime = 0.0;
219   memUsage = 0;
220   totalEntryMethodInvocations = 0;
221   b2mlen=0;
222   b3mlen=0;
223   b2=0;
224   b3=0;
225   lastResetTime = CmiWallTimer();
226   totalUntracedTime = 0;
227   if(whenStoppedTracing !=0){
228     whenStoppedTracing = CmiWallTimer();
229   }
230 }
231
232
233
234
235
236
237 TraceControlPoints *localControlPointTracingInstance(){
238   return CkpvAccess(_trace);
239 }
240
241
242
243 extern "C" void traceControlPointsExitFunction() {
244   // The exit function of any Charm++ module must call CkExit() or
245   // the entire exit process will hang if multiple modules are linked.
246   // FIXME: This is NOT a feature. Something needs to be done about this.
247   CkExit();
248 }
249
250 // Initialization of the parallel trace module.
251 void initTraceControlPointsBOC() {
252 /*
253 #ifdef __BLUEGENE__
254   if (BgNodeRank()==0) {
255 #else
256     if (CkMyRank() == 0) {
257 #endif
258       registerExitFn(traceControlPointsExitFunction);
259     }
260 */
261 }
262
263
264
265 #include "TraceControlPoints.def.h"
266
267
268 /*@}*/