Python: Multicore-Verarbeitung?

Ich ve wurde Lesen über Python ' s multiprocessing-Modul. Ich glaube trotzdem nicht, dass ich ein sehr gutes Verständnis von, was es tun kann.

Sagen wir, ich habe ein quadcore-Prozessor und ich habe eine Liste mit 1.000.000 Integer und ich möchte die Summe aller ganzen zahlen. Ich könnte einfach tun:

list_sum = sum(my_list)

Aber das nur sendet es an einen Kern.

Ist es möglich, mit dem multiprocessing-Modul, teilen Sie das array, und jeder Kern bekommt die Summe seiner Teil und geben den Wert zurück, damit die gesamte Summe berechnet werden?

Etwas wie:

core1_sum = sum(my_list[0:500000])          #goes to core 1
core2_sum = sum(my_list[500001:1000000])    #goes to core 2
all_core_sum = core1_sum + core2_sum        #core 3 does final computation

Jede mögliche Hilfe würde geschätzt.

InformationsquelleAutor der Frage Nope | 2009-07-25

  1. 30

    Ja, es ist möglich, dies zu tun Summierung über mehrere Prozesse, die sehr viel tun, wie es mit mehreren threads:

    from multiprocessing import Process, Queue

def do_sum(q,l):
    q.put(sum(l))

def main():
    my_list = range(1000000)

    q = Queue()

    p1 = Process(target=do_sum, args=(q,my_list[:500000]))
    p2 = Process(target=do_sum, args=(q,my_list[500000:]))
    p1.start()
    p2.start()
    r1 = q.get()
    r2 = q.get()
    print r1+r2

if __name__=='__main__':
    main()

    Allerdings ist es wahrscheinlich, dass es zu tun mit mehreren Prozessen ist wahrscheinlich langsamer als wenn man es in einem einzelnen Prozess, wie das kopieren der Daten hin und zurück ist teurer als Sie zu addieren sofort.

    InformationsquelleAutor der Antwort Martin v. Löwis

  2. 20

    Willkommen der Welt des concurrent programming.

    Was Python kann (und nicht kann) zu tun, hängt von zwei Dingen.

    1. Was das OS kann (und nicht kann) zu tun. Die meisten OS ' s zuweisen von Prozessen auf Kerne. Zu nutzen 4 Kerne, die Sie brauchen, um zu brechen, Ihr problem in vier Prozesse. Dies ist einfacher als es klingt. Manchmal.

    2. Welche die zugrunde liegenden C-Bibliotheken kann (und nicht kann) zu tun. Wenn die C-Bibliotheken setzen features des OS UND das Betriebssystem stellt Funktionen von der hardware, Sie sind solide.

    Brechen ein problem in mehrere Prozesse-vor allem bei GNU/Linux -- ist einfach. Brechen Sie in ein multi-Schritt-pipeline.

    Im Falle der Summen-eine million zahlen, denken Sie an das folgende shell-Skript. Vorausgesetzt, einige hypothetische sum.py Programm, das Summen entweder eine Reihe von zahlen oder eine Liste von zahlen auf stdin.

    ( sum.py 0 500000 & sum.py 50000 1000000 ) | sum.py

    Dies hätte 3 gleichzeitige Prozesse. Zwei sind dabei Summen von einer Menge von zahlen, die Dritte ist addieren zwei zahlen.

    Da die GNU/Linux-shells und das OS bereits handhaben einige Teile der Parallelität für Sie ist, können Sie einfache (sehr einfache) Programme, die von stdin Lesen, nach stdout schreiben, und sind entworfen, um kleine Teile eine große Aufgabe.

    Können Sie versuchen, zu reduzieren die Gemeinkosten durch die Verwendung von Teilprozess zum Bau der pipeline statt der Aufteilung der Arbeit auf der shell. Sie können feststellen, jedoch, dass die shell baut pipelines sehr, sehr schnell. (Es wurde direkt geschrieben in C und ermöglicht eine direkte OS-API-Aufrufe für Sie.)

    InformationsquelleAutor der Antwort S.Lott

  3. 7

    Sicher, zum Beispiel:

    from multiprocessing import Process, Queue

thelist = range(1000*1000)

def f(q, sublist):
    q.put(sum(sublist))

def main():
    start = 0
    chunk = 500*1000
    queue = Queue()
    NP = 0
    subprocesses = []
    while start < len(thelist):
      p = Process(target=f, args=(queue, thelist[start:start+chunk]))
      NP += 1
      print 'delegated %s:%s to subprocess %s' % (start, start+chunk, NP)
      p.start()
      start += chunk
      subprocesses.append(p)
    total = 0
    for i in range(NP):
      total += queue.get()
    print "total is", total, '=', sum(thelist)
    while subprocesses:
      subprocesses.pop().join()

if __name__ == '__main__':
    main()

    Ergebnisse in:

    $ python2.6 mup.py 
delegated 0:500000 to subprocess 1
delegated 500000:1000000 to subprocess 2
total is 499999500000 = 499999500000

    beachten Sie, dass diese Granularität zu fein ist, den Wert von Laich-Prozesse für -- die insgesamt summieren Aufgabe ist klein (das ist, warum kann ich das neu berechnen der Summe im wesentlichen als eine Prüfung;-) und zu viele Daten hin und her verschoben (in der Tat werden die Teilprozesse würde nicht brauchen, um Kopien der Teillisten arbeiten Sie an -- Indizes würden schon reichen). Also, es ist ein "Spielzeug-Beispiel" wo multiprocessing ist nicht wirklich gerechtfertigt. Mit unterschiedlichen Architekturen (verwenden Sie einen pool von Teilprozessen, die mehrere Aufgaben aus einer Warteschlange, die Daten minimieren Bewegungen hin und her, etc, etc) und auf der weniger granularen Aufgaben, die Sie könnte tatsächlich Vorteile in Bezug auf Leistung, aber.

    InformationsquelleAutor der Antwort Alex Martelli

Schreibe einen Kommentar