bpo-21302: Add Waitable timer implementation for time.sleep() in Windows

Include/cpython/pytime.h

@@ -114,6 +114,11 @@ PyAPI_FUNC(_PyTime_t) _PyTime_AsMicroseconds(_PyTime_t t,
 /* Convert timestamp to a number of nanoseconds (10^-9 seconds). */
 PyAPI_FUNC(_PyTime_t) _PyTime_AsNanoseconds(_PyTime_t t);
 
+/* Convert timestamp to a number of 100 nanoseconds (10^-7 seconds).
+   Can be used for Waitable timer object in Windows. */
+PyAPI_FUNC(_PyTime_t) _PyTime_As100Nanoseconds(_PyTime_t t,
+    _PyTime_round_t round);
+
 /* Convert timestamp to a number of nanoseconds (10^-9 seconds) as a Python int
    object. */
 PyAPI_FUNC(PyObject *) _PyTime_AsNanosecondsObject(_PyTime_t t);

Misc/NEWS.d/next/Library/2021-09-15-23-49-21.bpo-21302.KTsR8i.rst

@@ -0,0 +1 @@
+In Windows operating system, :func:`time.sleep` now uses the ``waitable timer`` object, which allows to sleep for an interval absolute time. Desired sleep time can be set in 100 nsecs resolution.

Modules/timemodule.c

@@ -2044,41 +2044,42 @@ PyInit_time(void)
     return PyModuleDef_Init(&timemodule);
 }
 
+#ifdef MS_WINDOWS
+enum event_indexes {
+    EVENT_TIMER,
+    EVENT_INTERRUPT,
+    EVENT_SIZE
+};
+#endif
+
 /* Implement pysleep() for various platforms.
    When interrupted (or when another error occurs), return -1 and
    set an exception; else return 0. */
 
 static int
 pysleep(_PyTime_t secs)
 {
-    _PyTime_t deadline, monotonic;
+    int ret = -1;
 #ifndef MS_WINDOWS
 #ifdef HAVE_CLOCK_NANOSLEEP
     struct timespec timeout_abs;
 #else
     struct timeval timeout;
 #endif
+    _PyTime_t deadline, monotonic;
     int err = 0;
-    int ret = 0;
-#else
-    _PyTime_t millisecs;
-    unsigned long ul_millis;
-    DWORD rc;
-    HANDLE hInterruptEvent;
-#endif
 
     if (get_monotonic(&monotonic) < 0) {
         return -1;
     }
     deadline = monotonic + secs;
-#if defined(HAVE_CLOCK_NANOSLEEP) && !defined(MS_WINDOWS)
+#ifdef HAVE_CLOCK_NANOSLEEP
     if (_PyTime_AsTimespec(deadline, &timeout_abs) < 0) {
         return -1;
     }
 #endif
 
     do {
-#ifndef MS_WINDOWS
 #ifndef HAVE_CLOCK_NANOSLEEP
         if (_PyTime_AsTimeval(secs, &timeout, _PyTime_ROUND_CEILING) < 0) {
             return -1;
@@ -2106,12 +2107,56 @@ pysleep(_PyTime_t secs)
             PyErr_SetFromErrno(PyExc_OSError);
             return -1;
         }
+
+        /* sleep was interrupted by SIGINT */
+        if (PyErr_CheckSignals()) {
+            return -1;
+        }
+
+#ifndef HAVE_CLOCK_NANOSLEEP
+        if (get_monotonic(&monotonic) < 0) {
+            return -1;
+        }
+        secs = deadline - monotonic;
+        if (secs < 0) {
+            ret = 0;
+            break;
+        }
+        /* retry with the recomputed delay */
+#endif
+    } while (1);
 #else
+    _PyTime_t millisecs;
+    DWORD ul_millis;
+    DWORD rc;
+    FILETIME FileTime;
+    LARGE_INTEGER deadline;
+    /* hTimer, hInterruptEvent */
+    HANDLE hEvents[EVENT_SIZE] = {NULL, NULL};
+
+    GetSystemTimePreciseAsFileTime(&FileTime);
+    CopyMemory(&deadline, &FileTime, sizeof(FILETIME));
+
+    /* convert to 100 nsec unit and add */
+    deadline.QuadPart += _PyTime_As100Nanoseconds(secs, _PyTime_ROUND_CEILING);
+
+    hEvents[EVENT_TIMER] = CreateWaitableTimerW(NULL, FALSE, NULL);
+    if (NULL == hEvents[EVENT_TIMER]) {
+        return -1;
+    }
+
+    if (!SetWaitableTimer(hEvents[EVENT_TIMER], &deadline, 0, NULL, NULL, FALSE)) {
+        ret = -1;
+        goto exit;
+    }
+
+    do {
         millisecs = _PyTime_AsMilliseconds(secs, _PyTime_ROUND_CEILING);
-        if (millisecs > (double)ULONG_MAX) {
+        if (millisecs > ((_PyTime_t)ULONG_MAX)) {
             PyErr_SetString(PyExc_OverflowError,
-                            "sleep length is too large");
-            return -1;
+                "sleep length is too large");
+            ret = -1;
+            break;
         }
 
         /* Allow sleep(0) to maintain win32 semantics, and as decreed
@@ -2122,36 +2167,50 @@ pysleep(_PyTime_t secs)
             Py_BEGIN_ALLOW_THREADS
             Sleep(ul_millis);
             Py_END_ALLOW_THREADS
+            ret = 0;
             break;
         }
 
-        hInterruptEvent = _PyOS_SigintEvent();
-        ResetEvent(hInterruptEvent);
+        hEvents[EVENT_INTERRUPT] = _PyOS_SigintEvent();
+        ResetEvent(hEvents[EVENT_INTERRUPT]);
 
         Py_BEGIN_ALLOW_THREADS
-        rc = WaitForSingleObjectEx(hInterruptEvent, ul_millis, FALSE);
+        rc = WaitForMultipleObjectsEx(EVENT_SIZE, hEvents, FALSE, INFINITE, FALSE);
         Py_END_ALLOW_THREADS
 
-        if (rc != WAIT_OBJECT_0)
+        /* Something went wrong */
+        if (rc == WAIT_FAILED) {
+            ret = -1;
             break;
-#endif
-
-        /* sleep was interrupted by SIGINT */
-        if (PyErr_CheckSignals()) {
-            return -1;
         }
 
-#ifndef HAVE_CLOCK_NANOSLEEP
-        if (get_monotonic(&monotonic) < 0) {
-            return -1;
+        /* Timer signaled: we are done */
+        if (rc == (WAIT_OBJECT_0 + EVENT_TIMER)) {
+            ret = 0;
+            break;
         }
-        secs = deadline - monotonic;
-        if (secs < 0) {
+
+        /* Does it make sense to check? */
+        //if (rc != (WAIT_OBJECT_0 + EVENT_INTERRUPT)) {
+        //    ret = 0;
+        //    break;
+        //}
+
+        /* sleep was interrupted by SIGINT */
+        if (PyErr_CheckSignals()) {
+            ret = -1;
             break;
         }
-        /* retry with the recomputed delay */
-#endif
+
+        /* The SIGINT signal handler was called and did not raise a Python exception.
+         * Restart sleeping. The timer deadline doesn't need to be recomputed:
+         * SetWaitableTimer() uses absolute time.
+         */
     } while (1);
 
-    return 0;
+exit:
+    CloseHandle(hEvents[EVENT_TIMER]);
+#endif
+
+    return ret;
 }

Python/pytime.c

@@ -33,6 +33,7 @@
 /* Conversion from nanoseconds */
 #define NS_TO_MS (1000 * 1000)
 #define NS_TO_US (1000)
+#define NS_TO_100NS (100)
 
 
 static void
@@ -568,6 +569,14 @@ _PyTime_AsNanoseconds(_PyTime_t t)
 }
 
 
+_PyTime_t
+_PyTime_As100Nanoseconds(_PyTime_t t, _PyTime_round_t round)
+{
+    _PyTime_t ns = pytime_as_nanoseconds(t);
+    return pytime_divide(ns, NS_TO_100NS, round);
+}
+
+
 _PyTime_t
 _PyTime_AsMicroseconds(_PyTime_t t, _PyTime_round_t round)
 {