cvrTimer.h

Go to the documentation of this file.

/*
 * Copyright (C) 1998
 * Lehrstuhl fuer Technische Informatik, RWTH-Aachen, Germany
 *
 *
 * This file is part of the Computer Vision and Robotics Library (CVR-Lib)
 *
 * The CVR-Lib is free software; you can redistribute it and/or
 * modify it under the terms of the BSD License.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the authors nor the names of its contributors may be
 *    used to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */



/**
 * \file   cvrTimer.h
 *         Contains the class cvr::timer to measure wall-clock times with
 *         microsecond precision.
 * \author Pablo Alvarado
 * \date   12.06.2000
 *
 * $Id: cvrTimer.h,v 1.6 2005/04/20 15:05:24 libuda Exp $
 */

#ifndef _CVR_TIMER_H
#define _CVR_TIMER_H

#include "cvrObject.h"
#include "cvrMacroSymbols.h"
#include <string>

namespace cvr {

  /**
   * The timer allows to measure time with a precision of about 30us
   * on Linux systems and a value dependent on the performance counter
   * on Windows systems. It seems like the precision for CPU time is
   * 1ms on Windows systems. The elapsed time is returned in
   * microseconds.
   *
   * Depending on the eTimeType (setTimeType()) The CPU time (Cpu) or
   * wall-clock time (Wall) are measured. The default is Cpu.
   *
   * The maximum time that can be measured with this function in Wall
   * mode is 1 day (86.4E+09 microseconds).  To measure longer time
   * intervalls use the standard time() function.
   *
   * Example:
   *
   * \code
   *
   * cvr::timer chron;
   *
   * chron.start();
   *
   * // do something
   *
   * chron.stop();
   *
   * std::cout << "something takes " << chron.getTime() << " microseconds\n";
   *
   * \endcode
   */
  class timer : public object {
  public:

    /**
     * Determines which time is measured.
     */
    enum eTimeType {
      Wall, /**< Use Wall-time */
      Cpu  /**< Use CPU time */
    };

    /**
     * Default constructor
     */
    timer();

    /**
     * Constructor to set the time type.
     */
    timer(const eTimeType& timeType);

    /**
     * Copy constructor
     */
    timer(const timer& other);

    /**
     * Destructor
     */
    virtual ~timer();

    /**
     * Start the timer
     */
    void start();

    /**
     * Stop the timer
     */
    void stop();

    /**
     * Get the elapsed time (in microsecond) between start() and stop() or the
     * actual time (if stop() is not been called yet!)
     *
     * @return Elapsed time
     */
    double getTime() const;

    /**
     * Sets the time type.
     *
     * @param timeType the new eTimeType
     */
    void setTimeType(const eTimeType& timeType);

    /**
     * Returns the current time type.
     *
     * @return the current eTimeType.
     */
    const eTimeType& getTimeType();

    /**
     * Return a string containing the current time. Obviously this
     * always uses the Wall time.
     *
     * The format is the one return by the libc function \c ctime, for example
     * \code
     * Sat Jul 24 22:46:18 CEST 2004
     * \endcode
     *
     */
    static std::string getDateAndTime();

    /**
     * Returns the current CPU time in usec. Don't use this function
     * for time measurement. Use start(), stop(), getTime() instead.
     */
    static double getCpuTime();

    /**
     * Class name
     */
    virtual const std::string& name() const;

    /**
     * Clone method.
     */
    virtual timer* clone() const;

    /**
     * New instance method.
     */
    virtual timer* newInstance() const;

  protected:

    /**
     * Time type used.
     */
    eTimeType timeType_;

    /**
     * Time at which start() was called.
     */
    double startTime_;

    /**
     * Time at which stop() was called.
     */
    double endTime_;

    /**
     * Flag to indicate if start() was called, but not stop().
     */
    bool started_;

    /**
     * Get actual time.
     *
     * The implementation of this method depends on the OS.
     */
    double getActualTime() const;

# ifdef _CVR_MSC_VER
  private:
    /**
     * \name MS VC++ version
     */
    //@{
    /**
     * Constant used to represent in a floating point representation the
     * value 2^32
     */
    static const double max32bit_;

    /**
     * Frequency (Hz) of the performance counter
     */
    double freq_;
    //@}
# endif

  };
}

#endif