Suponha que eu tenha uma grande matriz numpy memória, eu tenho uma funçãofunc que leva nessa matriz gigante como entrada (juntamente com alguns outros parâmetros).func com diferentes parâmetros podem ser executados em paralelo. Por exemplo:

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]

Se eu usar a biblioteca de multiprocessamento, essa matriz gigante será copiada várias vezes em diferentes processos.

Existe uma maneira de permitir que diferentes processos compartilhem a mesma matriz? Este objeto de matriz é somente leitura e nunca será modificado.

O que é mais complicado, se arr não é um array, mas um objeto python arbitrário, existe uma maneira de compartilhá-lo?

[EDITADO]

Eu li a resposta, mas ainda estou um pouco confuso. Como fork () é copy-on-write, não devemos invocar nenhum custo adicional ao gerar novos processos na biblioteca de multiprocessamento python. Mas o código a seguir sugere que há uma sobrecarga enorme:

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;

saída (e, a propósito, o custo aumenta à medida que o tamanho da matriz aumenta, então eu suspeito que ainda há sobrecarga relacionada à cópia de memória):

construct array =  0.0178790092468
multiprocessing overhead =  0.252444982529

Por que existe uma sobrecarga tão grande se não copiarmos o array? E qual parte da memória compartilhada me salva?