Parallel Radix Sort by Using MPI

Tugas: Komputasi Paralel Desain & Implementasi Radix Sort Parallel

Wayan Sriyasa/G651080154

1

Parallel Radix Sort: Implementasi Dengan Menggunkan MPI

Pendahuluan

Pengurutan/sorting data merupakan operasi yang sangat umum dilakukan oleh komputer karena data yang terurut lebih mudah diproses daripada data yang masih acak. Sorting didefinisikan sebagi sebuah task untuk mengatur sekumpulan data yang tersusun secara acak sehingga dihasilkan susunan yang terurut sesuai dengan elemen-nya (dari yang kecil ke besar atau sebaliknya). Mem-parallel-kan sebuah algoritma sequencial sorting melibatkan pendistribusian elemen yang akan diurutkan kepada prosesor yang tersedia. Ada beberapa hal yang harus diperhatikan, yaitu:

1. dimana tempat penyimpanan input dan output o pada algoritma sekuensial proses ini dengan cepat dapat dilakukan hanya

dengan menggunakan memori lokalnya o pada algoritma parallel, jika elemen terletak pada proses lokal maka akan

menjadi cukup mudah sedangkan jika elemen berada pada proses yang berbeda maka akan menjadi lebih rumit

2. Bagaimana proses pembandingan dilakukan oleh algoritma o Satu elemen per proses o Lebih dari satu elemen per proses

Algoritma RadixSort Parallel

Algoritma Radix Sort dibuat dengan menggunakan representasi biner bilangan yang akan di-sort. Jika misalnya b merupakan jumlah bit pada bilangan maka radix sort akan melakukan proses sorting terhadap r bit setiap waktu, dimana r < b. Sehingga radix sort akan melakukan sebanyak b/r iterasi. Selama iterasi ke-i, akan dilakukan pengurutan bilangan sesuai dengan bit LSB ke-i dari r blok bit.

Algoritma parallel untuk algoritma radix sort adalh sebagai berikut (Ananth Grama, 2003): 1. procedure RADIX SORT(A, r) 2. begin 3. for i := 0 to b/r - 1 do 4. begin 5. offset := 0; 6. for j := 0 to 2r - 1 do 7. begin 8. flag := 0; 9. if the ith least significant r-bit block of A[Pk] = j then 10. flag := 1; 11. index := prefix_sum(flag) 12. if flag = 1 then 13. rank := offset + index; 14. offset := parallel_sum(flag); 15. endfor 16. each process Pk send its element A[Pk] to process Prank; 17. endfor 18. end RADIX_SORT

Selama iterasi dari loop pada baris 6-15, radix sort menentukan posisi elemen dengan nilai r bit dari j. Perhitungan ini dilakukan dengan menjumlahkan semua elemen dengan nilai yang sama dan kemudian mengirimkannya ke prosesor. Variable rank merupakan



2

penanda posisi setiap elemen, diakhir loop (baris 16), setiap proses mengirimkan elemennya ke prosesor Prank. Dalam implementasinya algoritma ini dapat dilakukan dengan pendekatan counting sort atau bucket sort. Desain Dengan Metode Foster

1. Partitioning Jenis partitioning yang dilakukan pada desain algoritma ini adalah data partitioning, dimana data akan dipecah menjadi sebanyak n/p dan dikirimkan kesetiap prosesor.

2. Communication Proses komunikasi yang terjadi antara lain: Scatter, dilakukan untuk mengirimkan n/p elemen kesetiap prosesor slave. Gather, dilakukan untuk mengirimkan hasil pengurutan ke prosesor master Send & receive, dilakukan untuk mengirimkan informasi besar array yang

akan dilakukan lokal komputasi 3. Aglomeration

Proses agglomerasi terjadi ketika penggabungan 2 sub-array, dan mengurutkannya kembali ke prosesor lain.

4. Mapping Mapping dilakukan ketika data yang telah di-agglomerasi siap dikirim ke prosesor terdekat.

Ilustrasi Penerapan Algoritma Radix Sort Berikut merupakan ilustrasi penerapan algoritma radix sort : Input data :

a. Iterasi pertama untuk bagian digit satuan Misalkan terdapat 2 prosessor, data dibagi menjadi 2 untuk masing- masing

prosessor : P0 P1

Menghitung frekuensi digit yang ditemukan dalam local array sebanyak base

Prosessor ke 0 Indeks Lokal array Bucket/simpan

0 0 0 1 1 2 2 2 0 2 3 0 2 4 0 2 5 1 2 4 6 1 5 7 0 5 8 0 5 9 0 5



3

Prosessor ke 1 Indeks Local array Bucket/simpan

0 1 1 1 0 1 2 0 1 3 0 1 4 0 1 5 2 3 6 0 3 7 1 4 8 0 4 9 1 5

Mengurutkan Local Data dalam tiap prosessor


0 0 0 1 2 2 1 0 2 0 2 3 0 2 4 0 2 5 2 4 3 2 6 1 5 4 7 0 5 8 0 5 9 0 5

Temp Local Data


0 1 0 1 0 1 2 0 1 3 0 1 4 0 1 5 2 1 6 0 3 7 1 3 8 0 4 9 1 4

Temp Local Data



4

Mengumpulkan frekuensi digit dari tiap prosessor ke prosessor 0 Local Num Item

Dari P0 Dari P1

Mengumpulkan data yang sudah terurut dari tiap prosessor ke prosessor 0 Temp Local Data

Dari P0 Dari P1

Mengurutkan data yang sudah terurut secara lokal dari tiap prosessor Local Num Item

Temp Local Data

Data

Isi data sekarang :

b. Iterasi kedua untuk digit puluhan

Bagi data menjadi 2 untuk tiap – tiap prosessor :



5

Menghitung frekuensi digit yang ditemukan dalam local Data sebanyak base Prosessor ke 0 : Indeks Local array Bucket/simpan

0 1 1 1 2 3 2 0 3 3 0 3 4 1 4 5 0 4 6 0 4 7 0 4 8 1 5 9 0 5

Menghitung frekuensi digit yang ditemukan dalam local Data sebanyak base

Prosessor ke 1 : Indeks Local array Bucket/simpan

0 2 2 1 1 3 2 1 4 3 0 4 4 0 4 5 1 5 6 0 5 7 0 5 8 0 5 9 0 5

Mengurutkan LocalData dalam tiap prosessor

Prosessor ke 0 Indeks Localn array Bucket/simpan

0 1 1 0 1 2 3 2 1 2 0 3 3 0 3 4 1 4 3 5 0 4 6 0 4 7 0 4 8 1 5 4 9 0 5



6

Temp Local Data

Prosessor ke 1 Indeks Localn array Bucket/simpan

0 2 2 1 0 1 1 3 2 2 1 4 3 3 0 4 4 0 4 5 1 5 4 6 0 5 7 0 5 8 0 5 9 0 5

Temp Local Data

Mengumpulkan frekuensi digit dari tiap prosessor ke prosessor 0 Local Num Item

Dari P0 Dari P1

Mengumpulkan data yang sudah terurut dari tiap prosessor ke prosessor 0 Temp Local Data

Dari P0 Dari P1

Mengurutkan data yang sudah terurut secara lokal dari tiap prosessor Local Num Item



7

Temp Local Data

Data telah terurut.

Implementasi Algoritma Kedalam Program Dalam implementasinya, algoritma ini didekati dengan menggunakan pendekatan bucket sesuai dengan ilustrasi diatas. Secara keseluruhan program terdiri dari 3 fungsi yang masing-masing berfungsi untuk penyedia data, sorting pada bucket dan fungsi utama yang memanggil ketiga fungsi tersebut. Berikut detail fungsi yang dimaksudkan: Fungsi BuatData (long int [], int, int, int) Sebagai input data, pada program disertakan fungsi untuk mengenerate bilangan acak sebanyak n buah bilangan sesuai dengan keinginan user. Bilangan acak dibangkitkan dengan menggunakan fungsi RAND(). Berikut cuplikan fungsi untuk membuat data input: /*****************************************************************/ void BuatData(long int array_utama[] /* out */, int n /* in */, int n_par /* in */, int p /* in */) { /* menyimpan elemen kedalam penyiman sementara */ int i, q; MPI_Status status; printf("Sebelum sorting:\n"); for (q = 0; q < p; q++) { printf("\nP%d: ", q); for (i = 0; i < n_par; i++) { array_utama[q*n_par+i] = rand() % (2*n/p) + (q*2*n/p); printf("%7ld %s", array_utama[q*n_par+i], i%8==7 ? "\n " : " "); } printf("\n"); } printf("\n"); } /* BuatData */ /*****************************************************************/ Data yang digenerate oleh fungsi ini adalah desimal dengan 3 digit bilangan.



8

Fungsi Seq_sort(long int [], int) Fungsi ini bertugas untuk melakukan sortir pada bucket, berikut cuplikan kode programnya: /*****************************************************************/ void Seq_sort(long int array[] /* in/out */, int size /* in */) { /* sort dengan menggunakan selection sort */ int eff_size, minpos; long int temp; for(eff_size = size; eff_size > 1; eff_size--) { minpos = posisi(array, eff_size); temp = array[minpos]; array[minpos] = array[eff_size-1]; array[eff_size-1] = temp; } } /* mengembalikan index elemen terkecil ke kiri */ int posisi(long int array[], int eff_size) { int i, minpos = 0; for (i=0; i<eff_size; i++) minpos = array[i] > array[minpos] ? i: minpos; return minpos; } /*****************************************************************/ Algoritma sorting yang digunakan pada fungsi ini adalah algoritma sequensial sort, dengan asumsi bahwa algoritma tersebut memiliki stabilitas yang cukup baik. Fungsi main(int argc, char* argv[]) Fungsi utama ini melakukan proses paralelisasi secara utuh, mulai dari pembuatan data, penyebaran ke setiap prosesor sampai dengan megumpulkan kembali hasil sorting yang telah dilakukan. Berikut detail fungsi ini: /*****************************************************************/ main(int argc, char* argv[]) { long int * array_utama; long int * array_lokal; int n=80; int n_par; /* = n/p */ long int number; int p; int my_rank; int i; double start, stop; /* timing */ MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &p); MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); n = atoi(argv[1]);



9

array_utama = malloc(n*sizeof(long int)); if (my_rank == 0) { start = MPI_Wtime(); /* Timing */ /* untuk cek kelipatan elemen dengan jumlah prosesor */ if (n%p != 0) { fprintf(stderr,"Jumlah elemen bukan kelipatan jumlah prosesor.\n"); MPI_Abort( MPI_COMM_WORLD, 2 ); exit(1); } /* membuat array untuk menampung semua data */ if (array_utama==NULL) { fprintf(stderr, "alokasi memori array_utama gagal!!\n"); MPI_Abort( MPI_COMM_WORLD, 3 ); exit(0); } printf("\nTotal elemen = %d; \n", n); BuatData(array_utama, n, n/p, p); } n_par = n/p; array_lokal = malloc(n_par*sizeof(long int)); if (array_lokal==NULL) { fprintf(stderr, "alokasi memori array_lokal gagal!!\n"); MPI_Abort( MPI_COMM_WORLD, 4 ); exit(0); } /* menyebarkan elemen data yang ada pada array_utama ke setiap prosesor */ MPI_Scatter(array_utama, n_par, MPI_LONG, array_lokal, n_par, MPI_LONG, 0, MPI_COMM_WORLD); Seq_sort(array_lokal, n_par); MPI_Gather(array_lokal, n_par, MPI_LONG, array_utama, n_par, MPI_LONG, 0, MPI_COMM_WORLD); stop = MPI_Wtime(); if (my_rank==0) { printf("\nSetelah sorting:\n"); for(i=0; i<n; i++) printf("%7ld %c", array_utama[i], i%8==7 ? '\n' : ' '); printf("\n\nWaktu yang diperlukan untuk sort %d processes = %lf msecs\n", p, (stop - start)/0.001); } free(array_lokal); if (my_rank==0) free(array_utama); MPI_Finalize(); } /* main */ /*****************************************************************/ Mula-mula fungsi ini memanggil fungsi BuatData untuk membangkitkan sejumlah data yang nantinya digunakan sebagai input, kemudian data ini dibagi menjadi n/p dan dikirimkan (scatter) ke seluruh prosesor untuk dilakukan sorting ditiap bucket yang ada. Kemudian setelah selesai melakukan pengurutan data, prosesor slave mengirimkan hasil berupa array yang elemenya telah terurut ke prosesor master (root).



10

Berikut hasil running kode program diatas: Kompleksitas, Speedup, Efisiensi dan Issoefisiensi Kompleksitas sekuensial dari algoritma radix adalah Ts = O(n). Kompleksitas parallel algoritma ini adalah Tp = Tkomputasi + Tkomunikasi, dimana Tkomputas untuk algoritma ini adalah nlog sedangkan Tkomunikasi = )(n , kedua proses (komputasi &

komunikasi terjadi sebanyak rr

b 2 kali), dengan demikian Tp= nrb r log2 + )(n .

Speedup (SN) = p

sT

T = nnr

bn

r

log2)(

.

Efisiensi = pSN =

p

nnrb

nr

log2)(

; issoefisiensi = p

nrb r log2

Referensi Grama, A; Gupta, A; Karypis, George; dan Kumar, V. 2003. Introduction to Parallel

Computing, Second Edition. Addison Wesley. USA

Quinn, M.J. 2004. Parallel Programming in C with MPI and OpenMP. McGrawHill. USA.

Documents

Parallel Radix Sort by Using MPI