1cp -rf Python-3.6.0/Modules/_multiprocessing Modules/_multiprocessing
2cp -rf Python-3.6.0/Lib/multiprocessing multiprocessing
3cp -rf Python-3.6.0/Lib/test/*test_multiprocessing*.py multiprocess/tests/
4cp -rf py3.5/examples .
5cp -f py3.5/setup.py .
6cp -rf py3.5/doc .
7cp -f py3.5/index.html .
8cp Python-3.6.13/Lib/test/mp_*py multiprocess/tests
9cp Python-3.6.13/Lib/test/_test_multiprocessing.py tests/__init__.py
10
11# ----------------------------------------------------------------------
12diff Modules/_multiprocess/multiprocess.c Python-3.6.0/Modules/_multiprocessing/multiprocessing.c
1310c10
14< #include "multiprocess.h"
15---
16> #include "multiprocessing.h"
17144c144
18< "_multiprocess",
19---
20> "_multiprocessing",
21156c156
22< PyInit__multiprocess(void)
23---
24> PyInit__multiprocessing(void)
25
26diff Modules/_multiprocess/semaphore.c Python-3.6.0/Modules/_multiprocessing/semaphore.c
2710c10
28< #include "multiprocess.h"
29---
30> #include "multiprocessing.h"
31201c201
32< // ifndef HAVE_SEM_TIMEDWAIT
33---
34> #ifndef HAVE_SEM_TIMEDWAIT
35262c262
36< // endif /* !HAVE_SEM_TIMEDWAIT */
37---
38> #endif /* !HAVE_SEM_TIMEDWAIT */
39616c616
40< /* tp_name */ "_multiprocess.SemLock",
41---
42> /* tp_name */ "_multiprocessing.SemLock",
43
44diff multiprocess/__init__.py Python-3.6.0/Lib/multiprocessing/__init__.py
4518,19d17
46< __version__ = '0.70.5.dev0'
47<
48
49diff multiprocess/connection.py Python-3.6.0/Lib/multiprocessing/connection.py
5021,24c21
51< try:
52< import _multiprocess as _multiprocessing
53< except ImportError:
54< import _multiprocessing
55---
56> import _multiprocessing
57
58diff multiprocess/forkserver.py Python-3.6.0/Lib/multiprocessing/forkserver.py
5995c95
60< cmd = ('from multiprocess.forkserver import main; ' +
61---
62> cmd = ('from multiprocessing.forkserver import main; ' +
63
64diff multiprocess/popen_fork.py Python-3.6.0/Lib/multiprocessing/popen_fork.py
6547c47
66< from multiprocess.connection import wait
67---
68> from multiprocessing.connection import wait
69
70diff multiprocess/popen_forkserver.py Python-3.6.0/Lib/multiprocessing/popen_forkserver.py
7160c60
72< from multiprocess.connection import wait
73---
74> from multiprocessing.connection import wait
75
76diff multiprocess/queues.py Python-3.6.0/Lib/multiprocessing/queues.py
7722,25c22
78< try:
79< import _multiprocess as _multiprocessing
80< except ImportError:
81< import _multiprocessing
82---
83> import _multiprocessing
84
85diff multiprocess/reduction.py Python-3.6.0/Lib/multiprocessing/reduction.py
8614,17c14
87< try:
88< import dill as pickle
89< except ImportError:
90< import pickle
91---
92> import pickle
93
94diff multiprocess/semaphore_tracker.py Python-3.6.0/Lib/multiprocessing/semaphore_tracker.py
9519,22c19
96< try:
97< import _multiprocess as _multiprocessing
98< except ImportError:
99< import _multiprocessing
100---
101> import _multiprocessing
10253c50
103< cmd = 'from multiprocess.semaphore_tracker import main;main(%d)'
104---
105> cmd = 'from multiprocessing.semaphore_tracker import main;main(%d)'
106
107diff multiprocess/spawn.py Python-3.6.0/Lib/multiprocessing/spawn.py
10889c86
109< prog = 'from multiprocess.spawn import spawn_main; spawn_main(%s)'
110---
111> prog = 'from multiprocessing.spawn import spawn_main; spawn_main(%s)'
112
113diff multiprocess/synchronize.py Python-3.6.0/Lib/multiprocessing/synchronize.py
11417,20c17
115< try:
116< import _multiprocess as _multiprocessing
117< except ImportError:
118< import _multiprocessing
119---
120> import _multiprocessing
12132,40c29,34
122< from _multiprocess import SemLock, sem_unlink
123< except ImportError:
124< try:
125< from _multiprocessing import SemLock, sem_unlink
126< except (ImportError):
127< raise ImportError("This platform lacks a functioning sem_open" +
128< " implementation, therefore, the required" +
129< " synchronization primitives needed will not" +
130< " function, see issue 3770.")
131---
132> from _multiprocessing import SemLock, sem_unlink
133> except (ImportError):
134> raise ImportError("This platform lacks a functioning sem_open" +
135> " implementation, therefore, the required" +
136> " synchronization primitives needed will not" +
137> " function, see issue 3770.")
138
139diff multiprocess/util.py Python-3.6.0/Lib/multiprocessing/util.py
14038c38
141< LOGGER_NAME = 'multiprocess'
142---
143> LOGGER_NAME = 'multiprocessing'
144
145# ----------------------------------------------------------------------
146REPLACED "from multiprocessing" with "from multiprocess"
147REPLACED "from _multiprocessing" with "from _multiprocess"
148REPLACED "import _multiprocessing" with "import _multiprocess as _multiprocessing"
149REPLACED "multprocessing" with "multiprocess" wherever else relevant...
150# ----------------------------------------------------------------------
151diff Python-3.6.0/Lib/multiprocessing/context.py Python-3.6.6rc1/Lib/multiprocessing/context.py
152199c199
153< def set_start_method(self, method=None):
154---
155> def set_start_method(self, method, force=False):
156Common subdirectories: Python-3.6.0/Lib/multiprocessing/dummy and Python-3.6.6rc1/Lib/multiprocessing/dummy
157diff Python-3.6.0/Lib/multiprocessing/forkserver.py Python-3.6.6rc1/Lib/multiprocessing/forkserver.py
15835a36
159> self._forkserver_pid = None
16092,93c93,103
161< if self._forkserver_alive_fd is not None:
162< return
163---
164> if self._forkserver_pid is not None:
165> # forkserver was launched before, is it still running?
166> pid, status = os.waitpid(self._forkserver_pid, os.WNOHANG)
167> if not pid:
168> # still alive
169> return
170> # dead, launch it again
171> os.close(self._forkserver_alive_fd)
172> self._forkserver_address = None
173> self._forkserver_alive_fd = None
174> self._forkserver_pid = None
175129a140
176> self._forkserver_pid = pid
177152,153c163,171
178< # ignoring SIGCHLD means no need to reap zombie processes
179< handler = signal.signal(signal.SIGCHLD, signal.SIG_IGN)
180---
181> handlers = {
182> # no need to reap zombie processes;
183> signal.SIGCHLD: signal.SIG_IGN,
184> # protect the process from ^C
185> signal.SIGINT: signal.SIG_IGN,
186> }
187> old_handlers = {sig: signal.signal(sig, val)
188> for (sig, val) in handlers.items()}
189>
190178c196
191< _serve_one(s, listener, alive_r, handler)
192---
193> _serve_one(s, listener, alive_r, old_handlers)
194189,190c207,208
195< def _serve_one(s, listener, alive_r, handler):
196< # close unnecessary stuff and reset SIGCHLD handler
197---
198> def _serve_one(s, listener, alive_r, handlers):
199> # close unnecessary stuff and reset signal handlers
200193c211,212
201< signal.signal(signal.SIGCHLD, handler)
202---
203> for sig, val in handlers.items():
204> signal.signal(sig, val)
205diff Python-3.6.0/Lib/multiprocessing/pool.py Python-3.6.6rc1/Lib/multiprocessing/pool.py
206121c121
207< if wrap_exception:
208---
209> if wrap_exception and func is not _helper_reraises_exception:
210130a131,132
211>
212> task = job = result = func = args = kwds = None
213133a136,139
214> def _helper_reraises_exception(ex):
215> 'Pickle-able helper function for use by _guarded_task_generation.'
216> raise ex
217>
218277a284,294
219> def _guarded_task_generation(self, result_job, func, iterable):
220> '''Provides a generator of tasks for imap and imap_unordered with
221> appropriate handling for iterables which throw exceptions during
222> iteration.'''
223> try:
224> i = -1
225> for i, x in enumerate(iterable):
226> yield (result_job, i, func, (x,), {})
227> except Exception as e:
228> yield (result_job, i+1, _helper_reraises_exception, (e,), {})
229>
230286,287c303,307
231< self._taskqueue.put((((result._job, i, func, (x,), {})
232< for i, x in enumerate(iterable)), result._set_length))
233---
234> self._taskqueue.put(
235> (
236> self._guarded_task_generation(result._job, func, iterable),
237> result._set_length
238> ))
239293,294c313,319
240< self._taskqueue.put((((result._job, i, mapstar, (x,), {})
241< for i, x in enumerate(task_batches)), result._set_length))
242---
243> self._taskqueue.put(
244> (
245> self._guarded_task_generation(result._job,
246> mapstar,
247> task_batches),
248> result._set_length
249> ))
250305,306c330,334
251< self._taskqueue.put((((result._job, i, func, (x,), {})
252< for i, x in enumerate(iterable)), result._set_length))
253---
254> self._taskqueue.put(
255> (
256> self._guarded_task_generation(result._job, func, iterable),
257> result._set_length
258> ))
259312,313c340,346
260< self._taskqueue.put((((result._job, i, mapstar, (x,), {})
261< for i, x in enumerate(task_batches)), result._set_length))
262---
263> self._taskqueue.put(
264> (
265> self._guarded_task_generation(result._job,
266> mapstar,
267> task_batches),
268> result._set_length
269> ))
270324c357
271< self._taskqueue.put(([(result._job, None, func, args, kwds)], None))
272---
273> self._taskqueue.put(([(result._job, 0, func, args, kwds)], None))
274355,356c388,395
275< self._taskqueue.put((((result._job, i, mapper, (x,), {})
276< for i, x in enumerate(task_batches)), None))
277---
278> self._taskqueue.put(
279> (
280> self._guarded_task_generation(result._job,
281> mapper,
282> task_batches),
283> None
284> )
285> )
286378d416
287< i = -1
288380c418,419
289< for i, task in enumerate(taskseq):
290---
291> # iterating taskseq cannot fail
292> for task in taskseq:
293387c426
294< job, ind = task[:2]
295---
296> job, idx = task[:2]
297389c428
298< cache[job]._set(ind, (False, e))
299---
300> cache[job]._set(idx, (False, e))
301395c434,435
302< set_length(i+1)
303---
304> idx = task[1] if task else -1
305> set_length(idx + 1)
306398,404c438,439
307< except Exception as ex:
308< job, ind = task[:2] if task else (0, 0)
309< if job in cache:
310< cache[job]._set(ind + 1, (False, ex))
311< if set_length:
312< util.debug('doing set_length()')
313< set_length(i+1)
314---
315> finally:
316> task = taskseq = job = None
317408d442
318<
319447a482
320> task = job = obj = None
321463a499
322> task = job = obj = None
323diff Python-3.6.0/Lib/multiprocessing/popen_fork.py Python-3.6.6rc1/Lib/multiprocessing/popen_fork.py
32417,18c17
325< sys.stdout.flush()
326< sys.stderr.flush()
327---
328> util._flush_std_streams()
329diff Python-3.6.0/Lib/multiprocessing/process.py Python-3.6.6rc1/Lib/multiprocessing/process.py
330106a107,109
331> # Avoid a refcycle if the target function holds an indirect
332> # reference to the process object (see bpo-30775)
333> del self._target, self._args, self._kwargs
334131a135
335>
336134,135c138,144
337< self._popen.poll()
338< return self._popen.returncode is None
339---
340>
341> returncode = self._popen.poll()
342> if returncode is None:
343> return True
344> else:
345> _children.discard(self)
346> return False
347268,269c277
348< sys.stdout.flush()
349< sys.stderr.flush()
350---
351> util._flush_std_streams()
352diff Python-3.6.0/Lib/multiprocessing/queues.py Python-3.6.6rc1/Lib/multiprocessing/queues.py
353104c104
354< if timeout < 0 or not self._poll(timeout):
355---
356> if not self._poll(timeout):
357172,179c172
358< # On process exit we will wait for data to be flushed to pipe.
359< #
360< # However, if this process created the queue then all
361< # processes which use the queue will be descendants of this
362< # process. Therefore waiting for the queue to be flushed
363< # is pointless once all the child processes have been joined.
364< created_by_this_process = (self._opid == os.getpid())
365< if not self._joincancelled and not created_by_this_process:
366---
367> if not self._joincancelled:
368224,225c217,218
369< try:
370< while 1:
371---
372> while 1:
373> try:
374252,259c245,251
375< except Exception as e:
376< if ignore_epipe and getattr(e, 'errno', 0) == errno.EPIPE:
377< return
378< # Since this runs in a daemon thread the resources it uses
379< # may be become unusable while the process is cleaning up.
380< # We ignore errors which happen after the process has
381< # started to cleanup.
382< try:
383---
384> except Exception as e:
385> if ignore_epipe and getattr(e, 'errno', 0) == errno.EPIPE:
386> return
387> # Since this runs in a daemon thread the resources it uses
388> # may be become unusable while the process is cleaning up.
389> # We ignore errors which happen after the process has
390> # started to cleanup.
391261a254
392> return
393265,266d257
394< except Exception:
395< pass
396339a331
397> self._poll = self._reader.poll
398diff Python-3.6.0/Lib/multiprocessing/semaphore_tracker.py Python-3.6.6rc1/Lib/multiprocessing/semaphore_tracker.py
39931a32
400> self._pid = None
40143,44c44,57
402< if self._fd is not None:
403< return
404---
405> if self._pid is not None:
406> # semaphore tracker was launched before, is it still running?
407> pid, status = os.waitpid(self._pid, os.WNOHANG)
408> if not pid:
409> # => still alive
410> return
411> # => dead, launch it again
412> os.close(self._fd)
413> self._fd = None
414> self._pid = None
415>
416> warnings.warn('semaphore_tracker: process died unexpectedly, '
417> 'relaunching. Some semaphores might leak.')
418>
41958c71
420< util.spawnv_passfds(exe, args, fds_to_pass)
421---
422> pid = util.spawnv_passfds(exe, args, fds_to_pass)
42363a77
424> self._pid = pid
425diff Python-3.6.0/Lib/multiprocessing/spawn.py Python-3.6.6rc1/Lib/multiprocessing/spawn.py
426220c220
427< set_start_method(data['start_method'])
428---
429> set_start_method(data['start_method'], force=True)
430diff Python-3.6.0/Lib/multiprocessing/util.py Python-3.6.6rc1/Lib/multiprocessing/util.py
431244c244
432< f = lambda p : p[0][0] is not None
433---
434> f = lambda p : p[0] is not None
435246c246
436< f = lambda p : p[0][0] is not None and p[0][0] >= minpriority
437---
438> f = lambda p : p[0] is not None and p[0] >= minpriority
439248,249c248,249
440< items = [x for x in list(_finalizer_registry.items()) if f(x)]
441< items.sort(reverse=True)
442---
443> # Careful: _finalizer_registry may be mutated while this function
444> # is running (either by a GC run or by another thread).
445251,257c251,265
446< for key, finalizer in items:
447< sub_debug('calling %s', finalizer)
448< try:
449< finalizer()
450< except Exception:
451< import traceback
452< traceback.print_exc()
453---
454> # list(_finalizer_registry) should be atomic, while
455> # list(_finalizer_registry.items()) is not.
456> keys = [key for key in list(_finalizer_registry) if f(key)]
457> keys.sort(reverse=True)
458>
459> for key in keys:
460> finalizer = _finalizer_registry.get(key)
461> # key may have been removed from the registry
462> if finalizer is not None:
463> sub_debug('calling %s', finalizer)
464> try:
465> finalizer()
466> except Exception:
467> import traceback
468> traceback.print_exc()
469383a392,405
470> # Flush standard streams, if any
471> #
472>
473> def _flush_std_streams():
474> try:
475> sys.stdout.flush()
476> except (AttributeError, ValueError):
477> pass
478> try:
479> sys.stderr.flush()
480> except (AttributeError, ValueError):
481> pass
482>
483> #
484389c411
485< passfds = sorted(passfds)
486---
487> passfds = tuple(sorted(map(int, passfds)))
488# ----------------------------------------------------------------------
489diff Python-3.6.6rc1/Modules/_multiprocessing/semaphore.c Python-3.6.8/Modules/_multiprocessing/semaphore.c
490442,443c442,444
491< if (name_copy == NULL)
492< goto failure;
493---
494> if (name_copy == NULL) {
495> return PyErr_NoMemory();
496> }
497466c467,469
498< _PyMp_SetError(NULL, MP_STANDARD_ERROR);
499---
500> if (!PyErr_Occurred()) {
501> _PyMp_SetError(NULL, MP_STANDARD_ERROR);
502> }
503diff Python-3.6.6rc1/Lib/multiprocessing/connection.py Python-3.6.8/Lib/multiprocessing/connection.py
50460c60
505< return time.time() + timeout
506---
507> return time.monotonic() + timeout
50863c63
509< return time.time() > t
510---
511> return time.monotonic() > t
512908c908
513< deadline = time.time() + timeout
514---
515> deadline = time.monotonic() + timeout
516916c916
517< timeout = deadline - time.time()
518---
519> timeout = deadline - time.monotonic()
520Common subdirectories: Python-3.6.6rc1/Lib/multiprocessing/dummy and Python-3.6.8/Lib/multiprocessing/dummy
521diff Python-3.6.6rc1/Lib/multiprocessing/managers.py Python-3.6.8/Lib/multiprocessing/managers.py
52220a21
523> import time
52422d22
525< from time import time as _time
5261009c1009
527< endtime = _time() + timeout
528---
529> endtime = time.monotonic() + timeout
5301015c1015
531< waittime = endtime - _time()
532---
533> waittime = endtime - time.monotonic()
5341098c1098
535< '__contains__', '__delitem__', '__getitem__', '__len__',
536---
537> '__contains__', '__delitem__', '__getitem__', '__iter__', '__len__',
5381101a1102,1104
539> DictProxy._method_to_typeid_ = {
540> '__iter__': 'Iterator',
541> }
542diff Python-3.6.6rc1/Lib/multiprocessing/queues.py Python-3.6.8/Lib/multiprocessing/queues.py
54398c98
544< deadline = time.time() + timeout
545---
546> deadline = time.monotonic() + timeout
547103c103
548< timeout = deadline - time.time()
549---
550> timeout = deadline - time.monotonic()
551diff Python-3.6.6rc1/Lib/multiprocessing/reduction.py Python-3.6.8/Lib/multiprocessing/reduction.py
552153c153
553< msg, ancdata, flags, addr = sock.recvmsg(1, socket.CMSG_LEN(bytes_size))
554---
555> msg, ancdata, flags, addr = sock.recvmsg(1, socket.CMSG_SPACE(bytes_size))
556diff Python-3.6.6rc1/Lib/multiprocessing/synchronize.py Python-3.6.8/Lib/multiprocessing/synchronize.py
55718,19c18
558<
559< from time import time as _time
560---
561> import time
562316c315
563< endtime = _time() + timeout
564---
565> endtime = time.monotonic() + timeout
566322c321
567< waittime = endtime - _time()
568---
569> waittime = endtime - time.monotonic()
570diff Python-3.6.6rc1/Lib/test/test_multiprocessing_fork.py Python-3.6.8/Lib/test/test_multiprocessing_fork.py
5713a4
572> import sys
5738a10,14
574> if sys.platform == "win32":
575> raise unittest.SkipTest("fork is not available on Windows")
576>
577> if sys.platform == 'darwin':
578> raise unittest.SkipTest("test may crash on macOS (bpo-33725)")
579diff Python-3.6.6rc1/Lib/test/test_multiprocessing_forkserver.py Python-3.6.8/Lib/test/test_multiprocessing_forkserver.py
5803a4
581> import sys
5828a10,12
583> if sys.platform == "win32":
584> raise unittest.SkipTest("forkserver is not available on Windows")
585>
586diff Python-3.6.6rc1/Lib/test/test_multiprocessing_main_handling.py Python-3.6.8/Lib/test/test_multiprocessing_main_handling.py
58761c61
588< deadline = time.time() + 10 # up to 10 s to report the results
589---
590> start_time = time.monotonic()
59164,65c64,67
592< if time.time() > deadline:
593< raise RuntimeError("Timed out waiting for results")
594---
595> # up to 1 min to report the results
596> dt = time.monotonic() - start_time
597> if dt > 60.0:
598> raise RuntimeError("Timed out waiting for results (%.1f sec)" % dt)
59989c91
600< deadline = time.time() + 10 # up to 10 s to report the results
601---
602> start_time = time.monotonic()
60392,93c94,97
604< if time.time() > deadline:
605< raise RuntimeError("Timed out waiting for results")
606---
607> # up to 1 min to report the results
608> dt = time.monotonic() - start_time
609> if dt > 60.0:
610> raise RuntimeError("Timed out waiting for results (%.1f sec)" % dt)
611# ----------------------------------------------------------------------
612ADDED *args, **kwds for ForkingPickler in __init__, dump, and dumps
613# ----------------------------------------------------------------------
614diff Python-3.6.13/Lib/test/_test_multiprocessing.py tests/__init__.py
6152c2
616< # Unit tests for the multiprocessing package
617---
618> # Unit tests for the multiprocess package
61930c30
620< support.import_module('multiprocessing.synchronize')
621---
622> support.import_module('multiprocess.synchronize')
62336,41c36,41
624< import multiprocessing.connection
625< import multiprocessing.dummy
626< import multiprocessing.heap
627< import multiprocessing.managers
628< import multiprocessing.pool
629< import multiprocessing.queues
630---
631> import multiprocess.connection
632> import multiprocess.dummy
633> import multiprocess.heap
634> import multiprocess.managers
635> import multiprocess.pool
636> import multiprocess.queues
63743c43
638< from multiprocessing import util
639---
640> from multiprocess import util
64146c46
642< from multiprocessing import reduction
643---
644> from multiprocess import reduction
64552c52
646< from multiprocessing.sharedctypes import Value, copy
647---
648> from multiprocess.sharedctypes import Value, copy
64971c71
650< if isinstance(queue, multiprocessing.queues.Queue):
651---
652> if isinstance(queue, multiprocess.queues.Queue):
65398c98
654< from multiprocessing.connection import wait
655---
656> from multiprocess.connection import wait
657111c111
658< PRELOAD = ['__main__', 'test.test_multiprocessing_forkserver']
659---
660> PRELOAD = ['__main__', 'test_multiprocessing_forkserver']
661347c347
662< cpus = multiprocessing.cpu_count()
663---
664> cpus = multiprocess.cpu_count()
665376a377
666> @unittest.skipIf(True, "fails with is_dill(obj, child=True)")
667488c489
668< sm = multiprocessing.get_start_method()
669---
670> sm = multiprocess.get_start_method()
671494c495
672< from multiprocessing.forkserver import _forkserver
673---
674> from multiprocess.forkserver import _forkserver
675534c535
676< class _UpperCaser(multiprocessing.Process):
677---
678> class _UpperCaser(multiprocess.Process):
679537,538c538,539
680< multiprocessing.Process.__init__(self)
681< self.child_conn, self.parent_conn = multiprocessing.Pipe()
682---
683> multiprocess.Process.__init__(self)
684> self.child_conn, self.parent_conn = multiprocess.Pipe()
685583c584
686< self.assertIn("test_multiprocessing.py", err)
687---
688> self.assertIn("__init__.py", err)
689864c865
690< import multiprocessing
691---
692> import multiprocess as multiprocessing
693881c882
694< q = multiprocessing.Queue()
695---
696> q = multiprocess.Queue()
6971286,1287c1287,1288
698< wrapper = multiprocessing.heap.BufferWrapper(struct.calcsize('i'))
699< lock = multiprocessing.Lock()
700---
701> wrapper = multiprocess.heap.BufferWrapper(struct.calcsize('i'))
702> lock = multiprocess.Lock()
7031642c1643
704< self.skipTest("requires multiprocessing.sharedctypes")
705---
706> self.skipTest("requires multiprocess.sharedctypes")
7071826c1827
708< def test_list_proxy_in_list(self):
709---
710> def _test_list_proxy_in_list(self):
7111869c1870
712< def test_dict_proxy_nested(self):
713---
714> def _test_dict_proxy_nested(self):
7152008c2009
716< def test_map_async_callbacks(self):
717---
718> def _test_map_async_callbacks(self):
7192034c2035
720< except multiprocessing.TimeoutError:
721---
722> except multiprocess.TimeoutError:
7232072c2073
724< self.assertRaises(multiprocessing.TimeoutError, get, timeout=TIMEOUT2)
725---
726> self.assertRaises(multiprocess.TimeoutError, get, timeout=TIMEOUT2)
7272208a2210
728> @unittest.skipIf(True, "fails with is_dill(obj, child=True)")
7292224c2226
730< self.assertIs(type(cause), multiprocessing.pool.RemoteTraceback)
731---
732> self.assertIs(type(cause), multiprocess.pool.RemoteTraceback)
7332250a2253
734> @unittest.skipIf(True, "fails with is_dill(obj, child=True)")
7352258c2261
736< def test_map_no_failfast(self):
737---
738> def _test_map_no_failfast(self):
7392303c2306
740< p = multiprocessing.Pool(2)
741---
742> p = multiprocess.Pool(2)
7432317,2319c2320,2322
744< def test_unpickleable_result(self):
745< from multiprocessing.pool import MaybeEncodingError
746< p = multiprocessing.Pool(2)
747---
748> def _test_unpickleable_result(self):
749> from multiprocess.pool import MaybeEncodingError
750> p = multiprocess.Pool(2)
7512343c2346
752< p = multiprocessing.Pool(3, maxtasksperchild=10)
753---
754> p = multiprocess.Pool(3, maxtasksperchild=10)
7552374c2377
756< p = multiprocessing.Pool(3, maxtasksperchild=1)
757---
758> p = multiprocess.Pool(3, maxtasksperchild=1)
7592388c2391
760< from multiprocessing.managers import BaseManager, BaseProxy, RemoteError
761---
762> from multiprocess.managers import BaseManager, BaseProxy, RemoteError
7632636c2639
764< except multiprocessing.BufferTooShort as e:
765---
766> except multiprocess.BufferTooShort as e:
7672764c2767
768< @unittest.skipUnless(HAS_REDUCTION, "test needs multiprocessing.reduction")
769---
770> @unittest.skipUnless(HAS_REDUCTION, "test needs multiprocess.reduction")
7712783c2786
772< @unittest.skipUnless(HAS_REDUCTION, "test needs multiprocessing.reduction")
773---
774> @unittest.skipUnless(HAS_REDUCTION, "test needs multiprocess.reduction")
7752820c2823
776< @unittest.skipUnless(HAS_REDUCTION, "test needs multiprocessing.reduction")
777---
778> @unittest.skipUnless(HAS_REDUCTION, "test needs multiprocess.reduction")
7793002c3005
780< @unittest.skipUnless(HAS_REDUCTION, "test needs multiprocessing.reduction")
781---
782> @unittest.skipUnless(HAS_REDUCTION, "test needs multiprocess.reduction")
7833009c3012
784< from multiprocessing import resource_sharer
785---
786> from multiprocess import resource_sharer
7873151c3154
788< b = multiprocessing.heap.BufferWrapper(size)
789---
790> b = multiprocess.heap.BufferWrapper(size)
7913158c3161
792< heap = multiprocessing.heap.BufferWrapper._heap
793---
794> heap = multiprocess.heap.BufferWrapper._heap
7953198,3199c3201,3202
796< a = multiprocessing.heap.BufferWrapper(1)
797< b = multiprocessing.heap.BufferWrapper(1)
798---
799> a = multiprocess.heap.BufferWrapper(1)
800> b = multiprocess.heap.BufferWrapper(1)
8013220c3223
802< self.skipTest("requires multiprocessing.sharedctypes")
803---
804> self.skipTest("requires multiprocess.sharedctypes")
8053312c3315
806< # call multiprocessing's cleanup function then exit process without
807---
808> # call multiprocess's cleanup function then exit process without
8093392c3395
810< folder = os.path.dirname(multiprocessing.__file__)
811---
812> folder = os.path.dirname(multiprocess.__file__)
8133396,3398c3399,3401
814< modules = ['multiprocessing.' + m for m in modules]
815< modules.remove('multiprocessing.__init__')
816< modules.append('multiprocessing')
817---
818> modules = ['multiprocess.' + m for m in modules]
819> modules.remove('multiprocess.__init__')
820> modules.append('multiprocess')
8213404,3406c3407,3409
822< modules.remove('multiprocessing.popen_fork')
823< modules.remove('multiprocessing.popen_forkserver')
824< modules.remove('multiprocessing.popen_spawn_posix')
825---
826> modules.remove('multiprocess.popen_fork')
827> modules.remove('multiprocess.popen_forkserver')
828> modules.remove('multiprocess.popen_spawn_posix')
8293408c3411
830< modules.remove('multiprocessing.popen_spawn_win32')
831---
832> modules.remove('multiprocess.popen_spawn_win32')
8333410c3413
834< modules.remove('multiprocessing.popen_forkserver')
835---
836> modules.remove('multiprocess.popen_forkserver')
8373414c3417
838< modules.remove('multiprocessing.sharedctypes')
839---
840> modules.remove('multiprocess.sharedctypes')
8413436c3439
842< logger = multiprocessing.get_logger()
843---
844> logger = multiprocess.get_logger()
8453445c3448
846< logger = multiprocessing.get_logger()
847---
848> logger = multiprocess.get_logger()
8493452c3455
850< logger = multiprocessing.get_logger()
851---
852> logger = multiprocess.get_logger()
8533456c3459
854< reader, writer = multiprocessing.Pipe(duplex=False)
855---
856> reader, writer = multiprocess.Pipe(duplex=False)
8573478c3481
858< # assert record.processName == multiprocessing.current_process().name
859---
860> # assert record.processName == multiprocess.current_process().name
8613487c3490
862< # 'multiprocessing.test.TestLoggingProcessName')
863---
864> # 'multiprocess.test.TestLoggingProcessName')
8653536c3539
866< conn = multiprocessing.connection.Connection(44977608)
867---
868> conn = multiprocess.connection.Connection(44977608)
8693547c3550
870< multiprocessing.connection.Connection, -1)
871---
872> multiprocess.connection.Connection, -1)
8733559,3560c3562,3563
874< self.assertRaises(multiprocessing.AuthenticationError,
875< multiprocessing.connection.deliver_challenge,
876---
877> self.assertRaises(multiprocess.AuthenticationError,
878> multiprocess.connection.deliver_challenge,
8793570c3573
880< return multiprocessing.connection.CHALLENGE
881---
882> return multiprocess.connection.CHALLENGE
8833576,3577c3579,3580
884< self.assertRaises(multiprocessing.AuthenticationError,
885< multiprocessing.connection.answer_challenge,
886---
887> self.assertRaises(multiprocess.AuthenticationError,
888> multiprocess.connection.answer_challenge,
8893589c3592
890< self.mgr = multiprocessing.Manager()
891---
892> self.mgr = multiprocess.Manager()
8933598c3601
894< m = multiprocessing.managers.SyncManager()
895---
896> m = multiprocess.managers.SyncManager()
8973606,3607c3609,3610
898< self.assertRaises(TypeError, multiprocessing.Pool, initializer=1)
899< p = multiprocessing.Pool(1, initializer, (self.ns,))
900---
901> self.assertRaises(TypeError, multiprocess.Pool, initializer=1)
902> p = multiprocess.Pool(1, initializer, (self.ns,))
9033624,3625c3627,3628
904< queue = multiprocessing.Queue()
905< subProc = multiprocessing.Process(target=_this_sub_process, args=(queue,))
906---
907> queue = multiprocess.Queue()
908> subProc = multiprocess.Process(target=_this_sub_process, args=(queue,))
9093634c3637
910< pool = multiprocessing.Pool(processes=4)
911---
912> pool = multiprocess.Pool(processes=4)
9133663c3666
914< proc = multiprocessing.Process(target=_test_process)
915---
916> proc = multiprocess.Process(target=_test_process)
9173668c3671
918< p = multiprocessing.Process(target=pool_in_process)
919---
920> p = multiprocess.Process(target=pool_in_process)
9213676c3679
922< proc = multiprocessing.Process(target=lambda: flike.flush())
923---
924> proc = multiprocess.Process(target=lambda: flike.flush())
9253692c3695
926< from multiprocessing.connection import wait
927---
928> from multiprocess.connection import wait
9293698,3699c3701,3702
930< r, w = multiprocessing.Pipe(duplex=False)
931< p = multiprocessing.Process(target=self._child_test_wait, args=(w, slow))
932---
933> r, w = multiprocess.Pipe(duplex=False)
934> p = multiprocess.Process(target=self._child_test_wait, args=(w, slow))
9353732c3735
936< from multiprocessing.connection import wait
937---
938> from multiprocess.connection import wait
9393742c3745
940< p = multiprocessing.Process(target=self._child_test_wait_socket,
941---
942> p = multiprocess.Process(target=self._child_test_wait_socket,
9433775c3778
944< from multiprocessing.connection import wait
945---
946> from multiprocess.connection import wait
9473778c3781
948< a, b = multiprocessing.Pipe()
949---
950> a, b = multiprocess.Pipe()
9513803c3806
952< from multiprocessing.connection import wait
953---
954> from multiprocess.connection import wait
9553807,3809c3810,3812
956< sem = multiprocessing.Semaphore(0)
957< a, b = multiprocessing.Pipe()
958< p = multiprocessing.Process(target=self.signal_and_sleep,
959---
960> sem = multiprocess.Semaphore(0)
961> a, b = multiprocess.Pipe()
962> p = multiprocess.Process(target=self.signal_and_sleep,
9633846,3847c3849,3850
964< from multiprocessing.connection import wait
965< a, b = multiprocessing.Pipe()
966---
967> from multiprocess.connection import wait
968> a, b = multiprocess.Pipe()
9693865c3868
970< multiprocessing.connection.Listener(r'\\.\test')
971---
972> multiprocess.connection.Listener(r'\\.\test')
9733870c3873
974< multiprocessing.connection.Listener('/var/test.pipe')
975---
976> multiprocess.connection.Listener('/var/test.pipe')
9773884,3885c3887,3888
978< r, w = multiprocessing.Pipe(duplex=False)
979< p = multiprocessing.Process(target=cls.run_in_grandchild, args=(w,))
980---
981> r, w = multiprocess.Pipe(duplex=False)
982> p = multiprocess.Process(target=cls.run_in_grandchild, args=(w,))
9833894c3897
984< def test_flags(self):
985---
986> def _test_flags(self):
9873897c3900
988< prog = ('from test._test_multiprocessing import TestFlags; ' +
989---
990> prog = ('from multiprocess.tests import TestFlags; ' +
9913914c3917
992< conn = multiprocessing.connection.Client(address)
993---
994> conn = multiprocess.connection.Client(address)
9953922,3924c3925,3927
996< parent, child = multiprocessing.Pipe(duplex=True)
997< l = multiprocessing.connection.Listener(family='AF_INET')
998< p = multiprocessing.Process(target=self._test_timeout,
999---
1000> parent, child = multiprocess.Pipe(duplex=True)
1001> l = multiprocess.connection.Listener(family='AF_INET')
1002> p = multiprocess.Process(target=self._test_timeout,
10033943,3944c3946,3947
1004< def test_noforkbomb(self):
1005< sm = multiprocessing.get_start_method()
1006---
1007> def _test_noforkbomb(self):
1008> sm = multiprocess.get_start_method()
10093967c3970
1010< p = multiprocessing.Process(target=cls.child, args=(n-1, conn))
1011---
1012> p = multiprocess.Process(target=cls.child, args=(n-1, conn))
10133976c3979
1014< r, w = multiprocessing.Pipe(False)
1015---
1016> r, w = multiprocess.Pipe(False)
10173979c3982
1018< p = multiprocessing.Process(target=self.child, args=(5, w))
1019---
1020> p = multiprocess.Process(target=self.child, args=(5, w))
10214030c4033
1022< reader, writer = multiprocessing.Pipe()
1023---
1024> reader, writer = multiprocess.Pipe()
10254033c4036
1026< p = multiprocessing.Process(target=self._test_closefds,
1027---
1028> p = multiprocess.Process(target=self._test_closefds,
10294044c4047
1030< if multiprocessing.get_start_method() == 'fork':
1031---
1032> if multiprocess.get_start_method() == 'fork':
10334058c4061
1034< # Sending CONN_MAX_SIZE bytes into a multiprocessing pipe must block
1035---
1036> # Sending CONN_MAX_SIZE bytes into a multiprocess pipe must block
10374073c4076
1038< conn, child_conn = multiprocessing.Pipe()
1039---
1040> conn, child_conn = multiprocess.Pipe()
10414075c4078
1042< p = multiprocessing.Process(target=self._test_ignore,
1043---
1044> p = multiprocess.Process(target=self._test_ignore,
10454099c4102
1046< with multiprocessing.connection.Listener() as l:
1047---
1048> with multiprocess.connection.Listener() as l:
10494106c4109
1050< conn, child_conn = multiprocessing.Pipe()
1051---
1052> conn, child_conn = multiprocess.Pipe()
10534108c4111
1054< p = multiprocessing.Process(target=self._test_ignore_listener,
1055---
1056> p = multiprocess.Process(target=self._test_ignore_listener,
10574117c4120
1058< client = multiprocessing.connection.Client(address)
1059---
1060> client = multiprocess.connection.Client(address)
10614126c4129
1062< conn.send(multiprocessing.get_start_method())
1063---
1064> conn.send(multiprocess.get_start_method())
10654138c4141
1066< def test_context(self):
1067---
1068> def _test_context(self):
10694141c4144
1070< ctx = multiprocessing.get_context(method)
1071---
1072> ctx = multiprocess.get_context(method)
10734150,4151c4153,4154
1074< def test_set_get(self):
1075< multiprocessing.set_forkserver_preload(PRELOAD)
1076---
1077> def _test_set_get(self):
1078> multiprocess.set_forkserver_preload(PRELOAD)
10794153c4156
1080< old_method = multiprocessing.get_start_method()
1081---
1082> old_method = multiprocess.get_start_method()
10834157c4160
1084< multiprocessing.set_start_method(method, force=True)
1085---
1086> multiprocess.set_start_method(method, force=True)
10874160,4161c4163,4164
1088< self.assertEqual(multiprocessing.get_start_method(), method)
1089< ctx = multiprocessing.get_context()
1090---
1091> self.assertEqual(multiprocess.get_start_method(), method)
1092> ctx = multiprocess.get_context()
10934166c4169
1094< self.check_context(multiprocessing)
1095---
1096> self.check_context(multiprocess)
10974169c4172
1098< multiprocessing.set_start_method(old_method, force=True)
1099---
1100> multiprocess.set_start_method(old_method, force=True)
11014173c4176
1102< methods = multiprocessing.get_all_start_methods()
1103---
1104> methods = multiprocess.get_all_start_methods()
11054181c4184
1106< if multiprocessing.get_start_method() != 'forkserver':
1107---
1108> if multiprocess.get_start_method() != 'forkserver':
11094197c4200
1110< def test_semaphore_tracker(self):
1111---
1112> def _test_semaphore_tracker(self):
11134203c4206
1114< import multiprocessing as mp, time, os
1115---
1116> import multiprocess as mp, time, os
11174237c4240
1118< from multiprocessing.semaphore_tracker import _semaphore_tracker
1119---
1120> from multiprocess.semaphore_tracker import _semaphore_tracker
11214243c4246
1122< ctx = multiprocessing.get_context("spawn")
1123---
1124> ctx = multiprocess.get_context("spawn")
11254281,4283c4284,4286
1126< queue = multiprocessing.SimpleQueue()
1127< child_can_start = multiprocessing.Event()
1128< parent_can_continue = multiprocessing.Event()
1129---
1130> queue = multiprocess.SimpleQueue()
1131> child_can_start = multiprocess.Event()
1132> parent_can_continue = multiprocess.Event()
11334285c4288
1134< proc = multiprocessing.Process(
1135---
1136> proc = multiprocess.Process(
11374311c4314
1138< cls.dangling = (multiprocessing.process._dangling.copy(),
1139---
1140> cls.dangling = (multiprocess.process._dangling.copy(),
11414316c4319
1142< # bpo-26762: Some multiprocessing objects like Pool create reference
1143---
1144> # bpo-26762: Some multiprocess objects like Pool create reference
11454320c4323
1146< processes = set(multiprocessing.process._dangling) - set(cls.dangling[0])
1147---
1148> processes = set(multiprocess.process._dangling) - set(cls.dangling[0])
11494335,4353c4338,4356
1150< Process = multiprocessing.Process
1151< connection = multiprocessing.connection
1152< current_process = staticmethod(multiprocessing.current_process)
1153< active_children = staticmethod(multiprocessing.active_children)
1154< Pool = staticmethod(multiprocessing.Pool)
1155< Pipe = staticmethod(multiprocessing.Pipe)
1156< Queue = staticmethod(multiprocessing.Queue)
1157< JoinableQueue = staticmethod(multiprocessing.JoinableQueue)
1158< Lock = staticmethod(multiprocessing.Lock)
1159< RLock = staticmethod(multiprocessing.RLock)
1160< Semaphore = staticmethod(multiprocessing.Semaphore)
1161< BoundedSemaphore = staticmethod(multiprocessing.BoundedSemaphore)
1162< Condition = staticmethod(multiprocessing.Condition)
1163< Event = staticmethod(multiprocessing.Event)
1164< Barrier = staticmethod(multiprocessing.Barrier)
1165< Value = staticmethod(multiprocessing.Value)
1166< Array = staticmethod(multiprocessing.Array)
1167< RawValue = staticmethod(multiprocessing.RawValue)
1168< RawArray = staticmethod(multiprocessing.RawArray)
1169---
1170> Process = multiprocess.Process
1171> connection = multiprocess.connection
1172> current_process = staticmethod(multiprocess.current_process)
1173> active_children = staticmethod(multiprocess.active_children)
1174> Pool = staticmethod(multiprocess.Pool)
1175> Pipe = staticmethod(multiprocess.Pipe)
1176> Queue = staticmethod(multiprocess.Queue)
1177> JoinableQueue = staticmethod(multiprocess.JoinableQueue)
1178> Lock = staticmethod(multiprocess.Lock)
1179> RLock = staticmethod(multiprocess.RLock)
1180> Semaphore = staticmethod(multiprocess.Semaphore)
1181> BoundedSemaphore = staticmethod(multiprocess.BoundedSemaphore)
1182> Condition = staticmethod(multiprocess.Condition)
1183> Event = staticmethod(multiprocess.Event)
1184> Barrier = staticmethod(multiprocess.Barrier)
1185> Value = staticmethod(multiprocess.Value)
1186> Array = staticmethod(multiprocess.Array)
1187> RawValue = staticmethod(multiprocess.RawValue)
1188> RawArray = staticmethod(multiprocess.RawArray)
11894358c4361
1190< Process = multiprocessing.Process
1191---
1192> Process = multiprocess.Process
11934381c4384
1194< cls.manager = multiprocessing.Manager()
1195---
1196> cls.manager = multiprocess.Manager()
11974390c4393
1198< while len(multiprocessing.active_children()) > 1:
1199---
1200> while len(multiprocess.active_children()) > 1:
12014395c4398
1202< print("Warning -- multiprocessing.Manager still has %s active "
1203---
1204> print("Warning -- multiprocess.Manager still has %s active "
12054397c4400
1206< % (multiprocessing.active_children(), dt),
1207---
1208> % (multiprocess.active_children(), dt),
12094418,4434c4421,4437
1210< Process = multiprocessing.dummy.Process
1211< connection = multiprocessing.dummy.connection
1212< current_process = staticmethod(multiprocessing.dummy.current_process)
1213< active_children = staticmethod(multiprocessing.dummy.active_children)
1214< Pool = staticmethod(multiprocessing.dummy.Pool)
1215< Pipe = staticmethod(multiprocessing.dummy.Pipe)
1216< Queue = staticmethod(multiprocessing.dummy.Queue)
1217< JoinableQueue = staticmethod(multiprocessing.dummy.JoinableQueue)
1218< Lock = staticmethod(multiprocessing.dummy.Lock)
1219< RLock = staticmethod(multiprocessing.dummy.RLock)
1220< Semaphore = staticmethod(multiprocessing.dummy.Semaphore)
1221< BoundedSemaphore = staticmethod(multiprocessing.dummy.BoundedSemaphore)
1222< Condition = staticmethod(multiprocessing.dummy.Condition)
1223< Event = staticmethod(multiprocessing.dummy.Event)
1224< Barrier = staticmethod(multiprocessing.dummy.Barrier)
1225< Value = staticmethod(multiprocessing.dummy.Value)
1226< Array = staticmethod(multiprocessing.dummy.Array)
1227---
1228> Process = multiprocess.dummy.Process
1229> connection = multiprocess.dummy.connection
1230> current_process = staticmethod(multiprocess.dummy.current_process)
1231> active_children = staticmethod(multiprocess.dummy.active_children)
1232> Pool = staticmethod(multiprocess.dummy.Pool)
1233> Pipe = staticmethod(multiprocess.dummy.Pipe)
1234> Queue = staticmethod(multiprocess.dummy.Queue)
1235> JoinableQueue = staticmethod(multiprocess.dummy.JoinableQueue)
1236> Lock = staticmethod(multiprocess.dummy.Lock)
1237> RLock = staticmethod(multiprocess.dummy.RLock)
1238> Semaphore = staticmethod(multiprocess.dummy.Semaphore)
1239> BoundedSemaphore = staticmethod(multiprocess.dummy.BoundedSemaphore)
1240> Condition = staticmethod(multiprocess.dummy.Condition)
1241> Event = staticmethod(multiprocess.dummy.Event)
1242> Barrier = staticmethod(multiprocess.dummy.Barrier)
1243> Value = staticmethod(multiprocess.dummy.Value)
1244> Array = staticmethod(multiprocess.dummy.Array)
12454471,4473c4474,4476
1246< multiprocessing.set_forkserver_preload(PRELOAD)
1247< multiprocessing.process._cleanup()
1248< dangling[0] = multiprocessing.process._dangling.copy()
1249---
1250> multiprocess.set_forkserver_preload(PRELOAD)
1251> multiprocess.process._cleanup()
1252> dangling[0] = multiprocess.process._dangling.copy()
12534475c4478
1254< old_start_method[0] = multiprocessing.get_start_method(allow_none=True)
1255---
1256> old_start_method[0] = multiprocess.get_start_method(allow_none=True)
12574477c4480
1258< multiprocessing.set_start_method(start_method, force=True)
1259---
1260> multiprocess.set_start_method(start_method, force=True)
12614484c4487
1262< lock = multiprocessing.RLock()
1263---
1264> lock = multiprocess.RLock()
12654490c4493
1266< multiprocessing.get_logger().setLevel(LOG_LEVEL)
1267---
1268> multiprocess.get_logger().setLevel(LOG_LEVEL)
12694495c4498
1270< # bpo-26762: Some multiprocessing objects like Pool create reference
1271---
1272> # bpo-26762: Some multiprocess objects like Pool create reference
12734499c4502
1274< multiprocessing.set_start_method(old_start_method[0], force=True)
1275---
1276> multiprocess.set_start_method(old_start_method[0], force=True)
12774501c4504
1278< processes = set(multiprocessing.process._dangling) - set(dangling[0])
1279---
1280> processes = set(multiprocess.process._dangling) - set(dangling[0])
12814518c4521
1282< multiprocessing.process._cleanup()
1283---
1284> multiprocess.process._cleanup()
1285diff Python-3.6.13/Lib/test/mp_preload.py tests/mp_preload.py
12861c1
1287< import multiprocessing
1288---
1289> import multiprocessing as multiprocess
12903c3
1291< multiprocessing.Lock()
1292---
1293> multiprocess.Lock()
129411c11
1295< ctx = multiprocessing.get_context("forkserver")
1296---
1297> ctx = multiprocess.get_context("forkserver")
1298diff Python-3.6.13/Lib/test/mp_fork_bomb.py tests/mp_fork_bomb.py
12991c1
1300< import multiprocessing, sys
1301---
1302> import multiprocessing as multiprocess, sys
130311c11
1304< multiprocessing.set_start_method(sys.argv[1])
1305---
1306> multiprocess.set_start_method(sys.argv[1])
130713c13
1308< multiprocessing.set_start_method('spawn')
1309---
1310> multiprocess.set_start_method('spawn')
131115c15
1312< p = multiprocessing.Process(target=foo)
1313---
1314> p = multiprocess.Process(target=foo)
1315