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
,
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
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
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
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
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
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
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
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
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
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
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
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
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
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
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
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
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
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
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
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
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
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
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
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
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
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