Python-multiprocessing: Wie Sie wissen, zu verwenden, den Pool oder Prozess?

So, ich habe eine Algorithmus, den ich Schreibe, und die Funktion multiprocess soll eine andere Funktion aufrufen, CreateMatrixMp(), auf wie viele Prozesse es gibt cpus, parallel. Ich habe noch nie getan, multiprocessing vor, und kann nicht sicher sein, welche eine der folgenden Methoden effizienter ist. Das Wort "effizient" im Kontext der Funktion CreateMatrixMp() benötigen, um potenziell aufgerufen werden Tausende Male.Ich habe gelesen, die Dokumentation der python - multiprocessing Modul, und sind gekommen, um diese zwei Möglichkeiten:

Erste ist mit der Pool Klasse:

def MatrixHelper(self, args):
    return self.CreateMatrix(*args)

def Multiprocess(self, sigmaI, sigmaX):

    cpus = mp.cpu_count()
    print('Number of cpu\'s to process WM: %d' % cpus)
    poolCount = cpus*2
    args = [(sigmaI, sigmaX, i) for i in range(self.numPixels)]

    pool = mp.Pool(processes = poolCount, maxtasksperchild= 2)
    tempData = pool.map(self.MatrixHelper, args)
    pool.close()
    pool.join()

Und die nächste ist mit der Process Klasse:

def Multiprocess(self, sigmaI, sigmaX):

    cpus = mp.cpu_count()
    print('Number of cpu\'s to process WM: %d' % cpus)

    processes = [mp.Process(target = self.CreateMatrixMp, args = (sigmaI, sigmaX, i,)) for i in range(self.numPixels)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()

Pool scheint die bessere Wahl sein. Ich habe gelesen, dass es verursacht weniger overhead. Und Process berücksichtigt nicht die Anzahl der cpus auf der Maschine. Das einzige problem ist, dass mit Pool in dieser Art und Weise gibt mir Fehler nach, und wenn ich das beheben, gibt es eine neue darunter. Process scheint einfacher zu implementieren, und für alles, was ich weiß, es kann die bessere Wahl sein. Was macht Ihrer Erfahrung sagen Sie?

Wenn Pool verwendet werden soll, dann bin ich Recht in der Wahl map()? Es wäre bevorzugt, dass die Reihenfolge beibehalten wird. Ich habe tempData = pool.map(...) weil die map - Funktion soll, um eine Liste der Ergebnisse von jedem Prozess. Ich bin nicht sicher, wie Process verarbeitet die zurückgegebenen Daten.

Dies scheint ähnlich zu stackoverflow.com/questions/18176178/... vielen Dank
Ich habe gelesen, dass post. Allerdings habe ich einige bitten, andere Fragen hier zu beantworten. Er wird mit zwei Ziel-Funktionen, während ich mich mit ein, er führt keine Argumente an, während ich pass mehrere, und er nicht besorgt zu sein mit seinem target wird eine Instanz-Methode, wie mir ist. Ich habe eine Menge Forschung auf diesem so weit, und beide Pool und Process scheinen, sich anders zu Verhalten in verschiedenen Kontexten, und es scheint sicher, dass einer besser wäre, in bestimmten Situationen, in anderen nicht. Ich dachte, es angebracht, starten Sie eine neue Frage.

InformationsquelleAutor Anonymous | 2015-07-29

15

Ich denke, die Pool Klasse ist in der Regel bequemer, aber es hängt davon ab, ob Sie möchten, dass Ihre Ergebnisse geordnet oder ungeordnet.

Sagen, das Sie erstellen möchten 4 zufällige Zeichenfolgen (e.g,. könnte eine zufällige Benutzer-ID-generator oder so):
```
import multiprocessing as mp
import random
import string

# Define an output queue
output = mp.Queue()

# define a example function
def rand_string(length, output):
    """ Generates a random string of numbers, lower- and uppercase chars. """
    rand_str = ''.join(random.choice(
                    string.ascii_lowercase
                    + string.ascii_uppercase
                    + string.digits)
               for i in range(length))
    output.put(rand_str)

# Setup a list of processes that we want to run
processes = [mp.Process(target=rand_string, args=(5, output)) for x in range(4)]

# Run processes
for p in processes:
    p.start()

# Exit the completed processes
for p in processes:
    p.join()

# Get process results from the output queue
results = [output.get() for p in processes]

print(results)

# Output
# ['yzQfA', 'PQpqM', 'SHZYV', 'PSNkD']
```
Hier, ist die Reihenfolge wohl egal. Ich bin nicht sicher, ob es einen besseren Weg, es zu tun, aber wenn ich will, die Ergebnisse in der Reihenfolge, in der die Funktionen aufgerufen werden, habe ich in der Regel zurück Tupel mit der ID als erstes Element, z.B.,
```
# define a example function
def rand_string(length, pos, output):
    """ Generates a random string of numbers, lower- and uppercase chars. """
    rand_str = ''.join(random.choice(
                    string.ascii_lowercase
                    + string.ascii_uppercase
                    + string.digits)
                for i in range(length))
    output.put((pos, rand_str))

# Setup a list of processes that we want to run
processes = [mp.Process(target=rand_string, args=(5, x, output)) for x in range(4)]

print(processes)

# Output
# [(1, '5lUya'), (3, 'QQvLr'), (0, 'KAQo6'), (2, 'nj6Q0')]
```
Dieses let ' s me Sortieren Sie die Ergebnisse dann:
```
results.sort()
results = [r[1] for r in results]
print(results)

# Output:
# ['KAQo6', '5lUya', 'nj6Q0', 'QQvLr']
```
Der Pool Klasse

Nun zu deiner Frage: Wie unterscheidet sich dies von der Pool Klasse?
Sie würde bevorzugen in der Regel Pool.map zurück geordnete Liste der Ergebnisse ohne Umweg über den Reifen zu schaffen Tupel und sortiert Sie nach ID. Also, ich würde sagen, es ist in der Regel effizienter.
```
def cube(x):
    return x**3

pool = mp.Pool(processes=4)
results = pool.map(cube, range(1,7))
print(results)

# output:
# [1, 8, 27, 64, 125, 216]
```
Gleichwertig, es gibt auch eine "apply" - Methode:
```
pool = mp.Pool(processes=4)
results = [pool.apply(cube, args=(x,)) for x in range(1,7)]
print(results)

# output:
# [1, 8, 27, 64, 125, 216]
```
Beide Pool.apply und Pool.map sperrt das Hauptprogramm, bis ein Prozess beendet wurde.

Nun, Sie haben auch Pool.apply_async und Pool.map_async, die das Ergebnis zurückzugeben, sobald der Prozess abgeschlossen ist, die im wesentlichen ähnlich zu der Process Klasse vor. Der Vorteil kann sein, dass Sie Ihnen die bequeme apply und map Funktionalität, dass Sie wissen, von Python eingebaute apply und map
- Danke für die Antwort. Mein Hauptanliegen bei der Wahl einen über den anderen ist die Berücksichtigung der Maschinen Anzahl der Prozessoren. Im Pool kann man es so einstellen, dass es die gleiche Anzahl von Prozessen als cpus. Aber mit Process, die Anzahl der cpus kommt im nirgendwo. Wird diese behandelt werden, auf Ihre eigenen? Wird es zu etwas mehr Zeit zu gehen über Process? Ich möchte Process, und Pool ist mir eine sehr harte Zeit, mit all seinen pickle-Fehler, aber Process fühlt sich einfach nicht konkret genug sind, wie Pool tut.
- Ich denke, "Prozess" ist eher ein "bare bones" - Ansatz, soweit ich weiß, würden Sie haben, um es zu verwalten manuell. Wenn Sie laichen Prozess ist, sondern alle CPUs ausgelastet sind, wird es in eine Warteschlange eingereiht, bis ein CPU wieder frei. Das könnte ein problem sein, wenn Sie versandfertig zu viele Prozesse auf einmal, das warten (es könnte leicht Essen, bis Ihr system verfügbaren Speicher, wenn die Zahl ist "relativ" groß)
- Ja, der Speicher war ein problem, wenn Sie versuchen zu verwenden Process. Ich habe es mit Pool, vielen Dank für deinen Rat, ich werde markieren Sie diese als beantwortet.
InformationsquelleAutor

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Der Pool Klasse