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