Anda di halaman 1dari 14

Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan

Aturan Simpson March 30, 2010

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:

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 = x0 < x1 < · · · < xn−1 < xn = 1

Ambil salah satu partisi sebagai berikut :

f(xi-1)

xi-1 xi

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

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)
Pemetaan (Mapping)

Partitioning
Problem Communication

Mapping Agglomeration

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.

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

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 grup yang 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 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

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

7|Page
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
Aturan Simpson March 30, 2010
4

3.5

2.5

0.2 0.4 0.6 0.8 1

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

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

10 | P a g e
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
Aturan Simpson March 30, 2010

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.

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

13 | P a g e
Algoritma Paralel untuk Menghitung Nilai π dengan Pendekatan
Aturan Simpson March 30, 2010

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;
}

14 | P a g e