1
Kajian Tematik
Komputasi Paralel dan GPU
Editor : Heru Suhartanto
Fakultas Ilmu Komputer
Universitas Indonesia
Yohanes Gultom
KAJIAN TEMATIK KOMPUTASI PARALEL DAN GPU
FAKULTAS ILMU KOMPUTER UNIVERSITAS INODNESIA KAMPUS UI, DEPOK 16424
KAJIAN TEMATIK KOMPUTASI PARALEL DAN GPU
Cetakan Oktober 2018 30 cm, 42 halaman
______________________________________________________________
ISBN 978-979-1421-28-7
____________________________________________________
EDITOR:
Heru Suhartanto
PENYUNTING : Yohanes Gultom
FAKULTAS ILMU KOMPUTER UNIVERSITAS INDONESIA
Kampus UI Depok Gedung Fakultas Ilmu Komputer Kampus UI Depok www.cs.ui.ac.id
__________________________________________________________
Hak Cipta dilindungi oleh undang-undang,
Dilarang memperbanyak sebagaian atau seluruh isi buku ini tanpa izin
2
Kajian Tematik Komputasi Paralel dan GPU
Penyusun : Mahasiswa Peserta Mata Kuliah Komputasi Parallel Lanjut, Fakultas Ilmu Komputer UI
Editor : Heru Suhartanto, email : [email protected]
Desain sampul dan Tata letak : Yohanes Gultom Penerbit : Fakultas Ilmu Komputer UI,
Kampus UI, Depok 16424
3 DAFTAR ISI
KATA PENGANTAR ... 5
1 GPU-ACCELERATED ANT COLONY OPTIMIZATION ... 6
1.1 LATAR BELAKANG ... 6
1.2 METODE DASAR ... 6
1.3 ALGORITMA DAN IMPLEMENTASI ... 7
1.3.1 Pheromone Initialization ... 10
1.3.2 Heuristic Value Computation ... 10
1.3.3 Edge Probabilities ... 10
1.3.4 Solution Generation ... 11
1.3.5 Pheromone Evaporation ... 11
1.3.6 Solutions Evaluation ... 11
1.3.7 Pheromone Deposition ... 12
1.3.8 Remove Covered Data Points ... 12
1.4 EVALUASI ... 13
1.5 KESIMPULAN ... 14
2 LARGE-SCALE MACHINE LEARNING ... 15
2.1 LATAR BELAKANG ... 15
2.2 KONTRIBUSI AUTHOR ... 15
2.2.1 Core Technology ... 15
2.2.2 Base Algorithm ... 16
2.2.3 Algoritma Parallel ... 17
2.3 IMPLEMENTASI ... 19
2.3.1 Calculating Energy ... 19
2.3.2 Normalizing Probabilities ... 19
2.3.3 Summing Value ... 23
2.3.4 Calculating the Gradient ... 24
2.4 PENGUJIAN PERFORMA ... 24
2.4.1 Hasil Pengujian Umum... 24
2.4.2 Pengujian Menggunakan Implementasi Character Recognition Application ... 25
2.5 KESIMPULAN ... 26
2.6 OPEN PROBLEM ... 26
3 KOMPUTASI PARALEL UNTUK ALGORITMA SMITH-WATERMAN ... 27
4
3.1 LATAR BELAKANG ... 27
3.2 ALGORITMA SMITH-WATERMAN ... 28
3.3 KOMPUTASI PARALEL UNTUK ALGORITMA SMITH-WATERMAN ... 31
3.3.1 Reduced Dependency ... 32
3.3.2 Antidiagonal Approach ... 32
3.3.3 Row (or Column) Parallel Approach ... 33
3.3.4 Overlapping Search ... 34
3.3.5 Data Packing ... 35
3.3.6 Hash Tables ... 35
3.4 EKSPERIMEN DAN EVALUASI ... 36
3.4.1 Lingkungan Eksperimen ... 36
3.4.2 Hasil Eksperimen ... 36
3.5 OPEN PROBLEM ... 40
3.6 KESIMPULAN ... 40
3.7 DAFTAR PUSTAKA ... 41
5
K ATA P ENGANTAR
Komputasi berkinerja tinggi atau dalam bahasa Inggris dikenal dengan istilah High Performance Computing (HPC), sangat membantu efisiensi pemecahan masalah yang melibatkan data yang sangat besar dan waktu komputasi yang sangat lama. Infrastruktur HPC yang ada di dunia saat ini bervariasi dari kapasitas dan harga, banyak aplikasi yang sudah menerapkaan teknologi HPC untuk mempercepat prosesnya. Mahalnya infrstruktur tersebut mendorong para peneliti untuk mencari jalan keluar, salah satunya adalah dengan memperkenalkan konsep dan teknologi komputasi klaster atau Cluster Computing. Namun, untuk banyak aplikasi tertentu banyaknya node pada komputasi klaster tidak menjamin terjadi percepatan yang berarti. Waktu komunikasi merupakan salah satu hambatan. Kebutuhan ruang dan suplai listrik juga merupakan suatu kendala. Beberapa penelitia dan produsen akhirnya memperkenalkan suatu kartu grafis (graphic cards) yang disebut dengan nama Graphical Processing Units. Kartu ini pada awalnya diperuntukkan memroses data gambar atau image.
Namun telah dikembangkan teknologi pendukung sehingga mampu dipakai untuk pemrograman paralel secara umum, dimana ratusan dan bahkan ribuan processor kecil di dalamnya dapat dimanfaatkan untuk memroses suatu aplikasi.
Book Chapters ini, dikumpulkan sebagai bagian dari penelitian dan perkuliahan Komputasi Paralel pada tingkat Sarjana dan Komputasi Paralel Lanjut pada tingkat pascasarjana. Mahasiswa di bawah arahan dosen sebagai pembimbing, diminta untuk mengkaji tema tema tertentu. Kali ini penulis membahas beberapa tema yang manfaatnya sangat banyak bagi para peneliti dan pengembang yang berhadapan dengan data besar, yakni beberapa algoritma yang dapat diterapkan pada lingkungan komputasi GPU. Pada akhir kajian pada setiap tema, dilengkapi dengan Open Problems, atau masalah terbuka yang dapat dilakukan untuk mencari jalan bagi masalah masalah yang ditemukan. Semoga kumpulan bab ini bisa bermanfaat bagi setiap pembaca, kami dengan tangan terbuka siap menerima saran untuk perbaikan.
Jakarta Oktober 2018 Heru Suhartanto
Guru Besar Komputasi Parallel Fakultas Ilmu Komputer UI
6
1 GPU-A CCELERATED A NT C OLONY O PTIMIZATION
1.1 L
ATARB
ELAKANGAnt Colony Optimization (ACO) adalah salah satu algoritma swarm inteligence yang didasarkan pada perilaku koloni semut. ACO dapat digunakan untuk menyelesaikan masalah optimisasi pada traveling salesman, quadratic assignment dan routing pada jaringan.
Karakteristik dari algoritma ACO adalah adanya perulangan proses penciptaan kemungkinan solusi, evaluasi dan penguatan. Solusi yang diciptakan oleh agen-agen semut lama kelamaan akan menuju pada solusi yang optimal. Penciptaan lebih banyak solusi pada satu iterasi dapat menghasilkan solusi yang lebih baik dalam waktu yang lebih cepat namun membutuhkan populasi semut yang semakin besar. Penggunaan agen semut yang besar dalam algoritma ACO yang sekuensial akan membutuhkan waktu yang lama dalam prosesnya.
Tiap koloni semut bekerja sendiri-sendiri secara terdistribusi, hal ini dapat dimanfaatkan untuk melakukan paralelisasi pada algoritma ACO menggunakan komputasi GPGPU. Penggunaan paralelisasi diharapkan dapat mengurangi waktu jalannya proses dengan populasi semut yang besar.
1.2 M
ETODED
ASARSistem koloni semut yang paling banyak dipelajari adalah kemampuannya untuk menemukan jalur yang optimal pada suatu lingkungan. Kemampuan menemukan jalur ini dapat diperluas untuk menyelesaikan berbagai masalah asalkan area solusinya dapat digambarkan sebagai graph dan jalurnya sebagai solusinya.
7
Gambar 1-1 Skema dasar ACO
Agen semut dalam ACO melakukan penjelajahan pada area solusi suatu masalah untuk menemukan solusi optimal. Solusi didefinisikan sebagai jalur yang dilewati agen semut dalam construction graph. Setiap solusi yang dihasilkan akan dievaluasi sesuai dengan fungsi fitness. Jalur yang dinyatakan terbaik (best solution) akan ditandai dengan pheromone. Pheromone dapat menarik agen semut berikutnya untuk mengikuti jalur yang sama. Gerakan agen semut yang acak dalam penjelajahan area solusi yang berulang-ulang lama- kelamaan akan menuju solusi yang optimal. Skema dasar dari algoritma ACO seperti pada Gambar 1-1.
1.3 A
LGORITMA DANI
MPLEMENTASIAlgoritma ACO yang digunakan dalam penelitian ini adalah AntMiner+. AntMiner+ adalah algoritma pengklasifikasian berdasarkan aturan (rule-based classification) yang dapat dinyataan dalam graph sehingga dapat digunakan tehnik ACO. AntMiner+ yang diparalelkan disebut dengan AntMinerGPU. Pada algoritma AntMinerGPU digunakan kemampuan multithreading dari GPU untuk membuat tiap semut memiliki thread masing-masing sehingga bisa digunakan populasi semut yang besar.
Pada AntMinerGPU digunakan input training dataset yang sudah diketahui kelas tiap datanya untuk membentuk aturan klasifikasi yang dapat digunakan untuk memprediksi kelas dari data yang baru.
Implementasi AntMinerGPU disini hanya pada klasifikasi biner yaitu kelasnya hanya dua. Tiap poin data yang tidak sesuai dengan rule dinyatakan sebagai kelas 0, seperti aturan berikut
if (Variable1 op Value1) AND (Variable2 op Value2) ... AND (Variablei op Valuek) then Class D1
else Class D0 where op (=, ≤, >)
8 Algoritma AntMinerGPU menggunakan directed acyclic graph (DAG) untuk merepresentasikan area solusi.
Construction graph GC (V, E) dibuat sedemikian rupa sehingga vertices merepresentasikan set kemungkian solusi dan edge Eij merepresentasikan kemampuan memilih komponen solusi j setelah memilih i. Solusi masalahnya dinyatakan sebgai jalur yang melalui GC. Tiap variabel data pada training dataset dibuat satu group node, dalam Gambar 2 dinyatakan sebagai kotak vertikal. Tiap group node merepresentasikan semua kemungkinan yang dapat dilakukan variabel yang bersesuaian.
Gerakan semut dalam construction graph dibatasi aturan bahwa tiap variabel hanya boleh muncul maksimal satu kali pada aturan klasifikasi final. Pembatasan dilakukan menggunakan directed edge pada construction graph. Pembatasan juga dilakukan untuk menghindari aturan (Variablei <= x) AND (Variablei >= y) where y > x. Dalam Gambar 1-2 terlihat node n2,2 tidak terhubung dengan node n2,1.
Gambar 1-2 Construction Graph pada AntMinerGPU
Pada fase konstruksi solusi sekumpulan agen semut menciptakan kandidat classification rules dari sekumpulan pilihan yang ada (vertices pada GC). Konstruksi dimulai dengan rule yang kosong Rp=Ø pada setiap tahapan konstruksi kemudian Rp ditambah aturan yang ada pada classification rule parsial. Agen mengulangi gerakan dari node i menuju node j, menambahkan aturan yang ada pada j pada Rp sampai node terakhir.
Penambahan aturan pada kandidat classification rule dilakukan oleh agen semut dengan melihat banyaknya pheromone pada edge yang menuju ke aturan tersebut. Pheromone akan ditambah pada jalur yang dianggap solusi bagus sedangkan pada jalur yang dianggap jelek pheromone akan dikurangi.
Setiap semut berjalan dari awal node melalui construction graph sampai akhir node dengan proses-proses dasar yang dapat dilihat pada pseudo code berikut:
9 AntMinerGPU dibagi dalam delapan fungsi kernel GPU yaitu Initialize pheromone to max, Compute heuristic values, Calculate edge probabilities, Solution construction, Pheromone evaporation, Iteration-best solution identified, Pheromone deposition dan Remove covered data points seperti pada Gambar 1-3.
Gambar 1-3 Control flow pada AntMinerGPU
Struktur dari construction graph di implementasikan dalam dua structs yaitu Node dan Link yang disimpan dalam dua array d_nodes dan d_links. Structs Node digunakan untuk menyimpan edge yang muncul dari
generate construction graph
do until (min. percentage of training data remains) calculate heuristic values of nodes
initial pheromone levels calculate edge probabilities
while (no improvement to globalbest solution for X iterations) create ants
let ants walk from start node to end node evaporate pheromone from edges
identify iterationbest ant
reinforce path of iterationbest ant if necessary, update globalbest solution kill ants
re-calculate edge probabilities end
record global-best solution
remove data points covered by globalbest solution from training data reset global-best solution
end
10 tiap node sehingga tiap semut dapat mengidentifikasi edge mana yang bisa dilewati. Struct Node memiliki dua nilai integer sehingga bisa dibaca sebagai 64-bit chunk.
Informasi yang ada pada tiap edges disimpan dengan nilai float dalam tiga array d_pheromone, d_heuristic
dan d_probability. Pembagian menjadi tiga array ini agar bila dibutuhkan kombinasi dari ketiganya dapat diambil secara terpisah oleh kernel. Pada data Training yang sifatnya statis dapat dilakukan caching ke dalam texture 1 dimensi sehingga dapat diakses lebih cepat.
1.3.1 Pheromone Initialization
Fungsi kernel ini memberikan nilai pheromone pada tiap edge sesuai dengan parameter tMax.
1.3.2 Heuristic Value Computation
Nilai heuristic node digunakan untuk mengetahui seberapa penting node tersebut pada classification rules.
Pada kernel calculatorHeuristic, pointernya diberikan pada link array d_links dan data training
d_translatedData. Kernel calculatorHeuristic dijalankan oleh threads sejumlah d_links yang disusun pada grid 1 dimensi pada blok 1 dimensi. Setiap threads melakukan iterasi pada seluruh data training pada
d_translatedData dan menyimpan nilai heuristic pada array d_heuristic.
1.3.3 Edge Probabilities
Kernel calculateProbabilities melakukan perhitungan probabilitas dari edge yang akan dilewati agen semut. Tiap thread mengidentifikasi node yang dia kerjakan berdasarkan indeks blok pada grid. Tiap thread menghitung perkalian banyaknya pheromone dan nilai heuristic yang diambil dari d_pheromone dan d_heuristic pada link. Hasil perkalian disimpan pada shared memory. Setelah semua thread selesai melakukan perhitungan, tiap thread menjumlahkan nilai yang ada pada shared memory dan disimpan pada register kemudian menghitung probabilitas masing-masing link dan disimpan pada array d_probability.
__global__ void initializePheromones(float d pheromone, float tMax) { int linkID = blockIdx.x blockDim.x + threadIdx.x;
d_pheromone[linkID] = tMax;
}
11 1.3.4 Solution Generation
Kernel runGeneration memberikan pointer pada d_nodes, d_probability dan array random d_random. Kernel ini menggunakan thread sejumlah banyaknya semut pada sistem dan disusun pada grid 1 dimensi pada blok 1 dimensi. Tiap thread melakukan iterasi sejumlah grup node pada construction graph. Setiap selesai satu putaran ditambahkan link baru pada tiap semut. Ketika semut memilih suatu edge untuk dilalui maka indeks edge tersebut disimpan pada global memory yang mencatat jalur seluruh semut.
1.3.5 Pheromone Evaporation
Kernel evaporizePheromone membaca nilai d_pheromone kemudian mengalikan dengan suatu parameter kemudian menyimpannya kembali.
1.3.6 Solutions Evaluation
Pada bagian ini tiap tour yang dilakukan semut pada seluruh data training diidentifikasi apakah menunjukkan poin data sebagai kandidat classification rule.
extern shared float choices[];
Node n = d nodes[blockIdx.x];
int idx = threadIdx.x;
if (idx < n.numLinks) {
choices[idx] = powf(d pheromone[n.firstLink + idx],alpha) * powf(d heuristic[n.firstLink + idx], beta);
syncthreads();
float sum = 0.0f;
for (int i = 0; i < n.numLinks; i++){
sum += choices[i];
}
D_probability[n.firstLink + idx] = choices[idx] / sum;
}
__global__ void evaporizePheromone(float evaporize,float d pLevels, float d pheromone) {
int linkID = blockIdx.x * blockDim.x + threadIdx.x;
float p = d_pheromone[linkID] *= evaporize;
if (p < d_pLevels[0]){
d_pheromone[linkID] = d_pLevels[0];
} }
12 1.3.7 Pheromone Deposition
Fungsi kernel ini menyalin kualitas tiap tour semut ke dalam shared memory kemudian mencari semut mana yang tournya paling baik. Setelah ditemukan, sejumlah thread sebanyak node yang ada pada construction graph menambahkan pheromone pada link yang merupakan tour terbaik.
1.3.8 Remove Covered Data Points
Setelah sejumlah iterasi tanpa ada peningkatan pada global-best solution dibuat global-best rule. Poin data yang ditunjukkan dalam rule tersebut kemudian dihapus dari training dataset. Kernel flagCoveredCases
memiliki thread sejumlah poin data yang ada. Setiap thread melakukan pengecekan apakah global-best solution menggunakan data bagiannya, jika ya maka kelas poin data diset 1, poin data tersebut dinyatakan covered.
int antID = blockIdx.x;
int idx = threadIdx.x;
// shared data structures
int* s_tour; // the tour of the ant this block is responsible for int* s_covered; // how many data points are covered by the solution
int* s_correct; // how many data points are accurately described by the solution int* s_graphVarType; // what type of term (==, <=, or >=) each term is
int* s_graphVarID; // what variable in the training data each term pertains to ... __syncthreads();
int dataID = idx;
while (dataID < dataCount){
int test = 0;
if (d_ classOf[dataID] != -1) {
for (int j = 0; j < graphVarCount; j++) { int tourValue = s_tour[j];
int varType = s_graphVarType[j];
int dataValue = tex1Dfetch(translatedDataTEX, s_graphVarID[j]
* dataCount + dataID);
// Test tourValue against dataValue // if tourValue == dataValue, test++
}
if (test == graphVarCount) { atomicAdd(s covered, 1);
if (d classOf[dataID] == 1) { atomicAdd(s_correct, 1);
} }
} }
__syncthreads();
if (idx == 0){
// Implement fitness function, storing result in d_ quality[antID]
}
13
1.4 E
VALUASIAntMinerGPU dijalankan pada komputer dengan prosesor 2,4 GHz Intel Core 2 Quad dan memori 3 GB DDR3 serta GPU Nvidia Tesla C1060. Eksperimen dilakukan untuk membandingkan efek penambahan populasi semut pada running time dan akurasi. Training dataset yang digunakan berasal dari Wisconsin Breast Cancer (WBC) dan Tic-Tac-Toe (TTT). Hasilnya dapat dilihat pada Gambar 1-4 dan Gambar 1-5.
Gambar 1-4 Efek populasi semut terhadap akurasi (a) dan running time (b)
14 Dari grafik pada Gambar 1-4 dan Gambar 1-5 terlihat ada penurunan running time yang cukup banyak dalam penggunaan GPU, komputasi dipercepat hampir 100x, sedangkan akurasinya hanya berkurang sekitar 2%.
Gambar 1-5 Efek populasi semut terhadap akurasi (a) dan running time (b)
1.5 K
ESIMPULANBerdasarkan hasil eksperimen diatas dapat disimpulkan bahwa penggunaan GPU pada algoritma ACO dapat mempercepat running time hingga mencapai 100x lebih cepat, semakin banyak data yang digunakan semakin terlihat percepatannya dibanding menggunakan algoritma ACO yang sekuensial tanpa banyak mengurangi akurasi.
15
2 L ARGE -S CALE M ACHINE L EARNING
2.1 L
ATARB
ELAKANGMachine-learning digunakan dalam berbagai macam permasalahan, termasuk prediksi pada bidang financial forecasting, mesin penerjemah, pengenalan karakter dan suara, hingga konservasi biologi.
Walaupun terdapat banyak metode yang dapat digunakan pada permasalahan klasifikasi, namun pada paper ini membahas lebih lanjut dengan pendekatan maximum entropy classifier. Metode maximum entropy membangun model probabilitas yang konsisten terhadap data pelatihan, namun dapat juga sebaliknya. Hal ini bisa terjadi ketika data latih yang digunakan kurang, tapi kinerja yang luar biasa dapat diraih bila data latih yang digunakan pada implementasi algoritma ini menggunakan data latih yang besar.
Waktu latih dari MaxEnt classifier ini berbanding lurus terhadap besar dataset yang digunakan. Beberapa efek dari pengunaan classifier ini hanya dapat dilihat jika data training tersedia dalam jumlah banyak, sehingga menjalankan eksperimen menggunakan MaxEnt dalam perulangan akan banyak menghabiskan waktu. Untungnya pembelajaran dalam algoritma MaxEnt dapat dijalankan secara paralel, sehingga dapat mengurangi waktu perulangan dari ekperimen.
Pada paper ini, motivasi utama penggunaan algoritma MaxEnt digunakan untuk meningkatkan hasil dari pengenalan karakter pada sembarang gambar alami. Menurut penulis paper, tugas ini lebih kompleks dibandingkan pengenalan karakter pada dokumen, karena melibatkan banyak tipe font dan kondisi yang tidak terkontrol. Untuk meningkatkan performa dari algoritma ini, penulis paper bermaksud menggunakan GPU mengimplementasikan algoritma MaxEnt ini.
2.2 K
ONTRIBUSIA
UTHOR2.2.1 Core Technology
Sebuah model maximum entropy terdiri dari L x D matrix W yang menentukan seberapa besar bobot yang menetapkan masing - masing fitur D pada vektor masukan untuk setiap L label kategori yang potensial.
Sebuah vektor berukuran D x 1 merupakan vektor kolom dari fitur input x yang akan diklasifikasikan, akan dikalikan dengan matriks berat. Label dengan nilai terbesar dari hasil kali Wx dapat diambil sebagai nilai yang diberikan (assigned value) atau nilai yang diprediksi (prediction value).
Proses pembelajaran melibatkan optimisasi fungsi konveks dari W untuk sebuah ukuran tetap D x N matriks X dari N contoh pembelajaran. Matriks L x D memerlukan optimasi dari beberapa parameter. Meskipun
16 permasalahan optimisasi merupakan permasalahan yang konveks, merepresentasikan turunan kedua dari suatu fungsi objektif menggunakan Hessian matrix merupakan hal yang tidak dibenarkan. Oleh sebab itu, algoritma limited-memory quazy-Newton harus digunakan dalam mencari bobot yang optimal. Bottleneck dari proses ini terjadi pada saat mengevaluasi fungsi objektif dan gradientnya ketika jumlah contoh data pembelajaran N sangat besar.
Untungnya, baik fungsi objektif maupun gradient merupakan penjumlahan dari N instance pembelajaran yang melibatkan operasi perkalian matriks, penjumlahan vektor, mencari sebuah vector maksimal, dan perhitungan sederhana lainnya. Untuk memparalelkan proses, data dapat dibagi menjadi potongan - potongan yang lebih kecil yang akan berulang kali ditambahkan ke result accumulator.
2.2.2 Base Algorithm
Secara keseluruhan, proses komputasi dari algoritma MaxEnt ini meliputi:
1. Hitung perkalian matriks U = WX
2. Log-normalizing kolom dari U untuk membuat matriks probabilitas L berukuran L x N
3. Jumlahkan satu masukan dari masing - masing kolom L untuk menemukan nilai dari fungsi objektif 4. Hitung gradien sebagai sebuah perkalian matriks G = (XPT)T
Pada paper ini dijelaskan bahwa algoritma di atas diimplementasi menggunakan MATLAB. Pseudocode dari implementasi algoritma di atas dapat dilihat pada Gambar 2-1 di bawah ini. Dalam implementasi secara sekuensial menggunakan MATLAB, dapat dilihat bahwa terdapat banyak fungsi yang dilakukan secara berulang. Dari hal ini kemudian penulis paper ini bermaksud menggunakan konsep komputasi paralel untuk dapat melakukan komputasi algoritma MaxEnt sehingga dapat meningkatkan performa komputasi. Pada implementasinya, penulis paper ini menggunakan pemrograman parallel berbasis GPU dengan menggunakan CUDA yang diimplementasikan pada MATLAB.
17
Gambar 2-1 Implementasi pseudocode MaxEnt pada MATLAB
2.2.3 Algoritma Parallel 2.2.3.1 Arsitektur Program
Pada program yang telah dibuat oleh penulis paper, terdapat 4 CUDA kernel yang di buat, yaitu energy, probabilities, values, gradient. Kernel-kernel ini akan dipanggil oleh main procedure CUDA value yang mengatur pembagian dari keseluruhan data training pada host menjadi potongan - potongan yang akan ditransfer ke CUDA device untuk diproses. Prosedure CUDA_value memberikan nilai balik berupa total nilai fungsi objektif dan gradient ke MATLAB mexFunction. Selanjutnya, MEX gateway akan melewatkan hasil tersebut ke fungsi MATLAB value yang dipanggil oleh semua rutin optimisasi. Optimizer menggunakan nilai fungsi objektif dan gradient yang dikembalikan oleh value untuk selanjutnya digunakan untuk menghitung dan mengupdate bobot matriks dari subsequent evaluation, dan mengulang proses training hingga mencapai tujuan yang maksimal. Pada Gambar 2-2, diilustrasikan keseluruhan arsitektur program meliputi fungsi yang ada pada host dan device. Pada Gambar 2-2 digambarkan fungsi-fungsi yang digunakan dan juga arah pertukaran data masing-masing fungsi tersebut.
18
Gambar 2-2 Arsitektur Program
2.2.3.2 Training Overview
Data training X dan label kategori y diberikan ke fungsi train, yang merupakan method MATLAB, bersama dengan parameter opsional yang berkaitan dengan proses belajar. Disebabkan nilai X dan y tetap selama proses optimisasi, maka nilai tersebut akan di cache pada fungsi value, yang menghitung nilai fungsi objektif dan gradient ketika fungsi optimizer melewatkan sebuah matriks bobot W untuk di evaluasi. Fungsi value kemudian melanjutkan request ke Mex gateway routine yang selanjutnya akan ditangani oleh implementasi paralel CUDA.
Umumnya untuk mencegah terjadinya overfitting dilakukan dengan menambah aturan pada bobot untuk suatu fungsi objektif. Hal ini dilakukan pada method value, karena aturan tersebut hanya bergantung terhadap W dan beberapa parameter yang diberikan pada method training, sehingga tidak diperlukan paralelisasi dalam penambahan aturannya. Nilai yang berisi aturan dan gradien dapat dengan mudah dihitung dalam fungsi value pada host dan selanjutnya ditambahkan pada nilai fungsi objektif dan gradient yang berdasarkan datanya masing-masing.
19 2.2.3.3 Host-Device Interface
Antar muka antara, host dan CUDA device adalah function CUDA_value. Fungsi ini bertanggungjawab dalam mengalokasikan memory pada device untuk bobot, data dan sekaligus sebagai perantara nilai hasil, seperti probabilitas dan gradient. Memori host lebih besar dari pada memori pada device, sehingga data training harus dipartisi menjadi potongan - potongan yang lebih kecil, kemudian tiap potongan tersebut di transfer ke device, kemudian data ini akan dihitung kontribusinya terhadap nilai fungsi objektif dan dan gradien untuk satu potongan tiap waktunya. Keempat langkah ini (mulai dari perhitungan energy sampai gradien) harus selesai pada device untuk tiap potongan yang diberikan sebelum potongan berikutnya dikerjakan.
Nilai objektif dan gradien merupakan hasil penjumlahan dari N training, hal ini dengan mudah dilakukan dengan menambahkan hasilnya ke variabel akumulasi. Jumlah parsial dari fungsi objektif dihitung pada device dan diakumulasi pada host. Penjumlahan parsial dari gradien matriks diakumulasikan pada CUDA device dan selanjutnya di salin kembali ke host ketika semua data sudah diproses. Penghitungan ini dilakukan di device, karena dalam menghitung gradien penulis menggunakan library CUBLAS, yang mempermudah mengakumulasi hasil kali matriks secara paralel.
2.3 I
MPLEMENTASISesuai dengan arsitektur yang dibuat terdapat 4 CUDA kernel yang akan mengkomputasi algoritma MaxEnt ini. Implementasi dari masing - masing CUDA kernel tersebut adalah sebagai berikut :
2.3.1 Calculating Energy
Komputasi utama dari model MaxEnt adalah inner product antara bobot dengan data, komputasi ini disebut energy. Jika direpresentasikan berupa matriks, hubungan ini dikaitkan dengan perkalian matriks U=WX. Bobot dan potongan dari data sebelumnya telah disalin ke CUDA device, sehingga hasil kali U yang disimpan pada device, dengan gampang dihitung menggunakan CUBLASS library (cublasSgemm) secara parallel. Selanjutnya untuk menghitung fungsi tujuan, raw energy ini harus dikonversi menjadi log probabilities, yang akan dilakukan oleh fungsi kernel selanjutnya.
2.3.2 Normalizing Probabilities
Seperti yang sudah dijelaskan sebelumnya, matriks data yang asli telah dibagi menjadi beberapa potongan.
Potongan data tersebut kemudian di salin ke CUDA device. Sebuah kolom dari potongan data merepresentasikan sebuah training instance, dan masing - masing kolom tersebut akan di-handle oleh satu block thread. Ilustrasi pembagian data tersebut dapat dilihat pada Gambar 2-3.
20
Gambar 2-3 Pemotongan dari matriks energy/probabilitas
Untuk menghitung probabilitas yang akan digunakan untuk nilai tujuan dan gradien, harus dilakukan penghitungan log-normalization log Zj. Proses ini membutuhkan 3 fase: menemukan sebuah nilai maksimum, totaling exponentiated energies, dan melakukan normalizing.
2.3.2.1 Menemukan Nilai Maximum
Untuk langkah pertama, menemukan nilai maksimum dari raw energy uij untuk semua label I dari instance j. Hal ini bertujuan untuk menghindari nilai yang membesar secara eksponen yang menyebabkan hasil yang tidak reliabel, khususnya dengan penggunaan angka single precision floatingpoint yang digunakan pada implementasi algoritma ini. Penulis paper ini telah melakukan uji coba terhadap 2 metode yang dapat digunakan untuk mencari nilai float maksimum pada vektor. Metode pertama menggunakan pembandingan dan statement kondisional. Metode lain menggunakan orderpreserving bijection antara type data unsigned int dengan float, sehingga pembandingan dapat dilakukan dengan menggunakan fungsi CUDA atomicMax.
Gambar 2-4 Pseudocode CUDA kernel untuk mencari local maximum
21 2.3.2.1.1 Menemukan Maximum Energy tanpa Atomics
Sebuah array di share untuk tiap thread dalam satu block. Karena terdapat kemungkinan jumlah label lebih banyak dari jumlah threads, labels dibagi secara merata diantara blocks thread, kemudian setiap thread mencari nilai maksimal diantara potongan data tersebut. Proses ini didemonstrasikan pada Gambar 2-4.
Pada tersebut dijelaskan bahwa satu buah thread digunakan untuk mencari nilai maksimum local terhadap data yang ditanganinya. Array P menyimpan raw energy dalam 1 block, sedangkan start dan end mengindikasikan batas partisi dari data yang ditangani thread tersebut.
Butterfly reduction kemudian meneruskan dengan mengalokasikan satu thread untuk dua data dari shared memory, dan memilih salah satu yang terbesar dari kedua data tersebut. Selanjutnya proses akan berulang sampai ditemukan nilai paling maksimal dari data yang disimpan pada shared memory. Proses ini didemonstrasikan pada Gambar 2-5.
Gambar 2-5 Max-reduction butterfly code
2.3.2.1.2 Menemukan Maximum Energy menggunakan Atomics dan Bijection
Untuk meningkatkan performa algoritma, penulis kemudian mengembangkan pencarian nilai maksimum dengan menggunakan fungsi CUDA atomicMax, yang merupakan fungsi bawaan dari CUDA. Oleh karena semua thread dalam butterfly harus selesai mencari nilai maksimal sebelum menuju level selanjutnya, sebuah barrier sinkronisasi tetap diperlukan. Ilustrasi dari penggunaan atomics dan bijection dapat dilihat pada Gambar 2-6.
22
Gambar 2-6 Local maximum dengan atomic dan bijection
Butterfly reduction juga mengalami perubahan, dengan mengganti conditional statement dengan menggunakan pemanggilan atomicMax, dan pada hasil akhir dari nilai maksimum dilakukan invert terhadap bijection, seperti diterangkan pada Gambar 2-7.
Gambar 2-7 Max-reduction butterfly code menggunakan CUDA atomic
2.3.2.2 Calculating the Normalizer: A Butterfly Sum Reduction
Langkah kedua untuk log-normalizing adalah dengan melakukan penjumlahan untuk menghitung Zj.
Pendekatan untuk melakukan penjumlahan sama dengan saat mencari nilai maksimum, karena dilakukan terhadap data yang sama. Setiap thread menghitung nilai subtotal untuk masing-masing potongan datanya, kemudian subtotal tersebut diakumulasikan dalam secara butterfly. Proses ini didemonstrasikan pada Gambar 2-8.
23
Gambar 2-8 Sum-reduction
2.3.2.3 Calculating the Probability
Langkah terakhir menggunakan hasil dari langkah sebelumnya untuk melakukan log-normalizing kolom probabilitas. Hal ini dilakukan dengan cara melakukan pengurangan log Zj untuk setiap row (label) dari raw energy uij. Karena raw energy sudah tidak diperlukan lagi, pengurangan ini dilakukan secara langsung pada raw data. Penghitungan ini didilihat pada Gambar 2-9.
Gambar 2-9 Menghitung normalized probabilities menggunakan satu thread
2.3.3 Summing Value
Langkah ketiga pada algoritma MaxEnt adalah melakukan penghitungan nilai untuk tiap instance pada potongan data. Dalam papernya, penulis menggunakan prosedur cublasSasum untuk menghitung total nilai absolut dari potongan data. Selanjutnya nilai potongan tersebut akan diakumulasikan pada host.
24 2.3.4 Calculating the Gradient
Pada kernel ini, penulis juga menggunakan library CUBLAS untuk melakukan perhitungannya. Untuk menghitung gradien pada host penulis menggunakan fungsi sparse matrix multiplication yang sudah ada pada library MATLAB.
2.4 P
ENGUJIANP
ERFORMAPada paper ini, penulis melakukan pengujian performa dengan membandingkan implementasi algoritma MaxEnt menggunakan MATLAB pada GPU dan CPU. Spesifikasi komputer yang digunakan untuk uji coba adalah sebagai berikut:
Intel Xeon Quad-Core 2.26 GHz CPU
48 GB of 1066 MHz DDR3 RAM
NVIDIA C1060 Tesla (240 streaming processors (SPs), 4 GB DDR3 RAM) 2.4.1 Hasil Pengujian Umum
Untuk mengukur speedup dari implementasi parallel ini, penulis paper ini menggunakan nilai N, L, dan D yang berbeda - beda. Pada Gambar 2-10 dapat dilihat bahwa maksimum speedup didapat ketika N = 215 dan D = 210 dengan L = 211.
Gambar 2-10 Speedup GPU vs CPU dengan L = 1024 (kiri) dan D = 1024 (kanan)
Hasil Eksperimen tambahan yang dilakukan dapat dilihat pada Gambar 2-11. Gambar tersebut mengindikasikan bahwa setelah N bernilai maksimum dan mencapai titik tertinggi, terdapat sedikit penurunan dan kemudian mendatar. Hal ini juga serupa pada L yang berangsur-angsur menurun. Menurut
25 penulis, hal ini terjadi karena pada titik maksimum merupakan titik dimana implementasi dari GPU lebih paralel dibandingkan dengan implementasi MATLAB tanpa CUDA.
Gambar 2-11 Penjelasan peningkatan performa untuk L = 1024 dan D=1024 (kiri), L=1024 dan N = 32768 (tengah), dan untuk D = 1024 dan N=32768 (kanan)
2.4.2 Pengujian Menggunakan Implementasi Character Recognition Application
Pada pengujian ini, penulis paper melakukan uji coba dengan jumlah fitur D = 32 pixel x 32 pixel x 25 images
= 25.600. Classifier yang dibuat harus dapat mengenali 63 ketegori karakter (huruf besar, huruf kecil, angka dan spasi) dalam satuan dari 7 satuan karakter. Hal ini menyebabkan jumlah L = 63 x 7 + 1 = 442 kategori.
Dalam pengujiannya, penulis paper ini menggunakan contoh karakter dari 1.600 font dengan keberagaman distorsi, karakter bertetangga, dan beberapa model kontekstual lainnya. Dengan 1.600 font dasar 4 jenis distorsi untuk masing-masing dari 62 karakterm dan 3 jenis spasi (beragam ukuran lebar), jumlah N = 409.600 training instance.
Dari hasil pengujian yang dilakukan, speedup yang didapatkan dengan implementasi CUDA adalah 30, 6x dibandingkan dengan MATLAB tanpa CUDA. Hasil ini didapat dari nilai rata-rata 5 kali pengujian. Pengujian selanjutnya yang dilakukan penulis paper adalah melakukan pengujian untuk mengukur dampak dari penambahan training data terhadap peningkatan hasil pada domain character recognition. Parameter hasil yang dipakai oleh penulis adalah log-likelihood. Data yang digunakan sebagai pengujian yaitu L = 62 kategori (hanya angka dan karakter) dengan jumlah fitur yang sama yaitu D = 25.600. Untuk dataset N yang digunakan untuk menguji bervariasi. Seperti yang dapat dilihat pada Gambar 2-12, terjadi peningkatan logaritmik pada nilai log-likelihood seiring dengan bertambahnya data training secara eksponensial.
26
Gambar 2-12 Performa character recognition dengan dataset lebih dari 100.000 karakter
2.5 K
ESIMPULANPada penelitian ini penulis mengembangkan aplikasi pengenalan karakter menggunakan algoritma MaxEnt dengan memanfaatkan komputasi paralel berbasis GPU. Implementasi aplikasi ini dikembangkan pada MATLAB dengan menggunakan CUDA kernel sebagai proses parallelnya. Dari hasil uji coba yang dilakukan bahwa penggunaan GPU dapat meningkatkan performa dari aplikasi jika dibandingkan dengan penggunaan CPU saja. Selain itu dari penelitian yang dilakukan oleh penulis paper ini didapatkan bahwa nilai log- likelihood yang merupakan parameter hasil pada domain character recognition, terjadi peningkatan logaritmik seiring dengan bertambahnya data training.
2.6 O
PENP
ROBLEMPada implementasi aplikasi large-scale machine-learning ini, penulis paper lebih banyak melakukan perbaikan pada permasalahan yang berkaitan dengan matrix multiplication. Namun pada beberapa bagian seperti mencari nilai max dan sum-reduction masih kurang parallel karena masih membutuhkan sinkronisasi antar thread. Untuk itu masih perlu dilakukan perbaikan terhadap algoritma dan teknik paralel yang berkaitan dengan mencari nilai max dan sum-reduction pada implementasi sistem ini sehingga diharapkan performa yang didapatkan akan lebih baik.
Selain itu implementasi dari aplikasi ini masih menggunakan single GPU. Dengan perkembangan CUDA saat ini, untuk meningkatkan performa dapat juga dilakukan implementasi aplikasi yang serupa pada multi GPU.
27
3 K OMPUTASI P ARALEL UNTUK A LGORITMA S MITH -W ATERMAN
3.1 L
ATARB
ELAKANGPattern matching merupakan kegiatan pencocokan atau pengecekan keberadaan suatu pola (pattern) terhadap sebuah database yang menunjukkan entitas tertentu. Proses pencocokan ini sendiri banyak digunakan di berbagai bidang, antara lain pencocokan pola gambar, video, audio, maupun teks. Contoh pattern matching yang sederhana adalah pencarian rangkaian kata tertentu pada sebuah word processor.
Proses yang terjadi adalah pencarian dari sebuah kueri tertentu terhadap rangkaian data yang telah disediakan. Pada umumnya permasalahan yang terjadi pada algoritma pencocokan pola ini adalah kompleksitas yang tinggi, terlebih untuk ukuran data yang besar.
Salah satu penggunaan pattern matching dalam proses pencocokan teks atau string antara lain untuk menemukan pola yang cocok dari serangkaian DNA terhadap rangkaian DNA yang lain. Dalam penelitiannya, Khajeh-Saeed and Perot [1] membahas permasalahan yang terjadi dalam proses pencocokan DNA. Secara umum, tubuh manusia terdiri atas jutaan rangkaian DNA, sehingga dalam proses pencocokan suatu pola DNA diperlukan algoitma yang efisien. Algoritma yang kurang tepat dapat menimbulkan komputasi yang mahal baik dari segi waktu komputasi maupun kompleksitasnya. Algoritma pattern matching yang dibahas dalam paper berjudul “GPU-Supercomputer Acceleration of Pattern Matching” ini adalah algoritma Smith-Waterman (SW). Permasalahan yang muncul dalam penggunaan algoritma ini adalah kompleksitasnya yang bersifat quadratic (dilihat dari dua rangkaian DNA yang harus dibandingkan), ditambah lagi dengan pertumbuhan database DNA sendiri yang bersifat eksponensial [2].
Dalam algoritma SW, terdapat sebuah proses dimana dalam membandingkan dua karakter dalam dua rangkaian DNA diperlukan perhitungan bobot yang dipengaruhi oleh bobot pada karakter sebelumnya (melalui pembentukan tabel berukuran rangkaian kueri x rangkaian database), hal ini menyebabkan adanya isu data dependency yang menyebabkan sulitnya algoritma paralel diimplementasikan. Karena antara satu data dengan data yang lainnya saling berpengaruh dalam proses pengolahan, rangkaian proses yang terjadi dalam algoritma harus dijalankan secara berurutan sehingga diperlukan waktu komputasi yang lama.
Berdasarkan penjelasan singkat mengenai algoritma pattern matching, khususnya dalam penggunaan algoritma SW, dalam paper ini, [1] mengidentifikasi permasalahan yang terjadi.
28 1. Bagaimana melakukan pencocokan pola (pattern matching) pada data DNA yang besar agar dapat
meminimalkan kompleksitas algoritma.
2. Bagaimana mengatasi permasalahan data dependency dalam penerapan algoritma SW.
3. Bagaimana melakukan modifikasi pada algoritma SW dalam implementasi konsep paralelisasi.
Tujuan yang ingin dicapai dalam paper berjudul “GPU-Supercomputer Acceleration of Pattern Matching”
ini adalah membahas beberapa modifikasi algoritma SW untuk proses pattern matching sehingga dapat diterapkan dalam proses paralelisasi algoritma SW itu sendiri. Selain itu juga ingin diketahui algoritma mana yang lebih baik diterapkan untuk dikomputasikan secara paralel. Pada paper ini juga dijelaskan hasil eksperimen dengan menggunakan beberapa lingkungan GPU yang berbeda.
3.2 A
LGORITMAS
MITH-W
ATERMANAlgoritma Smith-Waterman (SW) merupakan algoritma yang menerapkan paradigma pemrograman secara dinamis (dynamic programming) dalam mencari optimal local alignment antara dua rangkaian protein DNA untuk mencari similaritas antara keduanya [2]. Perhitungan similaritas antara kedua rangkaian DNA dilakukan dengan membentuk tabel berukuran nxm dimana n adalah panjang rangkaian DNA pertama (jumlah baris) dan m adalah panjang rangkaian DNA kedua (jumlah kolom). Masing-masing cell pada tabel diisi dengan skor similaritas antara karakter ke-i dengan karakter ke-j. Perhitungan skor tiap cell dijelaskan dalam persamaan berikut [3, 4].
Persamaan 3-1
Berdasarkan fungsi perhitungan skor pada Persamaan 3-1, secara umum nilai Hi,j yang menunjukkan skor pada cell baris ke-i dan kolom ke-j diperoleh dari nilai maksimum dari nilai cell-cell tetangganya. Hi,j
diperoleh dengan membandingkan nilai-nilai pada: (i) diagonal kiri atas (Hi-1,j-1) ditambahkan dengan skor similaritas antara karakter pada indeks i,j (Si,j), (ii) maksimum nilai cell-cell di atas Hi,j (Hi-k,j) dikurangi dengan fungsi gap (Gs + kGe), (iii) maksimum nilai cell cell di sebelah kiri Hi,j (Hi,j-k) dikurangi dengan fungsi gap (Gs
+ kGe), dan (iv) nilai 0. Dari keempat nilai tersebut diambil nilai maksimum untuk memperoleh skor bagi cell Hi,j.
29 Sebagai contoh terdapat dua sequence DNA yang akan dicari alignment antara keduanya, yaitu CAGCCUCGCUUAG (sebagai sequence database) dengan AAUGCCAUUGCCGG (sebagai sequence kueri).
Keduanya akan direpresentasikan dalam tabel untuk memperoleh skor perbandingan masing-masing karakter pada kedua sequence. Perhitungan skor similaritas antar keduanya diawali dengan menentukan dua hal, yaitu skor similaritas antara karakter pada cell (i,j) dan nilai gap yang terdiri atas gap start-penalty (Gs) dan gap extension-penalty (Ge). Dalam aplikasi biologi yang sesungguhnya, penetapan nilai inisialisasi kedua variabel tersebut akan sedikit rumit, namun sebagai gambaran, dalam implementasi algoritma SW, keduanya dapat ditentukan secara manual oleh user atau dengan perhitungan tertentu [3]. Salah satu sumber yang menjadi acuan dalam menentukan skor kemiripan antara dua karakter dalam dua sequence adalah tabel BLOSUM (BLOck Substitution Matrix). Contoh sederhana yang akan digunakan dalam penjelasan algoritma SW dalam pembahasan paper ini adalah dengan menentukan skor similaritas antar setiap karakter pada cell (i,j) dengan nilai 5 jika keduanya sama, dan nilai -3 jika keduanya berbeda, kemudian nilai gap start-penaity ditentukan sebesar 8 dan gap extension-penalty sebesar 1. Langkah- langkah pengisian setiap cell dalam tabel dijelaskan sebagai berikut.
1. Beri inisialisasi awal pada baris pertama (Hk,0) dan kolom pertama (H0,l) dengan nilai 0, dimana batas nilai k dan l ditentukan dengan 0 < k < n dan 0 < l < m.
2. Pada setiap cell yang ditunjukkan oleh Hij dimana batas i dan j adalah 1 < i < n dan 1 < j < m, dilakukan perhitungan skornya menggunakan Persamaan 3-1 dengan membandingkan nilai/skor pada cell yang bertetangga dengan cell Hij untuk dicari skor yang paling maksimal. Berdasar inisialisasi skor similaritas dan fungsi gap, hasil perhitungan di setiap cell ditunjukkan pada tabel pada Gambar 3-1.
30
Gambar 3-1 Contoh Tabel Perhitungan pada Algoritma Smith-Waterman
Sebagai contoh untuk mendapatkan skor 4 pada cell H6,8, berdasarkan Persamaan 3-1, perhitungan dari masing-masing bagian dijelaskan sebagai berikut:
i. Diagonal kiri atas (H5,7) = Max (H5,7 + S6,8, 0) = Max (5 + (-3), 0) = 2 ii. Nilai maksimum kolom di atas cell H6,8 adalah:
iii. Nilai maksimum kolom di sebelah kiri H6,8 adalah:
31 iv. Sehinggal diperoleh skor untuk cell H6,8:
v. Perhitungan yang sama diterapkan ketika ingin mengetahui skor untuk tiap cell lainnya.
3. Berdasarkan skor setiap cell yang telah diperoleh, selanjutnya dilakukan traceback untuk memperoleh alignment terpanjang antara dua sequence yang dibandingkan. Proses traceback dilakukan dengan mencari dari cell yang memiliki skor tertinggi kemudian secara berkebalikan arah ditelusuri cell-cell tetangga yang memiliki nilai maksimum. Ketika traceback telah bertemu dengan skor 0 pada diagonal kiri atas, berarti telah ditemukan alignment maksimum dari kedua sequence [3], panjang alignment maksimum diperoleh mulai dari ditemukannya cell dengan skor maksimum hingga ditemukan cell dengan skor 0. Pada Gambar 1, berdasar hasil traceback diperoleh rangkaian seperti nilai-nilai yang dicetak tebal. Penentuan gap pada alignment maksimum yang ditemukan dilakukan dengan menyisipkan gap pada sequence pertama (dalam hal ini kueri) ketika ditemukan perpindahan traceback ke arah kiri, dan menyisipkan gap pada sequence kedua (dalam hal ini database) ketika ditemukan perpindahan traceback ke arah atas [3]. Berdasarkan nilai yang dicetak tebal pada Gambar 1, alignment maksimum dapat dituliskan menjadi:
3.3 K
OMPUTASIP
ARALEL UNTUKA
LGORITMAS
MITH-W
ATERMANMasalah utama dalam implementasi algoritma SW ini adalah waktu komputasi yang mahal ketika diterapkan secara naive sehingga memerlukan penerapan konsep algoritma parallel, namun di sisi lain paralelisasi sulit dilakukan karena adanya isu data dependency dalam perhitungan skor setiap cell dalam tabel algoritma SW. Hal ini menimbulkan munculnya beberapa pendekatan dalam melakukan paralelisasi,
G C C – U C G C (pada database) G C C A U U G C (pada kueri)
32 beberapa diantaranya dilakukan dengan memodifikasi algoritma utama dengan perhitungan yang lebih bersifat independent sehingga memungkinkan proses parallel dalam komputasinya. Berikut ini dijelaskan beberapa pendekatan dalam proses paralel untuk algoritma SW.
3.3.1 Reduced Dependency
Dengan mengimplementasikan algoritma SW seperti dijelaskan dalam Persamaan 3-1, perhitungan skor maksimum pada setiap rangkaian baris dan kolom harus dilakukan berkali-kali pada setiap proses pencarian skor cell . Seperti disampaikan pada [3], hal ini menimbulkan kompleksitas O(L1L2(L1+L2)). Hal ini dapat dikurangi dengan membentuk variabel baru untuk menangani perhitungan skor maksimum di setiap baris dan kolom. Dalam paper ini, langkah penambahan variabel tersebut diidentifikasi juga sebagai cara untuk mengurangi data dependency dalam perhitungan masing-masing cell. Penambahan variabel dilakukan bersamaan dengan penggunaan memory tambahan untuk variabel-variabel tersebut.
Persamaan 3-2
Ei,j digunakan dalam menghitung skor maksimum pada cell-cell di sebelah kiri cell Hi,j, sedangkan Fi,j untuk cell-cell di atas Hi,j. Dengan menambahkan dua variabel baru tersebut, dalam setiap perhitungan skor untuk cell Hi,j diperlukan akses pembacaan pada lima variabel, yaitu Ei,j, Fi,j, Hi,j-1, Hi-1,j dan Hi-1,j-1 dan penulisan tiga variabel untuk menuliskan hasil skor maskimum untuk Hi,j, yaitu Ei,j, Fi,j, Hi,j-1. Data dependency tidak lagi bergantung pada banyak cell seperti digambarkan pada Gambar 3-1 pada area yang diarsir, tapi hanya pada cell-cell yang benar-benar bertetangga dengan cell Hi,j, yaitu cell-cell yang tepat berada di atas, kiri dan diagonal kiri atasnya.
3.3.2 Antidiagonal Approach
Melalui penambahan variabel baru pada perhitungan algoritma SW ini, paralelisasi dapat dilakukan dalam menghitung setiap antidiagonal cell. Dengan menggunakan tiga variabel, tidak perlu lagi menyimpan hasil perhitungan dari seluruh cell [1], sebuah baris antidiagonal dapat diperbaharui dari baris antidiagonal E dan F dan dua baris antidiagonal H sebelumnya dan disimpan dalam indeks cell ke-i dan ke-j.
33 Isu dalam pendekatan ini adalah terkadang kurang efisien digunakan jika panjang kedua sequence yang dibandingkan sama. Pada kondisi panjang sequence yang berbeda, panjang maksimum antidiagonal adalah panjang dari sequence terpendek dari keduanya. Pada implementasinya dalam lingkungan GPU diperlukan 128-256 thread per block, dan minimal 32-60 block untuk setiap multiprocessor. Hal ini memerlukan setidaknya panjang sequence sebesar 104. Pemrosesan pendekatan antidiagonal ini tidak dapat diproses hanya dalam register dan shared memory karena masih terdapat dependency pada penggunaan variabel E, F, dan H antar thread.
3.3.3 Row (or Column) Parallel Approach
Pendekatan row (or column) ini menggunakan perhitungan dengan tiga variabel E, F, dan H menggukanak konsep paralel scan. Dengan pendekatan ini, tujuan yang ingin dicapai adalah memodifikasi algoritma SW sehingga perhitungan dalam menentukan skor untuk cell dapat dilakukan dalam proses paralel satu baris (row) atau kolom (column) dalam satu waktu [3]. Dalam perhitungan berdasar Persamaan 3-2, algoritma SW dibagi ke dalam tiga tahap, yaitu:
1. Menghitung nilai variabel temporary Ȟi,j dengan hanya menggunakan perhitungan variabel Fi,j
sebagai berikut:
Persamaan 3-3
Skor Fi,j diperoleh dari nilai maksimum Fi-1,j dan Hi-1,j – Gs dikurangkan dengan nilai gap Ge, dimana nilai diperoleh berdasarkan Persamaan 3-2. Selanjutnya nilai Fi,j digunakan sebagai pembanding dalam menentukan nilai maksimum dari skor cell kiri atas (Hi-1,j-1 + Si,j), Fi,j, dan 0. Sebagain contoh ketika ingin dilakukan perhitungan skor untuk cell Ȟ6,8, terlebih dahulu dicari nilai F5,8 dan H5,8 untuk mencari nilai maksimumnya yang akan dijadikan sebagai nilai F6,8. Selanjutnya skor Ȟ6,8 diperoleh dari nilai maksimum dari (H5,7 + S6,8), F6,8, dan 0. Hasil perhitungan dapat dilihat pada Gambar 3-2.
2. Setelah diperoleh nilai variabel Ȟi,j, selanjutnya dilakukan perhitungan untuk variabel Ěi,j:
Persamaan 3-4
34 Nilai ini Ěi,j diperoleh dari nilai maksimum dari cell-cell variabel Ȟ dalam satu baris ke-(j-1) hingga indeks ke-(j-k). Semisal ingin diketahui skor untuk Ě6,8, maka perbandingan untuk mencari nilai maksimum dilakukan pada cell Ȟ6,7, Ȟ6,6, Ȟ6,5,…, Ȟ6,1.
3. Perhitungan untuk skor cell Hi,j berdasarkan hasil kedua perhitungan variabel Ȟi,j dan Ěi,j
sebelumnya:
Langkah pertama dan terakhir dalam pendekatan ini dilakukan dalam local memory, tidak memerlukan data dari thread yang berbeda. Pendekatan parallel row ini memerlukan akses sekuensial terhadap memori gabungan. Jika menggunakan contoh inisialisasi = 8 dan =1, maka perhitungan dengan pendekatan parallel row (or column) ini ditunjukkan sebagai berikut [1].
Gambar 3-2 Contoh Perhitungan Algoritma SW dengan Pendekatan Parallel Row (or Column)
Pada Gambar 3-2, dengan mengambil perhitungan untuk baris ke-6 pada tabel yang ditampilkan pada Gambar 3-1, dimisalkan ingin diketahui skor untuk variabel H pada baris ke-6 diperlukan perhitungan pada baris ke-5 untuk mencari nilai variabel F, H, dan E. Dalam pendekatan parallel row (or column) ini, paralelisasi dapat dilakukan pada setiap perhitungan untuk setiap barisnya.
3.3.4 Overlapping Search
Perhitungan algoritma SW juga dapat dilakukan menggunakan multiple GPU, contohnya ketika dalam sebuah motherboard digunakan lebih dari satu device GPU. Permasalahan yang muncul dalam penggunaan multiple GPU ini adalah kecepatan dari koneksi jaringan yang dipengaruhi oleh penggunaan banyak GPU (lebih dari 4) [3]. Permasalahan ini dapat diatasi dengan pendekatan overlapping search dengan membagai-bagi sequence database DNA ke dalam beberapa bagian block (N) yang overlapping.
35
Gambar 3-3 Ilustrasi Pendekatan Overlapping Search dengan Pembentukan Overlapping Block
Pada Gambar 3-3 dijelaskan mengenai pembagian sequence database ke dalam empat overlapping block.
Dalam pendekatan ini, jika panjang data yang overlap lebih panjang daripada panjang sequence yang ditemukan, maka pencarian alignment terpanjang dapat dilakukan secara independent [1]. Dalam pendekatan ini tidak diperlukan komunikasi antar GPU kecuali pada saat proses transfer pada bagian database yang overlap (ketika awal pemrosesan) dan proses pengurutan alignment terbaik pada akhir proses. Penerapan pendekatan ini dapat dilakukan pada pendekatan parallel row (or column) pada subbab sebelumnya.
3.3.5 Data Packing
Algoritma SW ini merupakan masalah keterbatasan akses memory (memory constrained) yang dapat berpengaruh pada kecepatan transfer datanya, salah satu pendekatan sederhana yang dapat digunakan adalah melakukan packing pada rangkaian data dan pada nilai pada intermediate table. Sebagai contoh, dalam kasus DNA dan RNA hanya terdapat empat kemungkinan karakter (2 bit), yaitu A-T (Adenine- Thymine), G-C (Guanine-Cytosine) untuk DNA dan A-U (Adenine-Uracil), G- C(Guanine-Cytosine) untuk RNA.
Ketika terdapat sebuah rangkaian RNA dengan panjang 16 maka dapat ditempatkan pada sebuah single 32-bit integer. Untuk meningkatkan performa dari pembacaan memori dapat dilakukan dengan menggunakan ukuran memori kelipatan 16. Namun demikian data packing memiliki satu keterbatasan, yaitu adanya isu dependency, sehingga dalam paper [1] ini tidak dilakukan eksperimen menggunakan pendekatan ini.
3.3.6 Hash Tables
Beberapa aplikasi penerapan algoritma SW adalah FASTA dan BLAST yang secara heuristik melakukan pencocokan antara dua sequence. Heuristik yang dilakukan adalah menentukan n rangkaian pertama pada DNA/RNA sebagai acuan untuk mencocokkan sebelum selanjutnya akan dicocokkan menggunakan rangkaian yang berada di belakang n rangkaian tersebut. Secara umum yang dilakukan dalam pendekatan ini adalah pembentukan hash table berdasarkan n rangkaian
DNA/RNA pertama sebagai penanda untuk rangkaian selanjutnya. Tujuan yang ingin dicapai adalah untuk mengurangi kompleksitas pencarian. Sebagai contoh, digunakan nilai n sebesar 4, terdapat 16
36 kemungkinan (karena 2 bit) 4 item pertama yang cocok. Penggunaan pendekatan ini dapat mengurangi komputasinya hingga 2n. Pada single CPU, BLAST dan FASTA dapat bekerja 60 kali lebih cepat daripada implementasi algoritma SW yang optimal. Pendekatan ini juga termasuk ke dalam problem dependence dan sulit untuk dilakukan paralelisasi. Oleh karenanya pendekatan ini tidak diikutsertakan dalam ekperimen.
3.4 E
KSPERIMEN DANE
VALUASI3.4.1 Lingkungan Eksperimen
Implementasi algoritma SW dan eksperimen dilakukan dalam lingkungan GPU yang terdapat pada Lincoln sebagai sebuah National Science Foundation (NSF) dari Teragrid GPU Cluster yang berlokasi di National Center for Supercomputing Applications (NCSA). Perangkat yang terdapat di dalamnya terdiri atas 96 server Tesla S1070 (384 Tesla GPU) dimana pada setiap 192 server terdapat dua prosesor Intel 64 (Harpertown) 2.33 GHz (dual-socket quad-processors) dengan 2x6 MB L2 cache dan setiap core kapasitas RAM nya sebesar 2 GB. Masing-masing CPU memiliki 4 core, terhubung dengan Tesla GPU melalui slot PCI-en Gen X8. Program ditulis dalam bahasa C++ dengan mengimplementasikan CUDA. Sistem operasi yang digunakan adalah Red Hat Enterprise Linux 4 (2.6.19) dengan menggunakan compiler GCC.
3.4.2 Hasil Eksperimen
Algoritma SW diimplementasikan ke dalam dua kernel berdasarkan fungsinya, yaitu:
1. Kernel pertama yang bertugas mengidentifikasi end-point dari best match sequence pada table algoritma SW. Tugas yang dilakukan oleh kernel pertama ini bersifat computationally intensive.
2. Kernel kedua bertugas untuk mengidentifikasi rangkaian sequence terbaik melalui proses traceback setelah kernel pertama selesai melakukan tugasnya dalam mengidentifikasi end-point dari best match sequence. Tugas yang dilakukan oleh kernel kedua ini tidak terlalu efisien dalam implementasinya pada lingkungan GPU, namun juga tidak bersifat computationally intensive.
Perbandingan dilakukan antara penggunaan beberapa jenis NVIDIA GPU dengan penggunaan AMD CPU (quad-core Phenom II X4 CPU 3.2 GHz dengan 4x512 KB L2 cache, 6 MB L3 cache ). Tipe GPU yang digunakan dalam eksperimen ini antara lain 9800 GT, 9800 GTX, 295 GTX, Tesla S1070, 480 GTX. Pengamatan dilakukan terhadap waktu komputasi yang diperlukan dalam memproses algoritma SW dan speed-up yang dihasilkan. Dalam Gambar 3-4 size menyatakan ukuran database yang digunakan, sedangkan panjang sequence kueri yang diujicobakan adalah 1024. Uji coba dilakukan dalam implementasi kernel 1 untuk
37 menemukan end-point dari best match sequence. Berdasarkan grafik pada Gambar 3-4 tersebut implementasi algoritma menggunakan CPU cenderung memerlukan waktu komputasi yang tinggi dibandingkan dengan penggunaan device GPU mencapai103 detik dengan ukuran database sebesar 1010.
Sedangkan speed-up terbaik pada jumlah data 1010 ditunjukkan oleh penggunaan device GPU 480 GTX.
Gambar 3-4 Perbandingan Performa NVIDIA GPU dan AMD Quad-Core Phenom II X4 CPU
Dengan menggunakan single GPU dapat dilakukan pencarian optimal untuk data kueri sepanjang 1000 terhadap rangkaian database dengan panjang 1M dalam waktu 1 s. Dalam eksperimen kernel 2 untuk pencarian 200 end-point dari 200 best match sequence diperlukan waktu 0.02 detik menggunakan proses pada CPU. Kernel 2 ini bersifat independen terhadap ukuran database. Dengan menggunakan GPU untuk menangani kernel 2, diperlukan waktu 0.055 s (8800 GT) dan 0.3 s (295 GTX). Karena Selisih waktu antara penggunaan GPU dibandingkan dengan CPU tidak terlalu besar, kernel 2 ini dapat dikatakan tidak terlalu berpengaruh pada keseluruhan waktu komputasi algoritma.
Eksperimen lain dilakukan dengan menetapkan nilai konstan pada ukuran data dan memvariasaikan jumlah proses parallel yang digunakan, hasil eksperimennya ditunjukkan pada Gambar 3-5. Pengamatan dilakukan untuk mengetahui waktu komputasi dan speed-up yang dihasilkan.
38
Gambar 3-5 Perbandingan Performa Penggunaan Jumlah Proses yang Berbeda (Strong Scaling)
Pada eksperimen kedua ini, ditetapkan panjang sequence database sebesar 16M dan panjang sequence kuerinya sebesar 128 untuk menunjukkan hasil penerapan strong scaling. Berdasarkan hasil yang ditunjukkan pada Gambar 3-5 diketahui penggunaan jumlah proses paralel yang semakin besar dapat meningkatkan performa komputasi, yaitu turunnya waktu komputasi yang diperlukan hingga menjadi 102 ms, sedangkan speed-up yang ditunjukkan juga semakin naik seiring bertambahnya jumlah proses paralel hingga 120 proses. Pengujian lain secara weak scaling dilakukan untuk mengetahui pertumbuhan problem size terhadap jumlah GPU yang digunakan, sehingga kerja yang dilakukan pada setiap GPU menjadi konstan.
Gambar 3-6 Performa Weak Scaling untuk GCUPS dan Speed-up pada Penerapan Kernel 1
Gambar 3-6 menunjukkan cell update per second (GCUPS) dan speed-up untuk penerapan kernel 1. Pada bagian (a) ditampilkan grafik GCUPS berbentuk linier seiring kenaikan jumlah GPU yang digunakan. Hal ini
39 karena jumlah pekerjaan yang dilakukan menaik secara proporsional terhadap jumlah GPU yang digunakan. Sedangkan speed-up yang ditunjukkan pada bagian (b) membandingkan antara penggunaan single AMD CPU dengan NVIDIA GPU dan hasilnya adalah terjadi speed-up sebesar 56x pada single GPU dan 5335x pada penggunaan 120 GPU.
Dalam eksperimen ini diimplementasikan pendekatan paralel dengan memanfaatkan variabel- variabel tambahan antara lain E, F, dan H. Berdasarkan beberapa pendekatan dalam melakukan paralelisasi algoritma SW, implementasi utama dalam paper ini adalah menggunakan pendekatan parallel row. Tiga tahap utama yang dijalankan pada pendekatan ini adalah perhitungan H melalui nilai F, proses scan E, dan perhitungan skor akhir untuk variabel H. Dari ketiga langkah tersebut, proses scan diidentifikasi sebagai bagian yang paling mahal komputasinya, seperti ditampilkan pada Gambar 7. Tahap ini menerapkan modifikasi algoritma dari model scanLargeArray pada SDK yang terdapat pada CUDA 2.2. Mahalnya komputasi pada tahap ini kemungkinan disebabkan karena adanya isu bank conflicts serta kemungkinan proses dilakukan pada puncak efisiensi. Berdasar Gambar 3-7, proses pencarian best macth sequence (dalam hal ini sebanyak 200 sequence) tidak terlalu berpengaruh dalam komputasi, hanya 2-3%. Komputasi utama tetap digunakan dlam proses perhitungan skor untuk masing-masing pasangan karakter yang dibandingkan. Pendekatan parallel row ini secara umum mampu menjauhkan sifat ketergantungan (data dependency) dalam algoritma SW dan berusaha menyelesaikan permasalahan data dependency tersebut sebaik dan seefisien mungkin menggunakan pendekatan parallel scan.
Gambar 3-7 Gambaran Persentase Komputasi pada Algoritma SW dengan Pendekatan Parallel Scan
Berdasar hasil implementasi pendekatan menggunakan perangkat Lincoln ini dengan 7 memori akses untuk setiap cell, diperoleh maximum theoretical GCUPS mendekati 3.0 (85/4/7) untuk single GPU.
Penggunaan pendekatan parallel row menghasilkan 1.04 GCUPS untuk setiap GPU, sehingga pendekatan ini cukup beralasan jika dikatakan efisien (sekitar 34% dari peak memory). Untuk mencapai nilai GCUPS yang lebih tinggi, mungkin dapat digunakan pendekatan dependent optimization berdasar data packing atau hash table. Namun demikian, penggunaan pendekatan parallel row ini dapat memproses sembarang ukuran data baik pada sequence kueri maupun pada sequence database. Tidak terdapat batas ukuran kueri maupun database-nya.
40
3.5 O
PENP
ROBLEMBerdasarkan hasil eksperimen, dalam paper ini dapat disimpulkan perlunya eksperimen lanjutan untuk mengoptimalisasi kinerja algoritma SW ini. Salah satu cara untuk mengoptimalkannya adalah dengan menggabungkan ketiga tahap utama pada pendekatan parallel row yang digunakan, yaitu perhitungan H melalui nilai F, proses scan E, dan perhitungan skor akhir untuk variabel H dilakukan dalam sebuah proses single GPU. Selain itu perlu dilakukan sinkronisasi setiap thread antar kernel karena algoritma yang bersifat saling menunggu, dimana masing-masing tahap pada semua thread harus selesai sebelum menjalankan tahap selanjutnya. Terdapat dua tahap sinkronisasi yang harus dilakukan, yaitu :
setelah menyelesaikan tahap up-sweep pada tahap parallel scan dan (2) setelah memperoleh nilai untuk variabel H. Nilai yang diperoleh setelah pada kedua proses sinkronisasi harus disimpan dalam global memory, selanjutnya data yang lain disimpan dalam shared memory. Secara umum satu- satunya batasan bagi penggunaan pendekatan parallel row ini adalah kesabaran dari pengguna itu sendiri. Ukuran data yang tidak terbatas pada akhirnya akan bergantung pada memori yang tersedia dalam GP
3.6 K
ESIMPULANBerdasarkan hasil pengkajian paper berjudul “GPU-Supercomputer Acceleration of Pattern Matching” ini, terdapat beberapa hal yang dapat disimpulkan sesuai dengan bahasan dalam paper ini, antara lain:
1. Dalam melakukan proses pencocokan pola (pattern matching) antara dua sequence protein yang berukuran besar diperlukan proses paralelisasi agar dapat mengurangi tingkat kompleksitasnya, yaitu dengan melakukan pembagian proses dalam algoritma SW tersebut sehingga dapat
dilakukan secara bersamaan dalam satu waktu. Salah satucaranya dalah dengan melibatkan lebih dari satu device.
2. Dalam mengatasi permasalahan yang terjadi dalam algoritma Smith-Waterman (SW) yaitu adanya isu data dependency, diperlukan strategi lain dalam memparalelkan perhitungan algoritma ini. Beberapa cara melakukan paralelisasi yang telah dibahas, yaitu: reduced
dependency, antidiagonal approach, row (or column) parallel approach, overlapping search, data packing, dan hash table. Dari pendekatan-pendekatan tersebut dapat dilakukan kombinasi implementasi dari masing-masingnya.
Karena permasalahan utama pada algoritma SW ini adalah amsalah data dependency, maka satu-satunya cara yang mungkin dilakukan adalah dengan melakukan modifikasi algoritma. Jika pada algoritma SW asli
