Module to measure performance counters on various machines.
[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 #ifdef CMK_ORIGIN2000
14
15 #ifndef __trace_counter_h__
16 #define __trace_counter_h__
17
18 #include <stdio.h>
19 #include <errno.h>
20 #include "trace.h"
21 #include "ck.h"
22 #include "trace-common.h"
23
24 #define MAX_ENTRIES 500
25
26 // track statistics for all entry points
27 class StatTable {
28   public:
29     StatTable();
30     ~StatTable();
31     // one entry is called for 'time' seconds, value is counter reading
32     void setEp(int epidx, int stat, UInt value, double time) {
33       CkAssert(epidx<MAX_ENTRIES);
34       CkAssert(stat<numStats_);
35
36       int count = stats_[stat].count[epidx];
37       stats_[stat].count[epidx]++;
38       double avg = stats_[stat].average[epidx];
39       stats_[stat].average[epidx] = (avg * count + value) / (count + 1);
40       stats_[stat].totTime[epidx] += time;
41     }
42     /**
43        write three lines for each stat:
44        1. number of calls for each entry
45        2. average count for each entry
46        3. total time in us spent for each entry
47     */
48     void write(FILE* fp) {
49       int i, j;
50       for (i=0; i<numStats_; i++) {
51         // write number of calls for each entry
52         fprintf(fp, "[%s] ", stats_[i].name);
53         for (j=0; j<_numEntries; j++) { 
54           fprintf(fp, "%d ", stats_[i].count[j]); 
55         }
56         fprintf(fp, "\n");
57         // write average count for each 
58         fprintf(fp, "[%s] ", stats_[i].name);
59         for (j=0; j<_numEntries; j++) { 
60           fprintf(fp, "%d ", stats_[i].average[j]); 
61         }
62         fprintf(fp, "\n");
63         // write total time in us spent for each entry
64         fprintf(fp, "[%s] ", stats_[i].name);
65         for (j=0; j<_numEntries; j++) {
66           fprintf(fp, "%ld ", (long)(stats_[i].totTime[j]*1.0e6));
67         }
68         fprintf(fp, "\n");
69       }
70     }
71
72   private:
73     // struct to maintain statistics
74     struct Statistics {
75       char*  name;                  // name of stat being tracked
76       UInt   count[MAX_ENTRIES];    // total number times called
77       double average[MAX_ENTRIES];  // track average of value
78       double totTime[MAX_ENTRIES];  // total time associated with this counter
79     };
80
81     Statistics* stats_;             // track stats for each entry point
82     int         numStats_;          // size of statistics being tracked
83 };
84
85 // counter log pool
86 class CountLogPool {
87   public:
88     CountLogPool(char* pgm);
89     ~CountLogPool();
90     void write(void) ;
91     void writeSts(void);
92     void setEp(int epidx, double time);
93
94   private:
95     FILE*     fp_;
96     StatTable stats_;
97 };
98
99 /**
100   For each processor, TraceCounter calculates mean, stdev, etc of 
101   CPU performance counters for each entry point.
102 */
103 class TraceCounter : public Trace {
104   public:
105     TraceCounter() { }
106     void userEvent(int e) { }
107     void creation(envelope *e, int num=1) { }
108     void beginExecute(envelope *e);
109     void beginExecute(int event, int msgType, int ep, int srcPe, int mlen=0);
110     void endExecute(void);
111     void beginIdle(void) { }
112     void endIdle(void) { }
113     void beginPack(void);
114     void endPack(void);
115     void beginUnpack(void);
116     void endUnpack(void);
117     void beginCharmInit(void) { }
118     void endCharmInit(void) { }
119     void enqueue(envelope *e) { }
120     void dequeue(envelope *e) { }
121     void beginComputation(void);
122     void endComputation(void) { }
123
124     void traceInit(char **argv);
125     int traceRegisterUserEvent(const char*) { return 0; }
126     void traceClearEps();
127     void traceWriteSts();
128     void traceClose();
129     void traceBegin() { }
130     void traceEnd() { }
131
132   private:
133     int    execEP_;       // id currently executing entry point
134     double startEP_;      // start time of currently executing ep
135     double startPack_;    // start time of pack operation
136     double startUnpack_;  // start time of unpack operation
137
138     int    msgNum_;
139 };
140
141 #endif  // __trace_counter_h__
142
143 #endif // CMK_ORIGIN2000
144
145 /*@}*/