libzypp  17.29.1
Measure.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 extern "C"
13 {
14 #include <sys/times.h>
15 #include <unistd.h>
16 }
17 #include <iostream>
18 
19 #include <zypp/base/Logger.h>
20 #include <zypp/base/Measure.h>
21 #include <zypp/base/String.h>
22 
23 using std::endl;
24 
25 #undef ZYPP_BASE_LOGGER_LOGGROUP
26 #define ZYPP_BASE_LOGGER_LOGGROUP "Measure"
27 
29 namespace zypp
30 {
32  namespace debug
33  {
34 
36  struct Tm
37  {
38  Tm()
39  : _real( 0 )
40  , _proc( tmsEmpty )
41  {}
42 
43  void get()
44  {
45  _real = ::time(NULL);
46  ::times( &_proc );
47  }
48 
49  Tm operator-( const Tm & rhs ) const
50  {
51  Tm ret( *this );
52  ret._real -= rhs._real;
53  ret._proc.tms_utime -= rhs._proc.tms_utime;
54  ret._proc.tms_stime -= rhs._proc.tms_stime;
55  ret._proc.tms_cutime -= rhs._proc.tms_cutime;
56  ret._proc.tms_cstime -= rhs._proc.tms_cstime;
57  return ret;
58  }
59 
60  std::string asString() const
61  {
62  std::string ret( timeStr( _real ) );
63  ret += " (u ";
64  ret += timeStr( asSec( _proc.tms_utime ) );
65  ret += " s ";
66  ret += timeStr( asSec( _proc.tms_stime ) );
67  ret += " c ";
68  ret += timeStr( asSec( _proc.tms_cutime + _proc.tms_cstime ) );
69  ret += ")";
70  return ret;
71  }
72 
73  std::string stringIf( clock_t ticks_r, const std::string & tag_r ) const
74  {
75  std::string ret;
76  if ( ticks_r )
77  {
78  ret += tag_r;
79  ret += timeStr( asSec( ticks_r ) );
80  }
81  return ret;
82  }
83 
84  double asSec( clock_t ticks_r ) const
85  { return double(ticks_r) / ticks; }
86 
87  std::string timeStr( time_t sec_r ) const
88  {
89  time_t h = sec_r/3600;
90  sec_r -= h*3600;
91  time_t m = sec_r/60;
92  sec_r -= m*60;
93  if ( h )
94  return str::form( "%lu:%02lu:%02lu", h, m, sec_r );
95  if ( m )
96  return str::form( "%lu:%02lu", m, sec_r );
97  return str::form( "%lu", sec_r );
98  }
99 
100  std::string timeStr( double sec_r ) const
101  {
102  time_t h = time_t(sec_r)/3600;
103  sec_r -= h*3600;
104  time_t m = time_t(sec_r)/60;
105  sec_r -= m*60;
106  if ( h )
107  return str::form( "%lu:%02lu:%05.2lf", h, m, sec_r );
108  if ( m )
109  return str::form( "%lu:%05.2lf", m, sec_r );
110  return str::form( "%.2lf", sec_r );
111  }
112 
114  static const long ticks;
116  static const struct tms tmsEmpty;
118  time_t _real;
120  struct tms _proc;
121  };
122 
123  const struct tms Tm::tmsEmpty = { 0, 0, 0, 0 };
124  const long Tm::ticks = sysconf(_SC_CLK_TCK);
125 
127  std::ostream & operator<<( std::ostream & str, const Tm & obj )
128  {
129  return str << obj.asString();
130  }
131 
132 
134  //
135  // CLASS NAME : Measure::Impl
136  //
139  {
140  public:
141  Impl( const std::string & ident_r, std::ostream * log_r = nullptr )
142  : _ident ( ident_r )
143  , _level ( _glevel )
144  , _seq ( 0 )
145  , _log ( log_r )
146  {
147  _glevel += "..";
148  log() << _level << "START MEASURE(" << _ident << ")" << endl;
149  _start.get();
150  }
151 
153  {
154  _stop.get();
155  ++_seq;
156  std::ostream & str( log() << _level << "MEASURE(" << _ident << ") " );
157  dumpMeasure( str );
158  _glevel.erase( 0, 2 );
159  }
160 
161  void restart()
162  {
163  log() << _level << "RESTART MEASURE(" << _ident << ")" << endl;
164  _start = _stop;
165  }
166 
167  void elapsed( const std::string & tag_r = std::string() ) const
168  {
169  _stop.get();
170  ++_seq;
171  std::ostream & str( log() << _level << "ELAPSED(" << _ident << ") " );
172  dumpMeasure( str, tag_r );
173  _elapsed = _stop;
174  }
175 
177  std::ostream & log() const
178  { return _log ? *_log : INT; }
179  std::ostream * logp() const
180  { return _log; }
181 
182  private:
183  std::ostream & dumpMeasure( std::ostream & str_r, const std::string & tag_r = std::string() ) const
184  {
185  str_r << ( _stop - _start );
186  if ( _seq > 1 ) // diff to previous _elapsed
187  {
188  str_r << " [" << ( _stop - _elapsed ) << "]";
189  }
190  if ( ! tag_r.empty() )
191  str_r << " - " << tag_r;
192  return str_r << endl;
193  }
194 
195  private:
196  static std::string _glevel;
197 
198  std::string _ident;
199  std::string _level;
201  mutable unsigned _seq;
202  mutable Tm _elapsed;
203  mutable Tm _stop;
204 
205  std::ostream * _log = nullptr;
206  };
207 
208  std::string Measure::Impl::_glevel;
209 
211 
213  //
214  // CLASS NAME : Measure
215  //
217 
219  {}
220 
221  Measure::Measure( const std::string & ident_r )
222  : _pimpl( new Impl( ident_r ) )
223  {}
224 
225  Measure::Measure( const std::string & ident_r, std::ostream & out_r )
226  : _pimpl( new Impl( ident_r, &out_r ) )
227  {}
228 
230  {}
231 
232  void Measure::start( const std::string & ident_r )
233  { stop(); _pimpl.reset( _pimpl ? new Impl( ident_r, _pimpl->logp() ) : new Impl( ident_r ) ); }
234 
236  { _pimpl->restart(); }
237 
238  void Measure::elapsed() const
239  { if ( _pimpl ) _pimpl->elapsed(); }
240  void Measure::elapsed( const std::string & tag_r ) const
241  { if ( _pimpl ) _pimpl->elapsed( tag_r ); }
242  void Measure::elapsed( long tag_r ) const
243  { if ( _pimpl ) _pimpl->elapsed( asString( tag_r ) ); }
244 
246  { _pimpl.reset(); }
247 
249  } // namespace debug
252 } // namespace zypp
Measure implementation.
Definition: Measure.cc:139
std::ostream * logp() const
Definition: Measure.cc:179
std::ostream & log() const
Return the log stream.
Definition: Measure.cc:177
std::ostream * _log
Definition: Measure.cc:205
static std::string _glevel
Definition: Measure.cc:196
void elapsed(const std::string &tag_r=std::string()) const
Definition: Measure.cc:167
std::ostream & dumpMeasure(std::ostream &str_r, const std::string &tag_r=std::string()) const
Definition: Measure.cc:183
Impl(const std::string &ident_r, std::ostream *log_r=nullptr)
Definition: Measure.cc:141
Measure()
Default Ctor does nothing.
Definition: Measure.cc:218
void elapsed() const
Print elapsed time for a running timer.
Definition: Measure.cc:238
void stop()
Stop a running timer.
Definition: Measure.cc:245
void restart()
re start the timer without reset-ing it.
Definition: Measure.cc:235
void start(const std::string &ident_r=std::string())
Start timer for ident_r string.
Definition: Measure.cc:232
RW_pointer< Impl > _pimpl
Pointer to implementation.
Definition: Measure.h:113
String related utilities and Regular expression matching.
std::ostream & operator<<(std::ostream &str, const Tm &obj)
\refers Tm Stream output.
Definition: Measure.cc:127
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
std::string asString(const Patch::Category &obj)
Definition: Patch.cc:122
Times measured by Measure.
Definition: Measure.cc:37
std::string stringIf(clock_t ticks_r, const std::string &tag_r) const
Definition: Measure.cc:73
time_t _real
Real time via ::time.
Definition: Measure.cc:118
std::string timeStr(double sec_r) const
Definition: Measure.cc:100
struct tms _proc
Process times via ::times.
Definition: Measure.cc:120
std::string asString() const
Definition: Measure.cc:60
static const long ticks
Systems ticks per second.
Definition: Measure.cc:114
Tm operator-(const Tm &rhs) const
Definition: Measure.cc:49
std::string timeStr(time_t sec_r) const
Definition: Measure.cc:87
double asSec(clock_t ticks_r) const
Definition: Measure.cc:84
void get()
Definition: Measure.cc:43
#define INT
Definition: Logger.h:100