Algoritma Paralel Untuk Menghitung Nilai Pi

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan

Aturan Simpson

March 30, 2010

Algoritma Paralel untuk untuk Menghitung Menghitung Nilai π dengan

Pendekatan Aturan Simpson Boy Dewa Priambada Program Pascasarjana Ilmu Komputer Institut Pertanian Bogor

Pendahuluan Dalam kehidupan sehari-hari sering dihadapkan oleh adanya upaya pemecahan suatu masalah yang mengarah pada evaluasi integral yang analitis dan sangat rumit atau bahkan tidak mungkin untuk dipecahkan oleh komputasi dengan single prosesor . Untuk dapat memecahkan masalah ini dibutuhkan sebuah komputasi yang menggunakan menggunakan multi prosesor secara paralel. Dalam paper ini dijelaskan contoh mencari nilai π secara diskret diskret dengan menggunakan pendekatan pendekatan aturan Simpson Simpson dan untuk dapat

dikomputasi secara paralel digunakan metode Foster. Implementasi dari algoritma paralel ini menggunakan bahasa C dengan menggunakan MPI (message passing interface) sebagai library -nya. -nya.

Aturan Simpson Untuk mencari nilai π secara diskret dapat digunakan pendekatan aturan Simpson. Dalam mencari nilai

tersebut, aturan Simpson menggunakan pendekatan piecewise kuadratik dimana dapat memberikan ketepatan yang cukup baik untuk menyelesaikan suatu masalah tetapi mudah dalam penerapannya. Untuk memperoleh aturan Simpson kami membagi interval integrasi a ≤ x ≤ b menjadi sama bah kan

untuk jumlah subintervals, kedalam

dengan panjang subinterval

, dengan endpoints

. Sekarang ambil dua sub interval yang pertama dan buat pendekatan dalam interval , dimana

dengan Lagrange Polynomial

. Dengan menggunakan aturan tersebut akan didapatkan rumus:

Penyebut adalah 2h ^ 2,-h ^ 2, dan 2h ^ 2, masing-masing. Setting ,

,

menjadi

, kita punya

, dan kita memperoleh:

1|Page

,


Aturan Simpson

March 30, 2010

Kemudian rumus tersebut kita integralkan sehingga didapat:

Dengan mensubstitusi nilai yang ada maka akan diperoleh aturan Simpson:

Aturan Rieman Partisi pada interval [0 ,1] terdiri atas n bagian yang sama lebar. Lebar tiap subinterval

, P

= 0 = x 0 < x 1 < · · · < x n−1 < x n = 1 Ambil salah satu partisi sebagai berikut :

f(xi-1)

xi-1

xi

Dalam tiap selang bagian [ x x i-1, i-1, x i i], ambil titik sampel

, Dengan menggunakan konsep penjumlahan

Riemann, maka luas daerah integral tersebut adalah hasil penjumlahan dari luas seluruh partisi yang ada.

, i = 1, 2, …, n.

Maka, dengan menggunakan metode diskrit untuk menghitung nilai integral dari diperoleh

2|Page


Aturan Simpson

March 30, 2010

Metodologi Foster dalam Desain Algoritma Paralel Foster didalam Quinn (2003) mengajukan sebuah metodologi dalam mendesain suatu algoritma paralel. Metodologi Foster pada dasarnya adalah suatu urutan langkah-langkah untuk partisi komputasi/data menjadi potongan-potongan (tugas), menentukan komunikasi antara potongan-potongan (tugas), pengelompokan potongan-potongan (tugas) yang memiliki komunikasi yang intens satu sama lain, lalu akhirnya pemetaan kelompok-kelompok ini menjadi beberapa prosesor yang kita miliki. Dalam mendesain suatu algoritma paralel, Foster mengelompokkannya kedalam empat langkah, yaitu: Partisi (Partitioning) Komunikasi (Communication) Aglomerasi ( Agglomeration Agglomeration) Pemetaan (Mapping)

Partitioning Problem

Communication

Mapping

Agglomeration

Gambar 1. Metodologi Foster dalam Desain Algoritma Paralel.

Partisi ( partitioning partitioning) Partisi adalah proses membagi perhitungan dan data kedalam potongan-potongan kecil. Foster menguraikan proses partisi kedalam 2 jenis yaitu: Domain decomposition Functional decomposition

paralel yang menggunakan menggunakan pendekatan pendekatan dimana data dibagi dibagi Domain decomposition adalah algoritma paralel terlebih dahulu kemudian menetapkan bagaimana hubungan antara data dan komputasi terjadi.

3|Page


Aturan Simpson

March 30, 2010

Gambar 2. Domain decomposition.

Functional decomposition adalah algoritma paralel yang menggunakan pendekatan dimana komputasi

dibagi terlebih dahulu kemudian menetapkan bagaimana hubungan data dengan komputasi yang ada.

Gambar 3. Functional decomposition.

Dekomposisi manapun yang kita pilih, keduanya dapat disebut sebagai primitif task . Tujuan utama dipergunakannya proses proses dekomposisi adalah untuk mengidentifikasi sebanyak sebanyak mungkin primitif task , karena jumlah primitif task adalah modal utama dalam memanfaatkan paralelisme. Untuk mengevaluasi suatu partisi agar dapat memenuhi semua kriteria kualitas yang baik dapat digunakan empat kriteria. a. Minimal ada suatu primitive task terurut yang jauh lebih banyak daripada prosesor pada komputer paralel target. 4|Page


Aturan Simpson

March 30, 2010

b. Redundansi pada komputasi dan redundansi pada struktur penyimpanan data minimal. (Jika kondisi ini tak terpenuhi maka desain tidak akan berjalan baik ketika ukuran masalah meningkat) c. Primitive task relatif berukuran sama. (Jika tidak maka sulit untuk menyeimbangkan kerja antar prosesor) d. Jumlah tugas adalah fungsi peningkatan dari ukuran masalah. (Jika tidak maka sangat tidak mungkin menggunakan lebih banyak prosesor untuk memecahkan masalah yang lebih besar) Komunikasi (Communication) Setelah melakukan pembagian perhitungan dan data kedalam potongan-potongan kecil maka kita harus membuat suatu skema komunikasi antar bagian tersebut. Pada proses ini komunikasi yang dapat digunakan dibagi menjadi dua jenis yaitu: Local Communication Global Communication

Local communication adalah ketika suatu pekerjaan membutuhkan suatu nilai dari sejumlah kecil pekerjaan yang lain, maka kita membuat channel dari pekerjaan yang menghasilkan data ke pekerjaan yang menggunakan data tersebut. Global communication digunakan ketika sejumlah besar primitive task harus menghasilkan data untuk menunjang suatu proses komputasi. Contoh dari komunikasi global adalah kalkulasi penjumlahan nilai yang dilakukan oleh suatu proses primitif. Selama komunikasi global secara umum tidak diperlukan channel komunikasi pada tahap desain algoritma. Untuk mengevaluasi kualitas dari sebuah struktur komunikasi dalam algoritma paralel, dibuat empat kriteria, yaitu: a.

Operasi komunikasi seimbang antara satu tugas dengan tugas yang lain.

b. Setiap modul komunikasi tugas hanya memiliki sejumlah kecil tetangga. c.

Task dapat menunjang komunikasi serempak.

d. Task mampu menunjang komputasi serempak. Aglomerasi (Agglomeration) Aglomerasi adalah proses mengelompokkan pekerjaan ke dalam pekerjaan yang lebih besar guna meningkatkan kinerja maupun menyederhanakan pemrograman. Pada proses ini, group pecahan dari pekerjaan yang ada di bagi secara rata ke dalam jumlah prosesor yang dibandingkan. Salah satu tujuan aglomerasi adalah mengurangi cost komunikasi suatu algoritma paralel. Cara lain untuk mengurangi cost komunikasi adalah mengkombinasikan mengkombinasikan grup yang menyampaikan menyampaikan dan menerima pekerjaan dengan cara mengurangi jumlah pengiriman pesan pendek dengan jumlah yang banyak digantikan dengan mengirim 5|Page


Aturan Simpson

March 30, 2010

pesan panjang dengan dengan jumlah sedikit sedikit sehingga dapat mengurangi mengurangi biaya pengiriman pesan. Hal ini berkaitan dengan message latency yang terjadi setiap kali pesan dikirim dan waktu itu tergantung pada panjang pesan. Tujuan lain aglomerasi adalah memelihara skalabilitas dari sebuah algoritma paralel. Selain itu, dengan menggunakan aglomerasi dapat mengurangi biaya perekayasaan perangkat lunak. Jika kita memparalelkan program sekuensial, satu proses aglomerasi memungkinkan kita untuk menggunakan kode sekuensial yang telah ada, mengurangi waktu dan mahalnya pengembangan program. Beberapa kriteria yang dapat mengevaluasi baik dan tidaknya kinerja dari aglomerasi yang telah dibuat adalah: a.

Aglomerasi telah meningkatkan lokalitas program paralel.

b. Replikasi komputasi membutuhkan waktu yang jauh lebih singkat daripada komunikasi yang dihilangkan. c.

Jumlah replikasi data cukup kecil bagi algoritma.

d. Tugas-tugas aglomerasi memiliki biaya komunikasi dan komputasi yang hampir sama. e. Jumlah pekerjaan yang ada adalah fungsi peningkatan dari jumlah masalah. f.

Jumlah pekerjaan yang ada minimal sebanyak prosesor pada komputer target.

g. Trade off antara aglomerasi yang dipilih dan dan biaya modifikasi menjadi kode kode sekuensial yang telah telah ada masih dalam batas wajar.

Gambar 4. Proses aglomerasi suatu pekerjaan. Pemetaan (Mapping) Pemetaan adalah suatu proses penandaan suatu pekerjaan kedalam prosesor yang bertujuan untuk memaksimalkan kerja prosesor dengan mengurangi komunikasi antar prosesor yang berlebihan yang dapat mempengaruhi kinerja dari suatu prosesor. Kemampuan kerja prosesor adalah waktu rata-rata prosesor dapat mengeksekusi pekerjaan dan menyelesaikannya menjadi sebuah solusi yang dibutuhkan. Kemampuan ini dapat maksimal jika komputasi berjalan seimbang sehingga memungkinkan semua prosesor dapat memulai dan mengakhiri suatu pekerjaan dalam waktu bersamaan. Kemampuan

6|Page


Aturan Simpson

March 30, 2010

prosesor dapat dikatakan minimal apabila ada satu atau lebih prosesor mengalami idle time atau waktu tunda karena tidak adanya pekerjaan yang dapat dilaksanakan. Peningkatan kemampuan prosesor dan meminimalisir komunikasi antar prosesor sering memiliki tujuan yang berseberangan. Sebagai contoh, misalkan tersedia sebanyak p prosesor. Pemetaan setiap task ke prosesor yang sama mampu menurunkan komunikasi antar prosesor hingga 0, namun mengurangi kemampuan prosesor sebesar 1/p. Tujuannya sekarang adalah bagaimana memilih suatu pemetaan yang merepresentasikan suatu titik tengah diantara memaksimalkan kemampuan prosesor dan mengurangi komunikasi. Beberapa kriteria yang dapat mengevaluasi baik dan tidaknya kinerja dari pemetaan yang telah dibuat adalah: a.

Desain dengan satu pekerjaan per prosesor dan multi pekerjaan per prosesor t elah dipertimbangkan dengan matang.

b. Alokasi pekerjaan dinamis dan statis per prosesor telah dievaluasi. c.

Jika alokasi pekerjaan dinamis telah dipilih, prosesor manajer bukan menjadi sumber masalah bagi kinerja program.

d. Jika alokasi pekerjaan statis yang dipilih, rasio pekerjaan per prosesor minimal 10 : 1.

Gambar 5. Proses pemetaan dari suatu pekerjaan.

Mencari Nilai π dengan Metode Foster

secara matematik untuk mencari nilai π dapat dihitung dengan menggunakan rumus integral:

Secara geometris nilai nilai tersebut dapat ditunjukkan sebagai sebagai suatu kurva. Untuk mendapatkan nilai π bisa

dilakukan dengan cara menjumlahkan luas di bawah kurva. Daerah di bawah kurva dibagi-bagi menjadi banyak bagian. Semakin banyak bagian yang t erbentuk maka makin baik hasilnya.

7|Page


Aturan Simpson

March 30, 2010

4

3.5

3

2.5

Gambar 6. Ilusutrasi nilai geometris π .

Secara integral, rumus tersebut dapat dituliskan kedalam bahasa C adalah sebagai berikut: double Function(double x) { return 4/(1+(x*x)); } Dengan menggunakan rumus diskret yang telah di turunkan oleh Simpson menjadi suatu formula yaitu:

Dengan

and

, yang kemudian dapat dituliskan kedalam bahasa C sebagai

berikut: double AturanSimpson(int AturanSimpson(int n, double a0, double an) { double h = (1.0-0.0)/n; int i = 0; double a = a0; double hasil = 0.0; while(a while (a <= an) { if(i if (i != n-1) { if(i%2 if (i%2 == 0) { hasil += 2*Sekuen(a); } else { hasil += 4*Sekuen(a); } } else { hasil += Sekuen(a);

8|Page


Aturan Simpson

March 30, 2010

} i++; a += h; } hasil = hasil / (3*n); return hasil; }

Untuk dapat diimplementasikan diimplementasikan kedalam komputasi paralel, digunakan metode pendekatan Foster yang dibagi kedalam 4 tahap, yaitu: Membuat Partisi

Pada tahap ini, kurva dari sebuah masalah dibagi dengan teknik domain dekomposisi ke dalam n partisi dengan masing-masing partisi berisi jumlah masalah yang sama. Proses membuat partisi tersebut dapat diilustrasikan kedalam sebuah gambar seperti dibawah ini.

Gambar 7. Ilustrasi pembuatan partisi dari masalah. Membuat Komunikasi

Pada tahap ini semua partisi yang telah dibuat sebelumnya dan dikomputasi secara terpisah perlu digabungkan kembali. Untuk menggabungkan hasil komputasi tersebut dibutuhkan sebuah komunikasi antar prosesor yang terlibat. Membuat Aglomerasi

Pada tahap ini sebanyak 20 partisi yang telah dibuat dikelompokkan kedalam empat group pekerjaan yang masing-masing memiliki anggota lima partisi. Tujuan di lakukannya aglomerasi adalah untuk mengurangi cost komunikasi yang dibutuhkan untuk pemrosesan paralel.

9|Page


Aturan Simpson

March 30, 2010

Gambar 8. Ilustrasi proses pengelompokkan partisi kedalam empat group. Memetakan

Pada tahap ini setiap group hasil aglomerasi dipetakan kedalam satu prosesor, karena aturan dari pemetaan adalah harus sesederhana mungkin. Tahap pemetaan ini dilaksanakan dengan tujuan untuk dapat mengetahui seberapa banyak prosesor yang dibutuhkan untuk memproses suatu pekerjaan.

Gambar 9. Proses pemetaan setiap group hasil aglomerasi.

Untuk dapat dikomputasi secara paralel dibutuhkan sebuah algoritma pemrograman paralel yang dapat membagi pekerjaan kedalam beberapa prosesor . Fungsi Fungsi “main” tersebut dapat dituliskan dituliskan dalam bahasa C sebagai berikut: int main(int main(int argc, char char** ** argv) { int ukuran, peringkat, i; int n = 500000; MPI_Status status; MPI_Init(&argc, &argv); 10 | P a g e


Aturan Simpson

March 30, 2010

MPI_Comm_size(MPI_COMM_WORLD, MPI_Comm_size(MPI_COMM_WORLD, &ukuran); MPI_Comm_rank(MPI_COMM_WORLD, MPI_Comm_rank(MPI_COM M_WORLD, &peringkat); if (peringkat (peringkat == 0) { double GlobalPi = 0.0; double bufferPi; for(i for (i = 1; i < ukuran; i++) { MPI_Recv(&bufferPi, 1, MPI_DOUBLE, i, 1, MPI_COMM_WORLD, &status); GlobalPi += bufferPi; } printf("Nilai printf("Nilai Pi menurut aturan Simpson adalah = %f\n" %f\n",, GlobalPi); printf("Nilai printf("Nilai Pi menurut teorema yang dibulatkan(6 digit) adalah = 3.141592 printf("------------------------------------------------------------------printf("------------------------------------------------------------------" ); "); printf(" printf(" Nilai Error = %f\n" %f\n",, GlobalPi-3.141592);

");

} else { double localPi; double a0 = (peringkat-1)/(ukuran-1); double an = (peringkat)/(ukuran-1); localPi = AturanSimpson(n, a0, an); MPI_Send(&localPi, 1, MPI_DOUBLE, 0, 1, MPI_COMM_WORLD); } MPI_Finalize(); return 0; } Hasil yang didapat dari pencarian nilai π dengan menggunakan metode Foster dengan aturan Simpson

dengan menggunakan komputasi paralel dapat dilihat dalam gambar berikut.

11 | P a g e


Aturan Simpson

March 30, 2010

Gambar 10. Proses uji dari algoritma paralel untuk menentukan nilai π.

Kesimpulan Dari proses uji algoritma diatas dapat disimpulkan bahwa semakin besar jumlah prosesor yang digunakan maka semakin besar juga simpangan nilai yang didapat, sehingga perlu diperhitungkan jumlah prosesor paralel yang digunakan secara optimal

Daftar Pustaka Anadra, Rezky. Jurnal : Metode Desain Foster dan Implementasinya dalam Mencari Nilai π. IPB.

Kreyszig, Erwin. 2003. Advanced Engineering Mathematics 8th Edition. John Wiley & Sons, Inc. Quinn, Michael J. 2003. Parallel Programming in C with MPI and OpenMP. McGrawHill. New York. Sasono, Norman. Jurnal : Parallel Implementation of Simpson’s Rule for Numerical Integration to Approximate The Value of π. IPB

12 | P a g e


Aturan Simpson

March 30, 2010

Lampiran #include "stdafx.h" #include #include double Sekuen(double Sekuen(double a) { return 4/(1+(a*a)); } double AturanSimpson(int AturanSimpson(int n, double a0, double an) { double h = (1.0-0.0)/n; int i = 0; double a = a0; double hasil = 0.0; while(a <= an) while(a { if (i (i != n-1) { if (i%2 (i%2 == 0) { hasil += 2*Sekuen(a); } else { hasil += 4*Sekuen(a); } } else { hasil += Sekuen(a); } i++; a += h; } hasil = hasil / (3*n); return hasil; } int main(int main(int argc, char char** ** argv) { int ukuran, peringkat, i; int n = 500000; MPI_Status status; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, MPI_Comm_size(MPI_COMM_WORLD, &ukuran); 13 | P a g e


Aturan Simpson

March 30, 2010

MPI_Comm_rank(MPI_COMM_WORLD, MPI_Comm_rank(MPI_COM M_WORLD, &peringkat); if (peringkat (peringkat == 0) { double GlobalPi = 0.0; double bufferPi; for(i for (i = 1; i < ukuran; i++) { MPI_Recv(&bufferPi, 1, MPI_DOUBLE, i, 1, MPI_COMM_WORLD, &status); GlobalPi += bufferPi; } printf("Nilai printf("Nilai Pi menurut aturan Simpson adalah = %f\n" %f\n",, GlobalPi); printf("Nilai printf("Nilai Pi menurut teorema yang dibulatkan(6 digit) adalah = 3.141592 printf("------------------------------------------------------------------printf("------------------------------------------------------------------" ); "); printf(" printf(" Nilai Error = %f\n" %f\n",, GlobalPi-3.141592);

");

} else { double localPi; double a0 = (peringkat-1)/(ukuran-1); double an = (peringkat)/(ukuran-1); localPi = AturanSimpson(n, a0, an); MPI_Send(&localPi, 1, MPI_DOUBLE, 0, 1, MPI_COMM_WORLD); } MPI_Finalize(); return 0; }

14 | P a g e

Algoritma Paralel Untuk Menghitung Nilai Pi

Recommend Documents