1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
multiprocess
============
better multiprocessing and multithreading in Python
About Multiprocess
------------------
``multiprocess`` is a fork of ``multiprocessing``. ``multiprocess`` extends ``multiprocessing`` to provide enhanced serialization, using `dill`. ``multiprocess`` leverages ``multiprocessing`` to support the spawning of processes using the API of the Python standard library's ``threading`` module. ``multiprocessing`` has been distributed as part of the standard library since Python 2.6.
``multiprocess`` is part of ``pathos``, a Python framework for heterogeneous computing.
``multiprocess`` is in active development, so any user feedback, bug reports, comments,
or suggestions are highly appreciated. A list of issues is located at https://github.com/uqfoundation/multiprocess/issues, with a legacy list maintained at https://uqfoundation.github.io/project/pathos/query.
Major Features
--------------
``multiprocess`` enables:
* objects to be transferred between processes using pipes or multi-producer/multi-consumer queues
* objects to be shared between processes using a server process or (for simple data) shared memory
``multiprocess`` provides:
* equivalents of all the synchronization primitives in ``threading``
* a ``Pool`` class to facilitate submitting tasks to worker processes
* enhanced serialization, using ``dill``
Current Release
[](https://pepy.tech/project/multiprocess)
[](https://anaconda.org/conda-forge/multiprocess)
[](https://stackoverflow.com/questions/tagged/multiprocess)
---------------
The latest released version of ``multiprocess`` is available from:
https://pypi.org/project/multiprocess
``multiprocess`` is distributed under a 3-clause BSD license, and is a fork of ``multiprocessing``.
Development Version
[](http://www.uqfoundation.org/pages/donate.html)
[](https://multiprocess.readthedocs.io/en/latest/?badge=latest)
[](https://travis-ci.com/github/uqfoundation/multiprocess)
[](https://codecov.io/gh/uqfoundation/multiprocess)
-------------------
You can get the latest development version with all the shiny new features at:
https://github.com/uqfoundation
If you have a new contribution, please submit a pull request.
Installation
------------
``multiprocess`` can be installed with ``pip``::
$ pip install multiprocess
For Python 2, a C compiler is required to build the included extension module from source. Python 3 and binary installs do not require a C compiler.
Requirements
------------
``multiprocess`` requires:
* ``python`` (or ``pypy``), **>=3.8**
* ``setuptools``, **>=42**
* ``dill``, **>=0.3.9**
Basic Usage
-----------
The ``multiprocess.Process`` class follows the API of ``threading.Thread``.
For example ::
from multiprocess import Process, Queue
def f(q):
q.put('hello world')
if __name__ == '__main__':
q = Queue()
p = Process(target=f, args=[q])
p.start()
print (q.get())
p.join()
Synchronization primitives like locks, semaphores and conditions are
available, for example ::
>>> from multiprocess import Condition
>>> c = Condition()
>>> print (c)
<Condition(<RLock(None, 0)>), 0>
>>> c.acquire()
True
>>> print (c)
<Condition(<RLock(MainProcess, 1)>), 0>
One can also use a manager to create shared objects either in shared
memory or in a server process, for example ::
>>> from multiprocess import Manager
>>> manager = Manager()
>>> l = manager.list(range(10))
>>> l.reverse()
>>> print (l)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> print (repr(l))
<Proxy[list] object at 0x00E1B3B0>
Tasks can be offloaded to a pool of worker processes in various ways,
for example ::
>>> from multiprocess import Pool
>>> def f(x): return x*x
...
>>> p = Pool(4)
>>> result = p.map_async(f, range(10))
>>> print (result.get(timeout=1))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
When ``dill`` is installed, serialization is extended to most objects,
for example ::
>>> from multiprocess import Pool
>>> p = Pool(4)
>>> print (p.map(lambda x: (lambda y:y**2)(x) + x, xrange(10)))
[0, 2, 6, 12, 20, 30, 42, 56, 72, 90]
More Information
----------------
Probably the best way to get started is to look at the documentation at
http://multiprocess.rtfd.io. Also see ``multiprocess.tests`` for scripts that
demonstrate how ``multiprocess`` can be used to leverge multiple processes
to execute Python in parallel. You can run the test suite with
``python -m multiprocess.tests``. As ``multiprocess`` conforms to the
``multiprocessing`` interface, the examples and documentation found at
http://docs.python.org/library/multiprocessing.html also apply to
``multiprocess`` if one will ``import multiprocessing as multiprocess``.
See https://github.com/uqfoundation/multiprocess/tree/master/py3.12/examples
for a set of examples that demonstrate some basic use cases and benchmarking
for running Python code in parallel. Please feel free to submit a ticket on
github, or ask a question on stackoverflow (**@Mike McKerns**). If you would
like to share how you use ``multiprocess`` in your work, please send an email
(to **mmckerns at uqfoundation dot org**).
Citation
--------
If you use ``multiprocess`` to do research that leads to publication, we ask that you
acknowledge use of ``multiprocess`` by citing the following in your publication::
M.M. McKerns, L. Strand, T. Sullivan, A. Fang, M.A.G. Aivazis,
"Building a framework for predictive science", Proceedings of
the 10th Python in Science Conference, 2011;
http://arxiv.org/pdf/1202.1056
Michael McKerns and Michael Aivazis,
"pathos: a framework for heterogeneous computing", 2010- ;
https://uqfoundation.github.io/project/pathos
Please see https://uqfoundation.github.io/project/pathos or
http://arxiv.org/pdf/1202.1056 for further information.
|
