updated copyright for release 1.1
[dyninst.git] / pdutil / src / Timer.C
1 /*
2  * Copyright (c) 1996 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  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 // Timer.C
43
44 #include "util/h/Timer.h"
45
46 timer::timer()
47 : usecs_(0), ssecs_(0), wsecs_(0), cu_(0), cs_(0), cw_(0),
48   state_(STOPPED),
49   CYCLES_PER_SEC_(sysconf(_SC_CLK_TCK)), MICROSECS_PER_SEC_(1.0e6),
50   NANOSECS_PER_SEC_(1.0e9)
51 {
52 }
53
54 timer::timer(const timer& t)
55     : usecs_(t.usecs_), ssecs_(t.ssecs_), wsecs_(t.wsecs_),
56     cu_(t.cu_), cs_(t.cs_), cw_(t.cw_), state_(t.state_),
57     CYCLES_PER_SEC_(t.CYCLES_PER_SEC_), MICROSECS_PER_SEC_(t.MICROSECS_PER_SEC_),
58     NANOSECS_PER_SEC_(t.NANOSECS_PER_SEC_)
59 {
60 }
61
62 timer::~timer() {}
63
64 timer&
65 timer::operator=(const timer& t) {
66     if (this != &t) {
67         usecs_ = t.usecs_; ssecs_ = t.ssecs_; wsecs_ = t.wsecs_;
68         cu_    = t.cu_;    cs_    = t.cs_;    cw_    = t.cw_;
69         state_ = t.state_;
70     }
71     return *this;
72 }
73
74 timer&
75 timer::operator+=(const timer& t) {
76     timer st = t; st.stop();
77     usecs_ += st.usecs_;
78     ssecs_ += st.ssecs_;
79     wsecs_ += st.wsecs_;
80     return *this;
81 }
82
83 timer
84 timer::operator+(const timer& t) const {
85     timer ret = *this;
86     return ret += t;
87 }
88
89 void
90 timer::clear() {
91     usecs_ = ssecs_ = wsecs_ = 0;
92     cu_    = cs_    = cw_    = 0;
93     state_ = STOPPED;
94 }
95
96 void
97 timer::start() {
98     get_current(cu_, cs_, cw_);
99     state_ = RUNNING;
100 }
101
102 void
103 timer::stop() {
104     if (state_ == RUNNING) {
105         double cu, cs, cw;
106         get_current(cu, cs, cw);
107
108         usecs_ += (cu - cu_);
109         ssecs_ += (cs - cs_);
110         wsecs_ += (cw - cw_);
111         state_ = STOPPED;
112     }
113 }
114
115 double
116 timer::usecs() const {
117     return usecs_;
118 }
119
120 double
121 timer::ssecs() const {
122     return ssecs_;
123 }
124
125 double
126 timer::wsecs() const {
127     return wsecs_;
128 }
129
130 bool
131 timer::is_running() const {
132     return (state_ == RUNNING);
133 }
134
135 #if defined(notdef)
136 void
137 timer::print(ostream& os) {
138     timer_state ostate = state_;
139     if (ostate == RUNNING) {
140         stop();
141     }
142
143     os << "{"
144        << " usecs=" << usecs_
145        << " ssecs=" << ssecs_
146        << " wsecs=" << wsecs_
147        << " }";
148
149     if (ostate == RUNNING) {
150         start();
151     }
152 }
153 #endif
154
155 \f
156
157
158 /************************************************************************
159  * architecture/operating system specific timer functions.
160 ************************************************************************/
161
162
163 \f
164
165
166 #undef HAVE_GET_CURRENT_DEFINITION
167
168
169 \f
170
171
172 #if defined(sparc_sun_solaris2_4)
173 #if !defined(HAVE_GET_CURRENT_DEFINITION)
174 #define HAVE_GET_CURRENT_DEFINITION
175
176 #include <sys/time.h>
177 #include <sys/times.h>
178
179 void
180 timer::get_current(double& u, double& s, double& w) {
181     timer t;
182     u = gethrvtime() / t.NANOSECS_PER_SEC();
183
184     struct tms tb;
185     if (times(&tb) == -1) {
186       P_perror("times");
187       P_abort();
188     }
189     s = tb.tms_stime / t.CYCLES_PER_SEC();
190
191     w = gethrtime() / t.NANOSECS_PER_SEC();
192 }
193
194 #endif /* !defined(HAVE_GET_CURRENT_DEFINITION) */
195 #endif /* defined(sparc_sun_solaris2_4) */
196
197
198 \f
199
200
201 #if !defined(HAVE_GET_CURRENT_DEFINITION)
202 #define HAVE_GET_CURRENT_DEFINITION
203
204 #include <sys/types.h>
205 #include <sys/time.h>
206 #include <sys/times.h>
207
208 #ifndef rs6000_ibm_aix4_1
209    // aix 4.1 goesn't need or agree with the following declaration:
210 extern "C" gettimeofday(struct timeval *tp, struct timezone *tzp);
211 #endif
212
213 void
214 timer::get_current(double& u, double& s, double& w) {
215     struct tms     tb;
216     struct timeval tv;
217     if (times(&tb) == -1) {
218         perror("times");
219         abort();
220     }
221     if (gettimeofday(&tv, 0) == -1) {
222       P_perror("gettimeofday");
223       P_abort();
224     }
225
226     timer t;
227     u = tb.tms_utime / t.CYCLES_PER_SEC();
228     s = tb.tms_stime / t.CYCLES_PER_SEC();
229     w = (tv.tv_sec + tv.tv_usec/t.MICROSECS_PER_SEC());
230 }
231 #endif /* !defined(HAVE_GET_CURRENT_DEFINITION) */