Sierra Toolkit  Version of the Day
Timer.hpp
1 /*------------------------------------------------------------------------*/
2 /* Copyright 2010 Sandia Corporation. */
3 /* Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive */
4 /* license for use of this work by or on behalf of the U.S. Government. */
5 /* Export of this program may require a license from the */
6 /* United States Government. */
7 /*------------------------------------------------------------------------*/
8 
9 #ifndef STK_UTIL_DIAG_Timer_hpp
10 #define STK_UTIL_DIAG_Timer_hpp
11 
12 #include <iosfwd>
13 #include <vector>
14 #include <list>
15 #include <string>
16 
17 #include <stk_util/stk_config.h>
18 #if defined( STK_HAS_MPI )
19 #include <mpi.h>
20 #endif
21 
22 #include <stk_util/diag/TimerMetricTraits.hpp>
23 #include <stk_util/parallel/Parallel.hpp>
24 #include <stk_util/environment/FormatTime.hpp>
25 #include <stk_util/diag/Writer_fwd.hpp>
26 
27 #include <stk_util/diag/String.hpp>
28 #include <stk_util/diag/WriterParser.hpp>
29 #include <stk_util/diag/Option.hpp>
30 
31 
36 
37 namespace stk_classic {
38 namespace diag {
39 
40 class Timer;
41 class TimerSet;
42 class TimerImpl;
43 
44 typedef unsigned TimerMask;
45 
52 MetricsMask getEnabledTimerMetricsMask();
53 
62 void setEnabledTimerMetricsMask(MetricsMask timer_mask);
63 
71 void updateRootTimer(Timer root_timer);
72 
86 Timer createRootTimer(const std::string &name, const TimerSet &timer_set);
87 
94 void deleteRootTimer(Timer timer);
95 
110 std::vector<Timer> &findTimers(Timer root_timer, const std::string &path_tail, std::vector<Timer> &found_timers);
111 
117 class TimerSet
118 {
119 public:
120  explicit TimerSet(TimerMask enabled_timer_mask)
121  : m_enabledTimerMask(enabled_timer_mask)
122  {}
123 
124 private:
125  TimerSet(const TimerSet &timer_set)
126  : m_enabledTimerMask(timer_set.m_enabledTimerMask)
127  {}
128 
129  TimerSet &operator=(TimerSet &timer_set) {
130  m_enabledTimerMask = timer_set.m_enabledTimerMask;
131 
132  return *this;
133  }
134 
135 public:
136  ~TimerSet()
137  {}
138 
145  TimerMask getEnabledTimerMask() const {
146  return m_enabledTimerMask;
147  }
148 
157  void setEnabledTimerMask(TimerMask timer_mask) {
158  m_enabledTimerMask = timer_mask;
159  }
160 
169  bool shouldRecord(TimerMask timer_mask) const {
170  return (timer_mask == 0 || (m_enabledTimerMask & timer_mask));
171  }
172 
173 private:
174  TimerMask m_enabledTimerMask;
175 };
176 
177 
178 typedef std::list<Timer> TimerList;
179 
185 class Timer
186 {
187  friend class TimerImpl;
188  friend class TimeBlock;
189  friend class TimeBlockSynchronized;
190  friend void updateRootTimer(Timer);
191  friend Timer createRootTimer(const std::string &, const TimerSet &);
192  friend void deleteRootTimer(Timer);
193  friend std::vector<Timer> &findTimers(Timer, const std::string &, std::vector<Timer> &);
194 
195 public:
204  template <typename T>
205  struct Metric
206  {
207  Metric()
208  : m_lapStart(0),
209  m_lapStop(0),
210  m_accumulatedLap(0),
211  m_checkpoint(0)
212  {}
213 
218  void reset() {
220  }
221 
227  typename MetricTraits<T>::Type addLap() {
229  }
230 
236  void checkpoint() const {
238  }
239 
246  typename MetricTraits<T>::Type getLap() const {
247  return m_lapStop - m_lapStart;
248  }
249 
255  typename MetricTraits<T>::Type getStart() const {
256  return m_lapStart;
257  }
258 
264  typename MetricTraits<T>::Type getStop() const {
265  return m_lapStop;
266  }
267 
279  typename MetricTraits<T>::Type getAccumulatedLap(bool arg_checkpoint = false) const {
280  if (arg_checkpoint)
282  else
283  return m_accumulatedLap;
284  }
285 
296  Writer &dump(Writer &dout) const;
297 
298  typename MetricTraits<T>::Type m_lapStart;
299  typename MetricTraits<T>::Type m_lapStop;
300  typename MetricTraits<T>::Type m_accumulatedLap;
301  mutable typename MetricTraits<T>::Type m_checkpoint;
302  };
303 
313  Timer(const std::string &name, const Timer parent);
314 
327  Timer(const std::string &name, const Timer parent, const TimerSet &timer_set);
328 
340  Timer(const std::string &name, TimerMask timer_mask, const Timer parent);
341 
356  Timer(const std::string &name, TimerMask timer_mask, const Timer parent, const TimerSet &timer_set);
357 
362  explicit Timer(TimerImpl &timer_impl)
363  : m_timerImpl(&timer_impl)
364  {}
365 
366  explicit Timer(TimerImpl *timer_impl)
367  : m_timerImpl(timer_impl)
368  {}
369 
370  Timer(const Timer &timer)
371  : m_timerImpl(timer.m_timerImpl)
372  {}
373 
374  Timer &operator=(const Timer &timer) {
375  if (this != &timer)
376  m_timerImpl = timer.m_timerImpl;
377 
378  return *this;
379  }
380 
381  virtual ~Timer()
382  {}
383 
384  const TimerList &getTimerList() const;
385 
386  TimerList::iterator begin();
387  TimerList::const_iterator begin() const;
388  TimerList::iterator end();
389  TimerList::const_iterator end() const;
390 
397  const std::string &getName() const;
398 
399 
405  const TimerSet &getTimerSet() const;
406 
412  TimerMask getTimerMask() const;
413 
414  bool shouldRecord() const;
415 
422  double getSubtimerLapCount() const;
423 
431  template <class T>
432  const Metric<T> &getMetric() const;
433 
440  double accumulateSubtimerLapCounts() const;
441 
447  Timer &start();
448 
454  Timer &lap();
455 
462  Timer &stop();
463 
469  void checkpoint() const;
470 
479  Writer &dump(Writer& dout) const;
480 
481 private:
482  TimerImpl * m_timerImpl;
483 };
484 
485 
486 
496 {
497 public:
511  explicit TimeBlock(Timer &timer, bool start_timer = true)
512  : m_timer(timer),
513  m_started(start_timer)
514  {
515  if (start_timer)
516  m_timer.start();
517  }
518 
519 private:
520  TimeBlock(const TimeBlock &);
521  TimeBlock &operator=(const TimeBlock &);
522 
523 public:
529  try {
530  if (m_started)
531  m_timer.stop();
532  }
533  catch (...) {
534  }
535  }
536 
541  void start() {
542  m_started = true;
543  m_timer.start();
544  }
545 
551  void lap() {
552  m_timer.lap();
553  }
554 
559  void stop() {
560  m_started = false;
561  m_timer.stop();
562  }
563 
564 private:
565  Timer & m_timer;
566  bool m_started;
567 };
568 
582 {
583 public:
597  TimeBlockSynchronized(Timer &timer, ParallelMachine mpi_comm, bool start_timer = true);
598 
605 
611  void start();
612 
617  void stop();
618 
619 private:
620  Timer & m_timer;
621  ParallelMachine m_mpiComm;
622  bool m_started;
623 };
624 
625 
637 template <class T>
638 inline Writer &operator<<(Writer &dout, const Timer::Metric<T> &timer) {
639  return timer.dump(dout);
640 }
641 
653 inline Writer &operator<<(Writer &dout, const Timer &timer) {
654  return timer.dump(dout);
655 }
656 
657 } // namespace diag
658 } // namespace stk_classic
659 
660 
661 namespace sierra {
662 namespace Diag {
663 
664 typedef stk_classic::diag::Timer Timer;
665 typedef stk_classic::diag::TimerSet TimerSet;
666 typedef stk_classic::TimeFormat TimeFormat;
667 typedef stk_classic::diag::TimeBlock TimeBlock;
668 typedef stk_classic::diag::TimeBlockSynchronized TimeBlockSynchronized;
669 
675 enum TimerSetMask{
676  TIMER_DOMAIN = 0x00000001,
677  TIMER_REGION = 0x00000002,
678  TIMER_PROCEDURE = 0x00000004,
679  TIMER_MECHANICS = 0x00000008,
680  TIMER_ALGORITHM = 0x00000010,
681  TIMER_SOLVER = 0x00000020,
682  TIMER_CONTACT = 0x00000040,
683  TIMER_MATERIAL = 0x00000080,
684  TIMER_SEARCH = 0x00000100,
685  TIMER_TRANSFER = 0x00000200,
686  TIMER_ADAPTIVITY = 0x00000400,
687  TIMER_RECOVERY = 0x00000800,
688  TIMER_PROFILE_1 = 0x00001000,
689  TIMER_PROFILE_2 = 0x00002000,
690  TIMER_PROFILE_3 = 0x00004000,
691  TIMER_PROFILE_4 = 0x00008000,
692  TIMER_APP_1 = 0x00010000,
693  TIMER_APP_2 = 0x00020000,
694  TIMER_APP_3 = 0x00040000,
695  TIMER_APP_4 = 0x00080000,
696  TIMER_ALL = 0x000FFFFF,
697  TIMER_NONE = 0x00000000,
698 
699  TIMER_FORCE = 0x00000000
700 };
701 
702 
703 TimerSet &sierraTimerSet();
704 
705 Timer &sierraTimer();
706 
707 void sierraTimerDestroy();
708 
709 class TimerParser;
710 
716 typedef sierra::OptionMask TimerMask;
717 
723 enum {
724  DEFAULT_TIMER_NAME_MAX_WIDTH = 40
725 };
726 
733 TimerParser &theTimerParser();
734 
743 void setEnabledTimerMask(TimerMask timer_mask);
744 
751 TimerMask getEnabledTimerMask();
752 
753 void setTimeFormat(int time_format);
754 
755 void setTimeFormatMillis();
756 
757 int getTimeFormat();
758 
767 void setTimerNameMaxWidth(size_t width);
768 
776 size_t getTimerNameMaxWidth();
777 
778 stk_classic::diag::MetricTraits<stk_classic::diag::CPUTime>::Type getCPULapTime(Timer timer);
779 
780 stk_classic::diag::MetricTraits<stk_classic::diag::CPUTime>::Type getCPUAccumulatedLapTime(Timer timer);
781 
782 stk_classic::diag::MetricTraits<stk_classic::diag::CPUTime>::Type getSierraCPUTime();
783 stk_classic::diag::MetricTraits<stk_classic::diag::CPUTime>::Type getSierraWallTime();
784 
785 
791 {
792 public:
797  TimerParser();
798 
808  Mask parse(const char *mask_string) const;
809 
819  virtual void parseArg(const std::string &name, const std::string &arg) const;
820 
821  mutable stk_classic::diag::MetricsMask m_metricsSetMask;
822  mutable stk_classic::diag::MetricsMask m_metricsMask;
823 };
824 
825 
826 class SierraRootTimer
827 {
828  public:
829  SierraRootTimer();
830  virtual ~SierraRootTimer();
831  stk_classic::diag::Timer & sierraTimer();
832 
833  private:
834  stk_classic::diag::Timer m_sierraTimer;
835 };
836 
837 } // namespace Diag
838 } // namespace sierra
839 
843 
844 #endif // STK_UTIL_DIAG_Timer_hpp
MetricTraits< T >::Type getStart() const
Definition: Timer.hpp:255
friend std::vector< Timer > & findTimers(Timer, const std::string &, std::vector< Timer > &)
Member function findTimer return a vector of timers whose tail of the dot separated name from root_ti...
Definition: Timer.cpp:420
TimerMask getEnabledTimerMask() const
Definition: Timer.hpp:145
friend void updateRootTimer(Timer)
Definition: Timer.cpp:394
Definition: Env.cpp:53
Timer(const std::string &name, const Timer parent)
Definition: Timer.cpp:727
MetricTraits< T >::Type getAccumulatedLap(bool arg_checkpoint=false) const
Definition: Timer.hpp:279
Class TimerParser implements the bit mask parser for the timer&#39;s bit masks.
Definition: Timer.hpp:790
friend void deleteRootTimer(Timer)
Definition: Timer.cpp:411
MetricTraits< T >::Type m_checkpoint
Checkpointed time/count.
Definition: Timer.hpp:301
void setEnabledTimerMask(TimerMask timer_mask)
Definition: Timer.hpp:157
double getSubtimerLapCount() const
Definition: Timer.cpp:760
MetricTraits< T >::Type m_lapStart
Most recent start time/count.
Definition: Timer.hpp:298
bool shouldRecord(TimerMask timer_mask) const
Definition: Timer.hpp:169
Timer(TimerImpl &timer_impl)
Definition: Timer.hpp:362
MetricTraits< T >::Type m_lapStop
Most recent stop or lap time/count.
Definition: Timer.hpp:299
void checkpoint() const
Definition: Timer.cpp:837
MetricTraits< T >::Type m_accumulatedLap
Accumulated time/count.
Definition: Timer.hpp:300
MetricTraits< T >::Type addLap()
Definition: Timer.hpp:227
TimerMask getTimerMask() const
Definition: Timer.cpp:750
Writer & dump(Writer &dout) const
Definition: Timer.cpp:842
Mask parse(const char *mask_string) const
Member function parse parses the mask string and generates the corresponding bit mask.
Definition: Timer.cpp:1151
Class TimerSet implements a set of timer classifications. A time classification consists of a bit mas...
Definition: Timer.hpp:117
Sierra Toolkit.
TimeBlockSynchronized(Timer &timer, ParallelMachine mpi_comm, bool start_timer=true)
Definition: Timer.cpp:870
const TimerSet & getTimerSet() const
Definition: Timer.cpp:755
Class Writer implements a runtime selectable diagnostic output writer to aid in the development and d...
Definition: Writer.hpp:49
TimeBlock(Timer &timer, bool start_timer=true)
Definition: Timer.hpp:511
MPI_Comm ParallelMachine
Definition: Parallel.hpp:32
virtual void parseArg(const std::string &name, const std::string &arg) const
Definition: Timer.cpp:1173
OptionMask Mask
Mask for this option.
Definition: Option.hpp:261
MetricTraits< T >::Type getStop() const
Definition: Timer.hpp:264
friend Timer createRootTimer(const std::string &, const TimerSet &)
Definition: Timer.cpp:402
double accumulateSubtimerLapCounts() const
Definition: Timer.cpp:814
const std::string & getName() const
Definition: Timer.cpp:745
const Metric< T > & getMetric() const
Definition: Timer.cpp:771
Writer & dump(Writer &dout) const
Definition: Timer.cpp:848
MetricTraits< T >::Type getLap() const
Definition: Timer.hpp:246
Class Timer implements a diagnostic timer and timer container for the collection and display of execu...
Definition: Timer.hpp:185