Fixed standard deb\7fv
[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-mach.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 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     void endExecute();
134     //! begin/end idle time for this pe
135     void beginIdle();
136     void endIdle();
137     //! begin/end the process of packing a message (to send)
138     void beginPack();
139     void endPack();
140     //! begin/end the process of unpacking a message (can occur before calling
141     //! a entry point or during an entry point when 
142     void beginUnpack();
143     void endUnpack();
144     //! ???
145     void enqueue(envelope *e) { }
146     void dequeue(envelope *e) { }
147     //! begin/end of execution
148     void beginComputation();
149     void endComputation();
150     //! clear all data collected for entry points
151     void traceClearEps();
152     //! write the summary sts file for this trace
153     void traceWriteSts();
154     //! do any clean-up necessary for tracing
155     void traceClose();
156
157     //! CounterArg is a linked list of strings that allows
158     //! processing of command line args
159     struct CounterArg {
160       int         code;
161       char*       arg;
162       char*       desc;
163       CounterArg* next;
164       int         index;  // index into statTable
165
166       CounterArg(): code(-1), arg(NULL), desc(NULL), next(NULL), index(-1) { }
167       CounterArg(int c, char* a, char* d):
168         code(c), arg(a), desc(d), next(NULL), index(-1) { }
169       void setValues(int _code, char* _arg, char* _desc) {
170         code = _code;  arg = _arg;  desc = _desc;
171       }
172     };
173
174   private:
175     enum TC_Status { IDLE, WORKING };
176     int cancel_beginIdle, cancel_endIdle;
177     
178     // command line processing
179     CounterArg* firstArg_;      // pointer to start of linked list of args
180     CounterArg* lastArg_;       // pointer to end of linked list of args
181     int         argStrSize_;    // size of max arg string (formatted output)
182     CounterArg* commandLine_;   // list of command line args
183     int         commandLineSz_; // size of commande line args array
184     CounterArg* counter1_;      // point to current counter, circle linked list
185     CounterArg* counter2_;      // point to current counter, circle linked list
186     int         counter1Sz_;    // size of cycle
187     int         counter2Sz_;    // size of cycle
188     
189     // result of different command line opts
190     bool        overview_;      // if true, just measure between phases
191     bool        switchRandom_;  // if true, switch counters randomly
192     bool        switchByPhase_; // if true, switch counters only at phases
193     bool        noLog_;         // if true, don't write a log file
194     bool        writeByPhase_;  // if true, write out a log file every phase
195
196     // store between start/stop of counter read
197     int         execEP_;        // id currently executing entry point
198     double      startEP_;       // start time of currently executing ep
199     double      startIdle_;     // start time of currently executing idle
200     int         genStart_;      // track value of start_counters
201
202     // store state
203     double      idleTime_;        // total idle time
204     int         phase_;           // current phase
205     int         reductionPhase_;  // for reduction output
206     bool        traceOn_;         // true if trace is turned on
207     TC_Status   status_;          // to prevent errors
208     bool        dirty_;           // true if endExecute called 
209
210     //! start/stop the overall counting ov eps (don't write to logCount, 
211     //! just print to screen
212     void beginOverview();
213     void endOverview();
214     //! switch counters by whatever switching strategy 
215     void switchCounters();
216     //! add the argument parameters to the linked list of args choices
217     void registerArg(CounterArg* arg);
218     //! see if the arg (str or code) matches any in the linked list of choices
219     //! and sets arg->code to the SGI code
220     //! return true if arg matches, false otherwise
221     bool matchArg(CounterArg* arg);
222     //! print out usage argument
223     void usage();
224     //! print out all arguments in the linked-list of choices
225     void printHelp();
226 };
227
228 #endif  // __trace_counter_h__
229
230 /*@}*/
231
232