You are on page 1of 28

Mengukur Efektifitas Komputasi Paralel melalui Implementasi Program Prime Sum, Simpson Rule dan Merge Sort dengan

menggunakan MPICH2

Untuk Memenuhi Tugas UTS Mata Kuliah Kapita Selekta

Disusun oleh Aji Gojali 107091003188

Dimas Riyan Hartadi 107091003148 Restyo Mahendra Riko Dwi Masetya 107091003630 107091003326

JURUSAN TEKNIK INFORMATIKA FAKULTAS SAINS DAN TEKNOLOGI UIN SYARIF HIDAYATULLAH JAKARTA

2010

Instalasi
A. Persiapan MPICH memerlukan sistem operasi dan beberapa program lain untuk brjalan. Sistem yang diperlukan haruslah terlebih dulu ada sebelum MPICH di -install. Adapun kebutuhan sistem tersebut antara lain: 1. sistem Operasi Windows 2000/XP/2003 2. Visual C++ 2005 dengan IDE Visual Studio 2005 (dalam laporan ini, digunakan Visual C++ 2005 Express Edition) B. Instalasi MPI Setelah kebutuhan instalasi MPICH2 terpenuhi, dilakukan instalasi MPICH2, 1. Klik ganda pada file setup MPICH2 yang telah didownload, sehingga akan mucul screenshot sebagai berikut:

2. Setelah muncul screenshot seperti di atas, klik Next, sehingga akan muncul jendela yang menampilkan kebutuhan system seperti berikut:

3. Selanjutnya akan muncul jendela yang menampilkan hak cipta dan persetujuan

tentukan direktori dimana kita akan meng-install MPICH2.lisensi. secara default installer MPICH2 akan meletakkannya di C:\Program Files\MPICH2\. Kemudian. 5. 4. SPMD mampu menjalankan proses dari berbagai platform jika format binernya sama. muncul jendela Process Manager Setup. SPMD merupakan process manager yang berjalan baik pada Unix maupun Windows. Passphrase yang sama pada MPICH harus digunakan untuk semua komputer. kemudian klik next. Jika tidak diberikan. hanya user yang sedang login atau semua user . Di dalam jendela ini terdapat pemberitahuan untuk mengin gat kata kunci atau passphrase yang akan digunakan untuk menjalankan service SPMD. Tentukan juga siapa yang bisa menggunakan MPICH pada komputer. Berikutnya. Pilih radio button I Agree .

6. klik next . Muncul notifikasi bahwa installer telah siap untuk melakukan instalasi MPICH2. untuk melanjutkan instalasi.

Berikan nama projek. misalnya MPI_Hello. klik Next. dalam hal 2. Selanjutnya.C. dibuat projek melalui File ini. Konfigurasi 1. New Project. Pertama. Pada window Win32 Application Wizard. Klik OK. .

Pilih pada menu C/C++ . Selanjutnya. Pada bagian Additional Include Directories berikan direktori dimana direktori include instalasi MPICH berada. secara default. pada menu tree C/C++ . pilih Compile as C Code (TC) . kemudian klik Finish D.3. Hilangkan centang Precompiled Header yang secara default tercentang. Konfigurasi Projek 1.General. klik Project Properties. direktori include ini berada ada direktori C:\Program Files\MPICH2\include 2. Setelah projek dibuat.Advanced di bagian Compile As.

. Kemudian pada menu tree C/C++ . direktori include ini berada ada direktori C: \Program Files\MPICH2\lib. secara default.Linker di bagian Additional Library Directories.3. berikan direktori dimana direktori library instalasi MPICH berada.

4. Path dapat dilakukan melalui Windows Explorer. pada bagian additional dependencies. Hasilnya akan muncul pada window seperti screenshot di b awah: . Langkah terakhir.exe yang selalu diperlukan untuk menjalankan aplikasi MPI yang kita compile dari visual C++.lib. klik Environment Variables. klik kanan pada My Computer kemudian pada tab advanced. 5. Langkah selanjutnya (opsional) adalah memberikan path pada folder bin MPICH2 sehingga windows akan mengenali mpiexec. tambahkan mpi.

Secara default. . direktori bin berada pada C:\Program Files\MPICH2\bin. dan tambahkan direktori bin dari MPICH pada bagian Variable Value. Pada bagian system variables Path. klik bagian edit.6.

Source Code Berikut ini adalah Source Code dari Prime Sum: # include <stdio.7} Mekanisme: Data di pecah dalam kedalam beberapa bagian dengan aturan range=n/m. char *argv[] ). maka rangenya adalah (1-5): jumlah bilangan prima {2.3. char *argv[] ) /***********************************/ /* Tujuan : Penulis : John Burkardt .Prime Sum A. /***********************************/ int main ( int argc. Contoh : n = 10 Hosts m=2 Maka Data bilangan prima sampai dengan n adalah: {2. Introduction Merupakan sebuah program yang berfungsi untuk melakukan penjumlahan bilangan prima dengan range 0 sampai n bilangan dan dilakukan oleh m yang merupakan variabel hosts.5.3.5} jumlah = 10 (6-10): jumlah bilangan prima jumlah{7} jumlah = 7 dan output : jumlah= 17 B.h> # include <stdlib. Variabel n dan m nantinya akan di inputkan bersamaan dengan perintah eksekusi mpiexec.h> # include "mpi.h" int main ( int argc.

int done = 0. int id. &argv ). . /* Mendapatkan Jumlah dari proses */ MPI_Comm_size ( MPI_COMM_WORLD. 1999. int total. &id ). int total_local. ISBN: 0262571323. &p ). Anthony Skjellum. int n_lo. MIT Press. Using MPI: Portable Parallel Programming with the Message-Passing Interface. Second Edition. int master = 0. double wtime. /* Inisialisasi MPI */ MPI_Init ( &argc. Ewing Lusk. int n_hi. */ { int i.Dimodifikasi oleh : dimas aji riko restio Referensi: William Gropp. /* Menentukan Rank dari suatu proses */ MPI_Comm_rank ( MPI_COMM_WORLD. int j.

j < i.id .0. /* setiap proses menambahkan masukannya */ wtime = MPI_Wtime ( ). for ( j = 2. for ( i = n_lo.1 ) * 1 + ( id + 1 ) * n ) /(p ).exe <jumlah data> \n Contoh : mpiexec -n 2 uts./* Proses pembacaan input data dari argv */ if (argc != 2) { if (id == master) printf(" Petunjuk: mpiexec -n <jumlah proses> uts. i++ ) { prime = 1. exit(0).exe 1000 \n"). //proses inisialisasi data N } /* Sekarang setiap proses (termasuk master) menentukan porsi dari jangkauan data mengikuti rumus dibawah ini yang akan membagi jangkauan data dari 2 hingga N secara merata keseluruh proses */ n_lo = ( ( p . i <= n_hi. //inisialsisasi waktu awal total_local = 0. MPI_Finalize().id ) * 1 + ( id ) * n ) /(p ) + 1. }else{ n = atof(argv[1]). n_hi = ( ( p . j++ ) { .

wtime ). &status ). /* setiap proses yang bekerja mengirim kembali hasilnya kepada master */ if ( id != master ) { MPI_Send ( &total_local. i++ ) { MPI_Recv ( &total_local. } } if ( prime == 1 ) { total_local = total_local + i. MPI_COMM_WORLD.wtime. 1. .if ( i % j == 0 ) { prime = 0. 1. break. MPI_ANY_SOURCE. total_local. 1. MPI_INT. master. MPI_COMM_WORLD ). } } wtime = MPI_Wtime ( ) . printf ( " Process %d. Pembagiana Data : %d . for ( i = 1.%d\tTotal : %d\tTime : %f\n". id+ 1. */ else { total = total_local. n_hi. } /* Master menginisialisasi jumlah dengan nilai local miliknya dan kemudian mengirim pesan ke proses yang lain. 1. i < p. MPI_INT. n_lo.

*/ MPI_Finalize ( ). 1.\n"). return 0. &total. } .total = total + total_local. total ). printf ( "PRIME_SUM:\n"). MPI_COMM_WORLD ) yang mengumpulkan seluruh nilai TOTAL_LOCAL kedalam penjumlaha tunggal yang dinamakan TOTAL dan mengirimnya ke proses */ if ( id == master ) { printf ( "\n Jumlah Total %d\n". printf ( " Normal end of execution. MPI_SUM. master. } /* mematikan MPI. } } /* baris perintah diatas dapat saja diganti dengan bari perintah tunggal: MPI_Reduce ( &total_local. MPI_INT.

Arsitektur jaringan yang kami gunakan pada percobaan program ini adalah Peer 2 Peer 2.C.7 3.1.168.7 aji.4 aji. Pada setiap PC mendaftarkan acount usernya pada wmpiregister.1.1.7 192. Dengan 1 komputer 1.exe 100 5.1. Tidak terhubung ke jaringan 2. Kemudian jalankan perintah mpiexec hosts 192. Pada analisis ini kami melibatkan 2 komputer sebagai host dengan IP Adress sebagai berikut: MPI1 : 192. Hanya melibatkan 1 host dengan IP Adress 192. Outputnya adalah sebagai berikut : 6.exe Kemudian jalankan perintah mpiexec hosts 192.1. Pada setiap PC mendaftarkan acount usernya pada wmpiregister.000012 detik b. Dengan 1 komputer host menghasilkan waktu process = 0.exe 100 4. Outputnya adalah sebagai berikut : .168.1.exe 4. Analisis ada beberapa teknik dalam mengeksekusi file MPI yang dilakukan kelompok kami. Dengan 2 komputer 1. teknik itu adalah sebagai berikut: a.168.4 3.168.168.168.7 SYUKUR : 192.

Dengan 3 Komputer Dengan menggunakan 3 processor menghasilkan waktu proses 0.00002 sec .Dengan 2 komputer host menghasilkan waktu process = 0.00002 detik c.

x2. xn+1. double simpson(). /* Number of processors */ int my_rank. pi. processor_output_share[8]. */ /* saleh@npac. double exact_val_of_Pi. y.syr. endtime. l. Introduction Merupakan sebuah program yang digunakan untuk menghitung luas dibawah kurva. berdasarkan nilai x yang dimiliki yang kemudian dimasukan kedalam fungsi menghasilkan nilai y. Source Code Berikut ini adalah Source Code dari Simpson Rule : /*--------------------------------------------*/ /* Saleh Elmohamed 1996. char *argv[]) { int Procs. /* Processor number */ double total.h> #define approx_val 2. int i. MPI_Status status.Simpson Rule A. Untuk menghitung trapesium nilai xn.edu. int main(int argc. double starttime. yn+1 dimasukkan ke dalam fungsi ½ ((xn+1)(xn))*(yn+yn+1) B. x1. yn. Luas dibawah kurva di bagi-bagi kedalam sebuah bentuk trapesium yang kecil-kecil.19328059 #define N 10000000 double integrate_f(). */ /*--------------------------------------------*/ #include <stdio.h> #include <mpi. */ /* 443-9182 */ /* Example for CPS-615.h> #include <math. sum. /* Let the system do what it needs to start up MPI */ /* Number of intervals in each processor */ /* Integral function */ .

i++) { y = x1 + (x2 . MPI_DOUBLE. i++) . tag = 0 */ MPI_Send(&total. */ MPI_Comm_size(MPI_COMM_WORLD. MPI_COMM_WORLD. i < N . /* Each processor computes its interval */ x1 = ((double) my_rank)/((double) Procs). i++) MPI_Recv(&(processor_output_share[i]). 0. tag = 0 */ for(i = 1. } /* Add up the value of Pi and print the result. */ if(my_rank == 0) { starttime = MPI_Wtime(). /* Find out how many processes are being used. /* source = i. MPI_DOUBLE.x1)*((double) i)/((double) N). 0.MPI_Init(&argc. l. i. total = sum. i < Procs. */ if(my_rank == 0) { pi = 0.0. sum = 0. x2 = ((double) (my_rank + 1))/((double) Procs).0/((double) (2 * N * Procs)). /* call Simpson's rule */ sum = (double) simpson(i. } else { /* dest = 0. MPI_COMM_WORLD). &Procs). /* Add up the integrals calculated by each process. y. for(i = 0. &my_rank). /* Get my process rank */ MPI_Comm_rank(MPI_COMM_WORLD. &status). i < Procs.0. } /* Include the endpoints of the intervals */ sum += (integrate_f(x1) + integrate_f(x2))/2. 1. processor_output_share[0] = total. 1.0. sum). for(i = 1. */ l = 1. 0. /* l is the same for all processes. &argv).

endtime). double sum) { /* store result in sum */ sum += integrate_f(y). printf("The computed Pi of the integral for %d grid points is %25.0 * log(approx_val).0 * integrate_f(y + l).\n").\n"). sum += 2. */ #if 1 exact_val_of_Pi = 4.16e\n". printf("\n\nWaktu mulai %f detik\n".endtime-starttime). endtime = MPI_Wtime(). printf("\n\nParellel Time %f seconds\n". double l. See the report.pi += processor_output_share[i]. fabs(pi .0. #endif printf("The error or the discrepancy between exact and computed value of Pi : %25.0 + x * x). printf("------------------------------------------------. printf("------------------------------------------------.0 * atan(1. pi). (N * Procs). } double integrate_f(double x) { return 4. printf("\n\nWaktu berhenti %f seconds\n". /* compute and return value */ } double simpson(int i.exact_val_of_Pi)).16e \n". #endif #if 0 exact_val_of_Pi = 4.0 * l/ 3. return sum. pi *= 2. } MPI_Finalize(). if(i == (N .0/(1.0 * integrate_f(y .1)) sum += 2.l). /* This is directly derived from the integeration of the formula. } /* simpson */ .starttime).0). double y.

4 MPI1: 192.exe .exe 4. Hanya melibatkan 1 host dengan IP Adress 192. Dengan 1 komputer host menghasilkan waktu process = 0.168. Analisis a.7 3.7 ALFATH-PC : 192.1 3.00016 detik b. Pada setiap PC mendaftarkan acount usernya pada wmpiregister.1. Tidak terhubung ke jaringan 2.1.1. Dengan 2 komputer 1.168.168. Hanya melibatkan 3 host dengan IP Adress SYUKUR : 192. Dengan 1 Komputer 1. Outputnya adalah sebagai berikut : 5.1.C.168. Arsitektur jaringan yang digunakan adalah peer 2 peer 2. Kemudian jalankan perintah mpiexec -n 1 MPI_simpson.

4 MPI_si mpson.168.220132 detik .Kemudian jalankan perintah mpiexec MPI_simpson.1.7 192.1. Dengan 3 Komputer Dengan menggunakan 3 Host Mpi menghasilkan parallel Time 0.168.1 192.003293 detik jalankan perintah mpiexec -hosts 192.1.1.046842 detik c.exe Dengan 2 komputer host menghasilkan waktu paralell = 0. Outputnya adalah sebagai berikut : -hosts 192.4 Dengan 2 komputer host menghasilkan waktu paralell = 0.exe 4.168.168.

Source Code /* menggabungkan 2 array dengan ukuran yang sama */ int *merge(int array1[]. i<size. . int size) { int i. i++) if (array[i-1] > array[i]) return 0. } while (i < size) { result[k++] = array1[i++]. const void *p2) { return *(int *)p1 . j=0. } /* validasi data terurut */ int sorted(int array[]. Setiap bagian yang kecil tersebut data diurutkan dan kemudian di satukan kembali sehingga lebih mudah untuk diurutkan: B. while ((i < size) && (j < size)) { result[k++] = (array1[i] <= array2[j])? array1[i++] : array2[j++]. return 1. for (i=1. } /*untuk qsort() */ int compare(const void *p1. } return result. Mekanismenya adalah membagi data ke dalam bagian yang kecil. } while (j < size) { result[k++] = array2[j++]. k=0.Merge Sort A. int size) { int *result = (int *)malloc(2*size*sizeof(int)). Introduction Merupakan sebuah program yang digunakan untuk mengurutkan sejumlah data acak. int i=0.*(int *)p2. int array2[].

} } /* paralel proses start */ start = MPI_Wtime(). .} int main(int argc. int localsize. finish. &argv). /* Scatter data */ localsize = datasize / nprocs. char** argv) { int i. myrank. *otherdata. *data = NULL. double start. *localdata. /* Read datasize argument */ datasize = (argc == 2)? atol(argv[1]) : nprocs*10. } if (datasize%nprocs != 0) { if (myrank == ROOT) printf("Besar data harus dapat dibagi jumlah prosesor. long datasize.\n").\n"). b. s. MPI_Init(&argc. i++) { data[i] = rand()%99 + 1. MPI_Comm_rank(MPI_COMM_WORLD. MPI_Status status. /* Check argument */ if (!ISPOWER2(nprocs)) { if (myrank == ROOT) printf("Jumlah Prosesor haruslah 2. p. return MPI_Finalize(). MPI_Comm_size(MPI_COMM_WORLD. } /* Generate data */ if (myrank == ROOT) { data = (int *)malloc(datasize * sizeof(int)). return MPI_Finalize(). int active = 1. for (i = 0. &myrank). nprocs. &nprocs). i < datasize.

\n\n"). myrank + b. /* Analisa kecepatan dan runtime */ if (myrank == ROOT) { #ifdef DEBUG if (sorted(localdata. . active = 0. myrank . 1. } else { printf("\nParallel sorting gagal. } else { otherdata = (int *) malloc(b * localsize * sizeof(int)). /* Merge sorted data */ for (b=1. MPI_COMM_WORLD). localsize. b * localsize. &status). MPI_COMM_WORLD). /* Sort localdata */ qsort(localdata. free(localdata). localdata. MPI_INT. p). b<nprocs. } #endif free(localdata). MPI_INT. printf("Waktu Proses Parallel : %. p = finish . MPI_Scatter(data.localdata = (int *) malloc(localsize * sizeof(int)). 1. b*=2) { if (active) { if ((myrank/b)%2 == 1) { MPI_Send(localdata. localsize. MPI_INT. b * localsize.\n\n"). otherdata. sizeof(int). localdata = merge(localdata. MPI_Recv(otherdata. localsize. MPI_INT. b * localsize). ROOT. MPI_COMM_WORLD.8f\n". } } } /*tahap akhir pemrosesan paralel */ finish = MPI_Wtime().start. nprocs*localsize)) { printf("\nParallel sorting berhasil. compare). free(otherdata).b.

free(data). printf("Peningkatan Kecepatan S/P: %. finish = MPI_Wtime(). datasize.8f\n". } return MPI_Finalize(). qsort(data. } .8f\n\n". printf("Waktu Proses Sequential : %. s/p)./* Sequential sort */ start = MPI_Wtime().start. compare). sizeof(int). s = finish . s).

Dengan 1 Komputer 1. Kemudian jalankan perintah mpiexec -n 1 MPI_merge_sort.168.4 .1.168.1.1 3. Analisis a.1. Tidak terhubung ke jaringan 2.4 MPI1: 192. Dengan 2 komputer 1.C.7.1. Hanya melibatkan 3 host dengan IP Adress SYUKUR : 192.168.exe Kemudian jalankan perintah mpiexec -hosts 192. Outputnya adalah sebagai berikut : 192.exe 4.1 MPI_merge_sort.exe 4.00598782detik b. Arsitektur jaringan yang digunakan adalah peer 2 peer 2.168.1. Dengan 1 komputer host menghasilkan waktu process = 0.1. Pada setiap PC mendaftarkan acount usernya pada wmpiregister. Outputnya adalah sebagai berikut : 5. pc=mpi1 3.7 ALFATH-PC : 192.16 8. Hanya melibatkan 1 host dengan IP Adress 192.168.

Dengan 3 Komputer Belum bisa menjalankan file exe melalui 3 host Setelah ditelaah Source Codenya.00799751 detik c. ditemukan bahwa program ini hanya dapat digunakan oleh paling banyak 2 processor .Dengan 2 komputer host menghasilkan peningkatan kecepatan= 0.

00598782 detik Dua Processor 0. didapat table sebagai berikut: No 1 2 3 Nama Program Prime Sum Simpson Rule Merge Sort Satu Processor 0.00002 detik 0.Kesimpulan Setelah mengeksekusi 3 program yang berbeda dan dengan teknik yang berbeda pula.00799751 detik Tiga Processor 0.000012 detik 0.00002 detik 0.220132 detik - Dari table tersebut dapat di ambil kesimpulan bahwa semakin banyak processor yang digunakan akan semakin lama waktu proses yang dibutuhkan untuk mengeksekusi sebuah program dengan metode komputasi parallel.003293 detik 0. Hal ini mungkin disebabkan karena cakupan data yang kecil sehingga belum efektif penggunaan komputasi parallel pada program di atas .00013 detik 0.