Use a monotonic clock to compute timeouts

Python/pytime.c

 #include "Python.h"
 #ifdef MS_WINDOWS
 #include <windows.h>
 #endif
 
 #if defined(__APPLE__)
 #include <mach/mach_time.h>   /* mach_absolute_time(), mach_timebase_info() */
 #endif
 
 #ifdef MS_WINDOWS
@@ skipping 108 matching lines @@
 {
     return pygettimeofday(tp, info, 1);
 }
 
 static int
 pymonotonic(_PyTime_timeval *tp, _Py_clock_info_t *info, int raise)
 {
 #if defined(MS_WINDOWS)
     static ULONGLONG (*GetTickCount64) (void) = NULL;
     static ULONGLONG (CALLBACK *Py_GetTickCount64)(void);
-    static int has_getickcount64 = -1;

[AntoinePitrou, 2014/08/31 02:24:18]

You should fix the typo in the variable name.

[haypo, 2014/08/31 15:02:33]

Oh, I just moved the code from timemodule.c. But ok, I fixed the typo.

+    static int has_gettickcount64 = -1;
     ULONGLONG result;
 
     assert(info == NULL || raise);
 
-    if (has_getickcount64 == -1) {
+    if (has_gettickcount64 == -1) {
         /* GetTickCount64() was added to Windows Vista */
-        if (winver.dwMajorVersion >= 6) {
+        has_gettickcount64 = (winver.dwMajorVersion >= 6);
+        if (has_gettickcount64) {
             HINSTANCE hKernel32;
             hKernel32 = GetModuleHandleW(L"KERNEL32");
             *(FARPROC*)&Py_GetTickCount64 = GetProcAddress(hKernel32,
                                                            "GetTickCount64");
-            has_getickcount64 = (Py_GetTickCount64 != NULL);

[AntoinePitrou, 2014/08/31 02:24:18]

Is it expected to fail?

[haypo, 2014/08/31 15:02:33]

MSDN documentation says that GetTickCount64() is available since Windows Vista
(6.0) and Windows Server 2008 (6.0).

So GetTickCount64() must be present in this case.

I replaced the test with an assertion.

-        }
-        else
-            has_getickcount64 = 0;
-    }
-
-    if (has_getickcount64) {
+            assert(Py_GetTickCount64 != NULL);
+        }
+    }
+
+    if (has_gettickcount64) {
         result = Py_GetTickCount64();
     }
     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 = (ULONGLONG)n_overflow << 32;
         result += ticks;
     }
 
     tp->tv_sec = result / 1000;
     tp->tv_usec = (result % 1000) * 1000;
 
     if (info) {
         DWORD timeAdjustment, timeIncrement;
         BOOL isTimeAdjustmentDisabled, ok;
-        if (has_getickcount64)
+        if (has_gettickcount64)
             info->implementation = "GetTickCount64()";
         else
             info->implementation = "GetTickCount()";
         info->monotonic = 1;
         ok = GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement,
                                      &isTimeAdjustmentDisabled);
         if (!ok) {
             PyErr_SetFromWindowsErr(0);
             return -1;
         }
@@ skipping 42 matching lines @@
 
     assert(info == NULL || raise);
 
     if (clock_gettime(clk_id, &ts) != 0) {
         if (raise) {
             PyErr_SetFromErrno(PyExc_OSError);
             return -1;
         }
         tp->tv_sec = 0;
         tp->tv_usec = 0;
         return -1;

[AntoinePitrou, 2014/08/31 02:24:18]

The doc in pytime.h says that "the function never fails".

[haypo, 2014/08/31 15:02:33]

_PyTime_monotonic() never fails, _PyTime_monotonic_info() can fail. That's why
_PyTime_monotonic() contains an assertion and its return type is "void".

My expectation is that clock_gettime(CLOCK_MONOTONIC) always work or always
fail. See clock_gettime() documentation: it returns EINVAL if CLOCK_MONOTONIC is
not supported on the system. I don't see why the behaviour would change between
two cals.

     }
 
     if (info) {
         struct timespec res;
         info->monotonic = 1;
         info->implementation = implementation;
         info->adjustable = 0;
         if (clock_getres(clk_id, &res) != 0) {
             PyErr_SetFromErrno(PyExc_OSError);
             return -1;
         }
         info->resolution = res.tv_sec + res.tv_nsec * 1e-9;
     }
     tp->tv_sec = ts.tv_sec;
     tp->tv_usec = ts.tv_nsec / 1000;
     return 0;
 #endif
 }
 
 void
 _PyTime_monotonic(_PyTime_timeval *tp)
 {
     if (pymonotonic(tp, NULL, 0) < 0) {
-        /* cannot happen, _PyTime_Init() checks that pygettimeofday() works */

[AntoinePitrou, 2014/08/31 02:24:18]

s/pygettimeofday/pymonotonic/

+        /* cannot happen, _PyTime_Init() checks that pymonotonic() works */
         assert(0);
         tp->tv_sec = 0;
         tp->tv_usec = 0;
     }
 }
 
 int
 _PyTime_monotonic_info(_PyTime_timeval *tp, _Py_clock_info_t *info)
 {
     return pymonotonic(tp, info, 1);
@@ skipping 146 matching lines @@
 
     /* ensure that the system clock works */
     if (_PyTime_gettimeofday_info(&tv, NULL) < 0)
         return -1;
 
     /* ensure that the operating system provides a monotonic clock */
     if (_PyTime_monotonic_info(&tv, NULL) < 0)
         return -1;
     return 0;
 }