python multiprocessing, pathos langsam

Question

Heute habe ich etwas Code ausgeführt und ich wollte es auf meinem Multicore-CPU ausführen, also wo ich sogar map schrieb änderte ich es in pool.map. überraschend lief mein Code langsamer, obwohl es so viel Prozessorleistung oder Speicher verwendete (meines Wissens). Also schrieb ich diesen Test, es verwendet Pathos und Multiprocessing.

from pathos.pools import ProcessPool 
from pathos.pools import ThreadPool 
#from pathos.pools import ParallelPool 
from pathos.pools import SerialPool 
from multiprocessing import Pool 

import time 

def timeit(method): 
    def timed(*args, **kw): 
     ts = time.time() 
     result = method(*args, **kw) 
     te = time.time() 
     print ('%r (%r, %r) %2.2f sec' % \ 
       (method.__name__, args, kw, te-ts)) 
     return result 

    return timed 

def times2(x): 
    return 2*x 

@timeit 
def test(max,p): 
    (p.map(times2, range(max))) 

def main(): 
    ppool = ProcessPool(4) 
    tpool = ThreadPool(4) 
    #parapool = ParallelPool(4) 
    spool = SerialPool(4) 
    pool = Pool(4) 
    for i in range(8): 
     max = 10**i 
     print(max) 
     print('ThreadPool') 
     test(max,tpool) 
     #print('ParallelPool') 
     #test(max,parapool) 
     print('SerialPool') 
     test(max,spool) 
     print('Pool') 
     test(max,pool) 
     print('ProcessPool') 
     test(max,ppool) 
     print('===============') 


if __name__ == '__main__': 
    main() 

das sind die Ergebnisse

1 
ThreadPool 
'test' ((1, <pool ThreadPool(nthreads=4)>), {}) 0.00 sec 
SerialPool 
'test' ((1, <pool SerialPool()>), {}) 0.00 sec 
Pool 
'test' ((1, <multiprocessing.pool.Pool object at 0x0000011E63D276A0>), {}) 0.17 sec 
ProcessPool 
'test' ((1, <pool ProcessPool(ncpus=4)>), {}) 0.00 sec 
=============== 
10 
ThreadPool 
'test' ((10, <pool ThreadPool(nthreads=4)>), {}) 0.00 sec 
SerialPool 
'test' ((10, <pool SerialPool()>), {}) 0.00 sec 
Pool 
'test' ((10, <multiprocessing.pool.Pool object at 0x0000011E63D276A0>), {}) 0.00 sec 
ProcessPool 
'test' ((10, <pool ProcessPool(ncpus=4)>), {}) 0.01 sec 
=============== 
100 
ThreadPool 
'test' ((100, <pool ThreadPool(nthreads=4)>), {}) 0.00 sec 
SerialPool 
'test' ((100, <pool SerialPool()>), {}) 0.00 sec 
Pool 
'test' ((100, <multiprocessing.pool.Pool object at 0x0000011E63D276A0>), {}) 0.00 sec 
ProcessPool 
'test' ((100, <pool ProcessPool(ncpus=4)>), {}) 0.01 sec 
=============== 
1000 
ThreadPool 
'test' ((1000, <pool ThreadPool(nthreads=4)>), {}) 0.00 sec 
SerialPool 
'test' ((1000, <pool SerialPool()>), {}) 0.00 sec 
Pool 
'test' ((1000, <multiprocessing.pool.Pool object at 0x0000011E63D276A0>), {}) 0.00 sec 
ProcessPool 
'test' ((1000, <pool ProcessPool(ncpus=4)>), {}) 0.02 sec 
=============== 
10000 
ThreadPool 
'test' ((10000, <pool ThreadPool(nthreads=4)>), {}) 0.00 sec 
SerialPool 
'test' ((10000, <pool SerialPool()>), {}) 0.00 sec 
Pool 
'test' ((10000, <multiprocessing.pool.Pool object at 0x0000011E63D276A0>), {}) 0.00 sec 
ProcessPool 
'test' ((10000, <pool ProcessPool(ncpus=4)>), {}) 0.09 sec 
=============== 
100000 
ThreadPool 
'test' ((100000, <pool ThreadPool(nthreads=4)>), {}) 0.04 sec 
SerialPool 
'test' ((100000, <pool SerialPool()>), {}) 0.00 sec 
Pool 
'test' ((100000, <multiprocessing.pool.Pool object at 0x0000011E63D276A0>), {}) 0.01 sec 
ProcessPool 
'test' ((100000, <pool ProcessPool(ncpus=4)>), {}) 0.74 sec 
=============== 
1000000 
ThreadPool 
'test' ((1000000, <pool ThreadPool(nthreads=4)>), {}) 0.42 sec 
SerialPool 
'test' ((1000000, <pool SerialPool()>), {}) 0.00 sec 
Pool 
'test' ((1000000, <multiprocessing.pool.Pool object at 0x0000011E63D276A0>), {}) 0.17 sec 
ProcessPool 
'test' ((1000000, <pool ProcessPool(ncpus=4)>), {}) 7.54 sec 
=============== 
10000000 
ThreadPool 
'test' ((10000000, <pool ThreadPool(nthreads=4)>), {}) 4.57 sec 
SerialPool 
'test' ((10000000, <pool SerialPool()>), {}) 0.00 sec 
Pool 
'test' ((10000000, <multiprocessing.pool.Pool object at 0x0000011E63D276A0>), {}) 2.25 sec 
ProcessPool 
'test' ((10000000, <pool ProcessPool(ncpus=4)>), {}) 81.51 sec 
=============== 

wie Sie oft ProcessPool schlägt Multiprozessing sehen und ist sogar langsamer als SerialPool. ich i5-2500 leite und ich installiert Pathos heute über pip

>pip freeze 
colorama==0.3.9 
decorator==4.1.2 
dill==0.2.7.1 
helper-htmlparse==0.1 
htmldom==2.0 
lxml==4.0.0 
multiprocess==0.70.5 
pathos==0.2.1 
pox==0.2.3 
ppft==1.6.4.7.1 
py==1.4.34 
pyfs==0.0.8 
pyreadline==2.1 
pytest==3.2.2 
six==1.11.0 

warum geschieht dies?

Answer 1

Sie profitieren nur von der Parallelisierung mit anspruchsvollen Aufgaben. Ihre Aufgabe ist im Vergleich zu den vom Multiprocessing-/Multithreading-Code benötigten Kommunikationen relativ unmittelbar. Versuchen Sie, eine Funktion zu verwenden, die 1s lang ist, und Sie werden den Effekt sehen. Denken Sie auch daran, dass Sie in Python aufgrund der GIL nur von Multithreading profitieren, wenn Sie IO-gebunden sind. Für CPU-beschränkte Tasks gelten Multiprocessing.

Siehe dieses Gespräch von Raymond.