Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

1 | P a g e

Algoritma Paralel untuk 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 multi prosesor secara paralel. Dalam paper ini dijelaskan contoh

mencari nilai π secara diskret dengan menggunakan pendekatan aturan 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.

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 bahkan

untuk jumlah subintervals, kedalam dengan panjang subinterval , dengan endpoints

. Sekarang ambil dua sub interval yang pertama dan buat pendekatan

dalam interval dengan Lagrange Polynomial menjadi ,

, dimana . Dengan menggunakan aturan tersebut akan didapatkan rumus:

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

, , , dan kita memperoleh:

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

2 | P a g e

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 = x0 < x1 < · · · < xn−1 < xn = 1 Ambil salah satu partisi sebagai berikut : Dalam tiap selang bagian [xi-1, xi], 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

f(xi-1)

xi-1 xi

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

3 | P a g e

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)

Pemetaan (Mapping)

Gambar 1. Metodologi Foster dalam Desain Algoritma Paralel.

Partisi (partitioning)

Partisi adalah proses membagi perhitungan dan data kedalam potongan-potongan kecil. Foster

menguraikan proses partisi kedalam 2 jenis yaitu:

Domain decomposition

Functional decomposition

Domain decomposition adalah algoritma paralel yang menggunakan pendekatan dimana data dibagi

terlebih dahulu kemudian menetapkan bagaimana hubungan antara data dan komputasi terjadi.

ProblemPartitioning

Communication

AgglomerationMapping

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

4 | P a g e

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 dekomposisi adalah untuk mengidentifikasi 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.

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

5 | P a g e

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 grup yang menyampaikan dan menerima pekerjaan dengan cara

mengurangi jumlah pengiriman pesan pendek dengan jumlah yang banyak digantikan dengan mengirim

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

6 | P a g e

pesan panjang dengan jumlah sedikit sehingga dapat 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 biaya modifikasi menjadi kode sekuensial yang 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

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

7 | P a g e

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 telah 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 tersebut dapat ditunjukkan 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 terbentuk maka makin baik hasilnya.

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

8 | P a g e

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

{

if(i != n-1)

{

if(i%2 == 0)

{

hasil += 2*Sekuen(a);

}

else

{

hasil += 4*Sekuen(a);

}

}

else

{

hasil += Sekuen(a);

0.2 0.4 0.6 0.8 1

2.5

3

3.5

4

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

9 | P a g e

}

i++;

a += h;

}

hasil = hasil / (3*n);

return hasil;

}

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

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

10 | P a g e

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 “main” tersebut dapat dituliskan dalam bahasa

C sebagai berikut:

int main(int argc, char** argv) { int ukuran, peringkat, i; int n = 500000; MPI_Status status; MPI_Init(&argc, &argv);

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

11 | P a g e

MPI_Comm_size(MPI_COMM_WORLD, &ukuran); MPI_Comm_rank(MPI_COMM_WORLD, &peringkat); if(peringkat == 0) { double GlobalPi = 0.0; double bufferPi; for(i = 1; i < ukuran; i++) { MPI_Recv(&bufferPi, 1, MPI_DOUBLE, i, 1, MPI_COMM_WORLD, &status); GlobalPi += bufferPi; } printf("Nilai Pi menurut aturan Simpson adalah = %f\n", GlobalPi);

printf("Nilai Pi menurut teorema yang dibulatkan(6 digit) adalah = 3.141592 "); printf("------------------------------------------------------------------- "); printf(" Nilai Error = %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.

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

12 | P a g e

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

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

13 | P a g e

Lampiran

#include "stdafx.h" #include <stdio.h> #include <mpi.h> double Sekuen(double a) { return 4/(1+(a*a)); } double 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) { if(i != n-1) { if(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 argc, char** argv) { int ukuran, peringkat, i; int n = 500000; MPI_Status status; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &ukuran);

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan Aturan Simpson March 30, 2010

14 | P a g e

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