/* Portable timers.
- Copyright (C) 2005 Free Software Foundation, Inc.
+ Copyright (C) 2005-2006 Free Software Foundation, Inc.
This file is part of GNU Wget.
GNU Wget 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
+the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
GNU Wget is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with Wget; if not, write to the Free Software Foundation, Inc.,
-51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+along with Wget. If not, see <http://www.gnu.org/licenses/>.
In addition, as a special exception, the Free Software Foundation
gives permission to link the code of its release of Wget with the
ptimer_destroy -- destroy the timer.
ptimer_granularity -- returns the approximate granularity of the timers.
- Timers measure time in milliseconds, but the timings they return
- are floating point numbers, so they can carry as much precision as
- the underlying system timer supports. For example, to measure the
- time it takes to run a loop, you can use something like:
+ Timers measure time in seconds, returning the timings as floating
+ point numbers, so they can carry as much precision as the
+ underlying system timer supports. For example, to measure the time
+ it takes to run a loop, you can use something like:
ptimer *tmr = ptimer_new ();
while (...)
... loop ...
- double msecs = ptimer_measure ();
- printf ("The loop took %.2f ms\n", msecs); */
+ double secs = ptimer_measure ();
+ printf ("The loop took %.2fs\n", secs); */
#include <config.h>
CLOCK_MONOTONIC where available, CLOCK_REALTIME otherwise. */
static int posix_clock_id;
-/* Resolution of the clock, in milliseconds. */
-static double posix_millisec_resolution;
+/* Resolution of the clock, initialized in posix_init. */
+static double posix_clock_resolution;
/* Decide which clock_id to use. */
if (clock_getres (clocks[i].id, &r) < 0)
continue; /* clock_getres doesn't work for this clock */
posix_clock_id = clocks[i].id;
- posix_millisec_resolution = r.tv_sec * 1000.0 + r.tv_nsec / 1000000.0;
- /* Guard against broken clock_getres returning nonsensical
- values. */
- if (posix_millisec_resolution == 0)
- posix_millisec_resolution = 1;
+ posix_clock_resolution = (double) r.tv_sec + r.tv_nsec / 1e9;
+ /* Guard against nonsense returned by a broken clock_getres. */
+ if (posix_clock_resolution == 0)
+ posix_clock_resolution = 1e-3;
break;
}
if (i == countof (clocks))
strerror (errno));
/* Use CLOCK_REALTIME, but invent a plausible resolution. */
posix_clock_id = CLOCK_REALTIME;
- posix_millisec_resolution = 1;
+ posix_clock_resolution = 1e-3;
}
}
static inline double
posix_diff (ptimer_system_time *pst1, ptimer_system_time *pst2)
{
- return ((pst1->tv_sec - pst2->tv_sec) * 1000.0
- + (pst1->tv_nsec - pst2->tv_nsec) / 1000000.0);
+ return ((pst1->tv_sec - pst2->tv_sec)
+ + (pst1->tv_nsec - pst2->tv_nsec) / 1e9);
}
static inline double
posix_resolution (void)
{
- return posix_millisec_resolution;
+ return posix_clock_resolution;
}
#endif /* PTIMER_POSIX */
static inline double
gettimeofday_diff (ptimer_system_time *pst1, ptimer_system_time *pst2)
{
- return ((pst1->tv_sec - pst2->tv_sec) * 1000.0
- + (pst1->tv_usec - pst2->tv_usec) / 1000.0);
+ return ((pst1->tv_sec - pst2->tv_sec)
+ + (pst1->tv_usec - pst2->tv_usec) / 1e6);
}
static inline double
static bool windows_hires_timers;
/* Frequency of high-resolution timers -- number of updates per
- millisecond. Calculated the first time ptimer_new is called
- provided that high-resolution timers are available. */
-static double windows_hires_msfreq;
+ second. Calculated the first time ptimer_new is called provided
+ that high-resolution timers are available. */
+static double windows_hires_freq;
static void
windows_init (void)
if (freq.QuadPart != 0)
{
windows_hires_timers = true;
- windows_hires_msfreq = (double) freq.QuadPart / 1000.0;
+ windows_hires_freq = (double) freq.QuadPart;
}
}
windows_diff (ptimer_system_time *pst1, ptimer_system_time *pst2)
{
if (windows_hires_timers)
- return (pst1->hires.QuadPart - pst2->hires.QuadPart) / windows_hires_msfreq;
+ return (pst1->hires.QuadPart - pst2->hires.QuadPart) / windows_hires_freq;
else
return pst1->lores - pst2->lores;
}
windows_resolution (void)
{
if (windows_hires_timers)
- return 1.0 / windows_hires_msfreq;
+ return 1.0 / windows_hires_freq;
else
return 10; /* according to MSDN */
}
time, yields elapsed time. */
ptimer_system_time start;
- /* The most recent elapsed time, calculated by ptimer_measure().
- Measured in milliseconds. */
+ /* The most recent elapsed time, calculated by ptimer_measure(). */
double elapsed_last;
/* Approximately, the time elapsed between the true start of the
}
/* Reset timer PT. This establishes the starting point from which
- ptimer_read() will return the number of elapsed milliseconds.
- It is allowed to reset a previously used timer. */
+ ptimer_measure() will return the elapsed time in seconds. It is
+ allowed to reset a previously used timer. */
void
ptimer_reset (struct ptimer *pt)
pt->elapsed_pre_start = 0;
}
-/* Measure the elapsed time since timer creation/reset and return it
- to the caller. The value remains stored for further reads by
- ptimer_read.
-
- This function causes the timer to call gettimeofday (or time(),
- etc.) to update its idea of current time. To get the elapsed
- interval in milliseconds, use ptimer_read.
+/* Measure the elapsed time since timer creation/reset. This causes
+ the timer to internally call clock_gettime (or gettimeofday, etc.)
+ to update its idea of current time. The time is returned, but is
+ also stored for later access through ptimer_read().
This function handles clock skew, i.e. time that moves backwards is
ignored. */
return elapsed;
}
-/* Return the elapsed time in milliseconds between the last call to
- ptimer_reset and the last call to ptimer_update. */
+/* Return the most recent elapsed time measured with ptimer_measure.
+ If ptimer_measure has not yet been called since the timer was
+ created or reset, this returns 0. */
double
ptimer_read (const struct ptimer *pt)
}
/* Return the assessed resolution of the timer implementation, in
- milliseconds. This is used by code that tries to substitute a
- better value for timers that have returned zero. */
+ seconds. This is used by code that tries to substitute a better
+ value for timers that have returned zero. */
double
ptimer_resolution (void)
projects / wget / blobdiff