Merge branch 'charm' into development
[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 void _createTracecontrolPoints(char **argv)
25 {
26   CkpvInitialize(TraceControlPoints*, _trace);
27   CkpvAccess(_trace) = new TraceControlPoints(argv);
28   CkpvAccess(_traces)->addTrace(CkpvAccess(_trace));
29 }
30
31 TraceControlPoints::TraceControlPoints(char **argv)
32 {
33   resetTimings();
34
35   nesting_level = 0;
36
37   b1=0;
38   b2=0;
39   b3=0;
40
41   if (CkpvAccess(traceOnPe) == 0) return;
42
43   // Process runtime arguments intended for the module
44   // CmiGetArgIntDesc(argv,"+ControlPointsPar0", &par0, "Fake integer parameter 0");
45 }
46
47 void TraceControlPoints::userEvent(int eventID) 
48 {
49   //  CkPrintf("[%d] User Point Event id %d encountered\n", CkMyPe(), eventID);
50 }
51
52 void TraceControlPoints::userBracketEvent(int eventID, double bt, double et) {
53   //  CkPrintf("[%d] User Bracket Event id %d encountered\n", CkMyPe(), eventID);
54 }
55
56 void TraceControlPoints::creation(envelope *, int epIdx, int num) {
57   //  CkPrintf("[%d] Point-to-Point Message for Entry Method id %d sent\n",  CkMyPe(), epIdx);
58 }
59
60 void TraceControlPoints::creationMulticast(envelope *, int epIdx, int num, 
61                                     int *pelist) {
62   //  CkPrintf("[%d] Multicast Message for Entry Method id %d sent to %d pes\n", CkMyPe(), epIdx, num);
63 }
64
65 void TraceControlPoints::creationDone(int num) {
66   //  CkPrintf("[%d] Last initiated send completes\n", CkMyPe());
67 }
68   
69 void TraceControlPoints::messageRecv(char *env, int pe) {
70   // CkPrintf("[%d] Message from pe %d received by scheduler\n", CkMyPe(), pe);
71 }
72   
73 void TraceControlPoints::beginExecute(CmiObjId *tid)
74 {
75   nesting_level++;
76   if(nesting_level == 1){
77     // CmiObjId is a 4-integer tuple uniquely identifying a migratable
78     //   Charm++ object. Note that there are other non-migratable Charm++
79     //   objects that CmiObjId will not identify.
80     b1++;
81     lastBeginExecuteTime = CmiWallTimer();
82     lastbeginMessageSize = -1;
83   }
84 }
85
86
87
88 void TraceControlPoints::beginExecute(envelope *e)
89 {
90   nesting_level++;
91   if(nesting_level == 1){
92     lastBeginExecuteTime = CmiWallTimer();
93     lastbeginMessageSize = e->getTotalsize();
94     b2++;
95     b2mlen += lastbeginMessageSize;
96   }
97 }
98  
99 void TraceControlPoints::beginExecute(int event,int msgType,int ep,int srcPe, 
100                                int mlen, CmiObjId *idx)
101 {
102   nesting_level++;
103   if(nesting_level == 1){
104     b3++;
105     b3mlen += mlen;
106     lastBeginExecuteTime = CmiWallTimer();
107     lastbeginMessageSize = mlen;
108   }
109 }
110
111 void TraceControlPoints::endExecute(void)
112 {
113   nesting_level--;
114   if(nesting_level == 0){
115     
116     double executionTime = CmiWallTimer() - lastBeginExecuteTime;
117     totalEntryMethodTime += executionTime;
118     totalEntryMethodInvocations ++;
119     
120     double m = (double)CmiMemoryUsage();
121     if(memUsage < m){
122       memUsage = m;
123     }    
124   }
125 }
126
127 void TraceControlPoints::beginIdle(double curWallTime) {
128   lastBeginIdle = CmiWallTimer();
129   // CkPrintf("[%d] Scheduler has no useful user-work\n", CkMyPe());
130
131   double m = (double)CmiMemoryUsage();
132   if(memUsage < m){
133     memUsage = m;
134   }
135 }
136
137 void TraceControlPoints::endIdle(double curWallTime) {
138   totalIdleTime += CmiWallTimer() - lastBeginIdle;
139   //  CkPrintf("[%d] Scheduler now has useful user-work\n", CkMyPe());
140 }
141
142 void TraceControlPoints::beginComputation(void)
143 {
144   //  CkPrintf("[%d] Computation Begins\n", CkMyPe());
145   // Code Below shows what trace-summary would do.
146   // initialze arrays because now the number of entries is known.
147   // _logPool->initMem();
148 }
149
150 void TraceControlPoints::endComputation(void)
151 {
152   //  CkPrintf("[%d] Computation Ends\n", CkMyPe());
153 }
154
155 void TraceControlPoints::malloc(void *where, int size, void **stack, int stackSize)
156 {
157   // CkPrintf("[%d] Memory allocation of size %d occurred\n", CkMyPe(), size);
158   double m = (double)CmiMemoryUsage();
159   if(memUsage < m){
160     memUsage = m;
161   }
162 }
163
164 void TraceControlPoints::free(void *where, int size) {
165   //  CkPrintf("[%d] %d-byte Memory block freed\n", CkMyPe(), size);
166 }
167
168 void TraceControlPoints::traceClose(void)
169 {
170   // Print out some performance counters on BG/P
171   CProxy_TraceControlPointsBOC myProxy(traceControlPointsGID);
172   myProxy.ckLocalBranch()->printBGP_UPC_CountersBOC();
173
174     
175   CkpvAccess(_trace)->endComputation();
176   // remove myself from traceArray so that no tracing will be called.
177   CkpvAccess(_traces)->removeTrace(this);
178 }
179
180 void printBGP_UPC_Counters(void);
181
182 void TraceControlPointsBOC::printBGP_UPC_CountersBOC(void) {
183 #ifdef CMK_BLUEGENEP
184         printBGP_UPC_Counters();
185 #endif
186 }
187
188
189
190 void TraceControlPoints::resetTimings(){
191   totalIdleTime = 0.0;
192   totalEntryMethodTime = 0.0;
193   totalEntryMethodInvocations = 0;
194   lastResetTime = CmiWallTimer();
195 }
196
197 void TraceControlPoints::resetAll(){
198   totalIdleTime = 0.0;
199   totalEntryMethodTime = 0.0;
200   memUsage = 0;
201   totalEntryMethodInvocations = 0;
202   b2mlen=0;
203   b3mlen=0;
204   b2=0;
205   b3=0;
206   lastResetTime = CmiWallTimer();
207 }
208
209
210
211 TraceControlPoints *localControlPointTracingInstance(){
212   return CkpvAccess(_trace);
213 }
214
215
216
217 extern "C" void traceControlPointsExitFunction() {
218   // The exit function of any Charm++ module must call CkExit() or
219   // the entire exit process will hang if multiple modules are linked.
220   // FIXME: This is NOT a feature. Something needs to be done about this.
221   CkExit();
222 }
223
224 // Initialization of the parallel trace module.
225 void initTraceControlPointsBOC() {
226 #ifdef __BLUEGENE__
227   if (BgNodeRank()==0) {
228 #else
229     if (CkMyRank() == 0) {
230 #endif
231       registerExitFn(traceControlPointsExitFunction);
232     }
233 }
234
235 #include "TraceControlPoints.def.h"
236
237
238 /*@}*/