Runaway CPU investigation for python3.13: busy poll at __vdso_clock_gettime

Patch covered by related upstream fix

This diff is preserved for inspection, but a related issue family is already covered by an independent upstream fix. Use the retained patch as evidence only; do not claim it as a Fixer win.

python3.13 likely remains stuck in a busy poll loop. A diagnosis report and patch proposal were created locally.

subprocess: reduce wakeups in timed POSIX `Popen._wait` loop

diff --git a/Lib/subprocess.py b/Lib/subprocess.py
index 3a8c743..25ddcb2 100644
--- a/Lib/subprocess.py
+++ b/Lib/subprocess.py
@@ -2057,21 +2057,20 @@ class Popen:
 
             if timeout is not None:
                 endtime = _time() + timeout
-                # Enter a busy loop if we have a timeout.  This busy loop was
-                # cribbed from Lib/threading.py in Thread.wait() at r71065.
-                delay = 0.0005 # 500 us -> initial delay of 1 ms
-                while True:
+                # Enter a timed polling loop if we have a timeout.
+                # This follows Thread.wait()'s bounded backoff strategy.
+                delay = 0.001
+                while self.returncode is None:
                     if self._waitpid_lock.acquire(False):
                         try:
-                            if self.returncode is not None:
-                                break  # Another thread waited.
                             (pid, sts) = self._try_wait(os.WNOHANG)
                             assert pid == self.pid or pid == 0
                             if pid == self.pid:
                                 self._handle_exitstatus(sts)
-                                break
                         finally:
                             self._waitpid_lock.release()
+                    if self.returncode is not None:
+                        break
                     remaining = self._remaining_time(endtime)
                     if remaining <= 0:
                         raise TimeoutExpired(self.args, timeout)
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index a9f0ce2..3d54ba6 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -1427,6 +1427,32 @@ class ProcessTestCase(BaseTestCase):
         self.assertIn("0.0001", str(c.exception))  # For coverage of __str__.
         self.assertEqual(p.wait(timeout=support.SHORT_TIMEOUT), 0)
 
+    @unittest.skipIf(mswindows, "POSIX-only waitpid backoff behavior")
+    def test_wait_timeout_backoff(self):
+        proc = subprocess.Popen.__new__(subprocess.Popen)
+        proc.args = ("fake",)
+        proc.pid = 99999
+        proc.returncode = None
+        proc._waitpid_lock = threading.Lock()
+        proc._try_wait = mock.Mock(side_effect=[
+            (0, 0),
+            (0, 0),
+            (proc.pid, 0),
+        ])
+        proc._handle_exitstatus = mock.Mock(side_effect=lambda status: setattr(
+            proc, "returncode", 0))
+        sleep_deltas = []
+
+        with mock.patch("subprocess.time.sleep", side_effect=sleep_deltas.append):
+            proc._wait(1.0)
+
+        self.assertEqual(proc.returncode, 0)
+        self.assertEqual(proc._try_wait.call_count, 3)
+        self.assertEqual(len(sleep_deltas), 2)
+        self.assertLessEqual(sleep_deltas[0], sleep_deltas[1])
+        self.assertEqual(sleep_deltas[0], 0.001)
+        self.assertEqual(sleep_deltas[1], 0.002)
+
     def test_invalid_bufsize(self):
         # an invalid type of the bufsize argument should raise
         # TypeError.