lemon/time_measure.h
author Balazs Dezso <deba@google.com>
Tue, 15 May 2018 14:16:35 +0200
changeset 1174 1e5da3fc4fbc
parent 1092 dceba191c00d
permissions -rw-r--r--
Fix PlanarDrawing::run() function (#610)
alpar@209
     1
/* -*- mode: C++; indent-tabs-mode: nil; -*-
alpar@119
     2
 *
alpar@209
     3
 * This file is a part of LEMON, a generic C++ optimization library.
alpar@119
     4
 *
alpar@1092
     5
 * Copyright (C) 2003-2013
alpar@119
     6
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
alpar@119
     7
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
alpar@119
     8
 *
alpar@119
     9
 * Permission to use, modify and distribute this software is granted
alpar@119
    10
 * provided that this copyright notice appears in all copies. For
alpar@119
    11
 * precise terms see the accompanying LICENSE file.
alpar@119
    12
 *
alpar@119
    13
 * This software is provided "AS IS" with no warranty of any kind,
alpar@119
    14
 * express or implied, and with no claim as to its suitability for any
alpar@119
    15
 * purpose.
alpar@119
    16
 *
alpar@119
    17
 */
alpar@119
    18
alpar@119
    19
#ifndef LEMON_TIME_MEASURE_H
alpar@119
    20
#define LEMON_TIME_MEASURE_H
alpar@119
    21
alpar@119
    22
///\ingroup timecount
alpar@119
    23
///\file
alpar@119
    24
///\brief Tools for measuring cpu usage
alpar@119
    25
alpar@1143
    26
#include <lemon/config.h>
alpar@1143
    27
alpar@1143
    28
#ifdef LEMON_WIN32
alpar@482
    29
#include <lemon/bits/windows.h>
deba@126
    30
#else
alpar@479
    31
#include <unistd.h>
alpar@119
    32
#include <sys/times.h>
deba@126
    33
#include <sys/time.h>
deba@126
    34
#endif
alpar@119
    35
alpar@143
    36
#include <string>
alpar@119
    37
#include <fstream>
alpar@119
    38
#include <iostream>
alpar@1054
    39
#include <lemon/math.h>
alpar@119
    40
alpar@119
    41
namespace lemon {
alpar@119
    42
alpar@119
    43
  /// \addtogroup timecount
alpar@119
    44
  /// @{
alpar@119
    45
alpar@119
    46
  /// A class to store (cpu)time instances.
alpar@119
    47
alpar@119
    48
  /// This class stores five time values.
alpar@119
    49
  /// - a real time
alpar@119
    50
  /// - a user cpu time
alpar@119
    51
  /// - a system cpu time
alpar@119
    52
  /// - a user cpu time of children
alpar@119
    53
  /// - a system cpu time of children
alpar@119
    54
  ///
alpar@119
    55
  /// TimeStamp's can be added to or substracted from each other and
alpar@119
    56
  /// they can be pushed to a stream.
alpar@119
    57
  ///
alpar@119
    58
  /// In most cases, perhaps the \ref Timer or the \ref TimeReport
alpar@119
    59
  /// class is what you want to use instead.
alpar@119
    60
alpar@119
    61
  class TimeStamp
alpar@119
    62
  {
deba@126
    63
    double utime;
deba@126
    64
    double stime;
deba@126
    65
    double cutime;
deba@126
    66
    double cstime;
deba@126
    67
    double rtime;
alpar@209
    68
alpar@1054
    69
  public:
alpar@1054
    70
    ///Display format specifier
alpar@1054
    71
alpar@1054
    72
    ///\e
alpar@1054
    73
    ///
alpar@1054
    74
    enum Format {
alpar@1054
    75
      /// Reports all measured values
alpar@1054
    76
      NORMAL = 0,
alpar@1054
    77
      /// Only real time and an error indicator is displayed
alpar@1054
    78
      SHORT = 1
alpar@1054
    79
    };
alpar@1054
    80
alpar@1054
    81
  private:
alpar@1054
    82
    static Format _format;
alpar@1054
    83
alpar@209
    84
    void _reset() {
deba@126
    85
      utime = stime = cutime = cstime = rtime = 0;
alpar@119
    86
    }
alpar@119
    87
alpar@119
    88
  public:
alpar@119
    89
alpar@1054
    90
    ///Set output format
alpar@1054
    91
alpar@1054
    92
    ///Set output format.
alpar@1054
    93
    ///
alpar@1054
    94
    ///The output format is global for all timestamp instances.
alpar@1054
    95
    static void format(Format f) { _format = f; }
alpar@1054
    96
    ///Retrieve the current output format
alpar@1054
    97
alpar@1054
    98
    ///Retrieve the current output format
alpar@1054
    99
    ///
alpar@1054
   100
    ///The output format is global for all timestamp instances.
alpar@1054
   101
    static Format format() { return _format; }
alpar@1054
   102
alpar@1092
   103
alpar@119
   104
    ///Read the current time values of the process
alpar@119
   105
    void stamp()
alpar@119
   106
    {
alpar@1143
   107
#ifndef LEMON_WIN32
alpar@119
   108
      timeval tv;
deba@126
   109
      gettimeofday(&tv, 0);
deba@126
   110
      rtime=tv.tv_sec+double(tv.tv_usec)/1e6;
deba@126
   111
deba@126
   112
      tms ts;
deba@126
   113
      double tck=sysconf(_SC_CLK_TCK);
deba@126
   114
      times(&ts);
deba@126
   115
      utime=ts.tms_utime/tck;
deba@126
   116
      stime=ts.tms_stime/tck;
deba@126
   117
      cutime=ts.tms_cutime/tck;
deba@126
   118
      cstime=ts.tms_cstime/tck;
deba@126
   119
#else
alpar@482
   120
      bits::getWinProcTimes(rtime, utime, stime, cutime, cstime);
alpar@209
   121
#endif
alpar@119
   122
    }
alpar@209
   123
alpar@119
   124
    /// Constructor initializing with zero
alpar@119
   125
    TimeStamp()
alpar@119
   126
    { _reset(); }
alpar@119
   127
    ///Constructor initializing with the current time values of the process
alpar@119
   128
    TimeStamp(void *) { stamp();}
alpar@209
   129
alpar@119
   130
    ///Set every time value to zero
alpar@119
   131
    TimeStamp &reset() {_reset();return *this;}
alpar@119
   132
alpar@119
   133
    ///\e
alpar@119
   134
    TimeStamp &operator+=(const TimeStamp &b)
alpar@119
   135
    {
deba@126
   136
      utime+=b.utime;
deba@126
   137
      stime+=b.stime;
deba@126
   138
      cutime+=b.cutime;
deba@126
   139
      cstime+=b.cstime;
deba@126
   140
      rtime+=b.rtime;
alpar@119
   141
      return *this;
alpar@119
   142
    }
alpar@119
   143
    ///\e
alpar@119
   144
    TimeStamp operator+(const TimeStamp &b) const
alpar@119
   145
    {
alpar@119
   146
      TimeStamp t(*this);
alpar@119
   147
      return t+=b;
alpar@119
   148
    }
alpar@119
   149
    ///\e
alpar@119
   150
    TimeStamp &operator-=(const TimeStamp &b)
alpar@119
   151
    {
deba@126
   152
      utime-=b.utime;
deba@126
   153
      stime-=b.stime;
deba@126
   154
      cutime-=b.cutime;
deba@126
   155
      cstime-=b.cstime;
deba@126
   156
      rtime-=b.rtime;
alpar@119
   157
      return *this;
alpar@119
   158
    }
alpar@119
   159
    ///\e
alpar@119
   160
    TimeStamp operator-(const TimeStamp &b) const
alpar@119
   161
    {
alpar@119
   162
      TimeStamp t(*this);
alpar@119
   163
      return t-=b;
alpar@119
   164
    }
alpar@119
   165
    ///\e
alpar@119
   166
    TimeStamp &operator*=(double b)
alpar@119
   167
    {
deba@126
   168
      utime*=b;
deba@126
   169
      stime*=b;
deba@126
   170
      cutime*=b;
deba@126
   171
      cstime*=b;
deba@126
   172
      rtime*=b;
alpar@119
   173
      return *this;
alpar@119
   174
    }
alpar@119
   175
    ///\e
alpar@119
   176
    TimeStamp operator*(double b) const
alpar@119
   177
    {
alpar@119
   178
      TimeStamp t(*this);
alpar@119
   179
      return t*=b;
alpar@119
   180
    }
alpar@119
   181
    friend TimeStamp operator*(double b,const TimeStamp &t);
alpar@119
   182
    ///\e
alpar@119
   183
    TimeStamp &operator/=(double b)
alpar@119
   184
    {
deba@126
   185
      utime/=b;
deba@126
   186
      stime/=b;
deba@126
   187
      cutime/=b;
deba@126
   188
      cstime/=b;
deba@126
   189
      rtime/=b;
alpar@119
   190
      return *this;
alpar@119
   191
    }
alpar@119
   192
    ///\e
alpar@119
   193
    TimeStamp operator/(double b) const
alpar@119
   194
    {
alpar@119
   195
      TimeStamp t(*this);
alpar@119
   196
      return t/=b;
alpar@119
   197
    }
alpar@119
   198
    ///The time ellapsed since the last call of stamp()
alpar@119
   199
    TimeStamp ellapsed() const
alpar@119
   200
    {
alpar@119
   201
      TimeStamp t(NULL);
alpar@119
   202
      return t-*this;
alpar@119
   203
    }
alpar@209
   204
alpar@119
   205
    friend std::ostream& operator<<(std::ostream& os,const TimeStamp &t);
alpar@209
   206
alpar@119
   207
    ///Gives back the user time of the process
alpar@119
   208
    double userTime() const
alpar@119
   209
    {
deba@126
   210
      return utime;
alpar@119
   211
    }
alpar@119
   212
    ///Gives back the system time of the process
alpar@119
   213
    double systemTime() const
alpar@119
   214
    {
deba@126
   215
      return stime;
alpar@119
   216
    }
alpar@119
   217
    ///Gives back the user time of the process' children
deba@126
   218
alpar@209
   219
    ///\note On <tt>WIN32</tt> platform this value is not calculated.
deba@126
   220
    ///
alpar@119
   221
    double cUserTime() const
alpar@119
   222
    {
deba@126
   223
      return cutime;
alpar@119
   224
    }
alpar@119
   225
    ///Gives back the user time of the process' children
deba@126
   226
alpar@209
   227
    ///\note On <tt>WIN32</tt> platform this value is not calculated.
deba@126
   228
    ///
alpar@119
   229
    double cSystemTime() const
alpar@119
   230
    {
deba@126
   231
      return cstime;
alpar@119
   232
    }
alpar@119
   233
    ///Gives back the real time
deba@126
   234
    double realTime() const {return rtime;}
alpar@119
   235
  };
alpar@119
   236
alpar@494
   237
  inline TimeStamp operator*(double b,const TimeStamp &t)
alpar@119
   238
  {
alpar@119
   239
    return t*b;
alpar@119
   240
  }
alpar@209
   241
alpar@119
   242
  ///Prints the time counters
alpar@119
   243
alpar@119
   244
  ///Prints the time counters in the following form:
alpar@119
   245
  ///
alpar@119
   246
  /// <tt>u: XX.XXs s: XX.XXs cu: XX.XXs cs: XX.XXs real: XX.XXs</tt>
alpar@119
   247
  ///
alpar@119
   248
  /// where the values are the
alpar@119
   249
  /// \li \c u: user cpu time,
alpar@119
   250
  /// \li \c s: system cpu time,
alpar@119
   251
  /// \li \c cu: user cpu time of children,
alpar@119
   252
  /// \li \c cs: system cpu time of children,
alpar@119
   253
  /// \li \c real: real time.
alpar@119
   254
  /// \relates TimeStamp
deba@126
   255
  /// \note On <tt>WIN32</tt> platform the cummulative values are not
deba@126
   256
  /// calculated.
alpar@119
   257
  inline std::ostream& operator<<(std::ostream& os,const TimeStamp &t)
alpar@119
   258
  {
alpar@1054
   259
    switch(t._format)
alpar@1054
   260
      {
alpar@1054
   261
      case TimeStamp::NORMAL:
alpar@1054
   262
        os << "u: " << t.userTime() <<
alpar@1054
   263
          "s, s: " << t.systemTime() <<
alpar@1054
   264
          "s, cu: " << t.cUserTime() <<
alpar@1054
   265
          "s, cs: " << t.cSystemTime() <<
alpar@1054
   266
          "s, real: " << t.realTime() << "s";
alpar@1054
   267
        break;
alpar@1054
   268
      case TimeStamp::SHORT:
alpar@1054
   269
        double total = t.userTime()+t.systemTime()+
alpar@1054
   270
          t.cUserTime()+t.cSystemTime();
alpar@1054
   271
        os << t.realTime()
alpar@1054
   272
           << "s (err: " << round((t.realTime()-total)/
alpar@1054
   273
                                  t.realTime()*10000)/100
alpar@1054
   274
           << "%)";
alpar@1054
   275
        break;
alpar@1054
   276
      }
alpar@119
   277
    return os;
alpar@119
   278
  }
alpar@119
   279
alpar@119
   280
  ///Class for measuring the cpu time and real time usage of the process
alpar@119
   281
alpar@119
   282
  ///Class for measuring the cpu time and real time usage of the process.
alpar@119
   283
  ///It is quite easy-to-use, here is a short example.
alpar@119
   284
  ///\code
alpar@119
   285
  /// #include<lemon/time_measure.h>
alpar@119
   286
  /// #include<iostream>
alpar@119
   287
  ///
alpar@119
   288
  /// int main()
alpar@119
   289
  /// {
alpar@119
   290
  ///
alpar@119
   291
  ///   ...
alpar@119
   292
  ///
alpar@119
   293
  ///   Timer t;
alpar@119
   294
  ///   doSomething();
alpar@119
   295
  ///   std::cout << t << '\n';
alpar@119
   296
  ///   t.restart();
alpar@119
   297
  ///   doSomethingElse();
alpar@119
   298
  ///   std::cout << t << '\n';
alpar@119
   299
  ///
alpar@119
   300
  ///   ...
alpar@119
   301
  ///
alpar@119
   302
  /// }
alpar@119
   303
  ///\endcode
alpar@119
   304
  ///
alpar@119
   305
  ///The \ref Timer can also be \ref stop() "stopped" and
alpar@119
   306
  ///\ref start() "started" again, so it is possible to compute collected
alpar@119
   307
  ///running times.
alpar@119
   308
  ///
alpar@119
   309
  ///\warning Depending on the operation system and its actual configuration
alpar@119
   310
  ///the time counters have a certain (10ms on a typical Linux system)
alpar@119
   311
  ///granularity.
alpar@119
   312
  ///Therefore this tool is not appropriate to measure very short times.
alpar@119
   313
  ///Also, if you start and stop the timer very frequently, it could lead to
alpar@119
   314
  ///distorted results.
alpar@119
   315
  ///
alpar@119
   316
  ///\note If you want to measure the running time of the execution of a certain
alpar@119
   317
  ///function, consider the usage of \ref TimeReport instead.
alpar@119
   318
  ///
alpar@119
   319
  ///\sa TimeReport
alpar@119
   320
  class Timer
alpar@119
   321
  {
alpar@119
   322
    int _running; //Timer is running iff _running>0; (_running>=0 always holds)
alpar@119
   323
    TimeStamp start_time; //This is the relativ start-time if the timer
alpar@119
   324
                          //is _running, the collected _running time otherwise.
alpar@209
   325
alpar@119
   326
    void _reset() {if(_running) start_time.stamp(); else start_time.reset();}
alpar@209
   327
alpar@209
   328
  public:
alpar@119
   329
    ///Constructor.
alpar@119
   330
alpar@119
   331
    ///\param run indicates whether or not the timer starts immediately.
alpar@119
   332
    ///
alpar@119
   333
    Timer(bool run=true) :_running(run) {_reset();}
alpar@119
   334
kpeter@584
   335
    ///\name Control the State of the Timer
alpar@119
   336
    ///Basically a Timer can be either running or stopped,
alpar@119
   337
    ///but it provides a bit finer control on the execution.
kpeter@314
   338
    ///The \ref lemon::Timer "Timer" also counts the number of
kpeter@314
   339
    ///\ref lemon::Timer::start() "start()" executions, and it stops
kpeter@313
   340
    ///only after the same amount (or more) \ref lemon::Timer::stop()
kpeter@313
   341
    ///"stop()"s. This can be useful e.g. to compute the running time
alpar@119
   342
    ///of recursive functions.
alpar@119
   343
alpar@119
   344
    ///@{
alpar@119
   345
alpar@119
   346
    ///Reset and stop the time counters
alpar@119
   347
alpar@119
   348
    ///This function resets and stops the time counters
alpar@119
   349
    ///\sa restart()
alpar@119
   350
    void reset()
alpar@119
   351
    {
alpar@119
   352
      _running=0;
alpar@119
   353
      _reset();
alpar@119
   354
    }
alpar@119
   355
alpar@119
   356
    ///Start the time counters
alpar@209
   357
alpar@119
   358
    ///This function starts the time counters.
alpar@119
   359
    ///
alpar@119
   360
    ///If the timer is started more than ones, it will remain running
alpar@119
   361
    ///until the same amount of \ref stop() is called.
alpar@119
   362
    ///\sa stop()
alpar@209
   363
    void start()
alpar@119
   364
    {
alpar@119
   365
      if(_running) _running++;
alpar@119
   366
      else {
alpar@209
   367
        _running=1;
alpar@209
   368
        TimeStamp t;
alpar@209
   369
        t.stamp();
alpar@209
   370
        start_time=t-start_time;
alpar@119
   371
      }
alpar@119
   372
    }
alpar@119
   373
alpar@209
   374
alpar@119
   375
    ///Stop the time counters
alpar@119
   376
alpar@119
   377
    ///This function stops the time counters. If start() was executed more than
alpar@119
   378
    ///once, then the same number of stop() execution is necessary the really
alpar@119
   379
    ///stop the timer.
alpar@209
   380
    ///
alpar@119
   381
    ///\sa halt()
alpar@119
   382
    ///\sa start()
alpar@119
   383
    ///\sa restart()
alpar@119
   384
    ///\sa reset()
alpar@119
   385
alpar@209
   386
    void stop()
alpar@119
   387
    {
alpar@119
   388
      if(_running && !--_running) {
alpar@209
   389
        TimeStamp t;
alpar@209
   390
        t.stamp();
alpar@209
   391
        start_time=t-start_time;
alpar@119
   392
      }
alpar@119
   393
    }
alpar@119
   394
alpar@119
   395
    ///Halt (i.e stop immediately) the time counters
alpar@119
   396
alpar@120
   397
    ///This function stops immediately the time counters, i.e. <tt>t.halt()</tt>
alpar@119
   398
    ///is a faster
alpar@119
   399
    ///equivalent of the following.
alpar@119
   400
    ///\code
alpar@119
   401
    ///  while(t.running()) t.stop()
alpar@119
   402
    ///\endcode
alpar@119
   403
    ///
alpar@119
   404
    ///
alpar@119
   405
    ///\sa stop()
alpar@119
   406
    ///\sa restart()
alpar@119
   407
    ///\sa reset()
alpar@119
   408
alpar@209
   409
    void halt()
alpar@119
   410
    {
alpar@119
   411
      if(_running) {
alpar@209
   412
        _running=0;
alpar@209
   413
        TimeStamp t;
alpar@209
   414
        t.stamp();
alpar@209
   415
        start_time=t-start_time;
alpar@119
   416
      }
alpar@119
   417
    }
alpar@119
   418
alpar@119
   419
    ///Returns the running state of the timer
alpar@119
   420
alpar@119
   421
    ///This function returns the number of stop() exections that is
alpar@119
   422
    ///necessary to really stop the timer.
kpeter@786
   423
    ///For example, the timer
alpar@119
   424
    ///is running if and only if the return value is \c true
alpar@119
   425
    ///(i.e. greater than
alpar@119
   426
    ///zero).
alpar@119
   427
    int running()  { return _running; }
alpar@209
   428
alpar@209
   429
alpar@119
   430
    ///Restart the time counters
alpar@119
   431
alpar@119
   432
    ///This function is a shorthand for
alpar@119
   433
    ///a reset() and a start() calls.
alpar@119
   434
    ///
alpar@209
   435
    void restart()
alpar@119
   436
    {
alpar@119
   437
      reset();
alpar@119
   438
      start();
alpar@119
   439
    }
alpar@209
   440
alpar@119
   441
    ///@}
alpar@119
   442
kpeter@584
   443
    ///\name Query Functions for the Ellapsed Time
alpar@119
   444
alpar@119
   445
    ///@{
alpar@119
   446
alpar@119
   447
    ///Gives back the ellapsed user time of the process
alpar@119
   448
    double userTime() const
alpar@119
   449
    {
alpar@119
   450
      return operator TimeStamp().userTime();
alpar@119
   451
    }
alpar@119
   452
    ///Gives back the ellapsed system time of the process
alpar@119
   453
    double systemTime() const
alpar@119
   454
    {
alpar@119
   455
      return operator TimeStamp().systemTime();
alpar@119
   456
    }
alpar@119
   457
    ///Gives back the ellapsed user time of the process' children
deba@126
   458
alpar@209
   459
    ///\note On <tt>WIN32</tt> platform this value is not calculated.
deba@126
   460
    ///
alpar@119
   461
    double cUserTime() const
alpar@119
   462
    {
alpar@119
   463
      return operator TimeStamp().cUserTime();
alpar@119
   464
    }
alpar@119
   465
    ///Gives back the ellapsed user time of the process' children
deba@126
   466
alpar@209
   467
    ///\note On <tt>WIN32</tt> platform this value is not calculated.
deba@126
   468
    ///
alpar@119
   469
    double cSystemTime() const
alpar@119
   470
    {
alpar@119
   471
      return operator TimeStamp().cSystemTime();
alpar@119
   472
    }
alpar@119
   473
    ///Gives back the ellapsed real time
alpar@119
   474
    double realTime() const
alpar@119
   475
    {
alpar@119
   476
      return operator TimeStamp().realTime();
alpar@119
   477
    }
alpar@119
   478
    ///Computes the ellapsed time
alpar@119
   479
alpar@119
   480
    ///This conversion computes the ellapsed time, therefore you can print
alpar@119
   481
    ///the ellapsed time like this.
alpar@119
   482
    ///\code
alpar@119
   483
    ///  Timer t;
alpar@119
   484
    ///  doSomething();
alpar@119
   485
    ///  std::cout << t << '\n';
alpar@119
   486
    ///\endcode
alpar@119
   487
    operator TimeStamp () const
alpar@119
   488
    {
alpar@119
   489
      TimeStamp t;
alpar@119
   490
      t.stamp();
alpar@119
   491
      return _running?t-start_time:start_time;
alpar@119
   492
    }
alpar@119
   493
alpar@119
   494
alpar@119
   495
    ///@}
alpar@119
   496
  };
alpar@119
   497
kpeter@313
   498
  ///Same as Timer but prints a report on destruction.
alpar@119
   499
alpar@119
   500
  ///Same as \ref Timer but prints a report on destruction.
alpar@119
   501
  ///This example shows its usage.
alpar@119
   502
  ///\code
alpar@119
   503
  ///  void myAlg(ListGraph &g,int n)
alpar@119
   504
  ///  {
alpar@119
   505
  ///    TimeReport tr("Running time of myAlg: ");
alpar@119
   506
  ///    ... //Here comes the algorithm
alpar@119
   507
  ///  }
alpar@119
   508
  ///\endcode
alpar@119
   509
  ///
alpar@119
   510
  ///\sa Timer
alpar@119
   511
  ///\sa NoTimeReport
alpar@209
   512
  class TimeReport : public Timer
alpar@119
   513
  {
alpar@119
   514
    std::string _title;
alpar@119
   515
    std::ostream &_os;
alpar@1054
   516
    bool _active;
alpar@119
   517
  public:
kpeter@313
   518
    ///Constructor
alpar@119
   519
kpeter@313
   520
    ///Constructor.
alpar@119
   521
    ///\param title This text will be printed before the ellapsed time.
alpar@119
   522
    ///\param os The stream to print the report to.
alpar@119
   523
    ///\param run Sets whether the timer should start immediately.
alpar@1054
   524
    ///\param active Sets whether the report should actually be printed
alpar@1054
   525
    ///       on destruction.
alpar@1054
   526
    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true,
alpar@1092
   527
               bool active=true)
alpar@1054
   528
      : Timer(run), _title(title), _os(os), _active(active) {}
kpeter@313
   529
    ///Destructor that prints the ellapsed time
alpar@209
   530
    ~TimeReport()
alpar@119
   531
    {
alpar@1054
   532
      if(_active) _os << _title << *this << std::endl;
alpar@119
   533
    }
alpar@1092
   534
alpar@1054
   535
    ///Retrieve the activity status
alpar@1054
   536
alpar@1054
   537
    ///\e
alpar@1054
   538
    ///
alpar@1054
   539
    bool active() const { return _active; }
alpar@1054
   540
    ///Set the activity status
alpar@1054
   541
alpar@1054
   542
    /// This function set whether the time report should actually be printed
alpar@1054
   543
    /// on destruction.
alpar@1054
   544
    void active(bool a) { _active=a; }
alpar@119
   545
  };
alpar@209
   546
kpeter@313
   547
  ///'Do nothing' version of TimeReport
alpar@119
   548
alpar@119
   549
  ///\sa TimeReport
alpar@119
   550
  ///
alpar@119
   551
  class NoTimeReport
alpar@119
   552
  {
alpar@119
   553
  public:
alpar@119
   554
    ///\e
alpar@119
   555
    NoTimeReport(std::string,std::ostream &,bool) {}
alpar@119
   556
    ///\e
alpar@119
   557
    NoTimeReport(std::string,std::ostream &) {}
alpar@119
   558
    ///\e
alpar@119
   559
    NoTimeReport(std::string) {}
alpar@119
   560
    ///\e Do nothing.
alpar@119
   561
    ~NoTimeReport() {}
alpar@119
   562
alpar@119
   563
    operator TimeStamp () const { return TimeStamp(); }
alpar@119
   564
    void reset() {}
alpar@119
   565
    void start() {}
alpar@119
   566
    void stop() {}
alpar@209
   567
    void halt() {}
alpar@119
   568
    int running() { return 0; }
alpar@119
   569
    void restart() {}
alpar@119
   570
    double userTime() const { return 0; }
alpar@119
   571
    double systemTime() const { return 0; }
alpar@119
   572
    double cUserTime() const { return 0; }
alpar@119
   573
    double cSystemTime() const { return 0; }
alpar@119
   574
    double realTime() const { return 0; }
alpar@119
   575
  };
alpar@209
   576
alpar@119
   577
  ///Tool to measure the running time more exactly.
alpar@209
   578
alpar@119
   579
  ///This function calls \c f several times and returns the average
alpar@119
   580
  ///running time. The number of the executions will be choosen in such a way
alpar@119
   581
  ///that the full real running time will be roughly between \c min_time
alpar@119
   582
  ///and <tt>2*min_time</tt>.
alpar@119
   583
  ///\param f the function object to be measured.
alpar@119
   584
  ///\param min_time the minimum total running time.
alpar@119
   585
  ///\retval num if it is not \c NULL, then the actual
alpar@119
   586
  ///        number of execution of \c f will be written into <tt>*num</tt>.
alpar@119
   587
  ///\retval full_time if it is not \c NULL, then the actual
alpar@119
   588
  ///        total running time will be written into <tt>*full_time</tt>.
alpar@119
   589
  ///\return The average running time of \c f.
alpar@209
   590
alpar@119
   591
  template<class F>
alpar@119
   592
  TimeStamp runningTimeTest(F f,double min_time=10,unsigned int *num = NULL,
alpar@119
   593
                            TimeStamp *full_time=NULL)
alpar@119
   594
  {
alpar@119
   595
    TimeStamp full;
alpar@119
   596
    unsigned int total=0;
alpar@119
   597
    Timer t;
alpar@119
   598
    for(unsigned int tn=1;tn <= 1U<<31 && full.realTime()<=min_time; tn*=2) {
alpar@119
   599
      for(;total<tn;total++) f();
alpar@119
   600
      full=t;
alpar@119
   601
    }
alpar@119
   602
    if(num) *num=total;
alpar@119
   603
    if(full_time) *full_time=full;
alpar@119
   604
    return full/total;
alpar@119
   605
  }
alpar@209
   606
alpar@209
   607
  /// @}
alpar@119
   608
alpar@119
   609
alpar@119
   610
} //namespace lemon
alpar@119
   611
alpar@119
   612
#endif //LEMON_TIME_MEASURE_H