cp -rf py3.8/examples . cp -rf py3.8/doc . cp -f py3.8/index.html . cp -rf py3.8/_multiprocess _multiprocess cp -rf py3.8/multiprocess multiprocess cp -rf py3.8/Modules Modules cp Python-3.9.2/Lib/test/mp_*py multiprocess/tests cp Python-3.9.2/Lib/test/_test_multiprocessing.py multiprocess/tests/__init__.py # ---------------------------------------------------------------------- diff Python-3.8.1/Modules/_multiprocessing/multiprocessing.h Python-3.9.0a2/Modules/_multiprocessing/multiprocessing.h 30,37d29 < # define HANDLE int < # define SOCKET int < # define BOOL int < # define UINT32 uint32_t < # define INT32 int32_t < # define TRUE 1 < # define FALSE 0 < # define INVALID_HANDLE_VALUE (-1) 75,76d66 < # define F_DWORD "k" < # define T_DWORD T_ULONG # ---------------------------------------------------------------------- diff Python-3.8.1/Lib/multiprocessing/managers.py Python-3.9.0a2/Lib/multiprocessing/managers.py 251c251 < except KeyError as second_ke: --- > except KeyError: 299c299 < except Exception as e: --- > except Exception: 363c363 < def create(*args, **kwds): --- > def create(self, c, typeid, /, *args, **kwds): 367,392d366 < if len(args) >= 3: < self, c, typeid, *args = args < elif not args: < raise TypeError("descriptor 'create' of 'Server' object " < "needs an argument") < else: < if 'typeid' not in kwds: < raise TypeError('create expected at least 2 positional ' < 'arguments, got %d' % (len(args)-1)) < typeid = kwds.pop('typeid') < if len(args) >= 2: < self, c, *args = args < import warnings < warnings.warn("Passing 'typeid' as keyword argument is deprecated", < DeprecationWarning, stacklevel=2) < else: < if 'c' not in kwds: < raise TypeError('create expected at least 2 positional ' < 'arguments, got %d' % (len(args)-1)) < c = kwds.pop('c') < self, *args = args < import warnings < warnings.warn("Passing 'c' as keyword argument is deprecated", < DeprecationWarning, stacklevel=2) < args = tuple(args) < 424d397 < create.__text_signature__ = '($self, c, typeid, /, *args, **kwds)' 1296c1269 < def create(*args, **kwargs): --- > def create(self, c, typeid, /, *args, **kwargs): 1302,1311d1274 < if len(args) >= 3: < typeod = args[2] < elif 'typeid' in kwargs: < typeid = kwargs['typeid'] < elif not args: < raise TypeError("descriptor 'create' of 'SharedMemoryServer' " < "object needs an argument") < else: < raise TypeError('create expected at least 2 positional ' < 'arguments, got %d' % (len(args)-1)) 1314,1315c1277 < return Server.create(*args, **kwargs) < create.__text_signature__ = '($self, c, typeid, /, *args, **kwargs)' --- > return Server.create(self, c, typeid, *args, **kwargs) diff Python-3.8.1/Lib/multiprocessing/popen_fork.py Python-3.9.0a2/Lib/multiprocessing/popen_fork.py 28c28 < except OSError as e: --- > except OSError: diff Python-3.8.1/Lib/multiprocessing/util.py Python-3.9.0a2/Lib/multiprocessing/util.py 432c432 < False, False, None) --- > False, False, None, None, None, -1, None) # ---------------------------------------------------------------------- diff Python-3.9.0a2/Modules/_multiprocessing/posixshmem.c Python-3.9.0b1/Modules/_multiprocessing/posixshmem.c 8d7 < #include "structmember.h" diff Python-3.9.0a2/Modules/_multiprocessing/semaphore.c Python-3.9.0b1/Modules/_multiprocessing/semaphore.c 271d270 < double timeout; 274,275d272 < struct timeval now; < long sec, nsec; 288,290c285,288 < if (timeout_obj != Py_None) { < timeout = PyFloat_AsDouble(timeout_obj); < if (PyErr_Occurred()) --- > int use_deadline = (timeout_obj != Py_None); > if (use_deadline) { > double timeout = PyFloat_AsDouble(timeout_obj); > if (PyErr_Occurred()) { 292c290,291 < if (timeout < 0.0) --- > } > if (timeout < 0.0) { 293a293 > } 294a295 > struct timeval now; 299,300c300,301 < sec = (long) timeout; < nsec = (long) (1e9 * (timeout - sec) + 0.5); --- > long sec = (long) timeout; > long nsec = (long) (1e9 * (timeout - sec) + 0.5); 318c319 < if (timeout_obj == Py_None) { --- > if (!use_deadline) { diff Python-3.9.0a2/Lib/multiprocessing/connection.py Python-3.9.0b1/Lib/multiprocessing/connection.py 75a76,80 > # Prefer abstract sockets if possible to avoid problems with the address > # size. When coding portable applications, some implementations have > # sun_path as short as 92 bytes in the sockaddr_un struct. > if util.abstract_sockets_supported: > return f"\0listener-{os.getpid()}-{next(_mmap_counter)}" 105c110 < elif type(address) is str: --- > elif type(address) is str or util.is_abstract_socket_namespace(address): 600c605,606 < if family == 'AF_UNIX': --- > if family == 'AF_UNIX' and not util.is_abstract_socket_namespace(address): > # Linux abstract socket namespaces do not need to be explicitly unlinked diff Python-3.9.0a2/Lib/multiprocessing/forkserver.py Python-3.9.0b1/Lib/multiprocessing/forkserver.py 58c58,59 < os.unlink(self._forkserver_address) --- > if not util.is_abstract_socket_namespace(self._forkserver_address): > os.unlink(self._forkserver_address) 138c139,140 < os.chmod(address, 0o600) --- > if not util.is_abstract_socket_namespace(address): > os.chmod(address, 0o600) 238,245c240,241 < if os.WIFSIGNALED(sts): < returncode = -os.WTERMSIG(sts) < else: < if not os.WIFEXITED(sts): < raise AssertionError( < "Child {0:n} status is {1:n}".format( < pid,sts)) < returncode = os.WEXITSTATUS(sts) --- > returncode = os.waitstatus_to_exitcode(sts) > diff Python-3.9.0a2/Lib/multiprocessing/managers.py Python-3.9.0b1/Lib/multiprocessing/managers.py 23a24 > import types 62c63 < Type to uniquely indentify a shared object --- > Type to uniquely identify a shared object 797c798 < Try to call a method of the referrent and return a copy of the result --- > Try to call a method of the referent and return a copy of the result 1131a1133,1134 > __class_getitem__ = classmethod(types.GenericAlias) > 1264a1268,1271 > address = self.address > # The address of Linux abstract namespaces can be bytes > if isinstance(address, bytes): > address = os.fsdecode(address) 1266c1273 < _SharedMemoryTracker(f"shmm_{self.address}_{getpid()}") --- > _SharedMemoryTracker(f"shm_{address}_{getpid()}") diff Python-3.9.0a2/Lib/multiprocessing/pool.py Python-3.9.0b1/Lib/multiprocessing/pool.py 22a23 > import types 24d24 < from queue import Empty 654,655d653 < self._worker_handler._state = TERMINATE < self._change_notifier.put(None) 684a683,685 > # Notify that the worker_handler state has been changed so the > # _handle_workers loop can be unblocked (and exited) in order to > # send the finalization sentinel all the workers. 685a687,688 > change_notifier.put(None) > 779a783,784 > __class_getitem__ = classmethod(types.GenericAlias) > diff Python-3.9.0a2/Lib/multiprocessing/popen_fork.py Python-3.9.0b1/Lib/multiprocessing/popen_fork.py 33,37c33 < if os.WIFSIGNALED(sts): < self.returncode = -os.WTERMSIG(sts) < else: < assert os.WIFEXITED(sts), "Status is {:n}".format(sts) < self.returncode = os.WEXITSTATUS(sts) --- > self.returncode = os.waitstatus_to_exitcode(sts) diff Python-3.9.0a2/Lib/multiprocessing/process.py Python-3.9.0b1/Lib/multiprocessing/process.py 320,323c320,323 < if not e.args: < exitcode = 1 < elif isinstance(e.args[0], int): < exitcode = e.args[0] --- > if e.code is None: > exitcode = 0 > elif isinstance(e.code, int): > exitcode = e.code 325c325 < sys.stderr.write(str(e.args[0]) + '\n') --- > sys.stderr.write(str(e.code) + '\n') diff Python-3.9.0a2/Lib/multiprocessing/queues.py Python-3.9.0b1/Lib/multiprocessing/queues.py 16a17 > import types 51,52c52 < < self._after_fork() --- > self._reset() 65c65 < self._after_fork() --- > self._reset() 69c69,75 < self._notempty = threading.Condition(threading.Lock()) --- > self._reset(after_fork=True) > > def _reset(self, after_fork=False): > if after_fork: > self._notempty._at_fork_reinit() > else: > self._notempty = threading.Condition(threading.Lock()) 342a349,352 > def close(self): > self._reader.close() > self._writer.close() > 368a379,380 > > __class_getitem__ = classmethod(types.GenericAlias) diff Python-3.9.0a2/Lib/multiprocessing/resource_sharer.py Python-3.9.0b1/Lib/multiprocessing/resource_sharer.py 66d65 < self._old_locks = [] 116,119c115 < # If self._lock was locked at the time of the fork, it may be broken < # -- see issue 6721. Replace it without letting it be gc'ed. < self._old_locks.append(self._lock) < self._lock = threading.Lock() --- > self._lock._at_fork_reinit() diff Python-3.9.0a2/Lib/multiprocessing/shared_memory.py Python-3.9.0b1/Lib/multiprocessing/shared_memory.py 16a17 > import types 253a255,263 > # The shared memory area is organized as follows: > # - 8 bytes: number of items (N) as a 64-bit integer > # - (N + 1) * 8 bytes: offsets of each element from the start of the > # data area > # - K bytes: the data area storing item values (with encoding and size > # depending on their respective types) > # - N * 8 bytes: `struct` format string for each element > # - N bytes: index into _back_transforms_mapping for each element > # (for reconstructing the corresponding Python value) 285c295,296 < if sequence is not None: --- > if name is None or sequence is not None: > sequence = sequence or () 296,299c307,314 < self._allocated_bytes = tuple( < self._alignment if fmt[-1] != "s" else int(fmt[:-1]) < for fmt in _formats < ) --- > offset = 0 > # The offsets of each list element into the shared memory's > # data area (0 meaning the start of the data area, not the start > # of the shared memory area). > self._allocated_offsets = [0] > for fmt in _formats: > offset += self._alignment if fmt[-1] != "s" else int(fmt[:-1]) > self._allocated_offsets.append(offset) 309a325 > self.shm = SharedMemory(name, create=True, size=requested_size) 311,313d326 < requested_size = 8 # Some platforms require > 0. < < if name is not None and sequence is None: 315,316d327 < else: < self.shm = SharedMemory(name, create=True, size=requested_size) 325c336 < *(self._allocated_bytes) --- > *(self._allocated_offsets) 348,351c359,364 < self._allocated_bytes = struct.unpack_from( < self._format_size_metainfo, < self.shm.buf, < 1 * 8 --- > self._allocated_offsets = list( > struct.unpack_from( > self._format_size_metainfo, > self.shm.buf, > 1 * 8 > ) 373d385 < position = position if position >= 0 else position + self._list_len 390d401 < position = position if position >= 0 else position + self._list_len 409a421 > position = position if position >= 0 else position + self._list_len 411,412c423 < offset = self._offset_data_start \ < + sum(self._allocated_bytes[:position]) --- > offset = self._offset_data_start + self._allocated_offsets[position] 426a438 > position = position if position >= 0 else position + self._list_len 428,429c440,441 < offset = self._offset_data_start \ < + sum(self._allocated_bytes[:position]) --- > item_offset = self._allocated_offsets[position] > offset = self._offset_data_start + item_offset 435a448 > encoded_value = value 437,438c450,455 < if len(value) > self._allocated_bytes[position]: < raise ValueError("exceeds available storage for existing str") --- > allocated_length = self._allocated_offsets[position + 1] - item_offset > > encoded_value = (value.encode(_encoding) > if isinstance(value, str) else value) > if len(encoded_value) > allocated_length: > raise ValueError("bytes/str item exceeds available storage") 443c460 < self._allocated_bytes[position], --- > allocated_length, 451,452c468 < value = value.encode(_encoding) if isinstance(value, str) else value < struct.pack_into(new_format, self.shm.buf, offset, value) --- > struct.pack_into(new_format, self.shm.buf, offset, encoded_value) 465c481 < "The struct packing format used by all currently stored values." --- > "The struct packing format used by all currently stored items." 472,473c488,489 < "The struct packing format used for metainfo on storage sizes." < return f"{self._list_len}q" --- > "The struct packing format used for the items' storage offsets." > return "q" * (self._list_len + 1) 477c493 < "The struct packing format used for the values' packing formats." --- > "The struct packing format used for the items' packing formats." 482c498 < "The struct packing format used for the values' back transforms." --- > "The struct packing format used for the items' back transforms." 487c503,505 < return (self._list_len + 1) * 8 # 8 bytes per "q" --- > # - 8 bytes for the list length > # - (N + 1) * 8 bytes for the element offsets > return (self._list_len + 2) * 8 491c509 < return self._offset_data_start + sum(self._allocated_bytes) --- > return self._offset_data_start + self._allocated_offsets[-1] 510a529,530 > > __class_getitem__ = classmethod(types.GenericAlias) diff Python-3.9.0a2/Lib/multiprocessing/spawn.py Python-3.9.0b1/Lib/multiprocessing/spawn.py 39c39 < _python_exe = sys._base_executable --- > _python_exe = sys.executable diff Python-3.9.0a2/Lib/multiprocessing/util.py Python-3.9.0b1/Lib/multiprocessing/util.py 104a105,127 > > # Abstract socket support > > def _platform_supports_abstract_sockets(): > if sys.platform == "linux": > return True > if hasattr(sys, 'getandroidapilevel'): > return True > return False > > > def is_abstract_socket_namespace(address): > if not address: > return False > if isinstance(address, bytes): > return address[0] == 0 > elif isinstance(address, str): > return address[0] == "\0" > raise TypeError('address type of {address!r} unrecognized') > > > abstract_sockets_supported = _platform_supports_abstract_sockets() > 347,350d369 < self._reset() < register_after_fork(self, ForkAwareThreadLock._reset) < < def _reset(self): 353a373,376 > register_after_fork(self, ForkAwareThreadLock._at_fork_reinit) > > def _at_fork_reinit(self): > self._lock._at_fork_reinit() # ---------------------------------------------------------------------- diff Python-3.9.0b1/Lib/multiprocessing/context.py Python-3.9.0/Lib/multiprocessing/context.py 259a260 > methods = ['spawn', 'fork'] if sys.platform == 'darwin' else ['fork', 'spawn'] 261,263c262,264 < return ['fork', 'spawn', 'forkserver'] < else: < return ['fork', 'spawn'] --- > methods.append('forkserver') > return methods > Common subdirectories: Python-3.9.0b1/Lib/multiprocessing/dummy and Python-3.9.0/Lib/multiprocessing/dummy diff Python-3.9.0b1/Lib/multiprocessing/shared_memory.py Python-3.9.0/Lib/multiprocessing/shared_memory.py 78a79,80 > if size == 0: > raise ValueError("'size' must be a positive number different from zero") diff Python-3.9.0b1/Lib/multiprocessing/synchronize.py Python-3.9.0/Lib/multiprocessing/synchronize.py 273c273 < False), ('notify: Should not have been able to acquire' --- > False), ('notify: Should not have been able to acquire ' # ---------------------------------------------------------------------- diff Python-3.9.2/Lib/test/_test_multiprocessing.py multiprocess/tests/__init__.py 23c23 < import pickle --- > import pickle #XXX: use dill? 36c36 < support.skip_if_broken_multiprocessing_synchronize() --- > test.support.import_module('multiprocess.synchronize') 39,44c39,45 < import multiprocessing.connection < import multiprocessing.dummy < import multiprocessing.heap < import multiprocessing.managers < import multiprocessing.pool < import multiprocessing.queues --- > import multiprocess as multiprocessing > import multiprocess.connection > import multiprocess.dummy > import multiprocess.heap > import multiprocess.managers > import multiprocess.pool > import multiprocess.queues 46c47 < from multiprocessing import util --- > from multiprocess import util 49c50 < from multiprocessing import reduction --- > from multiprocess import reduction 55c56 < from multiprocessing.sharedctypes import Value, copy --- > from multiprocess.sharedctypes import Value, copy 61c62 < from multiprocessing import shared_memory --- > from multiprocess import shared_memory 89c90 < from multiprocessing import resource_tracker --- > from multiprocess import resource_tracker 117c118 < from multiprocessing.connection import wait --- > from multiprocess.connection import wait 130c131 < PRELOAD = ['__main__', 'test.test_multiprocessing_forkserver'] --- > PRELOAD = ['__main__', 'test_multiprocessing_forkserver'] 169c170 < t = time.monotonic() --- > t = getattr(time,'monotonic',time.time)() 173c174 < self.elapsed = time.monotonic() - t --- > self.elapsed = getattr(time,'monotonic',time.time)() - t 285c286 < from multiprocessing.process import parent_process --- > from multiprocess.process import parent_process 288c289 < def test_parent_process(self): --- > def _test_parent_process(self): 321c322 < from multiprocessing.process import parent_process --- > from multiprocess.process import parent_process 488a490 > @unittest.skipIf(True, "fails with is_dill(obj, child=True)") 740c742 < from multiprocessing.forkserver import _forkserver --- > from multiprocess.forkserver import _forkserver 829c831 < self.assertIn("test_multiprocessing.py", err) --- > self.assertIn("__init__.py", err) 1119c1121 < import multiprocessing --- > import multiprocess as multiprocessing 1137c1139 < start = time.monotonic() --- > start = getattr(time,'monotonic',time.time)() 1139c1141 < delta = time.monotonic() - start --- > delta = getattr(time,'monotonic',time.time)() - start 1541c1543 < dt = time.monotonic() --- > dt = getattr(time,'monotonic',time.time)() 1543c1545 < dt = time.monotonic() - dt --- > dt = getattr(time,'monotonic',time.time)() - dt 2012c2014 < self.skipTest("requires multiprocessing.sharedctypes") --- > self.skipTest("requires multiprocess.sharedctypes") 2578a2581 > @unittest.skipIf(True, "fails with is_dill(obj, child=True)") 2620a2624 > @unittest.skipIf(True, "fails with is_dill(obj, child=True)") 2634c2638 < t_start = time.monotonic() --- > t_start = getattr(time,'monotonic',time.time)() 2646c2650 < self.assertGreater(time.monotonic() - t_start, 0.9) --- > self.assertGreater(getattr(time,'monotonic',time.time)() - t_start, 0.9) 2718,2719c2722,2723 < def test_unpickleable_result(self): < from multiprocessing.pool import MaybeEncodingError --- > def _test_unpickleable_result(self): > from multiprocess.pool import MaybeEncodingError 2807c2811 < from multiprocessing.managers import BaseManager, BaseProxy, RemoteError --- > from multiprocess.managers import BaseManager, BaseProxy, RemoteError 3450c3454 < from multiprocessing import resource_sharer --- > from multiprocess import resource_sharer 3695c3699 < self.skipTest("requires multiprocessing.sharedctypes") --- > self.skipTest("requires multiprocess.sharedctypes") 3745c3749 < @unittest.skipUnless(HAS_SHMEM, "requires multiprocessing.shared_memory") --- > @unittest.skipUnless(HAS_SHMEM, "requires multiprocess.shared_memory") 4123c4127 < deadline = time.monotonic() + support.LONG_TIMEOUT --- > deadline = getattr(time,'monotonic',time.time)() + support.LONG_TIMEOUT 4125c4129 < while time.monotonic() < deadline: --- > while getattr(time,'monotonic',time.time)() < deadline: 4277,4279c4281,4283 < modules = ['multiprocessing.' + m for m in modules] < modules.remove('multiprocessing.__init__') < modules.append('multiprocessing') --- > modules = ['multiprocess.' + m for m in modules] > modules.remove('multiprocess.__init__') > modules.append('multiprocess') 4285,4287c4289,4291 < modules.remove('multiprocessing.popen_fork') < modules.remove('multiprocessing.popen_forkserver') < modules.remove('multiprocessing.popen_spawn_posix') --- > modules.remove('multiprocess.popen_fork') > modules.remove('multiprocess.popen_forkserver') > modules.remove('multiprocess.popen_spawn_posix') 4289c4293 < modules.remove('multiprocessing.popen_spawn_win32') --- > modules.remove('multiprocess.popen_spawn_win32') 4291c4295 < modules.remove('multiprocessing.popen_forkserver') --- > modules.remove('multiprocess.popen_forkserver') 4295c4299 < modules.remove('multiprocessing.sharedctypes') --- > modules.remove('multiprocess.sharedctypes') 4577c4581 < from multiprocessing.connection import wait --- > from multiprocess.connection import wait 4617c4621 < from multiprocessing.connection import wait --- > from multiprocess.connection import wait 4658c4662 < from multiprocessing.connection import wait --- > from multiprocess.connection import wait 4663c4667 < start = time.monotonic() --- > start = getattr(time,'monotonic',time.time)() 4665c4669 < delta = time.monotonic() - start --- > delta = getattr(time,'monotonic',time.time)() - start 4673c4677 < start = time.monotonic() --- > start = getattr(time,'monotonic',time.time)() 4675c4679 < delta = time.monotonic() - start --- > delta = getattr(time,'monotonic',time.time)() - start 4686c4690 < from multiprocessing.connection import wait --- > from multiprocess.connection import wait 4699c4703 < start = time.monotonic() --- > start = getattr(time,'monotonic',time.time)() 4701c4705 < delta = time.monotonic() - start --- > delta = getattr(time,'monotonic',time.time)() - start 4709c4713 < start = time.monotonic() --- > start = getattr(time,'monotonic',time.time)() 4711c4715 < delta = time.monotonic() - start --- > delta = getattr(time,'monotonic',time.time)() - start 4718c4722 < start = time.monotonic() --- > start = getattr(time,'monotonic',time.time)() 4720c4724 < delta = time.monotonic() - start --- > delta = getattr(time,'monotonic',time.time)() - start 4729c4733 < from multiprocessing.connection import wait --- > from multiprocess.connection import wait 4731c4735 < t = time.monotonic() --- > t = getattr(time,'monotonic',time.time)() 4733c4737 < t = time.monotonic() - t --- > t = getattr(time,'monotonic',time.time)() - t 4777c4781 < def test_flags(self): --- > def _test_flags(self): 4780c4784 < prog = ('from test._test_multiprocessing import TestFlags; ' + --- > prog = ('from multiprocess.tests import TestFlags; ' + 5082c5086 < def test_resource_tracker(self): --- > def _test_resource_tracker(self): 5088,5090c5092,5094 < import multiprocessing as mp < from multiprocessing import resource_tracker < from multiprocessing.shared_memory import SharedMemory --- > import multiprocess as mp > from multiprocess import resource_tracker > from multiprocess.shared_memory import SharedMemory 5134,5135c5138,5139 < deadline = time.monotonic() + support.LONG_TIMEOUT < while time.monotonic() < deadline: --- > deadline = getattr(time,'monotonic',time.time)() + support.LONG_TIMEOUT > while getattr(time,'monotonic',time.time)() < deadline: 5159c5163 < from multiprocessing.resource_tracker import _resource_tracker --- > from multiprocess.resource_tracker import _resource_tracker 5207c5211 < from multiprocessing.resource_tracker import _resource_tracker --- > from multiprocess.resource_tracker import _resource_tracker 5216c5220 < from multiprocessing.resource_tracker import _resource_tracker --- > from multiprocess.resource_tracker import _resource_tracker 5375c5379 < start_time = time.monotonic() --- > start_time = getattr(time,'monotonic',time.time)() 5380c5384 < dt = time.monotonic() - start_time --- > dt = getattr(time,'monotonic',time.time)() - start_time 5383c5387 < support.print_warning(f"multiprocessing.Manager still has " --- > support.print_warning(f"multiprocess.Manager still has " 5651c5655 < start_time = time.monotonic() --- > start_time = getattr(time,'monotonic',time.time)() 5656c5660 < dt = time.monotonic() - start_time --- > dt = getattr(time,'monotonic',time.time)() - start_time 5659c5663 < support.print_warning(f"multiprocessing.Manager still has " --- > support.print_warning(f"multiprocess.Manager still has " # ---------------------------------------------------------------------- diff Python-3.9.4/Lib/test/_test_multiprocessing.py Python-3.9.7/Lib/test/_test_multiprocessing.py 609a610 > gc.collect() # For PyPy or other GCs. 2284a2286,2295 > def test_nested_queue(self): > a = self.list() # Test queue inside list > a.append(self.Queue()) > a[0].put(123) > self.assertEqual(a[0].get(), 123) > b = self.dict() # Test queue inside dict > b[0] = self.Queue() > b[0].put(456) > self.assertEqual(b[0].get(), 456) > 2655a2667 > gc.collect() # For PyPy or other GCs. 4157a4170 > gc.collect() # For PyPy or other GCs. 4168a4182 > gc.collect() # For PyPy or other GCs. 4174a4189 > gc.collect() # For PyPy or other GCs. # ---------------------------------------------------------------------- diff Python-3.9.4/Lib/multiprocessing/managers.py Python-3.9.7/Lib/multiprocessing/managers.py 11,12c11 < __all__ = [ 'BaseManager', 'SyncManager', 'BaseProxy', 'Token', < 'SharedMemoryManager' ] --- > __all__ = [ 'BaseManager', 'SyncManager', 'BaseProxy', 'Token' ] 38d36 < HAS_SHMEM = True 40a39,41 > else: > HAS_SHMEM = True > __all__.append('SharedMemoryManager') 962c963 < exposed=None, incref=True): --- > exposed=None, incref=True, manager_owned=False): 982c983 < incref=incref) --- > incref=incref, manager_owned=manager_owned) # ---------------------------------------------------------------------- dude@borel>$ diff Python-3.9.7/Lib/test/_test_multiprocessing.py Python-3.9.9/Lib/test/_test_multiprocessing.py 3771a3772,3778 > def _new_shm_name(self, prefix): > # Add a PID to the name of a POSIX shared memory object to allow > # running multiprocessing tests (test_multiprocessing_fork, > # test_multiprocessing_spawn, etc) in parallel. > return prefix + str(os.getpid()) > > @unittest.skipIf(sys.platform == "win32", "test is broken on Windows") > @unittest.skipIf(True, "fails with is_dill(obj, child=True)") 3773c3780,3781 < sms = shared_memory.SharedMemory('test01_tsmb', create=True, size=512) --- > name_tsmb = self._new_shm_name('test01_tsmb') > sms = shared_memory.SharedMemory(name_tsmb, create=True, size=512) 3777c3785 < self.assertEqual(sms.name, 'test01_tsmb') --- > self.assertEqual(sms.name, name_tsmb) 3786c3794 < also_sms = shared_memory.SharedMemory('test01_tsmb') --- > also_sms = shared_memory.SharedMemory(name_tsmb) 3791c3799 < same_sms = shared_memory.SharedMemory('test01_tsmb', size=20*sms.size) --- > same_sms = shared_memory.SharedMemory(name_tsmb, size=20*sms.size) 3809c3817 < names = ['test01_fn', 'test02_fn'] --- > names = [self._new_shm_name('test01_fn'), self._new_shm_name('test02_fn')] 3830a3839,3844 > name_dblunlink = self._new_shm_name('test01_dblunlink') > sms_uno = shared_memory.SharedMemory( > name_dblunlink, > create=True, > size=5000 > ) 3832,3837d3845 < sms_uno = shared_memory.SharedMemory( < 'test01_dblunlink', < create=True, < size=5000 < ) < 3841c3849 < sms_duo = shared_memory.SharedMemory('test01_dblunlink') --- > sms_duo = shared_memory.SharedMemory(name_dblunlink) 3853c3861 < 'test01_tsmb', --- > name_tsmb, 3867c3875 < ok_if_exists_sms = OptionalAttachSharedMemory('test01_tsmb') --- > ok_if_exists_sms = OptionalAttachSharedMemory(name_tsmb) 4055c4063,4064 < sl_copy = shared_memory.ShareableList(sl, name='test03_duplicate') --- > name_duplicate = self._new_shm_name('test03_duplicate') > sl_copy = shared_memory.ShareableList(sl, name=name_duplicate) 4058c4067 < self.assertEqual('test03_duplicate', sl_copy.shm.name) --- > self.assertEqual(name_duplicate, sl_copy.shm.name) 4148a4158,4164 > # Without this line it was raising warnings like: > # UserWarning: resource_tracker: > # There appear to be 1 leaked shared_memory > # objects to clean up at shutdown > # See: https://bugs.python.org/issue45209 > resource_tracker.unregister(f"/{name}", "shared_memory") > # ---------------------------------------------------------------------- $ diff Python-3.9.10/Lib/test/_test_multiprocessing.py Python-3.9.12/Lib/test/_test_multiprocessing.py 71a72,77 > if support.check_sanitizer(address=True): > # bpo-45200: Skip multiprocessing tests if Python is built with ASAN to > # work around a libasan race condition: dead lock in pthread_create(). > raise unittest.SkipTest("libasan has a pthread_create() dead lock") > > # ---------------------------------------------------------------------- diff Python-3.9.12/Lib/multiprocessing/managers.py Python-3.9.13/Lib/multiprocessing/managers.py 672c672 < process.join(timeout=0.1) --- > process.join(timeout=1.0) diff Python-3.9.12/Lib/multiprocessing/queues.py Python-3.9.13/Lib/multiprocessing/queues.py 142,148c142,145 < try: < self._reader.close() < finally: < close = self._close < if close: < self._close = None < close() --- > close = self._close > if close: > self._close = None > close() 172,173c169,171 < self._wlock, self._writer.close, self._ignore_epipe, < self._on_queue_feeder_error, self._sem), --- > self._wlock, self._reader.close, self._writer.close, > self._ignore_epipe, self._on_queue_feeder_error, > self._sem), 214,215c212,213 < def _feed(buffer, notempty, send_bytes, writelock, close, ignore_epipe, < onerror, queue_sem): --- > def _feed(buffer, notempty, send_bytes, writelock, reader_close, > writer_close, ignore_epipe, onerror, queue_sem): 241c239,240 < close() --- > reader_close() > writer_close() diff Python-3.9.12/Lib/multiprocessing/util.py Python-3.9.13/Lib/multiprocessing/util.py 123c123 < raise TypeError('address type of {address!r} unrecognized') --- > raise TypeError(f'address type of {address!r} unrecognized') # ---------------------------------------------------------------------- diff Python-3.9.13/Lib/multiprocessing/connection.py Python-3.9.16/Lib/multiprocessing/connection.py 76,80d75 < # Prefer abstract sockets if possible to avoid problems with the address < # size. When coding portable applications, some implementations have < # sun_path as short as 92 bytes in the sockaddr_un struct. < if util.abstract_sockets_supported: < return f"\0listener-{os.getpid()}-{next(_mmap_counter)}"