Este exemplo (enormemente simplificado) funciona bem (Python 2.6.6, Debian Squeeze):

<code>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()
</code>

no entanto, depois de anos de ser ensinadoestado global ruim !!!, todos os meus instintos estão me dizendo que eu realmente prefiro estar escrevendo algo mais próximo de:

<code>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()
</code>

mas é claro que isso não funciona (desliga-se incapaz de pegar algo).

O exemplo aqui é trivial, mas no momento em que você adiciona várias funções de "processo", e cada uma delas depende de várias entradas adicionais ... bem, tudo se torna um pouco reminiscente de algo escrito em BASIC há 30 anos. Tentar usar classes para pelo menos agregar o estado com as funções apropriadas parece uma solução óbvia, masnão parece ser assim tão fácil na prática.

Existe algum padrão ou estilo recomendado para usar o multiprocessing.pool que evitará a proliferação do estado global para suportar cada função que eu quero mapear paralelamente?

Como os "profissionais de multiprocessamento" experientes lidam com isso?

Atualizar: Note que estou realmente interessado em processar matrizes muito maiores, então variações do acimasrc cada chamada / iteração não é tão boa quanto as que são inseridas nos processos de trabalho do pool.