파이썬에서 병렬 프로그래밍을 수행하는 방법?

C ++의 경우 OpenMP를 사용하여 병렬 프로그래밍을 수행 할 수 있습니다. 그러나 OpenMP는 Python에서 작동하지 않습니다. 파이썬 프로그램의 일부를 병렬화하려면 어떻게해야합니까?

코드의 구조는 다음과 같이 간주 될 수 있습니다.

solve1(A)
solve2(B)

어디에 solve1그리고 solve2두 개의 독립적 인 기능입니다. 실행 시간을 줄이기 위해 이러한 종류의 코드를 순차적이 아닌 병렬로 실행하는 방법은 무엇입니까? 누군가 나를 도울 수 있기를 바랍니다. 미리 감사드립니다. 코드는 다음과 같습니다

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

setinner와 setouter는 두 개의 독립적 인 기능입니다. 그것이 내가 평행하게하고 싶은 곳입니다 ...

다중 처리 모듈을 사용할 수 있습니다 . 이 경우 처리 풀을 사용할 수 있습니다.

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)

이렇게하면 일반적인 작업을 수행 할 수있는 프로세스가 생성됩니다. 통과하지 않았으므로 processes머신의 각 CPU 코어마다 하나의 프로세스가 생성됩니다. 각 CPU 코어는 하나의 프로세스를 동시에 실행할 수 있습니다.

목록을 단일 함수에 매핑하려면 다음을 수행하십시오.

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

GIL 은 파이썬 객체에 대한 작업을 잠그기 때문에 스레드를 사용하지 마십시오 .

이것은 Ray를 사용 하여 매우 우아하게 수행 할 수 있습니다 .

예제를 병렬화하려면 @ray.remote데코레이터로 함수를 정의한 다음로 호출해야합니다 .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])

멀티 프로세싱 모듈 에 비해 여러 가지 장점이 있습니다.

1. 멀티 코어 머신과 머신 클러스터에서 동일한 코드가 실행됩니다.
2. 프로세스는 공유 메모리 및 제로 카피 직렬화를 통해 데이터를 효율적으로 공유합니다 .
3. 오류 메시지가 잘 전달됩니다.

4. 이 함수 호출은 예를 들어

   @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. 함수를 원격으로 호출하는 것 외에도 클래스를 원격으로 액터 로 인스턴스화 할 수 있습니다 .

참고 레이 내가 개발할 수 있도록했습니다 프레임 워크입니다.

CPython은 C ++보다 병렬 프로그래밍을 좀 더 흥미롭게 만드는 Global Interpreter Lock을 사용합니다.

이 주제에는 문제에 대한 몇 가지 유용한 예와 설명이 있습니다.

Linux에서 태스크 셋을 사용하는 멀티 코어 시스템의 Python GIL (Global Interpreter Lock) 대안?

다른 사람들이 말했듯이 해결책은 여러 프로세스를 사용하는 것입니다. 그러나 어떤 프레임 워크가 더 적합한지는 많은 요소에 달려 있습니다. 이미 언급 한 것 외에도 charm4py 및 mpi4py ( charm4py 의 개발자입니다)도 있습니다.

작업자 풀 추상화를 사용하는 것보다 위의 예를 구현하는 것이 더 효율적인 방법입니다. 메인 루프는 G1000 개의 반복마다 작업자 에게 동일한 매개 변수 (전체 그래프 포함)를 반복해서 보냅니다 . 최소한 한 명의 작업자가 다른 프로세스에 상주하므로 인수를 다른 프로세스로 복사하여 보내야합니다. 객체의 크기에 따라 비용이 많이들 수 있습니다. 대신, 근로자가 상태를 저장하고 업데이트 된 정보를 보내도록하는 것이 좋습니다.

예를 들어, charm4py에서 다음과 같이 할 수 있습니다 :

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
        ...

이 예에서는 실제로 한 명의 작업자 만 필요합니다. 메인 루프는 함수 중 하나를 실행하고 작업자가 다른 함수를 실행하도록 할 수 있습니다. 그러나 내 코드는 몇 가지 사항을 설명하는 데 도움이됩니다.

1. 작업자 A는 프로세스 0에서 실행됩니다 (메인 루프와 동일). result_a.get()작업자 A는 결과를 기다리면서 차단 되지만 작업자 A는 동일한 프로세스에서 계산을 수행합니다.
2. 인수는 동일한 프로세스에 있기 때문에 작업자 A를 참조하여 자동으로 전달됩니다 (복사는 포함되지 않음).

경우에 따라 Numba 를 사용하여 루프를 자동으로 병렬화하는 것이 가능 하지만 작은 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

불행히도 Numba는 Numpy 배열에서만 작동하지만 다른 Python 객체에서는 작동하지 않는 것 같습니다. 이론적으로 파이썬을 C ++ 로 컴파일 한 다음 Intel C ++ 컴파일러를 사용하여 자동으로 병렬 처리 할 수는 있지만 아직 시도하지는 않았습니다.

joblib라이브러리를 사용 하여 병렬 계산 및 다중 처리를 수행 할 수 있습니다 .

from joblib import Parallel, delayed

foo병렬로 실행하려는 함수 를 작성 하고 다음 코드 구현 병렬 처리를 기반으로합니다.

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

다음과 같이 도서관 num_cores에서 얻을 수있는 곳 multiprocessing:

import multiprocessing

num_cores = multiprocessing.cpu_count()

입력 인수가 둘 이상인 함수가 있고 목록으로 인수 중 하나를 반복하려는 경우 라이브러리 의 partial함수를 functools다음과 같이 사용할 수 있습니다 .

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)

python 및 R 멀티 프로세싱에 대한 자세한 설명은 여기 에서 몇 가지 예를 참조하십시오 .