hpp-fcl: include/hpp/fcl/profile.h Source File

hpp-fcl 1.6.0 HPP fork of FCL -- The Flexible Collision Library

profile.h
Go to the documentation of this file.
1 /*
2 * Software License Agreement (BSD License)
3 *
4 * Copyright (c) 2008-2014, Willow Garage, Inc.
5 * Copyright (c) 2014-2015, Open Source Robotics Foundation
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * * Redistributions in binary form must reproduce the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer in the documentation and/or other materials provided
17 * with the distribution.
18 * * Neither the name of Open Source Robotics Foundation nor the names of its
19 * contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
28 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
30 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33 * POSSIBILITY OF SUCH DAMAGE.
34 */
35
36
37 /* Author Ioan Sucan */
38
39 #ifndef HPP_FCL_UTIL_PROFILER
40 #define HPP_FCL_UTIL_PROFILER
41
42 #define ENABLE_PROFILING 1
43
44 #ifndef ENABLE_PROFILING
45
47
48 # ifdef NDEBUG
49 # define ENABLE_PROFILING 0
50 # else
51 # define ENABLE_PROFILING 1
52 # endif
53
54 #endif
55
56 #if ENABLE_PROFILING
57
58 #include <map>
59 #include <string>
60 #include <iostream>
61 #include <boost/thread.hpp>
62 #include <boost/noncopyable.hpp>
63 #include <boost/date_time/posix_time/posix_time.hpp>
64
65 #include <hpp/fcl/config.hh>
66
67 namespace hpp
68 {
69 namespace fcl
70 {
71
73 namespace time
74 {
75
77 typedef boost::posix_time::ptime point;
78
80 typedef boost::posix_time::time_duration duration;
81
83 inline point now(void)
84 {
85 return boost::posix_time::microsec_clock::universal_time();
86 }
87
89 inline duration seconds(double sec)
90 {
91 long int s = static_cast<long int>(sec);
92 long int us = ((static_cast<long int>(sec) - s) * 1000000);
93 return boost::posix_time::seconds(s) + boost::posix_time::microseconds(us);
94 }
95
97 inline double seconds(const duration &d)
98 {
99 return (double)d.total_microseconds() / 1000000.0;
100 }
101
102 }
103
104 namespace tools
105 {
106
112 class HPP_FCL_DLLAPI Profiler : private boost::noncopyable
113 {
114 public:
115
117 class HPP_FCL_DLLAPI ScopedBlock
118 {
119 public:
121 ScopedBlock(const std::string &name, Profiler &prof = Profiler::Instance()) : name_(name), prof_(prof)
122 {
123 prof_.begin(name);
124 }
125
126 ~ScopedBlock(void)
127 {
128 prof_.end(name_);
129 }
130
131 private:
132
133 std::string name_;
134 Profiler &prof_;
135 };
136
139 class HPP_FCL_DLLAPI ScopedStart
140 {
141 public:
142
144 ScopedStart(Profiler &prof = Profiler::Instance()) : prof_(prof), wasRunning_(prof_.running())
145 {
146 if (!wasRunning_)
147 prof_.start();
148 }
149
150 ~ScopedStart(void)
151 {
152 if (!wasRunning_)
153 prof_.stop();
154 }
155
156 private:
157
158 Profiler &prof_;
159 bool wasRunning_;
160 };
161
163 static Profiler& Instance(void);
164
167 Profiler(bool printOnDestroy = false, bool autoStart = false) : running_(false), printOnDestroy_(printOnDestroy)
168 {
169 if (autoStart)
170 start();
171 }
172
174 ~Profiler(void)
175 {
176 if (printOnDestroy_ && !data_.empty())
177 status();
178 }
179
181 static void Start(void)
182 {
183 Instance().start();
184 }
185
187 static void Stop(void)
188 {
189 Instance().stop();
190 }
191
193 static void Clear(void)
194 {
195 Instance().clear();
196 }
197
199 void start(void);
200
202 void stop(void);
203
205 void clear(void);
206
208 static void Event(const std::string& name, const unsigned int times = 1)
209 {
210 Instance().event(name, times);
211 }
212
214 void event(const std::string &name, const unsigned int times = 1);
215
217 static void Average(const std::string& name, const double value)
218 {
219 Instance().average(name, value);
220 }
221
223 void average(const std::string &name, const double value);
224
226 static void Begin(const std::string &name)
227 {
228 Instance().begin(name);
229 }
230
232 static void End(const std::string &name)
233 {
234 Instance().end(name);
235 }
236
238 void begin(const std::string &name);
239
241 void end(const std::string &name);
242
246 static void Status(std::ostream &out = std::cout, bool merge = true)
247 {
248 Instance().status(out, merge);
249 }
250
254 void status(std::ostream &out = std::cout, bool merge = true);
255
257 bool running(void) const
258 {
259 return running_;
260 }
261
263 static bool Running(void)
264 {
265 return Instance().running();
266 }
267
268 private:
269
271 struct HPP_FCL_DLLAPI TimeInfo
272 {
273 TimeInfo(void) : total(0, 0, 0, 0), shortest(boost::posix_time::pos_infin), longest(boost::posix_time::neg_infin), parts(0)
274 {
275 }
276
278 time::duration total;
279
281 time::duration shortest;
282
284 time::duration longest;
285
287 unsigned long int parts;
288
290 time::point start;
291
293 void set(void)
294 {
295 start = time::now();
296 }
297
299 void update(void)
300 {
301 const time::duration &dt = time::now() - start;
302 if (dt > longest)
303 longest = dt;
304 if (dt < shortest)
305 shortest = dt;
306 total = total + dt;
307 ++parts;
308 }
309 };
310
312 struct HPP_FCL_DLLAPI AvgInfo
313 {
315 double total;
316
318 double totalSqr;
319
321 unsigned long int parts;
322 };
323
325 struct HPP_FCL_DLLAPI PerThread
326 {
328 std::map<std::string, unsigned long int> events;
329
331 std::map<std::string, AvgInfo> avg;
332
334 std::map<std::string, TimeInfo> time;
335 };
336
337 void printThreadInfo(std::ostream &out, const PerThread &data);
338
339 boost::mutex lock_;
340 std::map<boost::thread::id, PerThread> data_;
341 TimeInfo tinfo_;
342 bool running_;
343 bool printOnDestroy_;
344
345 };
346 }
347 }
348
349 #else
350
351 #include <string>
352 #include <iostream>
353
355 namespace hpp
356 {
357 namespace fcl
358 {
359
360 namespace tools
361 {
362
363 class HPP_FCL_DLLAPI Profiler
364 {
365 public:
366
367 class HPP_FCL_DLLAPI ScopedBlock
368 {
369 public:
370
371 ScopedBlock(const std::string &, Profiler & = Profiler::Instance())
372 {
373 }
374
375 ~ScopedBlock(void)
376 {
377 }
378 };
379
380 class HPP_FCL_DLLAPI ScopedStart
381 {
382 public:
383
384 ScopedStart(Profiler & = Profiler::Instance())
385 {
386 }
387
388 ~ScopedStart(void)
389 {
390 }
391 };
392
393 static Profiler& Instance(void);
394
395 Profiler(bool = true, bool = true)
396 {
397 }
398
399 ~Profiler(void)
400 {
401 }
402
403 static void Start(void)
404 {
405 }
406
407 static void Stop(void)
408 {
409 }
410
411 static void Clear(void)
412 {
413 }
414
415 void start(void)
416 {
417 }
418
419 void stop(void)
420 {
421 }
422
423 void clear(void)
424 {
425 }
426
427 static void Event(const std::string&, const unsigned int = 1)
428 {
429 }
430
431 void event(const std::string &, const unsigned int = 1)
432 {
433 }
434
435 static void Average(const std::string&, const double)
436 {
437 }
438
439 void average(const std::string &, const double)
440 {
441 }
442
443 static void Begin(const std::string &)
444 {
445 }
446
447 static void End(const std::string &)
448 {
449 }
450
451 void begin(const std::string &)
452 {
453 }
454
455 void end(const std::string &)
456 {
457 }
458
459 static void Status(std::ostream & = std::cout, bool = true)
460 {
461 }
462
463 void status(std::ostream & = std::cout, bool = true)
464 {
465 }
466
467 bool running(void) const
468 {
469 return false;
470 }
471
472 static bool Running(void)
473 {
474 return false;
475 }
476 };
477 }
478 }
479
480 #endif
481
482 } // namespace hpp
483
484 #endif
hpp::fcl::tools::Profiler::Instance
static Profiler & Instance(void)
Return an instance of the class.
hpp::fcl::tools::Profiler::average
void average(const std::string &name, const double value)
Maintain the average of a specific value.
hpp::fcl::tools::Profiler::Event
static void Event(const std::string &name, const unsigned int times=1)
Count a specific event for a number of times.
Definition: profile.h:208
hpp::fcl::tools::Profiler::End
static void End(const std::string &name)
Stop counting time for a specific chunk of code.
Definition: profile.h:232
hpp::fcl::tools::Profiler::ScopedStart::~ScopedStart
~ScopedStart(void)
Definition: profile.h:150
hpp::fcl::tools::Profiler::Clear
static void Clear(void)
Clear counted time and events.
Definition: profile.h:193
hpp::fcl::tools::Profiler
This is a simple thread-safe tool for counting time spent in various chunks of code....
Definition: profile.h:113
hpp::fcl::time::seconds
double seconds(const duration &d)
Return the number of seconds that a time duration represents.
Definition: profile.h:97
hpp::fcl::tools::Profiler::ScopedBlock::ScopedBlock
ScopedBlock(const std::string &name, Profiler &prof=Profiler::Instance())
Start counting time for the block named name of the profiler prof.
Definition: profile.h:121
hpp::fcl::tools::Profiler::Profiler
Profiler(bool printOnDestroy=false, bool autoStart=false)
Constructor. It is allowed to separately instantiate this class (not only as a singleton)
Definition: profile.h:167
hpp::fcl::tools::Profiler::ScopedStart
This instance will call Profiler::start() when constructed and Profiler::stop() when it goes out of s...
Definition: profile.h:140
hpp::fcl::tools::Profiler::Running
static bool Running(void)
Check if the profiler is counting time or not.
Definition: profile.h:263
hpp::fcl::tools::Profiler::Begin
static void Begin(const std::string &name)
Begin counting time for a specific chunk of code.
Definition: profile.h:226
hpp::fcl::tools::Profiler::Stop
static void Stop(void)
Stop counting time.
Definition: profile.h:187
hpp::fcl::time::seconds
duration seconds(double sec)
Return the time duration representing a given number of seconds.
Definition: profile.h:89
hpp::fcl::tools::Profiler::end
void end(const std::string &name)
Stop counting time for a specific chunk of code.
hpp::fcl::tools::Profiler::Status
static void Status(std::ostream &out=std::cout, bool merge=true)
Print the status of the profiled code chunks and events. Optionally, computation done by different th...
Definition: profile.h:246
hpp
Main namespace.
Definition: AABB.h:44
hpp::fcl::tools::Profiler::clear
void clear(void)
Clear counted time and events.
hpp::fcl::tools::Profiler::stop
void stop(void)
Stop counting time.
hpp::fcl::tools::Profiler::ScopedBlock::~ScopedBlock
~ScopedBlock(void)
Definition: profile.h:126
hpp::fcl::tools::Profiler::status
void status(std::ostream &out=std::cout, bool merge=true)
Print the status of the profiled code chunks and events. Optionally, computation done by different th...
hpp::fcl::tools::Profiler::event
void event(const std::string &name, const unsigned int times=1)
Count a specific event for a number of times.
hpp::fcl::tools::Profiler::ScopedBlock
This instance will call Profiler::begin() when constructed and Profiler::end() when it goes out of sc...
Definition: profile.h:118
hpp::fcl::time::duration
boost::posix_time::time_duration duration
Representation of a time duration.
Definition: profile.h:80
hpp::fcl::tools::Profiler::~Profiler
~Profiler(void)
Destructor.
Definition: profile.h:174
hpp::fcl::tools::Profiler::running
bool running(void) const
Check if the profiler is counting time or not.
Definition: profile.h:257
hpp::fcl::time::now
point now(void)
Get the current time point.
Definition: profile.h:83
hpp::fcl::tools::Profiler::start
void start(void)
Start counting time.
hpp::fcl::tools::Profiler::begin
void begin(const std::string &name)
Begin counting time for a specific chunk of code.
hpp::fcl::tools::Profiler::ScopedStart::ScopedStart
ScopedStart(Profiler &prof=Profiler::Instance())
Take as argument the profiler instance to operate on (prof)
Definition: profile.h:144
hpp::fcl::tools::Profiler::Average
static void Average(const std::string &name, const double value)
Maintain the average of a specific value.
Definition: profile.h:217
hpp::fcl::tools::Profiler::Start
static void Start(void)
Start counting time.
Definition: profile.h:181
hpp::fcl::time::point
boost::posix_time::ptime point
Representation of a point in time.
Definition: profile.h:77