Update copyright to LGPL on all files
[dyninst.git] / common / src / stats.C
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 /*
33  * Report statistics about dyninst and data collection.
34  * $Id: stats.C,v 1.2 2008/07/01 19:26:49 legendre Exp $
35  */
36
37 #include "common/h/headers.h"
38 #include "common/h/stats.h"
39 #include "dynutil/h/util.h"
40 #include <sstream>
41 #include <string>
42 #if 0
43 #include "dyninstAPI/src/stats.h"
44
45 CntStatistic trampBytes;
46 CntStatistic pointsUsed;
47 CntStatistic insnGenerated;
48 CntStatistic totalMiniTramps;
49 double timeCostLastChanged=0;
50 // HTable<resourceListRec*> fociUsed;
51 // HTable<metric*> metricsUsed;
52 CntStatistic ptraceOtherOps, ptraceOps, ptraceBytes;
53
54 void printDyninstStats()
55 {
56     sprintf(errorLine, "    %ld total points used\n", pointsUsed.value());
57     logLine(errorLine);
58     sprintf(errorLine, "    %ld mini-tramps used\n", totalMiniTramps.value());
59     logLine(errorLine);
60     sprintf(errorLine, "    %ld tramp bytes\n", trampBytes.value());
61     logLine(errorLine);
62     sprintf(errorLine, "    %ld ptrace other calls\n", ptraceOtherOps.value());
63     logLine(errorLine);
64     sprintf(errorLine, "    %ld ptrace write calls\n", 
65                 ptraceOps.value()-ptraceOtherOps.value());
66     logLine(errorLine);
67     sprintf(errorLine, "    %ld ptrace bytes written\n", ptraceBytes.value());
68     logLine(errorLine);
69     sprintf(errorLine, "    %ld instructions generated\n", 
70                 insnGenerated.value());
71     logLine(errorLine);
72 }
73 #endif
74
75 StatContainer::StatContainer() 
76    //stats_(::Dyninst::hash)
77 {
78 }
79
80 Statistic*
81 StatContainer::operator[](std::string &name) 
82 {
83     if (stats_.find(name) != stats_.end()) {
84         return stats_[name];
85     } else {
86         return NULL;
87     }
88 }
89
90 void
91 StatContainer::add(std::string name, StatType type)
92 {
93     Statistic *s = NULL;
94
95     switch(type) {
96         case CountStat:
97             s = (Statistic *)(new CntStatistic(this));
98             break;            
99         case TimerStat:
100             s = (Statistic *)(new TimeStatistic(this));
101             break;
102         default:
103           fprintf(stderr,"Error adding statistic %s: type %d not recognized\n",
104                 name.c_str(), type);
105           return;
106     }
107
108     stats_[name] = s;
109 }
110
111 void StatContainer::startTimer(std::string name) 
112 {
113     TimeStatistic *timer = dynamic_cast<TimeStatistic *>(stats_[name]);
114     if (!timer) return;
115     timer->start();
116 }
117
118 void StatContainer::stopTimer(std::string name) {
119     TimeStatistic *timer = dynamic_cast<TimeStatistic *>(stats_[name]);
120     if (!timer) return;
121     timer->stop();
122 }
123
124 void StatContainer::incrementCounter(std::string name) {
125     CntStatistic *counter = dynamic_cast<CntStatistic *>(stats_[name]);
126     if (!counter) return;
127     (*counter)++;
128 }
129
130 void StatContainer::decrementCounter(std::string name) {
131     CntStatistic *counter = dynamic_cast<CntStatistic *>(stats_[name]);
132     if (!counter) return;
133     (*counter)--;
134 }
135
136 void StatContainer::addCounter(std::string name, int val) {
137     CntStatistic *counter = dynamic_cast<CntStatistic *>(stats_[name]);
138     if (!counter) return;
139     (*counter) += val;
140 }
141
142                                   
143 CntStatistic 
144 CntStatistic::operator++( int )
145 {
146     CntStatistic ret = *this;
147     ++(*this);
148     return ret;
149 }
150
151
152 CntStatistic& 
153 CntStatistic::operator++()
154 {
155     cnt_++;
156     return *this;
157 }
158                                
159 CntStatistic 
160 CntStatistic::operator--( int )
161 {
162     CntStatistic ret = *this;
163     --(*this);
164     return ret;
165 }
166
167 CntStatistic&
168 CntStatistic::operator--()
169 {
170     cnt_--;
171     return *this;
172 }
173                                  
174 CntStatistic& 
175 CntStatistic::operator=( long int v )
176 {
177     cnt_ = v;
178     return *this;
179 }
180
181 CntStatistic& 
182 CntStatistic::operator=(CntStatistic & v )
183 {
184     if( this != &v ) {
185         cnt_ = v.cnt_;
186     }
187     return *this;
188 }
189                                      
190 CntStatistic& 
191 CntStatistic::operator+=( long int v )
192 {
193     cnt_ += v;
194     return *this;
195 }
196
197 CntStatistic&
198 CntStatistic::operator+=( CntStatistic & v )
199 {
200     cnt_ += v.cnt_;
201     return *this;
202 }
203
204     
205 CntStatistic& 
206 CntStatistic::operator-=( long int v )
207 {
208     cnt_ -= v;
209     return *this;
210 }
211
212 CntStatistic& 
213 CntStatistic::operator-=( CntStatistic & v)
214 {
215     cnt_ -= v.cnt_;
216     return *this;
217 }
218
219 inline long int 
220 CntStatistic::operator*()
221 {
222     return cnt_;
223 }
224
225 long int 
226 CntStatistic::value()
227 {
228     return cnt_;
229 }
230
231
232 TimeStatistic& 
233 TimeStatistic::operator=(TimeStatistic & t)
234 {
235     if( this != &t ) {
236         t_ = t.t_;
237     }
238     return *this;
239 }
240
241 TimeStatistic& 
242 TimeStatistic::operator+=(TimeStatistic & t)
243 {
244     t_ += t.t_;
245     return *this;
246 }
247
248 TimeStatistic& 
249 TimeStatistic::operator+(TimeStatistic & t) 
250 {
251     TimeStatistic * ret = new TimeStatistic;
252     *ret = *this;
253     *ret += t;
254     return *ret;
255 }
256
257 void 
258 TimeStatistic::clear()
259 {
260     t_.clear();
261 }
262
263 void 
264 TimeStatistic::start()
265 {
266     t_.start();
267 }
268
269 void
270 TimeStatistic::stop()
271 {
272     t_.stop();
273 }
274
275 double 
276 TimeStatistic::usecs() 
277 {
278     return t_.usecs();
279 }
280
281 double 
282 TimeStatistic::ssecs() 
283 {
284     return t_.ssecs();
285 }
286
287 double 
288 TimeStatistic::wsecs() 
289 {
290     return t_.wsecs();
291 }
292
293 bool 
294 TimeStatistic::is_running() 
295 {
296     return t_.is_running();
297 }
298