11. strategi partisi dan divide & conquer

11. STRATEGI PARTISI DAN DIVIDE & CONQUER

11.1 Partisi

Strategi

Divide & Conquer

Divide & Conquer M-ary

11.2 Contoh Divide & Conquer

Sortir dengan Bucket Sort

Referensi : Wilkinson, Barry & Allen, M, “Parallel Programming”, Prentice Hall, New Jersey, 1999; Chapter 4; hal. 107 - 122

Pengolahan Paralel/KK021239 11/1/26

11.1.1 Strategi Partisi

Deretan dipartisi ke dalam m bagian dan ditambahkan secara bebas untuk membuat penjumlahan parsial

Gambar 4.1 Deretan dipartisi menjadi m bagian dan ditambahkan.

Pengolahan Paralel/KK021239

Contoh - Menambah Sederetan Angka


Menggunakan send( ) s dan recv( ) sMasters = n/m; /* number of numbers for slaves*/for (i = 0, x = 0; i < m; i++, x = x + s) send(&numbers[x], s, Pi); /* send s numbers to slave */

sum = 0;for (i = 0; i < m; i++) { /* wait for results from slaves */ recv(&part_sum, PANY); sum = sum + part_sum; /* accumulate partial sums */}Slaverecv(numbers, s, Pmaster); /* receive s numbers from master */

part_sum = 0;for (i = 0; i < s; i++) /* add numbers */ part_sum = part_sum + numbers[i];send(&part_sum, Pmaster); /* send sum to master */

Pengolahan Paralel/KK021239Pengolahan Paralel/KK021239 11/3/26

Menggunakan rutin Broadcast/ Multicast

Masters = n/m; /* number of numbers for slaves */bcast(numbers, s, Pslave_group); /* send all numbers to slaves */

sum = 0;for (i = 0; i < m; i++){ /* wait for results from slaves */ recv(&part_sum, PANY);

sum = sum + part_sum; /* accumulate partial sums */}Slavebcast(numbers, s, Pmaster); /* receive all numbers from master*/

start = slave_number * s; /* slave number obtained earlier */end = start + s;part_sum = 0;for (i = start; i < end; i++) /* add numbers */ part_sum = part_sum + numbers[i];send(&part_sum, Pmaster); /* send sum to master */


Menggunakan rutin Scatter dan Reduce

Masters = n/m; /* number of numbers */scatter(numbers,&s,Pgroup,root=master); /* send numbers to slaves */reduce_add(&sum,&s,Pgroup,root=master); /* results from slaves */Slavescatter(numbers,&s,Pgroup,root=master); /* receive s numbers */. /* add numbers */reduce_add(&part_sum,&s,Pgroup,root=master); /* send sum to master */


AnalisisKomputasi sekuensial membutuhkan n-1 penambahan dengan kompleksitas waktu O(n)

Paralel : Dengan rutin send dan receiveFase 1 - Komunikasi

tcomm1 = m(tstartup + (n/m)tdata)

Fase 2 - Komputasitcomp1 = n/m - 1

Fase 3 - Komunikasi : mengembalikan hasil parsial dengan rutin send/ recv

tcomm2 = m(tstartup + tdata)

Fase 4 - Komputasi : Akumulasi akhirtcomp2 = m - 1

Jadi tp = (tcomm1 + tcomm2) + (tcomp1 + tcomp2) = 2mtstartup + (n + m)tdata + m + n/m -2 = O(n + m)

Waktu kompleksitas paralel lebih buruk dari sekuensialPengolahan Paralel/KK021239Pengolahan Paralel/KK021239 11/6/26

11.1.2 Divide & Conquer

int add(int *s) /* add list of numbers, s */{ if (number(s) =< 2) return (n1 + n2); /* see explanation */ else { Divide (s, s1, s2); /* divide s into two parts, s1 and s2 */ part_sum1 = add(s1); /*recursive calls to add sub lists */ part_sum2 = add(s2); return (part_sum1 + part_sum2); }}


Karakteristiknya adalah membagi masalah ke dalam sub-sub masalah yang sama bentuknya dengan masalah yang lebih besar.Pembagian selanjutnya ke dalam sub problem yang lebih kecil biasanya dilakukan melalui rekursi.

Definisi rekursi sekuensial untuk menambah sederetan angka :



Hasil akhir

Masalah Awal

Pembagian masalah

Gambar 4.2 Konstruksi Pohon.Pengolahan Paralel/KK021239 11/8/26


Implementasi Paralel

Gambar 4.3 Membagi deretan ke dalam beberapa bagian.

Deretan awal



Gambar 4.3 Penjumlahan Parsial.

Jumlah Akhir


Kode Paralel

/* division phase */divide(s1, s1, s2); /* divide s1 into two, s1 and s2 */send(s2, P4); /* send one part to another process */divide(s1, s1, s2);send(s2, P2);divide(s1, s1, s2);send(s2, P1};part_sum = *s1; /* combining phase */recv(&part_sum1, P1);part_sum = part_sum + part_sum1;recv(&part_sum1, P2);part_sum = part_sum + part_sum1;recv(&part_sum1, P4);part_sum = part_sum + part_sum1;


Misal dibuat ada 8 prosesor untuk menambah sederetan angka.

Proses P0


Kode yang serupa digunakan untuk proses-proses lainnya.

recv(s1, P0); /* division phase */

divide(s1, s1, s2);send(s2, P6);

divide(s1, s1, s2);send(s2, P5);

part_sum = *s1; /* combining phase */recv(&part_sum1, P5);

part_sum = part_sum + part_sum1;recv(&part_sum1, P6);

part_sum = part_sum + part_sum1;send(&part_sum, P0);


Kode untuk proses P4

Proses P4


AnalisisDiasumsikan n adalah pangkat dari 2. Waktu set up komunikasi, tstartup tidak diperhitungkan.

KomunikasiFase Pembagian

Fase Penggabungan

Total waktu komunikasi

Komputasi

Total waktu eksekusi paralel


Gambar 4.5 Bagian dari pohon pencarian


11.1.3 Divide & Conquer M-aryTugas (task) dibagi ke dalam lebih dari 2 bagian setiap tahapannya.Contoh : Tugas dibagi menjadi 4 bagian. Definisi rekursif sekuensialnya :int add(int *s) /* add list of numbers, s */{ if (number(s) =< 4) return(n1 + n2 + n3 + n4); else { Divide (s,s1,s2,s3,s4); /* divide s into s1,s2,s3,s4*/ part_sum1 = add(s1); /*recursive calls to add sublists */ part_sum2 = add(s2); part_sum3 = add(s3); part_sum4 = add(s4); return (part_sum1 + part_sum2 + part_sum3 + part_sum4); }}


Gambar 4.6 Pohon kuarternair (quadtree)


Gambar 4.7 Membagi sebuah citra


Daerah citra

Pembagian pertama ke dalam 4 bagian

Pembagian kedua


Sortir dengan Bucket Sort• Sederetan angka dibagi ke dalam m area yang sama, 0

.. a/m - 1, a/m .. 2a/m - 1, 2a/m .. 3a/m - 1, …• Sebuah “bucket” ditugaskan untuk menampung angka

dalam setiap area• Angka-angka tersebut dimasukkan ke bucket yang

sesuai• Angka-angka tersebut akan disortir dengan

menggunakan algoritma sortir sekuensial setiap bucket.Sortir ini akan baik jika angka-angka awalnya

didistribusikan ke interval yang sudah diketahui, misalnya 0 .. a - 1.


11.2 Contoh Divide & Conquer



Angka yang disortir

Angka yang belum disortir

Bucket

Gambar 4.8 Bucket sort

Merge List


Waktu Sekuensial


Algoritma Paralel

Bucket sort dapat diparalelkan dengan menugaskan satu prosesor untuk setiap bucket - mengurangi suku ke dua (second term) dari persamaan sebelumnya menjadi (n/p)log(n/p) untuk p prosesor (dimana p = m).



Angka yang disortir


Bucket

Gambar 4.9 Satu versi Paralel dari Bucket sort

Merge List

p prosesor


Paralelisasi Selanjutnya• Membagi deretan ke dalam m area, satu area untuk

setiap prosesor

• Setiap prosesor mengatur p “bucket” yang kecil dan memisahkan angka-angka dalam areanya ke dalam bucket-bucket tersebut

• Bucket-bucket kecil ini kemudian dikosongkan ke dalam p bucket akhir untuk sortir, yang membutuhkan masing-masing prosesornya untuk mengirimkan satu bucket kecil ke masing-masing prosesor yang lain (bucket i ke prosesor i).



Angka yang disortir


Bucket besar

Gambar 4.10 Versi Paralel dari Bucket sort

Merge List

p prosesor

Bucket kecil

Bucket kecil dikosongkan

n/m angka


AnalisisFase 1 - Komputasi dan komunikasi (membagi angka)

tcomp1 = n ; tcomm1 = tstartup + tdatanFase 2 - Komputasi (sortir ke bucket kecil)

tcomp2 = n/pFase 3 - Komunikasi (kirim ke bucket besar)

Jika seluruh komunikasi tumpang tindih :

tcomm3 = (p - 1)(tstartup + (n/p2)tdata)Fase 4 - Komputasi (sortir bucket besar)

tcomp4 = (n/p)log(n/p)

Jadi tp = tstartup + tdatan + n/p + (p - 1)(tstartup + (n/p2)tdata) +(n/p)log(n/p)

Diasumsikan angka-angka tersebut didistribusikan untuk mencapai formula ini. Skenario kasus terburuk (worse-case) terjadi ketika semua angka berada dalam satu bucket !


Rutin “all-to-all”Dapat digunakan untuk fase 3 - mengirimkan data dari setiap proses ke setiap proses yang lain

Gambar 4.11 Broadcast “all-to-all”Pengolahan Paralel/KK021239Pengolahan Paralel/KK021239 11/25/26

Rutin “all-to-all” sebenarnya mengubah baris sebuah array menjadi kolom

Gambar 4.12 Efek “all-to-all” dari sebuah arrayPengolahan Paralel/KK021239Pengolahan Paralel/KK021239 11/26/26