Changed traceBegin/traceEnd
[charm.git] / src / ck-perf / trace-counter.h
1 /*****************************************************************************
2  * $Source$
3  * $Author$
4  * $Date$
5  * $Revision$
6  *****************************************************************************/
7
8 /**
9  * \addtogroup CkPerf
10 */
11 /*@{*/
12
13 #ifndef __trace_counter_h__
14 #define __trace_counter_h__
15
16 #include <stdio.h>
17 #include <errno.h>
18 #include "trace.h"
19 #include "ck.h"
20 #include "trace-common.h"
21 #include "conv-mach.h"
22 #ifdef CMK_ORIGIN2000
23 #include <sys/hwperftypes.h>
24 #endif
25
26 #define MAX_ENTRIES 500
27
28 //! track statistics for all entry points
29 class StatTable {
30   public:
31     StatTable(char** name, char** desc, int argc);
32     ~StatTable();
33     //! one entry is called for 'time' seconds, value is counter reading 
34     void setEp(int epidx, int stat, long long value, double time);
35     //! write three lines for each stat:
36     //!   1. number of calls for each entry
37     //!   2. average count for each entry
38     //!   3. total time in us spent for each entry
39     void write(FILE* fp);
40     void clear();
41     inline int numStats() { return numStats_; }
42
43   private:
44     //! struct to maintain statistics
45     struct Statistics {
46       char*  name;                    // name of stat being tracked
47       char*  desc;                    // description of stat being tracked
48       UInt   numCalled[MAX_ENTRIES];  // total number times called
49       double avgCount[MAX_ENTRIES];   // track average of value
50       double totTime[MAX_ENTRIES];    // total time associated with counter
51
52       Statistics(): name(NULL) { }
53     };
54
55     Statistics* stats_;             // track stats for each entry point
56     int         numStats_;          // size of statistics being tracked
57     // bool        error_;             // will be set to true if error writing info
58 };
59
60 // counter log pool
61 class CountLogPool {
62   public:
63     CountLogPool(char* pgm, char** name, char** desc, int argc);
64     ~CountLogPool();
65     void write(int phase=-1) ;
66     void writeSts(int phase=-1);
67     void openFile(int phase=-1);
68     void setEp(int epidx, long long count1, long long count2, double time);
69     void clearEps() { stats_.clear(); }
70     void setTrace(bool on) { traceOn_ = on; }
71
72   private:
73     char*     pgm_;
74     FILE*     fp_;
75     StatTable stats_;
76     bool      traceOn_;
77 };
78
79 //! For each processor, TraceCounter calculates mean, stdev, etc of 
80 //! CPU performance counters for each entry point.
81 class TraceCounter : public Trace {
82   public:
83     TraceCounter();
84     ~TraceCounter();
85     void traceBegin();
86     void traceEnd();
87     int traceRegisterUserEvent(const char* userEvent) { 
88       // CmiPrintf("%d/%d traceRegisterUserEvent(%s)\n", 
89       // CkMyPe(), CkNumPes(), userEvent);
90       return 0;
91     }
92     void userEvent(int e) { 
93       // CmiPrintf("%d/%d userEvent %d\n", CkMyPe(), CkNumPes(), e); 
94     }
95     void creation(envelope *e, int num=1) { }
96     void messageRecv(char *env, int pe) { }
97     void beginExecute(envelope *e);
98     void beginExecute(int event, int msgType, int ep, int srcPe, int mlen=0);
99     void endExecute(void);
100     void beginIdle(void) { }
101     void endIdle(void) { }
102     void beginPack(void);
103     void endPack(void);
104     void beginUnpack(void);
105     void endUnpack(void);
106     void enqueue(envelope *e) { }
107     void dequeue(envelope *e) { }
108     void beginComputation(void);
109     void endComputation(void) { }
110
111     void traceInit(char **argv);
112     void traceClearEps();
113     void traceWriteSts();
114     void traceClose();
115
116     //! CounterArg is a linked list of strings that allows
117     //! processing of command line args
118     struct CounterArg {
119       int         code;
120       char*       arg;
121       char*       desc;
122       CounterArg* next;
123
124       CounterArg(): code(-1), arg(NULL), desc(NULL), next(NULL) { }
125       CounterArg(int c, char* a, char* d):
126         code(c), arg(a), desc(d), next(NULL) { }
127       void setValues(int _code, char* _arg, char* _desc) {
128         code = _code;  arg = _arg;  desc = _desc;
129       }
130     };
131
132   private:
133     int         execEP_;       // id currently executing entry point
134     double      startEP_;      // start time of currently executing ep
135     double      startPack_;    // start time of pack operation
136     double      startUnpack_;  // start time of unpack operation
137     CounterArg* firstArg_;     // pointer to start of linked list of args
138     CounterArg* lastArg_;      // pointer to end of linked list of args
139     int         argStrSize_;   // size of maximum arg string (formatted output)
140     int         phase_;        // current phase
141     bool        traceOn_;      // true if trace is turned on
142
143     int         counter1_;     // 1st counter to track
144     int         counter2_;     // 2nd counter to track
145
146     #ifdef CMK_ORIGIN2000
147     enum Status { IDLE, WORKING };
148     Status      status_;       // to prevent errors
149     int         genStart_;     // track value of start_counters
150     int         fileDesc_;     // file descriptor for accessing hw counters
151     hwperf_profevctrarg_t evctrArgs_;  // tells what type of counter to profile
152     hwperf_cntr_t         cnts_;       // reads the counters values
153     // starts hw profiling for these counters
154     // returns -1 if error, generation number if no error
155     int startCounter(int counter1, int counter2);
156     // gets hw profile values for these counters
157     // returns -1 if error, generation number if no error
158     int readCounters
159     (
160       int        counter1,
161       long long* value1,
162       int        counter2,
163       long long* value2
164     );
165     #endif // CMK_ORIGIN2000
166
167     //! add the argument parameters to the linked list of args choices
168     void registerArg(CounterArg* arg);
169     //! see if the arg (str or code) matches any in the linked list of choices
170     //! and sets arg->code to the SGI code
171     //! return true if arg matches, false otherwise
172     bool matchArg(CounterArg* arg);
173     //! print out all arguments in the linked-list of choices
174     void printHelp();
175 };
176
177 #endif  // __trace_counter_h__
178
179 /*@}*/
180
181