Como fazer programação paralela em Python?

Para C ++, podemos usar o OpenMP para fazer programação paralela; no entanto, o OpenMP não funcionará para Python. O que devo fazer se quiser fazer paralelo com algumas partes do meu programa python?

A estrutura do código pode ser considerada como:

solve1(A)
solve2(B)

Onde solve1e solve2são duas funções independentes. Como executar esse tipo de código em paralelo, em vez de em sequência, a fim de reduzir o tempo de execução? Espero que alguém possa me ajudar. Muito obrigado antecipadamente. O código é:

def solve(Q, G, n):
    i = 0
    tol = 10 ** -4

    while i < 1000:
        inneropt, partition, x = setinner(Q, G, n)
        outeropt = setouter(Q, G, n)

        if (outeropt - inneropt) / (1 + abs(outeropt) + abs(inneropt)) < tol:
            break

        node1 = partition[0]
        node2 = partition[1]

        G = updateGraph(G, node1, node2)

        if i == 999:
            print "Maximum iteration reaches"
    print inneropt

Onde setinner e setouter são duas funções independentes. É aí que eu quero fazer um paralelo ...

Você pode usar o módulo de multiprocessamento . Nesse caso, eu posso usar um pool de processamento:

from multiprocessing import Pool
pool = Pool()
result1 = pool.apply_async(solve1, [A])    # evaluate "solve1(A)" asynchronously
result2 = pool.apply_async(solve2, [B])    # evaluate "solve2(B)" asynchronously
answer1 = result1.get(timeout=10)
answer2 = result2.get(timeout=10)

Isso gerará processos que podem fazer um trabalho genérico para você. Como não passamos processes, ele gerará um processo para cada núcleo de CPU em sua máquina. Cada núcleo da CPU pode executar um processo simultaneamente.

Se você deseja mapear uma lista para uma única função, faça o seguinte:

args = [A, B]
results = pool.map(solve1, args)

Não use threads porque o GIL bloqueia qualquer operação em objetos python.

Isso pode ser feito de maneira muito elegante com Ray .

Para paralelizar seu exemplo, você precisa definir suas funções com o @ray.remotedecorador e depois invocá-las .remote.

import ray

ray.init()

# Define the functions.

@ray.remote
def solve1(a):
    return 1

@ray.remote
def solve2(b):
    return 2

# Start two tasks in the background.
x_id = solve1.remote(0)
y_id = solve2.remote(1)

# Block until the tasks are done and get the results.
x, y = ray.get([x_id, y_id])

Há várias vantagens disso sobre o módulo de multiprocessamento .

1. O mesmo código será executado em uma máquina multicore e em um cluster de máquinas.
2. Os processos compartilham dados de forma eficiente por meio de memória compartilhada e serialização de cópia zero .
3. As mensagens de erro são propagadas de maneira adequada.

4. Essas chamadas de função podem ser compostas juntas, por exemplo,

   @ray.remote
   def f(x):
       return x + 1
   
   x_id = f.remote(1)
   y_id = f.remote(x_id)
   z_id = f.remote(y_id)
   ray.get(z_id)  # returns 4

5. Além de chamar funções remotamente, as classes podem ser instanciadas remotamente como atores .

Observe que Ray é uma estrutura que eu tenho ajudado a desenvolver.

O CPython usa o Global Interpreter Lock, que torna a programação paralela um pouco mais interessante que o C ++

Este tópico possui vários exemplos e descrições úteis do desafio:

Solução alternativa do GIL (Python Global Interpreter Lock) em sistemas com vários núcleos usando o conjunto de tarefas no Linux?

A solução, como outros já disseram, é usar vários processos. Qual estrutura é mais apropriada, no entanto, depende de muitos fatores. Além dos já mencionados, há o charm4py e o mpi4py (eu sou o desenvolvedor do charm4py).

Existe uma maneira mais eficiente de implementar o exemplo acima do que usar a abstração do conjunto de trabalhadores. O loop principal envia os mesmos parâmetros (incluindo o gráfico completo G) repetidamente para os trabalhadores em cada uma das 1000 iterações. Como pelo menos um trabalhador residirá em um processo diferente, isso envolve copiar e enviar os argumentos para os outros processos. Isso pode ser muito caro, dependendo do tamanho dos objetos. Em vez disso, faz sentido que os funcionários armazenem o estado e simplesmente enviem as informações atualizadas.

Por exemplo, no charm4py, isso pode ser feito assim:

class Worker(Chare):

    def __init__(self, Q, G, n):
        self.G = G
        ...

    def setinner(self, node1, node2):
        self.updateGraph(node1, node2)
        ...


def solve(Q, G, n):
    # create 2 workers, each on a different process, passing the initial state
    worker_a = Chare(Worker, onPE=0, args=[Q, G, n])
    worker_b = Chare(Worker, onPE=1, args=[Q, G, n])
    while i < 1000:
        result_a = worker_a.setinner(node1, node2, ret=True)  # execute setinner on worker A
        result_b = worker_b.setouter(node1, node2, ret=True)  # execute setouter on worker B

        inneropt, partition, x = result_a.get()  # wait for result from worker A
        outeropt = result_b.get()  # wait for result from worker B
        ...

Observe que, para este exemplo, realmente precisamos apenas de um trabalhador. O loop principal pode executar uma das funções e fazer com que o trabalhador execute a outra. Mas meu código ajuda a ilustrar algumas coisas:

1. O trabalhador A é executado no processo 0 (igual ao loop principal). Enquanto result_a.get()está bloqueado aguardando o resultado, o trabalhador A faz o cálculo no mesmo processo.
2. Os argumentos são passados ​​automaticamente por referência ao trabalhador A, pois está no mesmo processo (não há cópia envolvida).

Em alguns casos, é possível paralelizar loops automaticamente usando o Numba , embora ele funcione apenas com um pequeno subconjunto do Python:

from numba import njit, prange

@njit(parallel=True)
def prange_test(A):
    s = 0
    # Without "parallel=True" in the jit-decorator
    # the prange statement is equivalent to range
    for i in prange(A.shape[0]):
        s += A[i]
    return s

Infelizmente, parece que o Numba funciona apenas com matrizes Numpy, mas não com outros objetos Python. Em teoria, também pode ser possível compilar Python para C ++ e paralelizar automaticamente usando o compilador Intel C ++ , embora eu ainda não tenha tentado isso.

Você pode usar a joblibbiblioteca para fazer computação e multiprocessamento paralelos.

from joblib import Parallel, delayed

Você pode simplesmente criar uma função fooque deseja executar paralelamente e com base no seguinte trecho de código implementar o processamento paralelo:

output = Parallel(n_jobs=num_cores)(delayed(foo)(i) for i in input)

Onde num_corespode ser obtido da multiprocessingbiblioteca, como segue:

import multiprocessing

num_cores = multiprocessing.cpu_count()

Se você possui uma função com mais de um argumento de entrada e deseja apenas repetir um dos argumentos por uma lista, pode usar o comando partial função da functoolsbiblioteca da seguinte maneira:

from joblib import Parallel, delayed
import multiprocessing
from functools import partial
def foo(arg1, arg2, arg3, arg4):
    '''
    body of the function
    '''
    return output
input = [11,32,44,55,23,0,100,...] # arbitrary list
num_cores = multiprocessing.cpu_count()
foo_ = partial(foo, arg2=arg2, arg3=arg3, arg4=arg4)
# arg1 is being fetched from input list
output = Parallel(n_jobs=num_cores)(delayed(foo_)(i) for i in input)

Você pode encontrar uma explicação completa do multiprocessamento python e R com alguns exemplos aqui .