Use a monotonic clock to compute timeouts

Modules/timemodule.c

 /* Time module */
 
 #include "Python.h"
 
 #include <ctype.h>
 
 #ifdef HAVE_SYS_TIMES_H
 #include <sys/times.h>
 #endif
 
@@ skipping 19 matching lines @@
 
 #if defined(__BORLANDC__)
 /* These overrides not needed for Win32 */
 #define timezone _timezone
 #define tzname _tzname
 #define daylight _daylight
 #endif /* __BORLANDC__ */
 #endif /* MS_WINDOWS */
 #endif /* !__WATCOMC__ || __QNX__ */
 
-#if defined(__APPLE__)
-#include <mach/mach_time.h>
-#endif
-
 /* Forward declarations */
 static int floatsleep(double);
 static PyObject* floattime(_Py_clock_info_t *info);
 
 #ifdef MS_WINDOWS
 static OSVERSIONINFOEX winver;
 #endif
 
 static PyObject *
 time_time(PyObject *self, PyObject *unused)
@@ skipping 35 matching lines @@
         info->adjustable = 0;
     }
     return PyFloat_FromDouble((double)value / CLOCKS_PER_SEC);
 }
 #endif /* HAVE_CLOCK */
 
 #if defined(MS_WINDOWS) && !defined(__BORLANDC__)
 #define WIN32_PERF_COUNTER
 /* Win32 has better clock replacement; we have our own version, due to Mark
    Hammond and Tim Peters */
-static int
-win_perf_counter(_Py_clock_info_t *info, PyObject **result)
+static PyObject*
+win_perf_counter(_Py_clock_info_t *info)
 {
     static LONGLONG cpu_frequency = 0;
     static LONGLONG ctrStart;
     LARGE_INTEGER now;
     double diff;
 
     if (cpu_frequency == 0) {
         LARGE_INTEGER freq;
         QueryPerformanceCounter(&now);
         ctrStart = now.QuadPart;
         if (!QueryPerformanceFrequency(&freq) || freq.QuadPart == 0) {
-            /* Unlikely to happen - this works on all intel
-               machines at least!  Revert to clock() */
-            *result = NULL;
-            return -1;
+            PyErr_SetFromWindowsErr(0);
+            return NULL;
         }
         cpu_frequency = freq.QuadPart;
     }
     QueryPerformanceCounter(&now);
     diff = (double)(now.QuadPart - ctrStart);
     if (info) {
         info->implementation = "QueryPerformanceCounter()";
         info->resolution = 1.0 / (double)cpu_frequency;
         info->monotonic = 1;
         info->adjustable = 0;
     }
-    *result = PyFloat_FromDouble(diff / (double)cpu_frequency);
-    return 0;
+    return PyFloat_FromDouble(diff / (double)cpu_frequency);
 }
 #endif
 
 #if defined(WIN32_PERF_COUNTER) || defined(HAVE_CLOCK)
 #define PYCLOCK
 static PyObject*
 pyclock(_Py_clock_info_t *info)
 {
 #ifdef WIN32_PERF_COUNTER
-    PyObject *res;
-    if (win_perf_counter(info, &res) == 0)
-        return res;
-#endif
+    return win_perf_counter(info);
+#else
     return floatclock(info);
+#endif
 }
 
 static PyObject *
 time_clock(PyObject *self, PyObject *unused)
 {
     return pyclock(NULL);
 }
 
 PyDoc_STRVAR(clock_doc,
 "clock() -> floating point number\n\
@@ skipping 743 matching lines @@
 os.environ['TZ']. The TZ environment variable should be specified in\n\
 standard Unix timezone format as documented in the tzset man page\n\
 (eg. 'US/Eastern', 'Europe/Amsterdam'). Unknown timezones will silently\n\
 fall back to UTC. If the TZ environment variable is not set, the local\n\
 timezone is set to the systems best guess of wallclock time.\n\
 Changing the TZ environment variable without calling tzset *may* change\n\
 the local timezone used by methods such as localtime, but this behaviour\n\
 should not be relied on.");
 #endif /* HAVE_WORKING_TZSET */
 
-#if defined(MS_WINDOWS) || defined(__APPLE__) \
-    || (defined(HAVE_CLOCK_GETTIME) \
-        && (defined(CLOCK_HIGHRES) || defined(CLOCK_MONOTONIC)))
-#define PYMONOTONIC
-#endif
-
-#ifdef PYMONOTONIC
-static PyObject*
+static PyObject *
 pymonotonic(_Py_clock_info_t *info)
 {
-#if defined(MS_WINDOWS)
-    static ULONGLONG (*GetTickCount64) (void) = NULL;
-    static ULONGLONG (CALLBACK *Py_GetTickCount64)(void);
-    static int has_getickcount64 = -1;
-    double result;
-
-    if (has_getickcount64 == -1) {
-        /* GetTickCount64() was added to Windows Vista */
-        if (winver.dwMajorVersion >= 6) {
-            HINSTANCE hKernel32;
-            hKernel32 = GetModuleHandleW(L"KERNEL32");
-            *(FARPROC*)&Py_GetTickCount64 = GetProcAddress(hKernel32,
-                                                           "GetTickCount64");
-            has_getickcount64 = (Py_GetTickCount64 != NULL);
-        }
-        else
-            has_getickcount64 = 0;
-    }
-
-    if (has_getickcount64) {
-        ULONGLONG ticks;
-        ticks = Py_GetTickCount64();
-        result = (double)ticks * 1e-3;
-    }
-    else {
-        static DWORD last_ticks = 0;
-        static DWORD n_overflow = 0;
-        DWORD ticks;
-
-        ticks = GetTickCount();
-        if (ticks < last_ticks)
-            n_overflow++;
-        last_ticks = ticks;
-
-        result = ldexp(n_overflow, 32);
-        result += ticks;
-        result *= 1e-3;
-    }
-
-    if (info) {
-        DWORD timeAdjustment, timeIncrement;
-        BOOL isTimeAdjustmentDisabled, ok;
-        if (has_getickcount64)
-            info->implementation = "GetTickCount64()";
-        else
-            info->implementation = "GetTickCount()";
-        info->monotonic = 1;
-        ok = GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement,
-                                     &isTimeAdjustmentDisabled);
-        if (!ok) {
-            PyErr_SetFromWindowsErr(0);
-            return NULL;
-        }
-        info->resolution = timeIncrement * 1e-7;
-        info->adjustable = 0;
-    }
-    return PyFloat_FromDouble(result);
-
-#elif defined(__APPLE__)
-    static mach_timebase_info_data_t timebase;
-    uint64_t time;
-    double secs;
-
-    if (timebase.denom == 0) {
-        /* According to the Technical Q&A QA1398, mach_timebase_info() cannot
-           fail: https://developer.apple.com/library/mac/#qa/qa1398/ */
-        (void)mach_timebase_info(&timebase);
-    }
-
-    time = mach_absolute_time();
-    secs = (double)time * timebase.numer / timebase.denom * 1e-9;
-    if (info) {
-        info->implementation = "mach_absolute_time()";
-        info->resolution = (double)timebase.numer / timebase.denom * 1e-9;
-        info->monotonic = 1;
-        info->adjustable = 0;
-    }
-    return PyFloat_FromDouble(secs);
-
-#elif defined(HAVE_CLOCK_GETTIME) && (defined(CLOCK_HIGHRES) || defined(CLOCK_MONOTONIC))
-    struct timespec tp;
-#ifdef CLOCK_HIGHRES
-    const clockid_t clk_id = CLOCK_HIGHRES;
-    const char *function = "clock_gettime(CLOCK_HIGHRES)";
-#else
-    const clockid_t clk_id = CLOCK_MONOTONIC;
-    const char *function = "clock_gettime(CLOCK_MONOTONIC)";
-#endif
-
-    if (clock_gettime(clk_id, &tp) != 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    if (info) {
-        struct timespec res;
-        info->monotonic = 1;
-        info->implementation = function;
-        info->adjustable = 0;
-        if (clock_getres(clk_id, &res) == 0)
-            info->resolution = res.tv_sec + res.tv_nsec * 1e-9;
-        else
-            info->resolution = 1e-9;
-    }
-    return PyFloat_FromDouble(tp.tv_sec + tp.tv_nsec * 1e-9);
-#endif
+    _PyTime_timeval tv;
+    if (_PyTime_monotonic_info(&tv, info) < 0) {
+        assert(info != NULL);
+        return NULL;
+    }
+    return PyFloat_FromDouble((double)tv.tv_sec + tv.tv_usec * 1e-6);
 }
 
 static PyObject *
 time_monotonic(PyObject *self, PyObject *unused)
 {
     return pymonotonic(NULL);
 }
 
 PyDoc_STRVAR(monotonic_doc,
 "monotonic() -> float\n\
 \n\
 Monotonic clock, cannot go backward.");
-#endif   /* PYMONOTONIC */
 
 static PyObject*
 perf_counter(_Py_clock_info_t *info)
 {
-#if defined(WIN32_PERF_COUNTER) || defined(PYMONOTONIC)
-    PyObject *res;
-#endif
-#if defined(WIN32_PERF_COUNTER)
-    static int use_perf_counter = 1;
-#endif
-#ifdef PYMONOTONIC
-    static int use_monotonic = 1;
-#endif
-
 #ifdef WIN32_PERF_COUNTER
-    if (use_perf_counter) {
-        if (win_perf_counter(info, &res) == 0)
-            return res;
-        use_perf_counter = 0;
-    }
-#endif
-
-#ifdef PYMONOTONIC
-    if (use_monotonic) {
-        res = pymonotonic(info);
-        if (res != NULL)
-            return res;
-        use_monotonic = 0;
-        PyErr_Clear();
-    }
-#endif
-
-    return floattime(info);
+    return win_perf_counter(info);
+#else
+    return pymonotonic(info);
+#endif
 }
 
 static PyObject *
 time_perf_counter(PyObject *self, PyObject *unused)
 {
     return perf_counter(NULL);
 }
 
 PyDoc_STRVAR(perf_counter_doc,
 "perf_counter() -> float\n\
@@ skipping 146 matching lines @@
     info.adjustable = 0;
     info.resolution = 1.0;
 #endif
 
     if (strcmp(name, "time") == 0)
         obj = floattime(&info);
 #ifdef PYCLOCK
     else if (strcmp(name, "clock") == 0)
         obj = pyclock(&info);
 #endif
-#ifdef PYMONOTONIC
     else if (strcmp(name, "monotonic") == 0)
         obj = pymonotonic(&info);
-#endif
     else if (strcmp(name, "perf_counter") == 0)
         obj = perf_counter(&info);
     else if (strcmp(name, "process_time") == 0)
         obj = py_process_time(&info);
     else {
         PyErr_SetString(PyExc_ValueError, "unknown clock");
         return NULL;
     }
     if (obj == NULL)
         return NULL;
@@ skipping 171 matching lines @@
 #ifdef HAVE_MKTIME
     {"mktime",          time_mktime, METH_O, mktime_doc},
 #endif
 #ifdef HAVE_STRFTIME
     {"strftime",        time_strftime, METH_VARARGS, strftime_doc},
 #endif
     {"strptime",        time_strptime, METH_VARARGS, strptime_doc},
 #ifdef HAVE_WORKING_TZSET
     {"tzset",           time_tzset, METH_NOARGS, tzset_doc},
 #endif
-#ifdef PYMONOTONIC
     {"monotonic",       time_monotonic, METH_NOARGS, monotonic_doc},
-#endif
     {"process_time",    time_process_time, METH_NOARGS, process_time_doc},
     {"perf_counter",    time_perf_counter, METH_NOARGS, perf_counter_doc},
     {"get_clock_info",  time_get_clock_info, METH_VARARGS, get_clock_info_doc},
     {NULL,              NULL}           /* sentinel */
 };
 
 
 PyDoc_STRVAR(module_doc,
 "This module provides various functions to manipulate time values.\n\
 \n\
@@ skipping 85 matching lines @@
     PyModule_AddIntConstant(m, "_STRUCT_TM_ITEMS", 9);
 #endif
     PyModule_AddObject(m, "struct_time", (PyObject*) &StructTimeType);
     initialized = 1;
     return m;
 }
 
 static PyObject*
 floattime(_Py_clock_info_t *info)
 {
-    _PyTimeSpec ts;
-#ifdef HAVE_CLOCK_GETTIME
-    struct timespec tp;
-    int ret;
-
-    /* _PyTime_gettimeofday() does not use clock_gettime()
-       because it would require to link Python to the rt (real-time)
-       library, at least on Linux */
-    ret = clock_gettime(CLOCK_REALTIME, &tp);
-    if (ret == 0) {
-        if (info) {
-            struct timespec res;
-            info->implementation = "clock_gettime(CLOCK_REALTIME)";
-            info->monotonic = 0;
-            info->adjustable = 1;
-            if (clock_getres(CLOCK_REALTIME, &res) == 0)
-                info->resolution = res.tv_sec + res.tv_nsec * 1e-9;
-            else
-                info->resolution = 1e-9;
-        }
-        return PyFloat_FromDouble(tp.tv_sec + tp.tv_nsec * 1e-9);
-    }
-#endif
-    if (_PyTimeSpec_get_time_info(&ts, info) < 0) {
-        assert(0 && "_PyTimeSpec_get_time_info should never fail");

[Charles-François Natali, 2014/07/31 19:50:26]

This is ugly.

[haypo, 2014/08/01 01:44:20]

Done.

-        return NULL;
-    }
-    return PyFloat_FromDouble((double)ts.tv_sec + ts.tv_nsec * 1e-9);
+    _PyTime_timeval t;
+    if (_PyTime_gettimeofday_info(&t, info) < 0) {
+        assert(info != NULL);
+        return NULL;
+    }
+    return PyFloat_FromDouble((double)t.tv_sec + t.tv_usec * 1e-6);
 }
 
 
 /* Implement floatsleep() for various platforms.
    When interrupted (or when another error occurs), return -1 and
    set an exception; else return 0. */
 
 static int
 floatsleep(double secs)
 {
@@ skipping 61 matching lines @@
     }
 #else
     /* XXX Can't interrupt this sleep */
     Py_BEGIN_ALLOW_THREADS
     sleep((int)secs);
     Py_END_ALLOW_THREADS
 #endif
 
     return 0;
 }