mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-09-27 02:39:58 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 13

2to3 run of multiprocessing examples.

Browse source 
mp_benchmarks, mp_newtypes and mp_distribution are still broken but the others are working properly. We should include the examples in our unit test suite ...
This commit is contained in:
Christian Heimes 2008-11-28 11:23:26 +00:00
parent 94e0772989
commit aae1b70a83
6 changed files with 177 additions and 177 deletions
Download patch file Download diff file Expand all files Collapse all files

84
Doc/includes/mp_benchmarks.py
View file

@ -2,7 +2,7 @@
# Simple benchmarks for the multiprocessing package # Simple benchmarks for the multiprocessing package
# #
import time, sys, multiprocessing, threading, Queue, gc import time, sys, multiprocessing, threading, queue, gc
if sys.platform == 'win32': if sys.platform == 'win32':
_timer = time.clock _timer = time.clock
@ -20,7 +20,7 @@ def queuespeed_func(q, c, iterations):
c.notify() c.notify()
c.release() c.release()
for i in xrange(iterations): for i in range(iterations):
q.put(a) q.put(a)
q.put('STOP') q.put('STOP')
@ -48,8 +48,8 @@ def test_queuespeed(Process, q, c):
p.join() p.join()
print iterations, 'objects passed through the queue in', elapsed, 'seconds' print(iterations, 'objects passed through the queue in', elapsed, 'seconds')
print 'average number/sec:', iterations/elapsed print('average number/sec:', iterations/elapsed)
#### TEST_PIPESPEED #### TEST_PIPESPEED
@ -60,7 +60,7 @@ def pipe_func(c, cond, iterations):
cond.notify() cond.notify()
cond.release() cond.release()
for i in xrange(iterations): for i in range(iterations):
c.send(a) c.send(a)
c.send('STOP') c.send('STOP')
@ -90,8 +90,8 @@ def test_pipespeed():
elapsed = _timer() - t elapsed = _timer() - t
p.join() p.join()
print iterations, 'objects passed through connection in',elapsed,'seconds' print(iterations, 'objects passed through connection in',elapsed,'seconds')
print 'average number/sec:', iterations/elapsed print('average number/sec:', iterations/elapsed)
#### TEST_SEQSPEED #### TEST_SEQSPEED
@ -105,13 +105,13 @@ def test_seqspeed(seq):
t = _timer() t = _timer()
for i in xrange(iterations): for i in range(iterations):
a = seq[5] a = seq[5]
elapsed = _timer()-t elapsed = _timer()-t
print iterations, 'iterations in', elapsed, 'seconds' print(iterations, 'iterations in', elapsed, 'seconds')
print 'average number/sec:', iterations/elapsed print('average number/sec:', iterations/elapsed)
#### TEST_LOCK #### TEST_LOCK
@ -125,14 +125,14 @@ def test_lockspeed(l):
t = _timer() t = _timer()
for i in xrange(iterations): for i in range(iterations):
l.acquire() l.acquire()
l.release() l.release()
elapsed = _timer()-t elapsed = _timer()-t
print iterations, 'iterations in', elapsed, 'seconds' print(iterations, 'iterations in', elapsed, 'seconds')
print 'average number/sec:', iterations/elapsed print('average number/sec:', iterations/elapsed)
#### TEST_CONDITION #### TEST_CONDITION
@ -141,7 +141,7 @@ def conditionspeed_func(c, N):
c.acquire() c.acquire()
c.notify() c.notify()
for i in xrange(N): for i in range(N):
c.wait() c.wait()
c.notify() c.notify()
@ -162,7 +162,7 @@ def test_conditionspeed(Process, c):
t = _timer() t = _timer()
for i in xrange(iterations): for i in range(iterations):
c.notify() c.notify()
c.wait() c.wait()
@ -171,8 +171,8 @@ def test_conditionspeed(Process, c):
c.release() c.release()
p.join() p.join()
print iterations * 2, 'waits in', elapsed, 'seconds' print(iterations * 2, 'waits in', elapsed, 'seconds')
print 'average number/sec:', iterations * 2 / elapsed print('average number/sec:', iterations * 2 / elapsed)
#### ####
@ -181,51 +181,51 @@ def test():
gc.disable() gc.disable()
print '\n\t######## testing Queue.Queue\n' print('\n\t######## testing Queue.Queue\n')
test_queuespeed(threading.Thread, Queue.Queue(), test_queuespeed(threading.Thread, queue.Queue(),
threading.Condition()) threading.Condition())
print '\n\t######## testing multiprocessing.Queue\n' print('\n\t######## testing multiprocessing.Queue\n')
test_queuespeed(multiprocessing.Process, multiprocessing.Queue(), test_queuespeed(multiprocessing.Process, multiprocessing.Queue(),
multiprocessing.Condition()) multiprocessing.Condition())
print '\n\t######## testing Queue managed by server process\n' print('\n\t######## testing Queue managed by server process\n')
test_queuespeed(multiprocessing.Process, manager.Queue(), test_queuespeed(multiprocessing.Process, manager.Queue(),
manager.Condition()) manager.Condition())
print '\n\t######## testing multiprocessing.Pipe\n' print('\n\t######## testing multiprocessing.Pipe\n')
test_pipespeed() test_pipespeed()
print print()
print '\n\t######## testing list\n' print('\n\t######## testing list\n')
test_seqspeed(range(10)) test_seqspeed(list(range(10)))
print '\n\t######## testing list managed by server process\n' print('\n\t######## testing list managed by server process\n')
test_seqspeed(manager.list(range(10))) test_seqspeed(manager.list(list(range(10))))
print '\n\t######## testing Array("i", ..., lock=False)\n' print('\n\t######## testing Array("i", ..., lock=False)\n')
test_seqspeed(multiprocessing.Array('i', range(10), lock=False)) test_seqspeed(multiprocessing.Array('i', list(range(10)), lock=False))
print '\n\t######## testing Array("i", ..., lock=True)\n' print('\n\t######## testing Array("i", ..., lock=True)\n')
test_seqspeed(multiprocessing.Array('i', range(10), lock=True)) test_seqspeed(multiprocessing.Array('i', list(range(10)), lock=True))
print print()
print '\n\t######## testing threading.Lock\n' print('\n\t######## testing threading.Lock\n')
test_lockspeed(threading.Lock()) test_lockspeed(threading.Lock())
print '\n\t######## testing threading.RLock\n' print('\n\t######## testing threading.RLock\n')
test_lockspeed(threading.RLock()) test_lockspeed(threading.RLock())
print '\n\t######## testing multiprocessing.Lock\n' print('\n\t######## testing multiprocessing.Lock\n')
test_lockspeed(multiprocessing.Lock()) test_lockspeed(multiprocessing.Lock())
print '\n\t######## testing multiprocessing.RLock\n' print('\n\t######## testing multiprocessing.RLock\n')
test_lockspeed(multiprocessing.RLock()) test_lockspeed(multiprocessing.RLock())
print '\n\t######## testing lock managed by server process\n' print('\n\t######## testing lock managed by server process\n')
test_lockspeed(manager.Lock()) test_lockspeed(manager.Lock())
print '\n\t######## testing rlock managed by server process\n' print('\n\t######## testing rlock managed by server process\n')
test_lockspeed(manager.RLock()) test_lockspeed(manager.RLock())
print print()
print '\n\t######## testing threading.Condition\n' print('\n\t######## testing threading.Condition\n')
test_conditionspeed(threading.Thread, threading.Condition()) test_conditionspeed(threading.Thread, threading.Condition())
print '\n\t######## testing multiprocessing.Condition\n' print('\n\t######## testing multiprocessing.Condition\n')
test_conditionspeed(multiprocessing.Process, multiprocessing.Condition()) test_conditionspeed(multiprocessing.Process, multiprocessing.Condition())
print '\n\t######## testing condition managed by a server process\n' print('\n\t######## testing condition managed by a server process\n')
test_conditionspeed(multiprocessing.Process, manager.Condition()) test_conditionspeed(multiprocessing.Process, manager.Condition())
gc.enable() gc.enable()

32
Doc/includes/mp_newtype.py
View file

@ -11,15 +11,15 @@ import operator
class Foo(object): class Foo(object):
def f(self): def f(self):
print 'you called Foo.f()' print('you called Foo.f()')
def g(self): def g(self):
print 'you called Foo.g()' print('you called Foo.g()')
def _h(self): def _h(self):
print 'you called Foo._h()' print('you called Foo._h()')
# A simple generator function # A simple generator function
def baz(): def baz():
for i in xrange(10): for i in range(10):
yield i*i yield i*i
# Proxy type for generator objects # Proxy type for generator objects
@ -27,7 +27,7 @@ class GeneratorProxy(BaseProxy):
_exposed_ = ('next', '__next__') _exposed_ = ('next', '__next__')
def __iter__(self): def __iter__(self):
return self return self
def next(self): def __next__(self):
return self._callmethod('next') return self._callmethod('next')
def __next__(self): def __next__(self):
return self._callmethod('__next__') return self._callmethod('__next__')
@ -59,7 +59,7 @@ def test():
manager = MyManager() manager = MyManager()
manager.start() manager.start()
print '-' * 20 print('-' * 20)
f1 = manager.Foo1() f1 = manager.Foo1()
f1.f() f1.f()
@ -67,7 +67,7 @@ def test():
assert not hasattr(f1, '_h') assert not hasattr(f1, '_h')
assert sorted(f1._exposed_) == sorted(['f', 'g']) assert sorted(f1._exposed_) == sorted(['f', 'g'])
print '-' * 20 print('-' * 20)
f2 = manager.Foo2() f2 = manager.Foo2()
f2.g() f2.g()
@ -75,21 +75,21 @@ def test():
assert not hasattr(f2, 'f') assert not hasattr(f2, 'f')
assert sorted(f2._exposed_) == sorted(['g', '_h']) assert sorted(f2._exposed_) == sorted(['g', '_h'])
print '-' * 20 print('-' * 20)
it = manager.baz() it = manager.baz()
for i in it: for i in it:
print '<%d>' % i, print('<%d>' % i, end=' ')
print print()
print '-' * 20 print('-' * 20)
op = manager.operator() op = manager.operator()
print 'op.add(23, 45) =', op.add(23, 45) print('op.add(23, 45) =', op.add(23, 45))
print 'op.pow(2, 94) =', op.pow(2, 94) print('op.pow(2, 94) =', op.pow(2, 94))
print 'op.getslice(range(10), 2, 6) =', op.getslice(range(10), 2, 6) print('op.getslice(range(10), 2, 6) =', op.getslice(list(range(10)), 2, 6))
print 'op.repeat(range(5), 3) =', op.repeat(range(5), 3) print('op.repeat(range(5), 3) =', op.repeat(list(range(5)), 3))
print 'op._exposed_ =', op._exposed_ print('op._exposed_ =', op._exposed_)
## ##

142
Doc/includes/mp_pool.py
View file

@ -43,17 +43,17 @@ def noop(x):
# #
def test(): def test():
print 'cpu_count() = %d\n' % multiprocessing.cpu_count() print('cpu_count() = %d\n' % multiprocessing.cpu_count())
# #
# Create pool # Create pool
# #
PROCESSES = 4 PROCESSES = 4
print 'Creating pool with %d processes\n' % PROCESSES print('Creating pool with %d processes\n' % PROCESSES)
pool = multiprocessing.Pool(PROCESSES) pool = multiprocessing.Pool(PROCESSES)
print 'pool = %s' % pool print('pool = %s' % pool)
print print()
# #
# Tests # Tests
@ -66,72 +66,72 @@ def test():
imap_it = pool.imap(calculatestar, TASKS) imap_it = pool.imap(calculatestar, TASKS)
imap_unordered_it = pool.imap_unordered(calculatestar, TASKS) imap_unordered_it = pool.imap_unordered(calculatestar, TASKS)
print 'Ordered results using pool.apply_async():' print('Ordered results using pool.apply_async():')
for r in results: for r in results:
print '\t', r.get() print('\t', r.get())
print print()
print 'Ordered results using pool.imap():' print('Ordered results using pool.imap():')
for x in imap_it: for x in imap_it:
print '\t', x print('\t', x)
print print()
print 'Unordered results using pool.imap_unordered():' print('Unordered results using pool.imap_unordered():')
for x in imap_unordered_it: for x in imap_unordered_it:
print '\t', x print('\t', x)
print print()
print 'Ordered results using pool.map() --- will block till complete:' print('Ordered results using pool.map() --- will block till complete:')
for x in pool.map(calculatestar, TASKS): for x in pool.map(calculatestar, TASKS):
print '\t', x print('\t', x)
print print()
# #
# Simple benchmarks # Simple benchmarks
# #
N = 100000 N = 100000
print 'def pow3(x): return x**3' print('def pow3(x): return x**3')
t = time.time() t = time.time()
A = map(pow3, xrange(N)) A = list(map(pow3, range(N)))
print '\tmap(pow3, xrange(%d)):\n\t\t%s seconds' % \ print('\tmap(pow3, xrange(%d)):\n\t\t%s seconds' % \
(N, time.time() - t) (N, time.time() - t))
t = time.time() t = time.time()
B = pool.map(pow3, xrange(N)) B = pool.map(pow3, range(N))
print '\tpool.map(pow3, xrange(%d)):\n\t\t%s seconds' % \ print('\tpool.map(pow3, xrange(%d)):\n\t\t%s seconds' % \
(N, time.time() - t) (N, time.time() - t))
t = time.time() t = time.time()
C = list(pool.imap(pow3, xrange(N), chunksize=N//8)) C = list(pool.imap(pow3, range(N), chunksize=N//8))
print '\tlist(pool.imap(pow3, xrange(%d), chunksize=%d)):\n\t\t%s' \ print('\tlist(pool.imap(pow3, xrange(%d), chunksize=%d)):\n\t\t%s' \
' seconds' % (N, N//8, time.time() - t) ' seconds' % (N, N//8, time.time() - t))
assert A == B == C, (len(A), len(B), len(C)) assert A == B == C, (len(A), len(B), len(C))
print print()
L = [None] * 1000000 L = [None] * 1000000
print 'def noop(x): pass' print('def noop(x): pass')
print 'L = [None] * 1000000' print('L = [None] * 1000000')
t = time.time() t = time.time()
A = map(noop, L) A = list(map(noop, L))
print '\tmap(noop, L):\n\t\t%s seconds' % \ print('\tmap(noop, L):\n\t\t%s seconds' % \
(time.time() - t) (time.time() - t))
t = time.time() t = time.time()
B = pool.map(noop, L) B = pool.map(noop, L)
print '\tpool.map(noop, L):\n\t\t%s seconds' % \ print('\tpool.map(noop, L):\n\t\t%s seconds' % \
(time.time() - t) (time.time() - t))
t = time.time() t = time.time()
C = list(pool.imap(noop, L, chunksize=len(L)//8)) C = list(pool.imap(noop, L, chunksize=len(L)//8))
print '\tlist(pool.imap(noop, L, chunksize=%d)):\n\t\t%s seconds' % \ print('\tlist(pool.imap(noop, L, chunksize=%d)):\n\t\t%s seconds' % \
(len(L)//8, time.time() - t) (len(L)//8, time.time() - t))
assert A == B == C, (len(A), len(B), len(C)) assert A == B == C, (len(A), len(B), len(C))
print print()
del A, B, C, L del A, B, C, L
@ -139,33 +139,33 @@ def test():
# Test error handling # Test error handling
# #
print 'Testing error handling:' print('Testing error handling:')
try: try:
print pool.apply(f, (5,)) print(pool.apply(f, (5,)))
except ZeroDivisionError: except ZeroDivisionError:
print '\tGot ZeroDivisionError as expected from pool.apply()' print('\tGot ZeroDivisionError as expected from pool.apply()')
else: else:
raise AssertionError, 'expected ZeroDivisionError' raise AssertionError('expected ZeroDivisionError')
try: try:
print pool.map(f, range(10)) print(pool.map(f, list(range(10))))
except ZeroDivisionError: except ZeroDivisionError:
print '\tGot ZeroDivisionError as expected from pool.map()' print('\tGot ZeroDivisionError as expected from pool.map()')
else: else:
raise AssertionError, 'expected ZeroDivisionError' raise AssertionError('expected ZeroDivisionError')
try: try:
print list(pool.imap(f, range(10))) print(list(pool.imap(f, list(range(10)))))
except ZeroDivisionError: except ZeroDivisionError:
print '\tGot ZeroDivisionError as expected from list(pool.imap())' print('\tGot ZeroDivisionError as expected from list(pool.imap())')
else: else:
raise AssertionError, 'expected ZeroDivisionError' raise AssertionError('expected ZeroDivisionError')
it = pool.imap(f, range(10)) it = pool.imap(f, list(range(10)))
for i in range(10): for i in range(10):
try: try:
x = it.next() x = next(it)
except ZeroDivisionError: except ZeroDivisionError:
if i == 5: if i == 5:
pass pass
@ -173,17 +173,17 @@ def test():
break break
else: else:
if i == 5: if i == 5:
raise AssertionError, 'expected ZeroDivisionError' raise AssertionError('expected ZeroDivisionError')
assert i == 9 assert i == 9
print '\tGot ZeroDivisionError as expected from IMapIterator.next()' print('\tGot ZeroDivisionError as expected from IMapIterator.next()')
print print()
# #
# Testing timeouts # Testing timeouts
# #
print 'Testing ApplyResult.get() with timeout:', print('Testing ApplyResult.get() with timeout:', end=' ')
res = pool.apply_async(calculate, TASKS[0]) res = pool.apply_async(calculate, TASKS[0])
while 1: while 1:
sys.stdout.flush() sys.stdout.flush()
@ -192,10 +192,10 @@ def test():
break break
except multiprocessing.TimeoutError: except multiprocessing.TimeoutError:
sys.stdout.write('.') sys.stdout.write('.')
print print()
print print()
print 'Testing IMapIterator.next() with timeout:', print('Testing IMapIterator.next() with timeout:', end=' ')
it = pool.imap(calculatestar, TASKS) it = pool.imap(calculatestar, TASKS)
while 1: while 1:
sys.stdout.flush() sys.stdout.flush()
@ -205,14 +205,14 @@ def test():
break break
except multiprocessing.TimeoutError: except multiprocessing.TimeoutError:
sys.stdout.write('.') sys.stdout.write('.')
print print()
print print()
# #
# Testing callback # Testing callback
# #
print 'Testing callback:' print('Testing callback:')
A = [] A = []
B = [56, 0, 1, 8, 27, 64, 125, 216, 343, 512, 729] B = [56, 0, 1, 8, 27, 64, 125, 216, 343, 512, 729]
@ -220,13 +220,13 @@ def test():
r = pool.apply_async(mul, (7, 8), callback=A.append) r = pool.apply_async(mul, (7, 8), callback=A.append)
r.wait() r.wait()
r = pool.map_async(pow3, range(10), callback=A.extend) r = pool.map_async(pow3, list(range(10)), callback=A.extend)
r.wait() r.wait()
if A == B: if A == B:
print '\tcallbacks succeeded\n' print('\tcallbacks succeeded\n')
else: else:
print '\t*** callbacks failed\n\t\t%s != %s\n' % (A, B) print('\t*** callbacks failed\n\t\t%s != %s\n' % (A, B))
# #
# Check there are no outstanding tasks # Check there are no outstanding tasks
@ -238,7 +238,7 @@ def test():
# Check close() methods # Check close() methods
# #
print 'Testing close():' print('Testing close():')
for worker in pool._pool: for worker in pool._pool:
assert worker.is_alive() assert worker.is_alive()
@ -252,13 +252,13 @@ def test():
for worker in pool._pool: for worker in pool._pool:
assert not worker.is_alive() assert not worker.is_alive()
print '\tclose() succeeded\n' print('\tclose() succeeded\n')
# #
# Check terminate() method # Check terminate() method
# #
print 'Testing terminate():' print('Testing terminate():')
pool = multiprocessing.Pool(2) pool = multiprocessing.Pool(2)
DELTA = 0.1 DELTA = 0.1
@ -270,13 +270,13 @@ def test():
for worker in pool._pool: for worker in pool._pool:
assert not worker.is_alive() assert not worker.is_alive()
print '\tterminate() succeeded\n' print('\tterminate() succeeded\n')
# #
# Check garbage collection # Check garbage collection
# #
print 'Testing garbage collection:' print('Testing garbage collection:')
pool = multiprocessing.Pool(2) pool = multiprocessing.Pool(2)
DELTA = 0.1 DELTA = 0.1
@ -291,7 +291,7 @@ def test():
for worker in processes: for worker in processes:
assert not worker.is_alive() assert not worker.is_alive()
print '\tgarbage collection succeeded\n' print('\tgarbage collection succeeded\n')
if __name__ == '__main__': if __name__ == '__main__':
@ -300,12 +300,12 @@ if __name__ == '__main__':
assert len(sys.argv) in (1, 2) assert len(sys.argv) in (1, 2)
if len(sys.argv) == 1 or sys.argv[1] == 'processes': if len(sys.argv) == 1 or sys.argv[1] == 'processes':
print ' Using processes '.center(79, '-') print(' Using processes '.center(79, '-'))
elif sys.argv[1] == 'threads': elif sys.argv[1] == 'threads':
print ' Using threads '.center(79, '-') print(' Using threads '.center(79, '-'))
import multiprocessing.dummy as multiprocessing import multiprocessing.dummy as multiprocessing
else: else:
print 'Usage:\n\t%s [processes | threads]' % sys.argv[0] print('Usage:\n\t%s [processes | threads]' % sys.argv[0])
raise SystemExit(2) raise SystemExit(2)
test() test()

80
Doc/includes/mp_synchronize.py
View file

@ -3,7 +3,7 @@
# #
import time, sys, random import time, sys, random
from Queue import Empty from queue import Empty
import multiprocessing # may get overwritten import multiprocessing # may get overwritten
@ -15,7 +15,7 @@ def value_func(running, mutex):
time.sleep(random.random()*4) time.sleep(random.random()*4)
mutex.acquire() mutex.acquire()
print '\n\t\t\t' + str(multiprocessing.current_process()) + ' has finished' print('\n\t\t\t' + str(multiprocessing.current_process()) + ' has finished')
running.value -= 1 running.value -= 1
mutex.release() mutex.release()
@ -31,12 +31,12 @@ def test_value():
while running.value > 0: while running.value > 0:
time.sleep(0.08) time.sleep(0.08)
mutex.acquire() mutex.acquire()
print running.value, print(running.value, end=' ')
sys.stdout.flush() sys.stdout.flush()
mutex.release() mutex.release()
print print()
print 'No more running processes' print('No more running processes')
#### TEST_QUEUE #### TEST_QUEUE
@ -57,22 +57,22 @@ def test_queue():
while o != 'STOP': while o != 'STOP':
try: try:
o = q.get(timeout=0.3) o = q.get(timeout=0.3)
print o, print(o, end=' ')
sys.stdout.flush() sys.stdout.flush()
except Empty: except Empty:
print 'TIMEOUT' print('TIMEOUT')
print print()
#### TEST_CONDITION #### TEST_CONDITION
def condition_func(cond): def condition_func(cond):
cond.acquire() cond.acquire()
print '\t' + str(cond) print('\t' + str(cond))
time.sleep(2) time.sleep(2)
print '\tchild is notifying' print('\tchild is notifying')
print '\t' + str(cond) print('\t' + str(cond))
cond.notify() cond.notify()
cond.release() cond.release()
@ -80,26 +80,26 @@ def test_condition():
cond = multiprocessing.Condition() cond = multiprocessing.Condition()
p = multiprocessing.Process(target=condition_func, args=(cond,)) p = multiprocessing.Process(target=condition_func, args=(cond,))
print cond print(cond)
cond.acquire() cond.acquire()
print cond print(cond)
cond.acquire() cond.acquire()
print cond print(cond)
p.start() p.start()
print 'main is waiting' print('main is waiting')
cond.wait() cond.wait()
print 'main has woken up' print('main has woken up')
print cond print(cond)
cond.release() cond.release()
print cond print(cond)
cond.release() cond.release()
p.join() p.join()
print cond print(cond)
#### TEST_SEMAPHORE #### TEST_SEMAPHORE
@ -109,7 +109,7 @@ def semaphore_func(sema, mutex, running):
mutex.acquire() mutex.acquire()
running.value += 1 running.value += 1
print running.value, 'tasks are running' print(running.value, 'tasks are running')
mutex.release() mutex.release()
random.seed() random.seed()
@ -117,7 +117,7 @@ def semaphore_func(sema, mutex, running):
mutex.acquire() mutex.acquire()
running.value -= 1 running.value -= 1
print '%s has finished' % multiprocessing.current_process() print('%s has finished' % multiprocessing.current_process())
mutex.release() mutex.release()
sema.release() sema.release()
@ -143,30 +143,30 @@ def test_semaphore():
#### TEST_JOIN_TIMEOUT #### TEST_JOIN_TIMEOUT
def join_timeout_func(): def join_timeout_func():
print '\tchild sleeping' print('\tchild sleeping')
time.sleep(5.5) time.sleep(5.5)
print '\n\tchild terminating' print('\n\tchild terminating')
def test_join_timeout(): def test_join_timeout():
p = multiprocessing.Process(target=join_timeout_func) p = multiprocessing.Process(target=join_timeout_func)
p.start() p.start()
print 'waiting for process to finish' print('waiting for process to finish')
while 1: while 1:
p.join(timeout=1) p.join(timeout=1)
if not p.is_alive(): if not p.is_alive():
break break
print '.', print('.', end=' ')
sys.stdout.flush() sys.stdout.flush()
#### TEST_EVENT #### TEST_EVENT
def event_func(event): def event_func(event):
print '\t%r is waiting' % multiprocessing.current_process() print('\t%r is waiting' % multiprocessing.current_process())
event.wait() event.wait()
print '\t%r has woken up' % multiprocessing.current_process() print('\t%r has woken up' % multiprocessing.current_process())
def test_event(): def test_event():
event = multiprocessing.Event() event = multiprocessing.Event()
@ -177,10 +177,10 @@ def test_event():
for p in processes: for p in processes:
p.start() p.start()
print 'main is sleeping' print('main is sleeping')
time.sleep(2) time.sleep(2)
print 'main is setting event' print('main is setting event')
event.set() event.set()
for p in processes: for p in processes:
@ -200,7 +200,7 @@ def sharedvalues_func(values, arrays, shared_values, shared_arrays):
sa = list(shared_arrays[i][:]) sa = list(shared_arrays[i][:])
assert a == sa assert a == sa
print 'Tests passed' print('Tests passed')
def test_sharedvalues(): def test_sharedvalues():
values = [ values = [
@ -209,9 +209,9 @@ def test_sharedvalues():
('d', 1.25) ('d', 1.25)
] ]
arrays = [ arrays = [
('i', range(100)), ('i', list(range(100))),
('d', [0.25 * i for i in range(100)]), ('d', [0.25 * i for i in range(100)]),
('H', range(1000)) ('H', list(range(1000)))
] ]
shared_values = [multiprocessing.Value(id, v) for id, v in values] shared_values = [multiprocessing.Value(id, v) for id, v in values]
@ -238,15 +238,15 @@ def test(namespace=multiprocessing):
test_semaphore, test_join_timeout, test_event, test_semaphore, test_join_timeout, test_event,
test_sharedvalues ]: test_sharedvalues ]:
print '\n\t######## %s\n' % func.__name__ print('\n\t######## %s\n' % func.__name__)
func() func()
ignore = multiprocessing.active_children() # cleanup any old processes ignore = multiprocessing.active_children() # cleanup any old processes
if hasattr(multiprocessing, '_debug_info'): if hasattr(multiprocessing, '_debug_info'):
info = multiprocessing._debug_info() info = multiprocessing._debug_info()
if info: if info:
print info print(info)
raise ValueError, 'there should be no positive refcounts left' raise ValueError('there should be no positive refcounts left')
if __name__ == '__main__': if __name__ == '__main__':
@ -255,19 +255,19 @@ if __name__ == '__main__':
assert len(sys.argv) in (1, 2) assert len(sys.argv) in (1, 2)
if len(sys.argv) == 1 or sys.argv[1] == 'processes': if len(sys.argv) == 1 or sys.argv[1] == 'processes':
print ' Using processes '.center(79, '-') print(' Using processes '.center(79, '-'))
namespace = multiprocessing namespace = multiprocessing
elif sys.argv[1] == 'manager': elif sys.argv[1] == 'manager':
print ' Using processes and a manager '.center(79, '-') print(' Using processes and a manager '.center(79, '-'))
namespace = multiprocessing.Manager() namespace = multiprocessing.Manager()
namespace.Process = multiprocessing.Process namespace.Process = multiprocessing.Process
namespace.current_process = multiprocessing.current_process namespace.current_process = multiprocessing.current_process
namespace.active_children = multiprocessing.active_children namespace.active_children = multiprocessing.active_children
elif sys.argv[1] == 'threads': elif sys.argv[1] == 'threads':
print ' Using threads '.center(79, '-') print(' Using threads '.center(79, '-'))
import multiprocessing.dummy as namespace import multiprocessing.dummy as namespace
else: else:
print 'Usage:\n\t%s [processes | manager | threads]' % sys.argv[0] print('Usage:\n\t%s [processes | manager | threads]' % sys.argv[0])
raise SystemExit, 2 raise SystemExit(2)
test(namespace) test(namespace)

10
Doc/includes/mp_webserver.py
View file

@ -13,8 +13,8 @@ import os
import sys import sys
from multiprocessing import Process, current_process, freeze_support from multiprocessing import Process, current_process, freeze_support
from BaseHTTPServer import HTTPServer from http.server import HTTPServer
from SimpleHTTPServer import SimpleHTTPRequestHandler from http.server import SimpleHTTPRequestHandler
if sys.platform == 'win32': if sys.platform == 'win32':
import multiprocessing.reduction # make sockets pickable/inheritable import multiprocessing.reduction # make sockets pickable/inheritable
@ -54,9 +54,9 @@ def test():
ADDRESS = ('localhost', 8000) ADDRESS = ('localhost', 8000)
NUMBER_OF_PROCESSES = 4 NUMBER_OF_PROCESSES = 4
print 'Serving at http://%s:%d using %d worker processes' % \ print('Serving at http://%s:%d using %d worker processes' % \
(ADDRESS[0], ADDRESS[1], NUMBER_OF_PROCESSES) (ADDRESS[0], ADDRESS[1], NUMBER_OF_PROCESSES))
print 'To exit press Ctrl-' + ['C', 'Break'][sys.platform=='win32'] print('To exit press Ctrl-' + ['C', 'Break'][sys.platform=='win32'])
os.chdir(DIR) os.chdir(DIR)
runpool(ADDRESS, NUMBER_OF_PROCESSES) runpool(ADDRESS, NUMBER_OF_PROCESSES)

6
Doc/includes/mp_workers.py
View file

@ -65,9 +65,9 @@ def test():
Process(target=worker, args=(task_queue, done_queue)).start() Process(target=worker, args=(task_queue, done_queue)).start()
# Get and print results # Get and print results
print 'Unordered results:' print('Unordered results:')
for i in range(len(TASKS1)): for i in range(len(TASKS1)):
print '\t', done_queue.get() print('\t', done_queue.get())
# Add more tasks using `put()` # Add more tasks using `put()`
for task in TASKS2: for task in TASKS2:
@ -75,7 +75,7 @@ def test():
# Get and print some more results # Get and print some more results
for i in range(len(TASKS2)): for i in range(len(TASKS2)):
print '\t', done_queue.get() print('\t', done_queue.get())
# Tell child processes to stop # Tell child processes to stop
for i in range(NUMBER_OF_PROCESSES): for i in range(NUMBER_OF_PROCESSES):