Bagaimana cara melakukan pemrograman paralel dengan Python?

Untuk C ++, kita dapat menggunakan OpenMP untuk melakukan pemrograman paralel; Namun, OpenMP tidak akan berfungsi untuk Python. Apa yang harus saya lakukan jika saya ingin memparalelkan beberapa bagian dari program python saya?

Struktur kode dapat dianggap sebagai:

solve1(A)
solve2(B)

Di mana solve1dan solve2dua fungsi independen. Bagaimana menjalankan kode semacam ini secara paralel dan bukan secara berurutan untuk mengurangi waktu berjalan? Semoga ada yang bisa membantu saya. Terima kasih banyak sebelumnya. Kode tersebut adalah:

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

Di mana setinner dan setouter adalah dua fungsi independen. Di situlah saya ingin paralel ...

Anda dapat menggunakan multiprocessing modul . Untuk kasus ini saya mungkin menggunakan kumpulan pemrosesan:

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)

Ini akan menelurkan proses yang dapat melakukan pekerjaan umum untuk Anda. Karena kami tidak lulus processes, itu akan menelurkan satu proses untuk setiap inti CPU pada mesin Anda. Setiap inti CPU dapat menjalankan satu proses secara bersamaan.

Jika Anda ingin memetakan daftar ke satu fungsi Anda akan melakukan ini:

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

Jangan gunakan utas karena GIL mengunci operasi apa pun pada objek python.

Ini bisa dilakukan dengan sangat elegan bersama Ray .

Untuk memparalelkan contoh Anda, Anda harus mendefinisikan fungsi Anda dengan @ray.remotedekorator, dan kemudian memohonnya .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])

Ada beberapa kelebihan dari hal ini dibandingkan modul multiprosesor .

1. Kode yang sama akan dijalankan pada mesin multicore serta sekelompok mesin.
2. Memproses berbagi data secara efisien melalui memori bersama dan serialisasi tanpa salinan .
3. Pesan kesalahan disebarkan dengan baik.

4. Panggilan fungsi ini dapat disusun bersama, misalnya,

   @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. Selain menjalankan fungsi dari jarak jauh, kelas dapat dipakai dari jauh sebagai aktor .

Perhatikan bahwa Ray adalah kerangka kerja yang telah saya bantu kembangkan.

CPython menggunakan Global Interpreter Lock yang membuat pemrograman paralel sedikit lebih menarik daripada C ++

Topik ini memiliki beberapa contoh dan deskripsi tantangan yang berguna:

Solusi Python Global Interpreter Lock (GIL) pada sistem multi-core menggunakan tasket di Linux?

Solusinya, seperti yang orang lain katakan, adalah menggunakan banyak proses. Namun kerangka mana yang lebih tepat tergantung pada banyak faktor. Selain yang sudah disebutkan, ada juga charm4py dan mpi4py (saya adalah pengembang charm4py).

Ada cara yang lebih efisien untuk menerapkan contoh di atas daripada menggunakan abstraksi kumpulan pekerja. Loop utama mengirimkan parameter yang sama (termasuk grafik lengkap G) berulang kali ke pekerja di masing-masing dari 1000 iterasi. Karena setidaknya satu pekerja akan berada pada proses yang berbeda, ini melibatkan menyalin dan mengirimkan argumen ke proses lain. Ini bisa sangat mahal tergantung pada ukuran benda. Sebagai gantinya, masuk akal untuk meminta pekerja menyimpan status dan hanya mengirim informasi yang diperbarui.

Misalnya, dalam charm4py ini dapat dilakukan seperti ini:

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

Perhatikan bahwa untuk contoh ini kita hanya perlu satu pekerja. Loop utama dapat menjalankan salah satu fungsi, dan meminta pekerja mengeksekusi yang lain. Tetapi kode saya membantu mengilustrasikan beberapa hal:

1. Worker A berjalan dalam proses 0 (sama seperti loop utama). Sementara result_a.get()diblokir menunggu hasil, pekerja A melakukan perhitungan dalam proses yang sama.
2. Argumen secara otomatis diteruskan dengan merujuk ke pekerja A, karena itu dalam proses yang sama (tidak ada penyalinan yang terlibat).

Dalam beberapa kasus, dimungkinkan untuk secara otomatis menyejajarkan loop menggunakan Numba , meskipun itu hanya bekerja dengan subset kecil dari 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

Sayangnya, tampaknya Numba hanya bekerja dengan array Numpy, tetapi tidak dengan objek Python lainnya. Secara teori, mungkin juga untuk mengkompilasi Python ke C ++ dan kemudian secara otomatis memparalelasinya menggunakan kompiler Intel C ++ , meskipun saya belum mencobanya.

Anda dapat menggunakan joblibpustaka untuk melakukan komputasi paralel dan multiprosesing.

from joblib import Parallel, delayed

Anda cukup membuat fungsi fooyang ingin Anda jalankan secara paralel dan berdasarkan pada potongan kode berikut yang mengimplementasikan pemrosesan paralel:

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

Di mana num_coresdapat diperoleh dari multiprocessingperpustakaan sebagai berikut:

import multiprocessing

num_cores = multiprocessing.cpu_count()

Jika Anda memiliki fungsi dengan lebih dari satu argumen input, dan Anda hanya ingin mengulangi salah satu argumen dengan daftar, Anda dapat menggunakan partialfungsi dari functoolspustaka sebagai berikut:

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)

Anda dapat menemukan penjelasan lengkap tentang python dan R multiprocessing dengan beberapa contoh di sini .