Update copyright to LGPL on all files
[dyninst.git] / common / h / stats.h
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 // $Id: stats.h,v 1.3 2008/09/03 06:08:43 jaw Exp $
33
34 #ifndef STATS_H
35 #define STATS_H
36
37 #include <string>
38 //#include "Dictionary.h"
39 #include "Timer.h"
40 #include "dynutil/h/util.h"
41
42 #if 0
43 extern void printDyninstStats();
44
45 class CntStatistic;
46
47 extern CntStatistic insnGenerated;
48 extern CntStatistic totalMiniTramps;
49 extern CntStatistic trampBytes;
50 extern CntStatistic ptraceOps;
51 extern CntStatistic ptraceOtherOps;
52 extern CntStatistic ptraceBytes;
53 extern CntStatistic pointsUsed;
54
55 #endif
56 class StatContainer;  // All your class declarations are forward. 
57
58 class COMMON_EXPORT Statistic  {
59  public:
60     virtual bool is_count()  { return false; }
61     virtual bool is_timer()  { return false; }
62     /* ... etc. */
63
64     // dynamic_casts are a pain in the neck
65     virtual long int value() { return 0; }
66     virtual double usecs()  { return 0; }
67     virtual double ssecs() { return 0; }
68     virtual double wsecs() { return 0; }
69
70
71  protected:
72     Statistic(StatContainer *c) : 
73         container_(c)
74     { }
75     virtual ~Statistic() {}; // Avoid warnings
76
77     StatContainer *container_;
78
79     // 
80     bool valid;
81 };
82
83 class COMMON_EXPORT CntStatistic : public Statistic {
84  friend class StatContainer;
85
86  protected:
87     // Constructor with which a StatContainer provides
88     // this statistic with an up-pointer to itself
89     CntStatistic(StatContainer *c) :
90         Statistic(c),
91         cnt_(0)
92     { }
93
94  public:
95     CntStatistic() : 
96         Statistic(NULL),
97         cnt_(0)
98     { }
99
100     // respond appropriately to type-of-stat requests
101     bool is_count() { return true; }
102
103     /** overloaded operators **/
104     CntStatistic operator++( int );
105     CntStatistic& operator++();
106
107     CntStatistic operator--( int );
108     CntStatistic& operator--();  
109
110     CntStatistic& operator=( long int );
111     CntStatistic& operator=( CntStatistic &);
112
113     CntStatistic& operator+=( long int );
114     CntStatistic& operator+=( CntStatistic &);
115     
116     CntStatistic& operator-=( long int );
117     CntStatistic& operator-=(  CntStatistic &);
118
119     // Return the value of this statistic
120     long int operator*();
121     long int value();
122
123  private:
124     long int cnt_;
125 };
126
127 /* Wraps the timer class */
128 class COMMON_EXPORT TimeStatistic : public Statistic {
129  friend class StatContainer;
130
131  protected:
132     TimeStatistic(StatContainer *c) :
133         Statistic(c)
134     {}
135
136  public:
137     TimeStatistic() :
138         Statistic(NULL)
139     {}
140
141     bool is_timer()  { return true; }
142
143     TimeStatistic& operator=( TimeStatistic &);
144     TimeStatistic& operator+=( TimeStatistic &);
145     TimeStatistic& operator+( TimeStatistic &) ;
146
147     void clear();
148     void start();
149     void stop();
150
151     double usecs() ;
152     double ssecs() ;
153     double wsecs() ;
154
155     bool is_running() ;
156
157  private:
158
159     timer t_;
160 };
161
162 typedef enum {
163     CountStat,
164     TimerStat
165 } StatType;
166
167
168 /* A container for a group of (one expects) mutually related statistics. */
169 class StatContainer {
170  public:
171     COMMON_EXPORT StatContainer(); 
172
173     /* Access or create a statistic indexed by the provided name.
174      *
175      * This operator may return null if the named statistic does
176      * not exist.
177      */
178     COMMON_EXPORT Statistic * operator[](std::string &);
179     COMMON_EXPORT Statistic * operator[](const char *s) {
180        std::string namestr(s);
181        return (*this)[namestr];
182     }
183
184     // Create a new statistic of the given type indexed by name.
185     // **This will replace any existing stat with the same index
186     //   within this container**
187     COMMON_EXPORT void add(std::string name, StatType type);
188
189     // Access all of the existing statistics
190     COMMON_EXPORT dyn_hash_map< std::string, Statistic * > &
191        allStats() { return stats_; }
192
193     // And some pass-through methods, encapsulated for
194     // ease of use
195     COMMON_EXPORT void startTimer(std::string);
196     COMMON_EXPORT void stopTimer(std::string);
197     COMMON_EXPORT void incrementCounter(std::string);
198     COMMON_EXPORT void decrementCounter(std::string);
199     COMMON_EXPORT void addCounter(std::string, int);
200
201  private:
202     dyn_hash_map< std::string, Statistic * > stats_;
203
204 };
205 #endif