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,45 @@ 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)
+
+    @unittest.skipIf(support.MS_WINDOWS, 'test only for non-Windows platforms')
+    def test_sleep_zero_posix(self):
+        # Test that time.sleep(0) does not accumulate delays.
+
+        N1 = 1000  # small number of samples for time.sleep(eps) with eps > 0
+        N2 = 100_000  # large number of samples for time.sleep(0)
+
+        # Compute how long time.sleep() takes for the 'time' clock resolution.
+        eps = time.get_clock_info('time').resolution
+        max_dt_ns = self.stat_for_test_sleep(N1, time.sleep, eps)
+
+        # We expect a gap between time.sleep(0) and time.sleep(eps).
+        avg_dt_ns = self.stat_for_test_sleep(N2, time.sleep, 0)
+        self.assertLess(avg_dt_ns, max_dt_ns)
+
+    @staticmethod
+    def stat_for_test_sleep(n_samples, func, *args, **kwargs):
+        """Compute the average (ns) time execution of func(*args, **kwargs)."""
+        samples = []
+        for _ in range(int(n_samples)):
+            t0 = time.monotonic_ns()
+            func(*args, **kwargs)
+            t1 = time.monotonic_ns()
+            samples.append(t1 - t0)
+        return math.fsum(samples) / n_samples
 
     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,9 @@ module time
 
 /* Forward declarations */
 static int pysleep(PyTime_t timeout);
+#ifndef MS_WINDOWS
+static int pysleep_zero_posix(void);  // see gh-125997
+#endif
 
 
 typedef struct {
@@ -2213,6 +2216,12 @@ static int
 pysleep(PyTime_t timeout)
 {
     assert(timeout >= 0);
+    assert(!PyErr_Occurred());
+#ifndef MS_WINDOWS
+    if (timeout == 0) { // gh-125997
+        return pysleep_zero_posix();
+    }
+#endif
 
 #ifndef MS_WINDOWS
 #ifdef HAVE_CLOCK_NANOSLEEP
@@ -2390,3 +2399,60 @@ pysleep(PyTime_t timeout)
     return -1;
 #endif
 }
+
+
+#ifndef MS_WINDOWS
+// 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_posix(void)
+{
+    assert(!PyErr_Occurred());
+
+    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;
+    }
+    return 0;
+}
+#endif