gh-125997: ensure that time.sleep(0) is not delayed on non-Windows platforms

Doc/whatsnew/3.14.rst

@@ -617,6 +617,15 @@ sys.monitoring
 Two new events are added: :monitoring-event:`BRANCH_LEFT` and
 :monitoring-event:`BRANCH_RIGHT`. The ``BRANCH`` event is deprecated.
 
+
+time
+----
+
+* Ensure that :func:`time.sleep(0) <time.sleep>` does not degrade over time
+  on non-Windows platforms.
+  (Contributed by Bénédikt Tran in :gh:`125997`.)
+
+
 tkinter
 -------
 

Lib/test/test_time.py

@@ -158,10 +158,19 @@ def test_conversions(self):
         self.assertEqual(int(time.mktime(time.localtime(self.t))),
                          int(self.t))
 
-    def test_sleep(self):
+    def test_sleep_exceptions(self):
+        self.assertRaises(TypeError, time.sleep, [])
+        self.assertRaises(TypeError, time.sleep, "a")
+        self.assertRaises(TypeError, time.sleep, complex(0, 0))
+
         self.assertRaises(ValueError, time.sleep, -2)
         self.assertRaises(ValueError, time.sleep, -1)
-        time.sleep(1.2)
+        self.assertRaises(ValueError, time.sleep, -0.1)
+
+    def test_sleep(self):
+        for value in [-0.0, 0, 0.0, 1e-6, 1, 1.2]:
+            with self.subTest(value=value):
+                time.sleep(value)
 
     def test_epoch(self):
         # bpo-43869: Make sure that Python use the same Epoch on all platforms:

Misc/NEWS.d/next/Library/2024-12-26-13-09-25.gh-issue-125997.Vsibep.rst

@@ -0,0 +1,2 @@
+Ensure that :func:`time.sleep(0) <time.sleep>` does not degrade over time
+on non-Windows platforms. Patch by Bénédikt Tran.

Modules/timemodule.c

@@ -72,6 +72,7 @@ module time
 
 /* Forward declarations */
 static int pysleep(PyTime_t timeout);
+static int pysleep_zero(void);  // see gh-125997
 
 
 typedef struct {
@@ -2213,6 +2214,19 @@ static int
 pysleep(PyTime_t timeout)
 {
     assert(timeout >= 0);
+    assert(!PyErr_Occurred());
+#ifndef MS_WINDOWS
+    if (timeout == 0) { // gh-125997
+        return pysleep_zero();
+    }
+#else
+    PyTime_t timeout_100ns = _PyTime_As100Nanoseconds(timeout,
+                                                      _PyTime_ROUND_CEILING);
+    // Maintain Windows Sleep() semantics for time.sleep(0)
+    if (timeout_100ns == 0) {
+        return pysleep_zero();
+    }
+#endif
 
 #ifndef MS_WINDOWS
 #ifdef HAVE_CLOCK_NANOSLEEP
@@ -2291,21 +2305,6 @@ pysleep(PyTime_t timeout)
 
     return 0;
 #else  // MS_WINDOWS
-    PyTime_t timeout_100ns = _PyTime_As100Nanoseconds(timeout,
-                                                       _PyTime_ROUND_CEILING);
-
-    // Maintain Windows Sleep() semantics for time.sleep(0)
-    if (timeout_100ns == 0) {
-        Py_BEGIN_ALLOW_THREADS
-        // A value of zero causes the thread to relinquish the remainder of its
-        // time slice to any other thread that is ready to run. If there are no
-        // other threads ready to run, the function returns immediately, and
-        // the thread continues execution.
-        Sleep(0);
-        Py_END_ALLOW_THREADS
-        return 0;
-    }
-
     LARGE_INTEGER relative_timeout;
     // No need to check for integer overflow, both types are signed
     assert(sizeof(relative_timeout) == sizeof(timeout_100ns));
@@ -2390,3 +2389,67 @@ pysleep(PyTime_t timeout)
     return -1;
 #endif
 }
+
+
+// time.sleep(0) optimized implementation.
+// On error, raise an exception and return -1.
+// On success, return 0.
+//
+// Rationale
+// ---------
+// time.sleep(0) accumulates delays in the generic implementation, but we can
+// skip some calls to `PyTime_Monotonic()` and other checks when the timeout
+// is zero. For details, see https://github.com/python/cpython/pull/128274.
+static int
+pysleep_zero(void)
+{
+    assert(!PyErr_Occurred());
+#ifndef MS_WINDOWS
+    int ret, err;
+    Py_BEGIN_ALLOW_THREADS
+#ifdef HAVE_CLOCK_NANOSLEEP
+    struct timespec zero = {0, 0};
+    ret = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &zero, NULL);
+    err = ret;
+#elif defined(HAVE_NANOSLEEP)
+    struct timespec zero = {0, 0};
+    ret = nanosleep(&zero, NULL);
+    err = errno;
+#else
+    // POSIX-compliant select(2) allows the 'timeout' parameter to
+    // be modified but also mandates that the function should return
+    // immediately if *both* structure's fields are zero (which is
+    // the case here).
+    //
+    // However, since System V (but not BSD) variant typically sets
+    // the timeout before returning (but does not specify whether
+    // this is also the case for zero timeouts), we prefer supplying
+    // a fresh timeout everytime.
+    struct timeval zero = {0, 0};
+    ret = select(0, NULL, NULL, NULL, &zero);
+    err = errno;
+#endif
+    Py_END_ALLOW_THREADS
+    if (ret == 0) {
+        return 0;
+    }
+    if (err != EINTR) {
+        errno = err;
+        PyErr_SetFromErrno(PyExc_OSError);
+        return -1;
+    }
+    /* sleep was interrupted by SIGINT */
+    if (PyErr_CheckSignals()) {
+        return -1;
+    }
+#else
+    Py_BEGIN_ALLOW_THREADS
+    // A value of zero causes the thread to relinquish the remainder of its
+    // time slice to any other thread that is ready to run. If there are no
+    // other threads ready to run, the function returns immediately, and
+    // the thread continues execution.
+    Sleep(0);
+    Py_END_ALLOW_THREADS
+#endif
+    return 0;
+}