Angenommen, ich habe ein großes Speicher-Numpy-Array, ich habe eine Funktionfunc das nimmt in diesem riesigen Array als Eingabe (zusammen mit einigen anderen Parametern).func mit unterschiedlichen Parametern kann parallel gefahren werden. Zum Beispiel:

def func(arr, param):
    # do stuff to arr, param

# build array arr

pool = Pool(processes = 6)
results = [pool.apply_async(func, [arr, param]) for param in all_params]
output = [res.get() for res in results]

Wenn ich eine Multiprozessorbibliothek verwende, wird dieses Riesenarray mehrmals in verschiedene Prozesse kopiert.

Gibt es eine Möglichkeit, verschiedene Prozesse das gleiche Array gemeinsam nutzen zu lassen? Dieses Array-Objekt ist schreibgeschützt und wird niemals geändert.

Was ist komplizierter, wenn arr kein Array, sondern ein beliebiges Python-Objekt ist, gibt es eine Möglichkeit, es zu teilen?

[EDITED]

Ich habe die Antwort gelesen, bin aber immer noch ein bisschen verwirrt. Da fork () beim Schreiben kopiert wird, sollten wir keine zusätzlichen Kosten verursachen, wenn neue Prozesse in der Python-Multiprozessorbibliothek erzeugt werden. Der folgende Code deutet jedoch auf einen enormen Overhead hin:

from multiprocessing import Pool, Manager
import numpy as np; 
import time

def f(arr):
    return len(arr)

t = time.time()
arr = np.arange(10000000)
print "construct array = ", time.time() - t;


pool = Pool(processes = 6)

t = time.time()
res = pool.apply_async(f, [arr,])
res.get()
print "multiprocessing overhead = ", time.time() - t;

Ausgabe (und im Übrigen steigen die Kosten mit zunehmender Größe des Arrays, so dass ich vermute, dass mit dem Kopieren des Speichers immer noch Overhead verbunden ist):

construct array =  0.0178790092468
multiprocessing overhead =  0.252444982529

Warum ist der Overhead so groß, wenn wir das Array nicht kopiert haben? Und welcher Teil rettet mich das Shared Memory?