Erster Versuch mit Multiprocessing

Hallo,

also auf die schnelle wäre dies hier mein Lösungsvorschlag:

from concurrent.futures import ProcessPoolExecutor
import math
import datetime


def wurzel(k):
    return k, math.sqrt(k)


def main():
    ergebnisse = []
    start = datetime.datetime.now()
    with ProcessPoolExecutor(max_workers=12) as worker:
        processes = [worker.submit(wurzel, nr)
                     for nr in range(1, 5001)]
        for process in processes:
            ergebnisse.extend(process.result())
    ende = datetime.datetime.now()
    print(ergebnisse)
    print(f"Dauer: {ende - start}")


if __name__ == "__main__":
    main()

Hat jetzt bei mir 5 Sekunden gedauert, hängt aber natürlich von der Hardware ab. Deshalb, wie lange dauert der Code bei dir?

Was die optimale Anzahl an max_workers ist, hängt von der CPU ab. Deshalb kann eine höhere oder niedirgere Zahl zu besseren Ergebnissen führen.

Bin hier aber auch nicht wirklich fit, weshalb ich sehr gespannt auf weiter Lösungsvorschläge bin.

EDIT: An diesem Rechner erziehle ich 4 Sekunden wenn ich max_workers auf 4 reduziere.

Noch ein kleiner Hinweis, deine for-Schleife geht nur bis 4999

import math
import datetime


def wurzel(k):
    return k, math.sqrt(k)


def main():
    ergebnisse = []
    start = datetime.datetime.now()
    for nr in range(1, 5001):
        ergebnisse.append(wurzel(nr))
    ende = datetime.datetime.now()
    print(ergebnisse)
    print(f"Dauer: {ende - start}")


if __name__ == "__main__":
    main()

und das geht am schnellsten, also ohne Multiprocessing. Dauer: 0:00:00.002991

Also immer aufpassen, ob es Sinn macht es zu verwenden oder nicht.

In meinem vorherigen Post Zeile 17, statt extend sollte dort append stehen. Kleiner Fehler.

neuernutzer Ein schönes Beispiel für *keine globalen Variablen*. Prozesse haben ihren eigenen Speicher und jeder Prozess hat seine eigene `wurzeln`-Liste und keiner trägt deshalb irgend etwas in die Liste die in dem Prozess existiert der die Arbeitsprozesse startet und jedem davon eine leere Kopie von `wurzeln` überträgt.

Und auch der Code hätte mindestens durch einen ``if __name__ == "__main__":`-Guard geschützt sein müssen, wenn er schon nicht sauber in einer Funktion steckt. Unter Linux/Unix funktioniert das zufällig, unter Windows wäre einem das um die Ohren geflogen. Steht auch laut und deutlich in der Dokumentation von `multiprocessing`.

Es ist ziemlich unsinnig 1250 mal jeweils vier Prozesse zu starten, die dann *eine* Wurzel berechnen, und dann den Prozess wieder beenden. Die Wurzelberechnung von einem Wert ist *sehr* schnell im Gegensatz zu dem ganzen Aufwand der für das starten und abräumen von kompletten Prozessen, dem synchronisieren für jeweils vier Werte, und dem Übertragen der leeren Liste und dem einzelnen Wert zwischen den Prozessen und der Rückgabe vom `None` an den aufrufenden Prozess. Das rechnet sich so gar nicht.

Die Lösung von Hofei ist schon ein bisschen besser, da werden maximal 12 Prozesse gestartet und nicht ein Prozess pro Wert, und die Werte werden einzeln auf diese 12 Prozesse verteilt. Aber eigentlich will man die Werte für so verdammt kurze Berechnungen nicht einzeln an Prozesse übertragen, sondern einen ganzen Haufen Werte auf einmal an die jeweiligen Prozesse übertragen um die kosten für die Kommunikation klein zu halten.

Wieder zurück zu `multiprocessing` gibt es dafür einen `Pool`, dem man die ganze Werte als Sequenz übergeben kann, und der die dann in grösseren Teilen an die Prozesse übergibt, und danach die Ergebnisse wieder einsammelt.

#!/usr/bin/env python3
from multiprocessing import Pool
import math


def sqrt(value):
    return value, math.sqrt(value)


def main():
    with Pool() as pool:
        results = pool.map(sqrt, range(1, 5001))
    print(results)


if __name__ == "__main__":
    main()

Das geht sehr schnell. Ob schneller als ohne zusätzliche Prozesse wage ich zu bezweifeln. Das braucht halt auch ohne Verteilung so gut wie keine Rechenzeit, also lohnt es sich auch nicht das überhaupt verteilen zu wollen.

Edit: Es macht auch keinen Sinn hier Tupel zu erstellen, weil `Pool.map()` die Ergebnisse in die richtige Reihenfolge bringt, also die auch alle brav aufsteigend von 1 bis 5000 als ersten Wert im Tupel stehen haben, im Ergebnis.

Quote from neuernutzer

Ist es in Ordnung, wenn ich (gerne in einem eigenen Thread) meinen Code komplett poste, und ihr sagt mir, was ich wo verbessern kann?

Klar, so hab ich am meisten gelernt, Code gezeigt und nach konstruktiver Kritik gefragt. Versuch aber gleich mal vorab so das Grundlegende zu beachten. Keine globalen Variablen, Pep8 ...

Hallo,

vielleicht könnte man ja noch einwerfen, dass 'time' auch Funktionen zur Messung der Prozessdauer bietet, zum Beispiel process_time

Der letzte Code von Hofei:

import math
from time import process_time


def wurzel(k):
    return k, math.sqrt(k)


def main():
    start = process_time()
    ergebnisse = []
    for nr in range(1, 5001):
        ergebnisse.append(wurzel(nr))
    print(ergebnisse)
    print(f"Dauer: {process_time()- start}")


if __name__ == "__main__":
    main()

Dauer: 0.013281221000000003

Aus Interesse der gleiche Code, nur mit list-comprehension (weil ich das wirklich gerne nutze)

import math
from time import process_time


def wurzel(k):
    return k, math.sqrt(k)


def main():
    start = process_time()
    ergebnisse = [wurzel(nr) for nr in range(1, 5001)]
    print(ergebnisse)
    print(f"Dauer: {process_time()- start}")


if __name__ == "__main__":
    main()

Dauer: 0.009870833999999995

Und dann noch der multiprocessing-Code von __blackjack__

#!/usr/bin/env python3
from multiprocessing import Pool
import math
from time import process_time


def sqrt(value):
    return value, math.sqrt(value)


def main():
    start = process_time()
    with Pool() as pool:
        results = pool.map(sqrt, range(1, 5001))
    print(results)
    print(f'Dauer: {process_time() - start}')


if __name__ == "__main__":
    main()

Dauer: 0.039969237000000005

Alles mit der gleiche Hardware, allerdings ging gerade die Sonne unter

Grüße

Dennis

neuernutzer ich kann mich dem letzten Post von Hofei nur anschließen. So habe ich auch mit Python gestartet und auf diesem Weg lerne ich so auch regelmäßig weiter

Hallo,

ich habe vor längerem mal was zu diversen Beschleunigungsmethoden für Python geschrieben: Link zum Blogpost

Sollte vom Prinzip auch heute noch gelten.

Gruß, noisefloor