Major restructuring with multiple counter commandline args
[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     //! one entry is called for 'time' seconds, value is counter reading 
31     void setEp(int epidx, int stat, long long value, double time);
32     //! write three lines for each stat:
33     //!   1. number of calls for each entry
34     //!   2. average count for each entry
35     //!   3. total time in us spent for each entry
36     void write(FILE* fp);
37     void clear();
38     int numStats() { return numStats_; }
39     void init(char** name, char** desc, int argc);
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     // bool        error_;             // will be set to true if error writing info
56 };
57
58 // counter log pool
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() { dirty_ = false; stats_.clear(); }
68     void setTrace(bool on) { traceOn_ = on; }
69     void setDirty(bool d) { dirty_ = d; }
70     void init(char** name, char** desc, int argc) { 
71       stats_.init(name, desc, argc);
72     }
73
74   private:
75     StatTable stats_;
76     bool      traceOn_;
77     int       lastPhase_;
78     bool      dirty_;
79 };
80
81 //! For each processor, TraceCounter calculates mean, stdev, etc of 
82 //! CPU performance counters for each entry point.
83 class TraceCounter : public Trace {
84   public:
85     TraceCounter();
86     ~TraceCounter();
87     void traceBegin();
88     void traceEnd();
89     int traceRegisterUserEvent(const char* userEvent) { 
90       // CmiPrintf("%d/%d traceRegisterUserEvent(%s)\n", 
91       // CkMyPe(), CkNumPes(), userEvent);
92       return 0;
93     }
94     void userEvent(int e) { 
95       // CmiPrintf("%d/%d userEvent %d\n", CkMyPe(), CkNumPes(), e); 
96     }
97     void creation(envelope *e, int num=1) { }
98     void messageRecv(char *env, int pe) { }
99     void beginExecute(envelope *e);
100     void beginExecute(int event, int msgType, int ep, int srcPe, int mlen=0);
101     void endExecute(void);
102     void beginIdle(void) { }
103     void endIdle(void) { }
104     void beginPack(void);
105     void endPack(void);
106     void beginUnpack(void);
107     void endUnpack(void);
108     void enqueue(envelope *e) { }
109     void dequeue(envelope *e) { }
110     void beginComputation(void);
111     void endComputation(void) { }
112
113     void traceInit(char **argv);
114     void traceClearEps();
115     void traceWriteSts();
116     void traceClose();
117
118     //! CounterArg is a linked list of strings that allows
119     //! processing of command line args
120     struct CounterArg {
121       int         code;
122       char*       arg;
123       char*       desc;
124       CounterArg* next;
125
126       CounterArg(): code(-1), arg(NULL), desc(NULL), next(NULL) { }
127       CounterArg(int c, char* a, char* d):
128         code(c), arg(a), desc(d), next(NULL) { }
129       void setValues(int _code, char* _arg, char* _desc) {
130         code = _code;  arg = _arg;  desc = _desc;
131       }
132     };
133
134   private:
135     int         execEP_;        // id currently executing entry point
136     double      startEP_;       // start time of currently executing ep
137     double      startPack_;     // start time of pack operation
138     double      startUnpack_;   // start time of unpack operation
139     CounterArg* firstArg_;      // pointer to start of linked list of args
140     CounterArg* lastArg_;       // pointer to end of linked list of args
141     int         argStrSize_;    // size of maximum arg string (formatted output)
142     int         phase_;         // current phase
143     bool        traceOn_;       // true if trace is turned on
144
145     CounterArg* commandLine_;   // list of command line args
146     int         commandLineSz_; // size of commande line args array
147     CounterArg* counter1_;      // point to current counter
148     CounterArg* counter2_;      // point to current counter
149
150     enum Status { IDLE, WORKING };
151     Status      status_;        // to prevent errors
152     int         genStart_;      // track value of start_counters
153     bool        dirty_;         // true if endExecute called 
154
155     //! add the argument parameters to the linked list of args choices
156     void registerArg(CounterArg* arg);
157     //! see if the arg (str or code) matches any in the linked list of choices
158     //! and sets arg->code to the SGI code
159     //! return true if arg matches, false otherwise
160     bool matchArg(CounterArg* arg);
161     //! print out all arguments in the linked-list of choices
162     void printHelp();
163 };
164
165 #endif  // __trace_counter_h__
166
167 /*@}*/
168
169