Runnable mode (no debug statements)
[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
22 #define MAX_ENTRIES 500
23
24 //! track statistics for all entry points
25 class StatTable {
26   public:
27     StatTable(char** args, int argc);
28     ~StatTable();
29     //! one entry is called for 'time' seconds, value is counter reading 
30     void setEp(int epidx, int stat, long long value, double time);
31     //! write three lines for each stat:
32     //!   1. number of calls for each entry
33     //!   2. average count for each entry
34     //!   3. total time in us spent for each entry
35     void write(FILE* fp);
36     void clear();
37
38   private:
39     //! struct to maintain statistics
40     struct Statistics {
41       char*  name;                  // name of stat being tracked
42       UInt   count[MAX_ENTRIES];    // total number times called
43       double average[MAX_ENTRIES];  // track average of value
44       double totTime[MAX_ENTRIES];  // total time associated with this counter
45
46       Statistics(): name(NULL) { }
47     };
48
49     Statistics* stats_;             // track stats for each entry point
50     int         numStats_;          // size of statistics being tracked
51     // bool        error_;             // will be set to true if error writing info
52 };
53
54 // counter log pool
55 class CountLogPool {
56   public:
57     CountLogPool(char* pgm, char** args, int argc);
58     ~CountLogPool();
59     void write(void) ;
60     void writeSts(void);
61     void setEp(int epidx, long long count1, long long count2, double time);
62     void clearEps() { stats_.clear(); }
63
64   private:
65     FILE*     fp_;
66     StatTable stats_;
67 };
68
69 //! For each processor, TraceCounter calculates mean, stdev, etc of 
70 //! CPU performance counters for each entry point.
71 class TraceCounter : public Trace {
72   public:
73     TraceCounter();
74     void userEvent(int e) { }
75     void creation(envelope *e, int num=1) { }
76     void beginExecute(envelope *e);
77     void beginExecute(int event, int msgType, int ep, int srcPe, int mlen=0);
78     void endExecute(void);
79     void beginIdle(void) { }
80     void endIdle(void) { }
81     void beginPack(void);
82     void endPack(void);
83     void beginUnpack(void);
84     void endUnpack(void);
85     void beginCharmInit(void) { }
86     void endCharmInit(void) { }
87     void enqueue(envelope *e) { }
88     void dequeue(envelope *e) { }
89     void beginComputation(void);
90     void endComputation(void) { }
91
92     void traceInit(char **argv);
93     int traceRegisterUserEvent(const char*) { return 0; }
94     void traceClearEps();
95     void traceWriteSts();
96     void traceClose();
97     void traceBegin() { }
98     void traceEnd() { }
99  
100     //! CounterArg is a linked list of strings that allows 
101     //! processing of command line args 
102     struct CounterArg {
103       int         code;
104       char*       arg;
105       char*       desc;
106       CounterArg* next;
107
108       CounterArg(): code(-1), arg(NULL), desc(NULL), next(NULL) { }
109       CounterArg(int c, char* a, char* d): 
110         code(c), arg(a), desc(d), next(NULL) { }
111       void setValues(int _code, char* _arg, char* _desc) {
112         code = _code;  arg = _arg;  desc = _desc;
113       }
114     };
115
116   private:
117     int         execEP_;       // id currently executing entry point
118     double      startEP_;      // start time of currently executing ep
119     double      startPack_;    // start time of pack operation
120     double      startUnpack_;  // start time of unpack operation
121     CounterArg* firstArg_;     // pointer to start of linked list of args
122     CounterArg* lastArg_;      // pointer to end of linked list of args
123     int         argStrSize_;   // size of maximum arg string (formatted output)
124
125     int         genStart_;     // track value of start_counters
126     int         counter1_;     // 1st counter to track
127     int         counter2_;     // 2nd counter to track
128
129     //! add the argument parameters to the linked list of args choices
130     void registerArg(CounterArg* arg);
131     //! see if the arg (str or code) matches any in the linked list of choices
132     //! and sets arg->code to the SGI code
133     //! return true if arg matches, false otherwise
134     bool matchArg(CounterArg* arg);
135     //! print out all arguments in the linked-list of choices
136     void printHelp();
137 };
138
139 #endif  // __trace_counter_h__
140
141 /*@}*/