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