changed a few things in order to link with application.
[charm.git] / src / ck-perf / trace.h
1 /*****************************************************************************
2  * $Source$
3  * $Author$
4  * $Date$
5  * $Revision$
6  *****************************************************************************/
7
8 #ifndef _TRACE_H
9 #define _TRACE_H
10
11 #if CMK_HAS_COUNTER_PAPI
12 #include <papi.h>
13 #endif
14
15 class envelope;
16
17 /**
18  \defgroup CkPerf  Charm++ Trace Module
19 */
20 /*@{*/
21
22 // An additional interface for summary data
23 extern "C" void traceClearEps();
24 extern double CmiTraceTimer();
25
26 extern int _dummyMsg, _dummyChare, _dummyEP;
27
28 /* CW Support for Thread Listener interface */
29 extern "C" void traceAddThreadListeners(CthThread tid, envelope *e);
30
31 // trace_in_charm means only do trace for Charm++ level, skip converse tracing
32 // Cpv traceOnPe controls if charm pe will generate trace logs (a default value)
33 // while traceOnPe flag in each trace module can also control independently if 
34 // tracing is wanted for each module
35 CkpvExtern(int, traceOnPe);
36
37 // A hack. We need to somehow tell the pup framework what size
38 // long_long is wrt PAPI.
39 #if CMK_HAS_COUNTER_PAPI
40 typedef long_long LONG_LONG_PAPI;
41 #else
42 typedef CMK_TYPEDEF_INT8 LONG_LONG_PAPI;
43 #endif
44
45 // Base class of all tracing strategies.
46 // 
47 class Trace {
48   protected:
49     int _traceOn;
50   public:
51     Trace(): _traceOn(0) {}
52     virtual void setTraceOnPE(int flag) { _traceOn = flag; }
53     virtual inline int traceOnPE() { return _traceOn; }
54     // turn trace on/off, note that charm will automatically call traceBegin()
55     // at the beginning of every run unless the command line option "+traceoff"
56     // is specified
57     virtual void traceBegin() {}
58     virtual void traceEnd() {}
59     // registers user event trace module returns int identifier 
60     virtual int traceRegisterUserEvent(const char* eventName, int e) { return 0; }
61     // a user event has just occured
62     virtual void userEvent(int eventID) {}
63     // a pair of begin/end user event has just occured
64     virtual void userBracketEvent(int eventID, double bt, double et) {}
65     // creation of message(s)
66     virtual void creation(envelope *, int epIdx, int num=1) {}
67     virtual void creationMulticast(envelope *, int epIdx, int num=1,
68                                      int *pelist=NULL) {}
69     virtual void creationDone(int num=1) {}
70     // ???
71     virtual void messageRecv(char *env, int pe) {}
72     virtual void beginSDAGBlock(
73       int event,   // event type defined in trace-common.h
74       int msgType, // message type
75       int ep,      // Charm++ entry point (will correspond to sts file) 
76       int srcPe,   // Which PE originated the call
77       int ml,      // message size
78       CmiObjId* idx)    // index
79     { }
80     virtual void endSDAGBlock(void) {}
81     // **************************************************************
82     // begin/end execution of a Charm++ entry point
83     // NOTE: begin/endPack and begin/endUnpack can be called in between
84     //       a beginExecute and its corresponding endExecute.
85     virtual void beginExecute(envelope *) {}
86     virtual void beginExecute(CmiObjId *tid) {}
87     virtual void beginExecute(
88       int event,   // event type defined in trace-common.h
89       int msgType, // message type
90       int ep,      // Charm++ entry point (will correspond to sts file) 
91       int srcPe,   // Which PE originated the call
92       int ml,      // message size
93       CmiObjId* idx)    // index
94     { }
95     virtual void endExecute(void) {}
96     // begin/end idle time for this pe
97     virtual void beginIdle(double curWallTime) {}
98     virtual void endIdle(double curWallTime) {}
99     // begin/end the process of packing a message (to send)
100     virtual void beginPack(void) {}
101     virtual void endPack(void) {}
102     // begin/end the process of unpacking a message (can occur before calling
103     // a entry point or during an entry point when 
104     virtual void beginUnpack(void) {}
105     virtual void endUnpack(void) {}
106     // ???
107     virtual void enqueue(envelope *) {}
108     virtual void dequeue(envelope *) {}
109     // begin/end of execution
110     virtual void beginComputation(void) {}
111     virtual void endComputation(void) {}
112     // clear all data collected for entry points
113     virtual void traceClearEps() {}
114     // write the summary sts file for this trace
115     virtual void traceWriteSts() {}
116     // do any clean-up necessary for tracing
117     virtual void traceClose() {}
118     // flush log buffer immediately
119     virtual void traceFlushLog() {}
120
121     //for tracing function calls
122     virtual void regFunc(const char *name, int &idx){}
123     virtual void beginFunc(char *name,char *file,int line){}
124     virtual void beginFunc(int idx,char *file,int line){}
125     virtual void endFunc(char *name){}    
126     virtual void endFunc(int idx){}
127
128     /* for implementing thread listeners */
129     virtual void traceAddThreadListeners(CthThread tid, envelope *e) {}
130
131     virtual ~Trace() {} /* for whining compilers */
132 };
133
134 #define ALLDO(x) for (int i=0; i<length(); i++) if (traces[i]->traceOnPE()) traces[i]->x
135 #define ALLREVERSEDO(x) for (int i=length()-1; i>=0; i--) if (traces[i]->traceOnPE()) traces[i]->x
136
137 /// Array of Traces modules,  every event raised will go through every Trace module.
138 class TraceArray {
139 private:
140   CkVec<Trace *>  traces;
141   int n;
142   int cancel_beginIdle, cancel_endIdle;
143 public:
144     TraceArray(): n(0) {}
145     inline void addTrace(Trace *tr) { traces.push_back(tr); n++;}
146     inline void setTraceOnPE(int flag) { for (int i=0; i<length(); i++) traces[i]->setTraceOnPE(flag); }
147     // to allow traceCLose() to be called multiple times, remove trace module
148     // from the array in each individual trace, and clean up (clearTrace)
149     // after the loop.
150     inline void removeTrace(Trace *tr) {    // remove a Trace from TraceArray
151         int i;
152         for (i=0; i<n; i++) if (tr == traces[i]) break;
153         CmiAssert(i<n);
154         traces[i] = NULL;
155     }
156     inline void clearTrace() {    // remove holes in TraceArray
157         int len = traces.length();
158         int removed = 0;
159         for (int i=0; i<len; i++) {
160           if (traces[i-removed] == NULL) { traces.remove(i-removed); removed++; }
161         }
162         n -= removed;
163     }
164     inline int length() const { return n; }
165
166     inline void userEvent(int e) { ALLDO(userEvent(e));}
167     inline void userBracketEvent(int e,double bt, double et) {ALLDO(userBracketEvent(e,bt,et));}
168     
169     /* Creation needs to access _entryTable, so moved into trace-common.C */
170     void creation(envelope *env, int ep, int num=1);
171     void creationMulticast(envelope *env, int ep, int num=1, int *pelist=NULL);
172     
173     inline void creationDone(int num=1) { ALLDO(creationDone(num)); }
174     inline void beginSDAGBlock(int event,int msgType,int ep,int srcPe, int mlen,CmiObjId *idx=NULL) {ALLDO(beginSDAGBlock(event, msgType, ep, srcPe, mlen,idx));}
175     inline void endSDAGBlock(void) {ALLREVERSEDO(endExecute());}
176     inline void beginExecute(envelope *env) {ALLDO(beginExecute(env));}
177     inline void beginExecute(CmiObjId *tid) {ALLDO(beginExecute(tid));}
178     inline void beginExecute(int event,int msgType,int ep,int srcPe, int mlen,CmiObjId *idx=NULL) {ALLDO(beginExecute(event, msgType, ep, srcPe, mlen,idx));}
179     inline void endExecute(void) {ALLREVERSEDO(endExecute());}
180     inline void messageRecv(char *env, int pe) {ALLDO(messageRecv(env, pe));}
181     inline void beginPack(void) {ALLDO(beginPack());}
182     inline void endPack(void) {ALLDO(endPack());}
183     inline void beginUnpack(void) {ALLDO(beginUnpack());}
184     inline void endUnpack(void) {ALLDO(endUnpack());}
185     inline void enqueue(envelope *e) {ALLDO(enqueue(e));}
186     inline void dequeue(envelope *e) {ALLDO(dequeue(e));}
187     inline void beginComputation(void) {ALLDO(beginComputation());}
188     inline void endComputation(void) {ALLDO(endComputation());}
189     inline int traceRegisterUserEvent(const char*x, int evt) {
190           int eno = 0;
191           for (int i=0; i<length(); i++) {
192             if (traces[i]->traceOnPE() == 0) continue;
193             int e = traces[i]->traceRegisterUserEvent(x, evt);
194             if (e) eno = e;
195           }
196           return eno;
197     }  
198     inline void traceClearEps() {ALLDO(traceClearEps());}
199     inline void traceWriteSts() {ALLDO(traceWriteSts());}
200     inline void traceClose() {ALLDO(traceClose()); clearTrace();}
201     inline void traceFlushLog() {ALLDO(traceFlushLog());}
202     
203     // Tracing module registers *itself* for begin/end idle callbacks:
204     inline void beginIdle(double curWallTime) {ALLDO(beginIdle(curWallTime));}
205     inline void endIdle(double curWallTime) {ALLDO(endIdle(curWallTime));}
206     void traceBegin();
207     void traceEnd();
208
209     /*Calls for tracing function begins and ends*/
210     inline void regFunc(const char *name, int &idx){ ALLDO(regFunc(name, idx)); }
211     inline void beginFunc(char *name,char *file,int line){ ALLDO(beginFunc(name,file,line)); };
212     inline void beginFunc(int idx,char *file,int line){ ALLDO(beginFunc(idx,file,line)); };
213     inline void endFunc(char *name){ ALLDO(endFunc(name)); }
214     inline void endFunc(int idx){ ALLDO(endFunc(idx)); }
215
216     /* calls for thread listener registration for each trace module */
217     inline void traceAddThreadListeners(CthThread tid, envelope *e) {
218       ALLDO(traceAddThreadListeners(tid, e));
219     }
220 };
221
222 CkpvExtern(TraceArray*, _traces);
223
224 #ifndef CMK_OPTIMIZE
225 #  define _TRACE_ONLY(code) do{if(CpvAccess(traceOn)){ code; }} while(0)
226 #  define _TRACE_ALWAYS(code) do{ code; } while(0)
227 #else
228 #  define _TRACE_ONLY(code) /*empty*/
229 #  define _TRACE_ALWAYS(code) /*empty*/
230 #endif
231
232 extern "C" {
233 #include "conv-trace.h"
234 }
235
236 #define _TRACE_USER_EVENT(x) _TRACE_ONLY(CkpvAccess(_traces)->userEvent(x))
237 #define _TRACE_USER_EVENT_BRACKET(x,bt,et) _TRACE_ONLY(CkpvAccess(_traces)->userBracketEvent(x,bt,et))
238 #define _TRACE_CREATION_1(env) _TRACE_ONLY(CkpvAccess(_traces)->creation(env,env->getEpIdx()))
239 #define _TRACE_CREATION_DETAILED(env,ep) _TRACE_ONLY(CkpvAccess(_traces)->creation(env,ep))
240 #define _TRACE_CREATION_N(env, num) _TRACE_ONLY(CkpvAccess(_traces)->creation(env,env->getEpIdx(), num))
241 #define _TRACE_CREATION_MULTICAST(env, num, pelist) _TRACE_ONLY(CkpvAccess(_traces)->creationMulticast(env, env->getEpIdx(), num, pelist))
242 #define _TRACE_CREATION_DONE(num) _TRACE_ONLY(CkpvAccess(_traces)->creationDone(num))
243 #define _TRACE_BEGIN_SDAG(env) _TRACE_ONLY(CkpvAccess(_traces)->beginSDAGBlock(env))
244 #define _TRACE_END_SDAG(env) _TRACE_ONLY(CkpvAccess(_traces)->endSDAGBlock(env))
245 #define _TRACE_BEGIN_EXECUTE(env) _TRACE_ONLY(CkpvAccess(_traces)->beginExecute(env))
246 #define _TRACE_BEGIN_EXECUTE_DETAILED(evt,typ,ep,src,mlen,idx) \
247         _TRACE_ONLY(CkpvAccess(_traces)->beginExecute(evt,typ,ep,src,mlen,idx))
248 #define _TRACE_END_EXECUTE() _TRACE_ONLY(CkpvAccess(_traces)->endExecute())
249 #define _TRACE_MESSAGE_RECV(env, pe) _TRACE_ONLY(CkpvAccess(_traces)->messageRecv(env, pe))
250 #define _TRACE_BEGIN_PACK() _TRACE_ONLY(CkpvAccess(_traces)->beginPack())
251 #define _TRACE_END_PACK() _TRACE_ONLY(CkpvAccess(_traces)->endPack())
252 #define _TRACE_BEGIN_UNPACK() _TRACE_ONLY(CkpvAccess(_traces)->beginUnpack())
253 #define _TRACE_END_UNPACK() _TRACE_ONLY(CkpvAccess(_traces)->endUnpack())
254 #define _TRACE_BEGIN_COMPUTATION() _TRACE_ALWAYS(CkpvAccess(_traces)->beginComputation())
255 #define _TRACE_END_COMPUTATION() _TRACE_ALWAYS(CkpvAccess(_traces)->endComputation())
256 #define _TRACE_ENQUEUE(env) _TRACE_ONLY(CkpvAccess(_traces)->enqueue(env))
257 #define _TRACE_DEQUEUE(env) _TRACE_ONLY(CkpvAccess(_traces)->dequeue(env))
258
259 #include "trace-bluegene.h"
260
261 #endif
262
263
264 /*@}*/