Added overview and commented well`
[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
23 #define MAX_ENTRIES 500
24
25 //! track statistics for all entry points
26 class StatTable {
27   public:
28     StatTable();
29     ~StatTable();
30     void init(char** name, char** desc, int argc);
31     //! one entry is called for 'time' seconds, value is counter reading 
32     void setEp(int epidx, int stat, long long value, double time);
33     //! write three lines for each stat:
34     //!   1. number of calls for each entry
35     //!   2. average count for each entry
36     //!   3. total time in us spent for each entry
37     void write(FILE* fp);
38     void clear();
39     int numStats() { return numStats_; }
40
41   private:
42     //! struct to maintain statistics
43     struct Statistics {
44       char*  name;                    // name of stat being tracked
45       char*  desc;                    // description of stat being tracked
46       UInt   numCalled[MAX_ENTRIES];  // total number times called
47       double avgCount[MAX_ENTRIES];   // track average of value
48       double totTime[MAX_ENTRIES];    // total time associated with counter
49
50       Statistics(): name(NULL) { }
51     };
52
53     Statistics* stats_;             // track stats for each entry point
54     int         numStats_;          // size of statistics being tracked
55 };
56
57 //! counter log pool this implements functions for TraceCounter but
58 //! that needed to be performed on a node-level
59 class CountLogPool {
60   public:
61     CountLogPool();
62     ~CountLogPool();
63     void write(int phase=-1) ;
64     void writeSts(int phase=-1);
65     FILE* openFile(int phase=-1);
66     void setEp(int epidx, long long count1, long long count2, double time);
67     void clearEps() { stats_.clear(); }
68     void init(char** name, char** desc, int argc) { 
69       stats_.init(name, desc, argc);
70     }
71
72   private:
73     StatTable stats_;       // store stats per counter
74     int       lastPhase_;   // keep track of last phase for closing behavior
75 };
76
77 //! For each processor, TraceCounter calculates mean, stdev, etc of 
78 //! CPU performance counters for each entry point.
79 class TraceCounter : public Trace {
80   public:
81     TraceCounter();
82     ~TraceCounter();
83     //! process command line arguments!
84     void traceInit(char **argv);
85     //! turn trace on/off, note that charm will automatically call traceBegin()
86     //! at the beginning of every run unless the command line option "+traceoff"
87     //! is specified
88     void traceBegin();
89     void traceEnd();
90     //! registers user event trace module returns int identifier 
91     int traceRegisterUserEvent(const char* userEvent) { 
92       // CmiPrintf("%d/%d traceRegisterUserEvent(%s)\n", 
93       // CkMyPe(), CkNumPes(), userEvent);
94       return 0;
95     }
96     //! a user event has just occured
97     void userEvent(int e) { 
98       // CmiPrintf("%d/%d userEvent %d\n", CkMyPe(), CkNumPes(), e); 
99     }
100     //! creation of message(s)
101     void creation(envelope *e, int num=1) { }
102     //! ???
103     void messageRecv(char *env, int pe) { }
104     //! begin/end execution of a Charm++ entry point
105     //! NOTE: begin/endPack and begin/endUnpack can be called in between
106     //!       a beginExecute and its corresponding endExecute.
107     void beginExecute(envelope *e);
108     void beginExecute(
109       int event,   //! event type defined in trace-common.h
110       int msgType, //! message type
111       int ep,      //! Charm++ entry point (will correspond to sts file) 
112       int srcPe,   //! Which PE originated the call
113       int ml=0);   //! message size
114     void endExecute(void);
115     //! begin/end idle time for this pe
116     void beginIdle(void) { if (traceOn_) { startIdle_ = TraceTimer(); } }
117     void endIdle(void) { 
118       if (traceOn_) { idleTime_ += TraceTimer()-startIdle_; }
119     }
120     //! begin/end the process of packing a message (to send)
121     void beginPack(void);
122     void endPack(void);
123     //! begin/end the process of unpacking a message (can occur before calling
124     //! a entry point or during an entry point when 
125     void beginUnpack(void);
126     void endUnpack(void);
127     //! ???
128     void enqueue(envelope *e) { }
129     void dequeue(envelope *e) { }
130     //! begin/end of execution
131     void beginComputation(void);
132     void endComputation(void) { }
133     //! clear all data collected for entry points
134     void traceClearEps();
135     //! write the summary sts file for this trace
136     void traceWriteSts();
137     //! do any clean-up necessary for tracing
138     void traceClose();
139
140     //! CounterArg is a linked list of strings that allows
141     //! processing of command line args
142     struct CounterArg {
143       int         code;
144       char*       arg;
145       char*       desc;
146       CounterArg* next;
147
148       CounterArg(): code(-1), arg(NULL), desc(NULL), next(NULL) { }
149       CounterArg(int c, char* a, char* d):
150         code(c), arg(a), desc(d), next(NULL) { }
151       void setValues(int _code, char* _arg, char* _desc) {
152         code = _code;  arg = _arg;  desc = _desc;
153       }
154     };
155
156   private:
157     enum TC_Status { IDLE, WORKING };
158     
159     // command line processing
160     CounterArg* firstArg_;      // pointer to start of linked list of args
161     CounterArg* lastArg_;       // pointer to end of linked list of args
162     int         argStrSize_;    // size of max arg string (formatted output)
163     CounterArg* commandLine_;   // list of command line args
164     int         commandLineSz_; // size of commande line args array
165     CounterArg* counter1_;      // point to current counter, circle linked list
166     CounterArg* counter2_;      // point to current counter, circle linked list
167     int         counter1Sz_;    // size of cycle
168     int         counter2Sz_;    // size of cycle
169     
170     // result of different command line opts
171     bool        overview_;      // if true, just measure between phases
172     bool        switchRandom_;  // if true, switch counters randomly
173     bool        switchByPhase_; // if true, switch counters only at phases
174
175     // store between start/stop of counter read
176     int         execEP_;        // id currently executing entry point
177     double      startEP_;       // start time of currently executing ep
178     double      startIdle_;     // start time of currently executing idle
179     int         genStart_;      // track value of start_counters
180
181     // store state
182     double      idleTime_;      // total idle time
183     int         phase_;         // current phase
184     bool        traceOn_;       // true if trace is turned on
185     TC_Status   status_;        // to prevent errors
186     bool        dirty_;         // true if endExecute called 
187
188     //! start/stop the overall counting ov eps (don't write to logCount, 
189     //! just print to screen
190     void beginOverview();
191     void endOverview();
192     //! switch counters by whatever switching strategy 
193     void switchCounters();
194     //! add the argument parameters to the linked list of args choices
195     void registerArg(CounterArg* arg);
196     //! see if the arg (str or code) matches any in the linked list of choices
197     //! and sets arg->code to the SGI code
198     //! return true if arg matches, false otherwise
199     bool matchArg(CounterArg* arg);
200     //! print out usage argument
201     void usage();
202     //! print out all arguments in the linked-list of choices
203     void printHelp();
204 };
205
206 #endif  // __trace_counter_h__
207
208 /*@}*/
209
210