Multiprocessing - Rohr vs-Warteschlange

• Einen Rohr() nur zwei Endpunkte.

• Einen Queue() können mehrere Erzeuger und Verbraucher.

Wann Sie zu verwenden

Wenn Sie mehr als zwei Punkte zu kommunizieren, verwenden Sie eine Queue().

Wenn Sie brauchen, absolute Leistung, ein Rohr() ist viel schneller, da Queue() baut auf Pipe().

Performance Benchmarking

Nehmen wir an, Sie wollen, um zu laichen zwei Prozesse und senden von Nachrichten zwischen Ihnen, so schnell wie möglich. Dies sind die timing-Ergebnisse einer drag-Rennen zwischen ähnlichen tests mit Pipe() und Queue()... Dies ist auf eine ThinkpadT61 unter Ubuntu 11.10 und Python-2.7.2.

FYI, warf ich in den Ergebnissen für JoinableQueue() als bonus; JoinableQueue() Konten für Aufgaben, wenn queue.task_done() genannt wird (es doesn ' T sogar wissen über die spezifische Aufgabe, es gilt nur unerledigte Aufgaben in der Warteschlange), so dass queue.join() weiß, die Arbeit ist fertig.

Code für jeden am Ende dieser Antwort...

mpenning@mpenning-T61:~$ python multi_pipe.py 
Sending 10000 numbers to Pipe() took 0.0369849205017 seconds
Sending 100000 numbers to Pipe() took 0.328398942947 seconds
Sending 1000000 numbers to Pipe() took 3.17266988754 seconds
mpenning@mpenning-T61:~$ python multi_queue.py 
Sending 10000 numbers to Queue() took 0.105256080627 seconds
Sending 100000 numbers to Queue() took 0.980564117432 seconds
Sending 1000000 numbers to Queue() took 10.1611330509 seconds
mpnening@mpenning-T61:~$ python multi_joinablequeue.py 
Sending 10000 numbers to JoinableQueue() took 0.172781944275 seconds
Sending 100000 numbers to JoinableQueue() took 1.5714070797 seconds
Sending 1000000 numbers to JoinableQueue() took 15.8527247906 seconds
mpenning@mpenning-T61:~$

Zusammenfassend Pipe() ist etwa drei mal schneller als ein Queue(). Denken Sie gar nicht über die JoinableQueue() es sei denn, Sie wirklich haben müssen, die Vorteile.

BONUS-MATERIAL 2

Multiprocessing eingeführt subtile Veränderungen in der Informationen fließen, die machen das Debuggen schwer, es sei denn, Sie wissen, einige Verknüpfungen. Zum Beispiel, haben Sie vielleicht ein Skript, das funktioniert gut, wenn die Indizierung durch ein Wörterbuch unter vielen Bedingungen, aber selten scheitert mit bestimmten Eingaben.

Normalerweise erhalten wir Hinweise auf die zu Versagen ist, wenn die gesamte python-Prozess stürzt ab, jedoch bekommen Sie keine unerwünschte crash-tracebacks auf der Konsole ausgegeben, wenn die multiprocessing-Funktion stürzt ab. Aufspüren von unbekannten Rendern abstürzt, ist es schwer, ohne eine Ahnung, was abgestürzten Prozess.

Die einfachste Möglichkeit, die ich gefunden habe, um track down multiprocessing crash informaiton ist, wickeln Sie die ganze multiprocessing-Funktion in einem try /except und verwenden traceback.print_exc():

import traceback
def reader(args):
    try:
        # Insert stuff to be multiprocessed here
        return args[0]['that']
    except:
        print "FATAL: reader({0}) exited while multiprocessing".format(args) 
        traceback.print_exc()

Nun, wenn Sie finden, ein crash, Sie sehen etwas wie:

FATAL: reader([{'crash', 'this'}]) exited while multiprocessing
Traceback (most recent call last):
  File "foo.py", line 19, in __init__
    self.run(task_q, result_q)
  File "foo.py", line 46, in run
    raise ValueError
ValueError

Source Code:

"""
multi_pipe.py
"""
from multiprocessing import Process, Pipe
import time

def reader_proc(pipe):
    ## Read from the pipe; this will be spawned as a separate Process
    p_output, p_input = pipe
    p_input.close()    # We are only reading
    while True:
        msg = p_output.recv()    # Read from the output pipe and do nothing
        if msg=='DONE':
            break

def writer(count, p_input):
    for ii in xrange(0, count):
        p_input.send(ii)             # Write 'count' numbers into the input pipe
    p_input.send('DONE')

if __name__=='__main__':
    for count in [10**4, 10**5, 10**6]:
        # Pipes are unidirectional with two endpoints:  p_input ------> p_output
        p_output, p_input = Pipe()  # writer() writes to p_input from _this_ process
        reader_p = Process(target=reader_proc, args=((p_output, p_input),))
        reader_p.daemon = True
        reader_p.start()     # Launch the reader process

        p_output.close()       # We no longer need this part of the Pipe()
        _start = time.time()
        writer(count, p_input) # Send a lot of stuff to reader_proc()
        p_input.close()
        reader_p.join()
        print("Sending {0} numbers to Pipe() took {1} seconds".format(count,
            (time.time() - _start)))

"""
multi_queue.py
"""

from multiprocessing import Process, Queue
import time
import sys

def reader_proc(queue):
    ## Read from the queue; this will be spawned as a separate Process
    while True:
        msg = queue.get()         # Read from the queue and do nothing
        if (msg == 'DONE'):
            break

def writer(count, queue):
    ## Write to the queue
    for ii in range(0, count):
        queue.put(ii)             # Write 'count' numbers into the queue
    queue.put('DONE')

if __name__=='__main__':
    pqueue = Queue() # writer() writes to pqueue from _this_ process
    for count in [10**4, 10**5, 10**6]:             
        ### reader_proc() reads from pqueue as a separate process
        reader_p = Process(target=reader_proc, args=((pqueue),))
        reader_p.daemon = True
        reader_p.start()        # Launch reader_proc() as a separate python process

        _start = time.time()
        writer(count, pqueue)    # Send a lot of stuff to reader()
        reader_p.join()         # Wait for the reader to finish
        print("Sending {0} numbers to Queue() took {1} seconds".format(count, 
            (time.time() - _start)))

"""
multi_joinablequeue.py
"""
from multiprocessing import Process, JoinableQueue
import time

def reader_proc(queue):
    ## Read from the queue; this will be spawned as a separate Process
    while True:
        msg = queue.get()         # Read from the queue and do nothing
        queue.task_done()

def writer(count, queue):
    for ii in xrange(0, count):
        queue.put(ii)             # Write 'count' numbers into the queue

if __name__=='__main__':
    for count in [10**4, 10**5, 10**6]:
        jqueue = JoinableQueue() # writer() writes to jqueue from _this_ process
        # reader_proc() reads from jqueue as a different process...
        reader_p = Process(target=reader_proc, args=((jqueue),))
        reader_p.daemon = True
        reader_p.start()     # Launch the reader process
        _start = time.time()
        writer(count, jqueue) # Send a lot of stuff to reader_proc() (in different process)
        jqueue.join()         # Wait for the reader to finish
        print("Sending {0} numbers to JoinableQueue() took {1} seconds".format(count, 
            (time.time() - _start)))