¿Patrones de uso alternativos para el multiprocesamiento de python que evitan la proliferación del estado global? Este

Question

(ejemplo enormemente simplificado) funciona bien (Python 2.6.6, Debian Squeeze):

from multiprocessing import Pool 
import numpy as np 

src=None 

def process(row): 
    return np.sum(src[row]) 

def main(): 
    global src 
    src=np.ones((100,100)) 

    pool=Pool(processes=16) 
    rows=pool.map(process,range(100)) 
    print rows 

if __name__ == "__main__": 
    main() 

sin embargo, después de años de ser enseñado mal estado global !!!, todos mis instintos me dicen que realmente realmente bien estaría escribiendo algo más cercano a:

from multiprocessing import Pool 
import numpy as np 

def main(): 
    src=np.ones((100,100)) 

    def process(row): 
     return np.sum(src[row]) 

    pool=Pool(processes=16) 
    rows=pool.map(process,range(100)) 
    print rows 

if __name__ == "__main__": 
    main() 

pero por supuesto que no funciona (cuelga incapaces de conservar en vinagre algo).

El ejemplo aquí es trivial, pero cuando se agregan varias funciones de "proceso", y cada una de ellas depende de múltiples entradas adicionales ... bueno, todo se parece un poco a algo escrito en BASIC hace 30 años . Intentar utilizar clases para al menos agregar el estado con las funciones apropiadas parece una solución obvia, pero doesn't seem to be that easy en la práctica.

¿Hay algún patrón o estilo recomendado para usar multiprocesamiento.pool que evitará la proliferación del estado global para admitir cada función sobre la que quiero hacer un mapa paralelo?

¿Cómo se enfrentan los experimentados "profesionales de multiprocesamiento" con esto?

actualización: Tenga en cuenta que estoy realmente interesado en gran parte del procesamiento matrices más grandes, por lo que las variaciones en la por encima del cual pickle src cada llamada/iteración no son tan buenos como los que tenedor en los procesos de trabajo de dicho grupo.

Answer 1

Siempre se puede pasar un objeto se puede llamar así, entonces el objeto puede Containe el estado compartido:

from multiprocessing import Pool 
import numpy as np 

class RowProcessor(object): 
    def __init__(self, src): 
     self.__src = src 
    def __call__(self, row): 
     return np.sum(self.__src[row]) 

def main(): 
    src=np.ones((100,100)) 
    p = RowProcessor(src) 

    pool=Pool(processes=16) 
    rows = pool.map(p, range(100)) 
    print rows 

if __name__ == "__main__": 
    main()