# HG changeset patch # Parent b32baa5b7626aed2fe722553584fe5b7c02f3f34 Make multiprocessing treat negative timeouts as it did in 3.2 In Python 3.2 and earlier, Process.join() and Connection.poll() treated negative timeouts as zero timeouts. Earlier versions from the 3.3 line of development treat them as infinite timeouts. The patch reverts to the old behaviour. diff -r b32baa5b7626 Doc/library/multiprocessing.rst --- a/Doc/library/multiprocessing.rst Tue May 08 03:54:05 2012 -0700 +++ b/Doc/library/multiprocessing.rst Tue May 08 15:57:12 2012 +0100 @@ -928,6 +928,12 @@ .. note:: + The :meth:`acquire` and :meth:`wait` methods of each of these types + treat negative timeouts as zero timeouts. This differs from + :mod:`threading` where, since version 3.2, the equivalent + :meth:`acquire` methods treat negative timeouts as infinite + timeouts. + On Mac OS X, ``sem_timedwait`` is unsupported, so calling ``acquire()`` with a timeout will emulate that function's behavior using a sleeping loop. @@ -1899,6 +1905,7 @@ those objects in *object_list* which are ready. If *timeout* is a float then the call blocks for at most that many seconds. If *timeout* is ``None`` then it will block for an unlimited period. + A negative timeout is equivalent to a zero timeout. For both Unix and Windows, an object can appear in *object_list* if it is diff -r b32baa5b7626 Lib/multiprocessing/connection.py --- a/Lib/multiprocessing/connection.py Tue May 08 03:54:05 2012 -0700 +++ b/Lib/multiprocessing/connection.py Tue May 08 15:57:12 2012 +0100 @@ -23,8 +23,7 @@ import _multiprocessing from multiprocessing import current_process, AuthenticationError, BufferTooShort -from multiprocessing.util import ( - get_temp_dir, Finalize, sub_debug, debug, _eintr_retry) +from multiprocessing.util import get_temp_dir, Finalize, sub_debug, debug from multiprocessing.forking import ForkingPickler try: import _winapi @@ -323,8 +322,6 @@ if (self._got_empty_message or _winapi.PeekNamedPipe(self._handle)[0] != 0): return True - if timeout < 0: - timeout = None return bool(wait([self], timeout)) def _get_more_data(self, ov, maxsize): @@ -402,8 +399,6 @@ return self._recv(size) def _poll(self, timeout): - if timeout < 0.0: - timeout = None r = wait([self._handle], timeout) return bool(r) diff -r b32baa5b7626 Lib/multiprocessing/forking.py --- a/Lib/multiprocessing/forking.py Tue May 08 03:54:05 2012 -0700 +++ b/Lib/multiprocessing/forking.py Tue May 08 15:57:12 2012 +0100 @@ -75,12 +75,9 @@ # if sys.platform != 'win32': - import select - exit = os._exit duplicate = os.dup close = os.close - _select = util._eintr_retry(select.select) # # We define a Popen class similar to the one from subprocess, but @@ -130,10 +127,10 @@ def wait(self, timeout=None): if self.returncode is None: if timeout is not None: - r = _select([self.sentinel], [], [], timeout)[0] - if not r: + from .connection import wait + if not wait([self.sentinel], timeout): return None - # This shouldn't block if select() returned successfully. + # This shouldn't block if wait() returned successfully. return self.poll(os.WNOHANG if timeout == 0.0 else 0) return self.returncode diff -r b32baa5b7626 Lib/multiprocessing/util.py --- a/Lib/multiprocessing/util.py Tue May 08 03:54:05 2012 -0700 +++ b/Lib/multiprocessing/util.py Tue May 08 15:57:12 2012 +0100 @@ -295,18 +295,3 @@ register_after_fork(self, lambda obj : obj.__dict__.clear()) def __reduce__(self): return type(self), () - - -# -# Automatic retry after EINTR -# - -def _eintr_retry(func): - @functools.wraps(func) - def wrapped(*args, **kwargs): - while True: - try: - return func(*args, **kwargs) - except InterruptedError: - continue - return wrapped diff -r b32baa5b7626 Lib/test/test_multiprocessing.py --- a/Lib/test/test_multiprocessing.py Tue May 08 03:54:05 2012 -0700 +++ b/Lib/test/test_multiprocessing.py Tue May 08 15:57:12 2012 +0100 @@ -83,23 +83,13 @@ 'HAVE_BROKEN_SEM_GETVALUE', False) WIN32 = (sys.platform == "win32") -if WIN32: - from _winapi import WaitForSingleObject, INFINITE, WAIT_OBJECT_0 - - def wait_for_handle(handle, timeout): - if timeout is None or timeout < 0.0: - timeout = INFINITE - else: - timeout = int(1000 * timeout) - return WaitForSingleObject(handle, timeout) == WAIT_OBJECT_0 -else: - from select import select - _select = util._eintr_retry(select) - - def wait_for_handle(handle, timeout): - if timeout is not None and timeout < 0.0: - timeout = None - return handle in _select([handle], [], [], timeout)[0] + +from multiprocessing.connection import wait + +def wait_for_handle(handle, timeout): + if timeout is not None and timeout < 0.0: + timeout = None + return wait([handle], timeout) try: MAXFD = os.sysconf("SC_OPEN_MAX") @@ -291,9 +281,18 @@ self.assertIn(p, self.active_children()) self.assertEqual(p.exitcode, None) + join = TimingWrapper(p.join) + + self.assertEqual(join(0), None) + self.assertTimingAlmostEqual(join.elapsed, 0.0) + self.assertEqual(p.is_alive(), True) + + self.assertEqual(join(-1), None) + self.assertTimingAlmostEqual(join.elapsed, 0.0) + self.assertEqual(p.is_alive(), True) + p.terminate() - join = TimingWrapper(p.join) self.assertEqual(join(), None) self.assertTimingAlmostEqual(join.elapsed, 0.0) @@ -1664,6 +1663,9 @@ self.assertEqual(poll(), False) self.assertTimingAlmostEqual(poll.elapsed, 0) + self.assertEqual(poll(-1), False) + self.assertTimingAlmostEqual(poll.elapsed, 0) + self.assertEqual(poll(TIMEOUT1), False) self.assertTimingAlmostEqual(poll.elapsed, TIMEOUT1) @@ -2785,6 +2787,16 @@ p.terminate() p.join() + def test_neg_timeout(self): + from multiprocessing.connection import wait + a, b = multiprocessing.Pipe() + t = time.time() + res = wait([a], timeout=-1) + t = time.time() - t + self.assertEqual(res, []) + self.assertLess(t, 1) + a.close() + b.close() # # Issue 14151: Test invalid family on invalid environment