---

more/sys/time.h

Go to the documentation of this file.

//  more/sys/time.h
//  Copyright (C) 1998--2001  Petter Urkedal (petter.urkedal@matfys.lth.se)
//
//  This file is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: time.h,v 1.1 2002/05/30 18:01:40 petter_urkedal Exp $



#ifndef MORE_SYS_TIME_H
#define MORE_SYS_TIME_H

#include <ctime>
#include <stdexcept>
#include <iosfwd>


namespace more {
namespace sys {

  /** A floating point type used to represent time.  Some philosopies
      regards time as a discrete sequence of moments.  A more common
      view is that time is continuous.

      Precision.  Assume this is a 64 bits double with a 53 bits
      mantissa.  If we use 33 bits for the year, 2↑33 s ≃ 272 y,
      i.e. in year 2242 there is still 20 bits left for subsecond
      precision down to 2^(-20) s = 0.95 μs.  For relative time within
      12 days ≃ 2↑20 s the precision is about 0.1 ns, but at the
      moment the OS calls limit the precision to 1 μs.  */
  typedef double time_t;

  /** The current real-world time.  More precisely, the time
      difference in seconds between present and Epoch (1970-01-01
      00:00:00 UTC).  If the \c gettimeofday is available on your
      system, the returned time will have 1 μs precision, otherwise it
      will have 1 s precision. */
  time_t current_time();

  /** Return the current real-world time relative to \a t_ref.  By
      supplying a reference point close to the current time, time
      differences may be calculated with better precision then when
      using Epoch times.  (At the moment the precision is most likely
      limited by the OS call, though.)  */
  time_t current_time(time_t const& t_ref);

  /** Return the processor time spent in this process.  If getrusage
      is not available \c clock(), which may overflow, is used. */
  time_t process_time();
//   inline time_t process_time() { return std::clock()/(time_t)CLOCKS_PER_SEC; }

  // XXX Maybe this should be in the IO module
  void print_time_nicely(std::ostream& out, double t);

  /** Sleep for the given time.  If nanosleep is available on the
      system, the precision may be down to ns, else if setitimer is
      available, the precision may be down to μs, otherwise the
      precision is down to s, but in any case the precision is limited
      by the scheduler. */
  void sleep(double);

} // sys
  using sys::time_t;
  using sys::current_time;
  using sys::process_time;
  using sys::print_time_nicely;
} // more

#endif

// Local Variables:
// coding: utf-8
// End:

---