Directory: | ./ |
---|---|
File: | src/utils/stop-watch.cpp |
Date: | 2024-08-13 12:13:25 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 37 | 132 | 28.0% |
Branches: | 19 | 208 | 9.1% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | Copyright (c) 2010-2013 Tommaso Urli | ||
3 | |||
4 | Tommaso Urli tommaso.urli@uniud.it University of Udine | ||
5 | |||
6 | Permission is hereby granted, free of charge, to any person obtaining | ||
7 | a copy of this software and associated documentation files (the | ||
8 | "Software"), to deal in the Software without restriction, including | ||
9 | without limitation the rights to use, copy, modify, merge, publish, | ||
10 | distribute, sublicense, and/or sell copies of the Software, and to | ||
11 | permit persons to whom the Software is furnished to do so, subject to | ||
12 | the following conditions: | ||
13 | |||
14 | The above copyright notice and this permission notice shall be | ||
15 | included in all copies or substantial portions of the Software. | ||
16 | |||
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | ||
18 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
19 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | ||
20 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE | ||
21 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | ||
22 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | ||
23 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
24 | |||
25 | */ | ||
26 | |||
27 | #ifndef WIN32 | ||
28 | #include <sys/time.h> | ||
29 | #else | ||
30 | #include <Windows.h> | ||
31 | |||
32 | #include <iomanip> | ||
33 | #endif | ||
34 | |||
35 | #include <iomanip> // std::setprecision | ||
36 | |||
37 | #include "sot/core/stop-watch.hh" | ||
38 | |||
39 | using std::map; | ||
40 | using std::ostringstream; | ||
41 | using std::string; | ||
42 | |||
43 | //#define START_PROFILER(name) getProfiler().start(name) | ||
44 | //#define STOP_PROFILER(name) getProfiler().stop(name) | ||
45 | |||
46 | 8 | Stopwatch &getProfiler() { | |
47 |
4/8✓ Branch 0 taken 2 times.
✓ Branch 1 taken 6 times.
✓ Branch 3 taken 2 times.
✗ Branch 4 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
|
8 | static Stopwatch s(REAL_TIME); // alternatives are CPU_TIME and REAL_TIME |
48 | 8 | return s; | |
49 | } | ||
50 | |||
51 | 2 | Stopwatch::Stopwatch(StopwatchMode _mode) : active(true), mode(_mode) { | |
52 | 2 | records_of = new map<string, PerformanceData>(); | |
53 | 2 | } | |
54 | |||
55 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | Stopwatch::~Stopwatch() { delete records_of; } |
56 | |||
57 | ✗ | void Stopwatch::set_mode(StopwatchMode new_mode) { mode = new_mode; } | |
58 | |||
59 | 4 | bool Stopwatch::performance_exists(string perf_name) { | |
60 |
1/2✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
|
4 | return (records_of->find(perf_name) != records_of->end()); |
61 | } | ||
62 | |||
63 | 8 | long double Stopwatch::take_time() { | |
64 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
|
8 | if (mode == CPU_TIME) { |
65 | // Use ctime | ||
66 | ✗ | return clock(); | |
67 | |||
68 |
1/2✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
|
8 | } else if (mode == REAL_TIME) { |
69 | // Query operating system | ||
70 | |||
71 | #ifdef WIN32 | ||
72 | /* In case of usage under Windows */ | ||
73 | FILETIME ft; | ||
74 | LARGE_INTEGER intervals; | ||
75 | |||
76 | // Get the amount of 100 nanoseconds intervals elapsed since January 1, 1601 | ||
77 | // (UTC) | ||
78 | GetSystemTimeAsFileTime(&ft); | ||
79 | intervals.LowPart = ft.dwLowDateTime; | ||
80 | intervals.HighPart = ft.dwHighDateTime; | ||
81 | |||
82 | long double measure = intervals.QuadPart; | ||
83 | measure -= 116444736000000000.0; // Convert to UNIX epoch time | ||
84 | measure /= 10000000.0; // Convert to seconds | ||
85 | |||
86 | return measure; | ||
87 | #else | ||
88 | /* Linux, MacOS, ... */ | ||
89 | struct timeval tv; | ||
90 | 8 | gettimeofday(&tv, NULL); | |
91 | |||
92 | 8 | long double measure = tv.tv_usec; | |
93 | 8 | measure /= 1000000.0; // Convert to seconds | |
94 | 8 | measure += tv.tv_sec; // Add seconds part | |
95 | |||
96 | 8 | return measure; | |
97 | #endif | ||
98 | |||
99 | } else { | ||
100 | // If mode == NONE, clock has not been initialized, then throw exception | ||
101 | ✗ | throw StopwatchException("Clock not initialized to a time taking mode!"); | |
102 | } | ||
103 | } | ||
104 | |||
105 | 4 | void Stopwatch::start(string perf_name) { | |
106 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (!active) return; |
107 | |||
108 | // Just works if not already present | ||
109 |
2/4✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 4 times.
✗ Branch 6 not taken.
|
4 | records_of->insert(make_pair(perf_name, PerformanceData())); |
110 | |||
111 | 4 | PerformanceData &perf_info = records_of->find(perf_name)->second; | |
112 | |||
113 | // Take ctime | ||
114 | 4 | perf_info.clock_start = take_time(); | |
115 | |||
116 | // If this is a new start (i.e. not a restart) | ||
117 | // if (!perf_info.paused) | ||
118 | // perf_info.last_time = 0; | ||
119 | |||
120 | 4 | perf_info.paused = false; | |
121 | } | ||
122 | |||
123 | 4 | void Stopwatch::stop(string perf_name) { | |
124 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (!active) return; |
125 | |||
126 | 4 | long double clock_end = take_time(); | |
127 | |||
128 | // Try to recover performance data | ||
129 |
2/4✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 4 times.
|
4 | if (!performance_exists(perf_name)) |
130 | ✗ | throw StopwatchException("Performance not initialized."); | |
131 | |||
132 | 4 | PerformanceData &perf_info = records_of->find(perf_name)->second; | |
133 | |||
134 | // check whether the performance has been reset | ||
135 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (perf_info.clock_start == 0) return; |
136 | |||
137 | 4 | perf_info.stops++; | |
138 | 4 | long double lapse = clock_end - perf_info.clock_start; | |
139 | |||
140 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (mode == CPU_TIME) lapse /= (double)CLOCKS_PER_SEC; |
141 | |||
142 | // Update last time | ||
143 | 4 | perf_info.last_time = lapse; | |
144 | |||
145 | // Update min/max time | ||
146 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | if (lapse >= perf_info.max_time) perf_info.max_time = lapse; |
147 |
2/4✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
|
4 | if (lapse <= perf_info.min_time || perf_info.min_time == 0) |
148 | 4 | perf_info.min_time = lapse; | |
149 | |||
150 | // Update total time | ||
151 | 4 | perf_info.total_time += lapse; | |
152 | } | ||
153 | |||
154 | ✗ | void Stopwatch::pause(string perf_name) { | |
155 | ✗ | if (!active) return; | |
156 | |||
157 | ✗ | long double clock_end = clock(); | |
158 | |||
159 | // Try to recover performance data | ||
160 | ✗ | if (!performance_exists(perf_name)) | |
161 | ✗ | throw StopwatchException("Performance not initialized."); | |
162 | |||
163 | ✗ | PerformanceData &perf_info = records_of->find(perf_name)->second; | |
164 | |||
165 | // check whether the performance has been reset | ||
166 | ✗ | if (perf_info.clock_start == 0) return; | |
167 | |||
168 | ✗ | long double lapse = clock_end - perf_info.clock_start; | |
169 | |||
170 | // Update total time | ||
171 | ✗ | perf_info.last_time += lapse; | |
172 | ✗ | perf_info.total_time += lapse; | |
173 | } | ||
174 | |||
175 | ✗ | void Stopwatch::reset_all() { | |
176 | ✗ | if (!active) return; | |
177 | |||
178 | ✗ | map<string, PerformanceData>::iterator it; | |
179 | |||
180 | ✗ | for (it = records_of->begin(); it != records_of->end(); ++it) { | |
181 | ✗ | reset(it->first); | |
182 | } | ||
183 | } | ||
184 | |||
185 | ✗ | void Stopwatch::report_all(int precision, std::ostream &output) { | |
186 | ✗ | if (!active) return; | |
187 | |||
188 | output << "\n*** PROFILING RESULTS [ms] (min - avg - max - lastTime - " | ||
189 | ✗ | "nSamples - totalTime) ***\n"; | |
190 | ✗ | map<string, PerformanceData>::iterator it; | |
191 | ✗ | for (it = records_of->begin(); it != records_of->end(); ++it) { | |
192 | ✗ | report(it->first, precision, output); | |
193 | } | ||
194 | } | ||
195 | |||
196 | ✗ | void Stopwatch::reset(string perf_name) { | |
197 | ✗ | if (!active) return; | |
198 | |||
199 | // Try to recover performance data | ||
200 | ✗ | if (!performance_exists(perf_name)) | |
201 | ✗ | throw StopwatchException("Performance not initialized."); | |
202 | |||
203 | ✗ | PerformanceData &perf_info = records_of->find(perf_name)->second; | |
204 | |||
205 | ✗ | perf_info.clock_start = 0; | |
206 | ✗ | perf_info.total_time = 0; | |
207 | ✗ | perf_info.min_time = 0; | |
208 | ✗ | perf_info.max_time = 0; | |
209 | ✗ | perf_info.last_time = 0; | |
210 | ✗ | perf_info.paused = false; | |
211 | ✗ | perf_info.stops = 0; | |
212 | } | ||
213 | |||
214 | ✗ | void Stopwatch::turn_on() { | |
215 | ✗ | std::cout << "Stopwatch active." << std::endl; | |
216 | ✗ | active = true; | |
217 | } | ||
218 | |||
219 | ✗ | void Stopwatch::turn_off() { | |
220 | ✗ | std::cout << "Stopwatch inactive." << std::endl; | |
221 | ✗ | active = false; | |
222 | } | ||
223 | |||
224 | ✗ | void Stopwatch::report(string perf_name, int precision, std::ostream &output) { | |
225 | ✗ | if (!active) return; | |
226 | |||
227 | // Try to recover performance data | ||
228 | ✗ | if (!performance_exists(perf_name)) | |
229 | ✗ | throw StopwatchException("Performance not initialized."); | |
230 | |||
231 | ✗ | PerformanceData &perf_info = records_of->find(perf_name)->second; | |
232 | |||
233 | ✗ | string pad = ""; | |
234 | ✗ | for (size_t i = perf_name.length(); i < STOP_WATCH_MAX_NAME_LENGTH; i++) | |
235 | ✗ | pad.append(" "); | |
236 | |||
237 | ✗ | output << perf_name << pad; | |
238 | ✗ | output << std::fixed << std::setprecision(precision) | |
239 | ✗ | << (perf_info.min_time * 1e3) << "\t"; | |
240 | ✗ | output << std::fixed << std::setprecision(precision) | |
241 | ✗ | << (perf_info.total_time * 1e3 / (long double)perf_info.stops) << "\t"; | |
242 | ✗ | output << std::fixed << std::setprecision(precision) | |
243 | ✗ | << (perf_info.max_time * 1e3) << "\t"; | |
244 | ✗ | output << std::fixed << std::setprecision(precision) | |
245 | ✗ | << (perf_info.last_time * 1e3) << "\t"; | |
246 | ✗ | output << std::fixed << std::setprecision(precision) << perf_info.stops | |
247 | ✗ | << std::endl; | |
248 | ✗ | output << std::fixed << std::setprecision(precision) | |
249 | ✗ | << perf_info.total_time * 1e3 << std::endl; | |
250 | } | ||
251 | |||
252 | ✗ | long double Stopwatch::get_time_so_far(string perf_name) { | |
253 | // Try to recover performance data | ||
254 | ✗ | if (!performance_exists(perf_name)) | |
255 | ✗ | throw StopwatchException("Performance not initialized."); | |
256 | |||
257 | long double lapse = | ||
258 | ✗ | (take_time() - (records_of->find(perf_name)->second).clock_start); | |
259 | |||
260 | ✗ | if (mode == CPU_TIME) lapse /= (double)CLOCKS_PER_SEC; | |
261 | |||
262 | ✗ | return lapse; | |
263 | } | ||
264 | |||
265 | ✗ | long double Stopwatch::get_total_time(string perf_name) { | |
266 | // Try to recover performance data | ||
267 | ✗ | if (!performance_exists(perf_name)) | |
268 | ✗ | throw StopwatchException("Performance not initialized."); | |
269 | |||
270 | ✗ | PerformanceData &perf_info = records_of->find(perf_name)->second; | |
271 | |||
272 | ✗ | return perf_info.total_time; | |
273 | } | ||
274 | |||
275 | ✗ | long double Stopwatch::get_average_time(string perf_name) { | |
276 | // Try to recover performance data | ||
277 | ✗ | if (!performance_exists(perf_name)) | |
278 | ✗ | throw StopwatchException("Performance not initialized."); | |
279 | |||
280 | ✗ | PerformanceData &perf_info = records_of->find(perf_name)->second; | |
281 | |||
282 | ✗ | return (perf_info.total_time / (long double)perf_info.stops); | |
283 | } | ||
284 | |||
285 | ✗ | long double Stopwatch::get_min_time(string perf_name) { | |
286 | // Try to recover performance data | ||
287 | ✗ | if (!performance_exists(perf_name)) | |
288 | ✗ | throw StopwatchException("Performance not initialized."); | |
289 | |||
290 | ✗ | PerformanceData &perf_info = records_of->find(perf_name)->second; | |
291 | |||
292 | ✗ | return perf_info.min_time; | |
293 | } | ||
294 | |||
295 | ✗ | long double Stopwatch::get_max_time(string perf_name) { | |
296 | // Try to recover performance data | ||
297 | ✗ | if (!performance_exists(perf_name)) | |
298 | ✗ | throw StopwatchException("Performance not initialized."); | |
299 | |||
300 | ✗ | PerformanceData &perf_info = records_of->find(perf_name)->second; | |
301 | |||
302 | ✗ | return perf_info.max_time; | |
303 | } | ||
304 | |||
305 | ✗ | long double Stopwatch::get_last_time(string perf_name) { | |
306 | // Try to recover performance data | ||
307 | ✗ | if (!performance_exists(perf_name)) | |
308 | ✗ | throw StopwatchException("Performance not initialized."); | |
309 | |||
310 | ✗ | PerformanceData &perf_info = records_of->find(perf_name)->second; | |
311 | |||
312 | ✗ | return perf_info.last_time; | |
313 | } | ||
314 |