Tugas: Komputasi Paralel

Desain & Implementasi Radix Sort Parallel

Wayan Sriyasa/G651080154

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

1
 Tugas: Komputasi Paralel
Desain & Implementasi Radix Sort Parallel

Wayan Sriyasa/G651080154

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

2
 Tugas: Komputasi Paralel
Desain & Implementasi Radix Sort Parallel

Wayan Sriyasa/G651080154

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

Prosessor ke 0
Indeks Local array Bucket/simpan
0 0 0
1 2 210
2 0 2
3 0 2
4 0 2
5 2 432
6 1 54
7 0 5
8 0 5
9 0 5

Temp Local Data

Prosessor ke 1
Indeks Local array Bucket/simpan
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

3
 Tugas: Komputasi Paralel
Desain & Implementasi Radix Sort Parallel

Wayan Sriyasa/G651080154

 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 :

4
 Tugas: Komputasi Paralel
Desain & Implementasi Radix Sort Parallel

Wayan Sriyasa/G651080154

 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 10
1 2 321
2 0 3
3 0 3
4 1 43
5 0 4
6 0 4
7 0 4
8 1 54
9 0 5

5
 Tugas: Komputasi Paralel
Desain & Implementasi Radix Sort Parallel

Wayan Sriyasa/G651080154

Temp Local Data

Prosessor ke 1
Indeks Localn array Bucket/simpan
0 2 210
1 1 32
2 1 43
3 0 4
4 0 4
5 1 54
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

6
 Tugas: Komputasi Paralel
Desain & Implementasi Radix Sort Parallel

Wayan Sriyasa/G651080154

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.

7
 Tugas: Komputasi Paralel
Desain & Implementasi Radix Sort Parallel

Wayan Sriyasa/G651080154

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

8
 Tugas: Komputasi Paralel
Desain & Implementasi Radix Sort Parallel

Wayan Sriyasa/G651080154

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

9
 Tugas: Komputasi Paralel
Desain & Implementasi Radix Sort Parallel

Wayan Sriyasa/G651080154

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 log n  sedangkan Tkomunikasi = (n) , kedua proses (komputasi &
komunikasi terjadi sebanyak b 2 r kali), dengan demikian Tp= b 2 r log n  + (n) .
r r
Ts ( n )
Speedup (SN) = = .
Tp b 2 r log n   n 
r
( n )
b r
b 2 r log n   n  2 log n 
Efisiensi =
SN = r ; issoefisiensi = r
p p p

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.

10