Boost logo

Boost :

From: Toon Knapen (toon.knapen_at_[hidden])
Date: 2001-10-31 10:54:05

I need some lightweight timer to calculate the total time a program
spends in some function (as it's a template function, `gprof`
incorporates it in the caller)

So I took a look at boost.timer. A few questions/remarks :

The comments in timer.hpp state : "It is recommended that
implementations measure wall clock rather than CPU time since ..."
`clock()` however returns process-time (CPU time) and not wall clock
time ? (although this is exactly what I wanted)

I need to be able to toggle the timer on and off. Since I want to
calculate the total time spend in some function I need to toggle the
timer off everytime the program leaves the function and back on
everytime the program enters the function again.
So I propose to add a member called `toggle()`.
A drawback though is that you need to `toggle` the timer back on before
asking the `elapsed()` time (otherwise I would need a bit to indicate if
the timer is on or off which increases the memory footprint. Maybe I
could use the MSB of the clock_t as a hack)

In attachment you can find my proposal implementation (Oh, I also
aligned with the coding guidelines AFAIK : trailing underscore for
members, ... )


// boost timer.hpp header file ---------------------------------------------//

// (C) Copyright Beman Dawes 1994-99. Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.

// See for most recent version including documentation.

// Revision History
// 01 Apr 01 Modified to use new <boost/limits.hpp> header. (JMaddock)
// 12 Jan 01 Change to inline implementation to allow use without library
// builds. See docs for more rationale. (Beman Dawes)
// 25 Sep 99 elapsed_max() and elapsed_min() added (John Maddock)
// 16 Jul 99 Second beta
// 6 Jul 99 Initial boost version


#include <boost/config.hpp>
#include <ctime>
#include <boost/limits.hpp>

namespace std { using ::clock_t; using ::clock; }
# endif

namespace boost {

  // timer -------------------------------------------------------------------//

  // A timer object measures elapsed time.

  // It is recommended that implementations measure wall clock rather than CPU
  // time since the intended use is performance measurement on systems where
  // total elapsed time is more important than just process or CPU time.

  // Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
  // due to implementation limitations. The accuracy of timings depends on the
  // accuracy of timing information provided by the underlying platform, and
  // this varies a great deal from platform to platform.

  class timer

    /// create new timer
    /// postcondition: elapsed()==0
      : start_time_( std::clock() )

    /// default copy constructor
    /// postcondition: elapsed() == src.elapsed()
    // timer( const timer& src );

    /// default destructor
    // ~timer(){}

    /// default assignment
    /// postcondition: elapsed()==src.elapsed()
    // timer& operator=( const timer& src );

    /// toggle the timer off and back on
    void toggle()
      start_time_ = std::clock() - start_time_;

    /// postcondition: elapsed()==0
    void restart()
      start_time_ = std::clock();

    /// return elapsed time in seconds
    /// precondition: timer should be toggled on
    double elapsed() const
      return double( std::clock() - start_time_ ) / CLOCKS_PER_SEC;

    /// return estimated maximum value for elapsed()
    double elapsed_max() const
      // Portability warning: elapsed_max() may return too high a value on systems
      // where std::clock_t overflows or resets at surprising values.
      return (double(std::numeric_limits<std::clock_t>::max())
              - double(start_time_)) / double(CLOCKS_PER_SEC);

    // return minimum value for elapsed()
    double elapsed_min() const
      return double(1)/double(CLOCKS_PER_SEC);


    std::clock_t start_time_;

  }; // timer

} // namespace boost


Boost list run by bdawes at, gregod at, cpdaniel at, john at