Paralelisasi Metode Jacobi untuk Komputasi SVD dalam GPU dan Modifikasinya

(1)

Paralelisasi Metode Jacobi untuk

Komputasi SVD dalam GPU dan

Modifikasinya

(2)

Daftar Isi

1.

Pendahuluan

• Pengantar

• Executive Summary

• Penelitian Sebelumnya

2.

Tinjauan Pustaka

• Metode Komputasi SVD

• Metode Jacobi: Two-Side, Kogbetliantz, One-Side

• QR dan SVD

• General-Purpose GPU

3.

Rancangan Algoritma

• Paralelisasi One-Side Jacobi

• Paralelisasi QR

• Prekondisi QR dan SVD Jacobi

• Analisis Kompleksitas

4.

Ujicoba dan Analisis

• Parameter Pengukuran

• Hasil dan Pembahasan

• Running Time

• Speed-Up

• Throughput

• Bandwidth

• Validasi

(3)

(4)

Pengantar

•

Komputasi SVD untuk matriks besar berjalan

lambat

•

Metode klasik untuk SVD: Golub-Kahan-Reisch

•

Diperlukan cara-cara inovatif untuk

mempercepatnya

•

Paralelisasi SVD dalam GPU

(5)

Executive Summary

•

Tujuan Penelitian:

menyelidiki kemungkinan akselerasi

SVD, khususnya metode Jacobi, dengan menggunakan

GPU

•

Penulis membangun:

–

Rutin SVD dengan metode One-Side Block Jacobi (OSBJA) dalam

GPU

–

Urutan ortogonalisasi baru: berdasarkan anti-diagonal

–

Rutin dekomposisi QR dengan metode Rotasi Givens dalam GPU

–

Kombinasi Jacobi dengan QR dalam GPU

•

Hasil:

–

Rutin SVD dengan metode Jacobi dan prekondisi QR mampu

(6)

Kontribusi

•

Paralelisasi Jacobian SVD dalam GPU

•

Metode pengurutan ortogonalisasi

per-anti-diagonal matriks pasangan baris

(7)

Mengapa GPU ?

•

Murah-Meriah

•

Tersedia luas (semua PC pasti memiliki GPU)

•

Cocok untuk aplikasi data-parallel

(8)

Penelitian Sebelumnya

•

Franklin Luk (1989) : pembuktian konvergensi

metode Jacobi

•

Strumpen et. al. (2003) : implementasi algoritma

Jacobi pada prosesor stream

•

Hari (2005) : modifikasi algoritma Jacobi dengan

prekondisi QR

•

Lahabar et. al. (2008) mengimplementasikan SVD

dengan metode Golub-Kahan pada GPU

•

Shane Ryoo et. al (2008) : prinsip-prinsip

(9)

Asumsi-Asumsi Dasar

•

Matriks sumber adalah

∈ ℝ

×

•

Format penyimpanan matriks dalam memori

adalah row-major

•

Presisi tunggal

(10)

(11)

Klasifikasi Algoritma SVD

SVD

Jacobi-Like

Jacobi (2-side)

Hestenes

(1-side Jacobi) Kogbetliantz

QR-Based

(12)

Two-Side Jacobi

•

Dasar: diagonalisasi matriks simetriks melalui

perkalian dengan matriks rotasi dari kiri dan

kanan

�

�+

=

, , � �

�

, , �

�

•

Update pada baris dan kolom ke-i dan j



dapat diparalelkan

(13)

Kogbetliantz Method

•

Dasar: diagonalisasi matriks segitiga

� ∈ ℝ

×

dengan perkalian dua matriks rotasi berbeda

dari kiri dan kanan

�

�+

=

, , � �

�

, , �

�

•

Seperti two-side Jacobi, harus bekerja pada

baris dan kolom bersamaan

•

Hari (2007) menyarankan transformasi matriks

e jadi e tuk Butterfly supaya dapat

(14)

Metode SVD: One-Side Block Jacobi

•

Dasar: Rotasi setiap pasang vektor baris sampai

saling ortogonal

•

Me erluka e erapa kali

sweep

sa pai

ter apai ortogo alitas ko verge .

•

Menggunakan rotasi Jacobi untuk membuat dua

vektor ortogonal

•

Mengalikan matriks dengan matriks rotasi dari sisi

kiri o e

-

side

•

Dilakukan per pasangan blok-blok baris

(15)

Penurunan OSBJA

Iterasi Rotasi

� = Φ Φ

−

… Φ Φ �

Sampai didapat baris-baris

�

saling ortogonal

Rotasi dapat diakumulasi sebagai

�

= Φ Φ

−

… Φ Φ

Sehingga

� =

�

= Σ

�

Nilai-nilai singular dari A:

�,�

= �

�

=

� � �

�,�

Matriks rotasiortogonal

Perkalian rotasiortogonal

Output:

Matriks

�

∈ ℝ

×

Vektor

∈ ℝ

(16)

Formula Rotasi

Matriks Rotasi:

Φ , , � =

⋱

⋱ −

⋱

Di mana

= cos �

dan

= sin �

Menghitung dan :

� = �_�_� − �_{⋅ �}

= sign � � + + �

=

+ =

Nilai baru baris-baris A setelah rotasi adalah

(17)

Kriteria Konvergensi Jacobi

Strumpen et. al (2003)

= � �

�

*Dipilih untuk percobaan ini

HPEC Challenge (2006)

(18)

Urutan Ortogonalisasi

•

Urutan ortogonalisasi baris mempengaruhi

jumlah sweep



kecepatan konvergensi

•

Tiga jenis urutan:

–

Serial cyclic-by-row/column

–

Paralel (Brent & Luk)

–

Odd-Even

•

Belum ada pembuktian apakah urutan

(19)

Brent-Luk Parallel Ordering

• Dapat dikerjakan oleh / jumlah prosesor secara serentak

• Hasil eksperimen: perlu terlalu banyak sweep jika dibandingkan urutan serial (untuk one-side)

(20)

Kunggulan dan Kelemahan Metode Jacobi

•

Keunggulan:

–

Sederhana, elegan

–

Akurat, mampu menghitung nilai-nilai singular

yang kecil

–

Potensial diparalelisasi

•

Kelemahan:

(21)

Prinsip-Prinsip Perbaikan Metode

Jacobi (Hari 2005)

•

Pengurangan jumlah langkah dan sweep

•

Pengurangan jumlah flop dan waktu CPU

dalam satu langkah

(22)

Modifikasi SVD dengan QR

•

Prekondisi matriks sumber untuk mengurangi

jumlah baris yang harus di-ortogonalisasi

•

Berguna jika

≫

•

Algoritma:

1. Dekomposisi QR:

� =

2. Dekomposisi LQ:

=

�

3. Hitung SVD:

= Σ

�

4. SVD dari A:

� =

Σ

�

Potong R berukuran ×

(23)

Metode QR: Rotasi Givens

1 0 0 0

0 1 0 0

0 0 1 0

0 0 0 1

X X X

skip

(24)

1 0 0 0

0 1 0 0

0 0 1 0

0 0 0 1

X X X

(25)

1 0 0 0

0 1 0 0

v v v v

X X X

(26)

1 0 0 0

0 1 0 0

v v v v

X X X

(27)

1 0 0 0

v v v v

X X X

0 X X

(28)

1 0 0 0

v v v v

X X X

0 X X

(29)

V V V V

X X X

0 X X

(30)

Metode QR: Rotasi Givens

V V V V

X X X

0 X X

(31)

V V V V

C C C C

X X X

0 X X

(32)

V V V V

C C C C

X X X

0 X X

(33)

V V V V

C C C C

X X X

0 X X

0 0 X

(34)

V V V V

C C C C

X X X

0 X X

0 0 X

(35)

V V V V

C C C C

Y Y Y Y

X X X

0 X X

0 0 X

0 0 0

(36)

Struktur GPU

GPU

Framebuffer / Global Memory SM 0 SP0 SP1 SP2 SP3 SP4 SP5 SP6 SP7 Memory Controller Register File Shared Memory Cache SM 1 SP0 SP1 SP2 SP3 SP4 SP5 SP6 SP7 Memory Controller Register File Shared Memory Cache SM 2 SP0 SP1 SP2 SP3 SP4 SP5 SP6 SP7 Memory Controller Register File Shared Memory Cache SM 3 SP0 SP1 SP2 SP3 SP4 SP5 SP6 SP7 Memory Controller Register File Shared Memory Cache Host

SM: Shared Multiprocessor SP: Streaming Processor

(37)

CUDA: Perangkat Pemrograman GPU

•

Kode konvensional yang berjalan dalam CPU

melakukan panggilan kernel yang berjalan pada GPU

•

Panggilan kernel disertai konfigurasi eksekusi: ukuran

grid, block

•

Kode dalam kernel berjalan per-thread

•

Thread



block



grid

•

Sinkronisasi antar thread dalam block (tidak bisa antar

block atau global)

(38)

Hirarki:

Thread



Block



Grid

• Satu block berjalan pada satu SM

• Beberapa block dapat berjalan bersama pada satu SM, dibatasi oleh konsumsi register dan shared memorytetap tidak ada sinkronisasi antar

blockbayangkan OS multitasking pada uniprosesor

• Grid: kumpulan semua block yang berada dalam GPU

• Warp: kelompok 32 thread yang berjalan serentak pada satu block

• Divergent warp: percabangan yang membuat anggota warp mengambil jalur kode berbeda

• Divergent warp memiliki ongkos yang mahal: setiap cabang harus

diselesaikan secara serial

• Percabangan antar warp tidak mendapat penalty.

• 8 SP untuk menjalankan 32

threadsatu instruksi sederhana perlu minimal 4 clock cycle

(39)

Pendekatan Pemrograman GPU

•

Data-Parallelism

•

Kode CPU sebagai sinkronisasi, GPU sebagai

pemrosesan

•

Implisit: pandang blok sebagai

vector

processor

, gunakan

shared memory

sebagai

penyimpan vektor sesering mungkin

•

Koordinasikan akses memori dengan sesama

thread dalam block

(40)

(41)

Paralelisasi OSBJA dalam GPU

•

Perlu

− /

proses ortogonalisasi per sweep

•

Urutan kerja: setiap kali proses tidak boleh ada satu

baris yang diproses bersamaan

•

Bagi baris-baris menjadi kelompok berukuran sama,

buat pasangan setiap kelompok dan didapat sebuah

matriks pasangan kelompok baris

•

Tidak semua urutan pengerjaan dijamin konvergen

•

Solusi: Urutan ortogonalisasi menurut anti-diagonal

(42)

Urutan Ortogonalisasi Menurut Anti-Diagonal

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7

1,1 1,2 1,3 1,4 1,5 1,6 1,7

2,2 2,3 2,4 2,5 2,6 2,7

3,3 3,4 3,5 3,6 3,7

4,4 4,5 4,6 4,7

5,5 5,6 5,7

6,6 6,7

7,7 Langkah 0

skip

(43)

Urutan Pengerjaan Menurut Anti-Diagonal

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7

1,1 1,2 1,3 1,4 1,5 1,6 1,7

2,2 2,3 2,4 2,5 2,6 2,7

3,3 3,4 3,5 3,6 3,7

4,4 4,5 4,6 4,7

5,5 5,6 5,7

6,6 6,7

(44)

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7

1,1 1,2 1,3 1,4 1,5 1,6 1,7

2,2 2,3 2,4 2,5 2,6 2,7

3,3 3,4 3,5 3,6 3,7

4,4 4,5 4,6 4,7

5,5 5,6 5,7

6,6 6,7

(45)

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7

1,1 1,2 1,3 1,4 1,5 1,6 1,7

2,2 2,3 2,4 2,5 2,6 2,7

3,3 3,4 3,5 3,6 3,7

4,4 4,5 4,6 4,7

5,5 5,6 5,7

6,6 6,7

(46)

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7

1,1 1,2 1,3 1,4 1,5 1,6 1,7

2,2 2,3 2,4 2,5 2,6 2,7

3,3 3,4 3,5 3,6 3,7

4,4 4,5 4,6 4,7

5,5 5,6 5,7

6,6 6,7

(47)

Urutan Pengerjaan Menurut Anti-Diagonal

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7

1,1 1,2 1,3 1,4 1,5 1,6 1,7

2,2 2,3 2,4 2,5 2,6 2,7

3,3 3,4 3,5 3,6 3,7

4,4 4,5 4,6 4,7

5,5 5,6 5,7

6,6 6,7

(48)

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7

1,1 1,2 1,3 1,4 1,5 1,6 1,7

2,2 2,3 2,4 2,5 2,6 2,7

3,3 3,4 3,5 3,6 3,7

4,4 4,5 4,6 4,7

5,5 5,6 5,7

6,6 6,7

(49)

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7

1,1 1,2 1,3 1,4 1,5 1,6 1,7

2,2 2,3 2,4 2,5 2,6 2,7

3,3 3,4 3,5 3,6 3,7

4,4 4,5 4,6 4,7

5,5 5,6 5,7

6,6 6,7

(50)

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7

1,1 1,2 1,3 1,4 1,5 1,6 1,7

2,2 2,3 2,4 2,5 2,6 2,7

3,3 3,4 3,5 3,6 3,7

4,4 4,5 4,6 4,7

5,5 5,6 5,7

6,6 6,7

(51)

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7

1,1 1,2 1,3 1,4 1,5 1,6 1,7

2,2 2,3 2,4 2,5 2,6 2,7

3,3 3,4 3,5 3,6 3,7

4,4 4,5 4,6 4,7

5,5 5,6 5,7

6,6 6,7

(52)

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7

1,1 1,2 1,3 1,4 1,5 1,6 1,7

2,2 2,3 2,4 2,5 2,6 2,7

3,3 3,4 3,5 3,6 3,7

4,4 4,5 4,6 4,7

5,5 5,6 5,7

6,6 6,7

(53)

Implementasi Jacobi dalam CUDA

•

Kode sinkronisasi antar anti-diagonal dalam

CPU

•

Kode kernel untuk ortogonalisasi sepasang

blok baris



dipetakan ke satu block GPU

(54)

Pembagian Kerja Thread, Block & Grid

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7

1,1 1,2 1,3 1,4 1,5 1,6 1,7

2,2 2,3 2,4 2,5 2,6 2,7

3,3 3,4 3,5 3,6 3,7

4,4 4,5 4,6 4,7

5,5 5,6 5,7

6,6 6,7

7,7

grid

(55)

Kernel Jacobi

for (i=0: / − ) {

row1 [tid] = A [ *n + i*b + tid]; row2 [tid] = A [ *n + i*b + tid]; row3 [tid] = row1 [tid] * row2 [tid]; row2 [tid] = row2 [tid] * row2 [tid]; row1 [tid] = row1 [tid] * row1 [tid]; __syncthreads ();

if (tid < 32) {

row1 [tid] += row1 [tid + 32]; row1 [tid] += row1 [tid + 16]; row1 [tid] += row1 [tid + 8]; row1 [tid] += row1 [tid + 4]; row1 [tid] += row1 [tid + 2]; row1 [tid] += row1 [tid + 1]; row3 [tid] += row3 [tid + 32]; row3 [tid] += row3 [tid + 16]; row3 [tid] += row3 [tid + 8]; row3 [tid] += row3 [tid + 4]; row3 [tid] += row3 [tid + 2]; row3 [tid] += row3 [tid + 1]; }

else {

row2 [tid] += row2 [tid + 32]; row2 [tid] += row2 [tid + 16]; row2 [tid] += row2 [tid + 8]; row2 [tid] += row2 [tid + 4]; row2 [tid] += row2 [tid + 2]; row2 [tid] += row2 [tid + 1]; }

if (tid==0) {

row1 [b] += row1 [0]; row2 [b] += row2 [0]; row3 [b] += row3 [0]; }

}

Tahap 1: Menghitung dot products

• = � ⋅ �

Loop U roll

Syarat jumlah baris harus kelipatan =

Akumulasi dot products

(56)

Kernel Jacobi

if (tid==0) {

swap = ( < ); if (swap) {

S [ ] = ; S [ ] = ; }

else {

S [ ] = ; S [ ] = ; }

if (� > )

converged = false; if (� > ) {

� = − = sign_{� + +�}� = ₊ =

}

else { c = 1; s = 0; }

}

__syncthreads ();

Tahap 2: Menghitung Rotasi (cos � dan sin �)

Proses ini hanya dikerjakan oleh thread pertama dan disimpan pada shared memory untuk mengurangi penggunaan register yang

berdampak berkurangnya utilisasi prosesor.

Penggunaan satu thread untuk kode serial seperti ini membuat kernel lebih efisien: 5~6% lebih cepat daripada semua thread ikut menghitung

(57)

Kernel Jacobi

for (i=0: / − ) {

= row1 [tid] = A [ *n + i*b + tid]; = row2 [tid] = A [ *n + i*b + tid]; row1 [tid] = c* – s* ;

row2 [tid] = s* + c* ; if (swap) {

A [ *n + i*b + tid] = row1 [tid]; A [ *n + i*b + tid] = row2 [tid]; }

else {

A [ *n + i*b + tid] = row1 [tid]; A [ *n + i*b + tid] = row2 [tid]; }

}

for (i=0: / − ) {

= row1 [tid] = U [ *n + i*b + tid]; = row2 [tid] = U [ *n + i*b + tid]; row1 [tid] = c* – s* ;

row2 [tid] = s* + c* ; if (swap) {

U [ *m + i*b + tid] = row1 [tid]; U [ *m + i*b + tid] = row2 [tid]; }

else {

U [ *m + i*b + tid] = row1 [tid]; U [ *m + i*b + tid] = row2 [tid]; }

}

Tahap 3: Menerapkan rotasi pada matriks � dan .

(58)

Paralelisasi Givens-QR dalam GPU

X X X

1 0 0 0

0 1 0 0

0 0 1 0

0 0 0 1

skip

(59)

X X X

0 X X

X X X

0 X X

X X X X

blok #0

(60)

X X X

0 X X

X X X X

(61)

X X X

0 X X

0 0 X

0 X X

X X X X

X X X X blok #0

Percabangan dalam GPU mahal, jadi seluruh baris

(62)

Paralelisasi Givens-QR dalam GPU

X X X

0 X X

0 0 X

X X X X

(63)

X X X

0 X X

0 0 X

0 0 0

X X X X

(64)

X X X

0 X X

0 0 X

0 0 0

X X X X

R

(65)

SVD Jacobi dengan Prekondisi QR

QR2

1. Dekomposisi QR:

� =

2. Dekomposisi LQ pada R:

1.

Transpose

∈ ℝ

×

2.

QR pada

�

:

�

=

�

3.

Transpose

,

�

3. Jacobi SVD pada :

= Σ

�

4. Bangun

�

:

�

=

� �

5. Bangun :

=

QR1

1. Dekomposisi QR:

� =

2. Jacobi SVD pada :

= Σ

�

(66)

Analisis Kompleksitas

•

Jacobi

– Memory: = + + +

– Workload: ≈ + + +

– Transfer: ≈ + + +

• Dekomposisi QR

– Memory: = +

– Workload: ≈ + −

– Transfer: ≈ + + −

• QR2

– Memory: = + + +

– Workload: ≈ + + + −

– Transfer: ≈ + + + + +

• QR1

– Memory: = + + +

– Workload: ≈ + + −

– Transfer: ≈ + + + +

Workload_{: jumlah FLOP selama}

rutin berjalan dalam GPU

Transfer_{: Jumlah transfer input dan}

output antara chip dan memori GPU

(67)

(68)

Pengujian Program

Percobaan: mencatat running time keempat program

dan rutin SVD dari Octave

•

Parameter

–

Running time

–

Throughput

–

Bandwidth

–

Speed-Up

•

Tipe matriks input

–

Random

–

Hilbert

(69)

Perangkat Pengujian

•

Yang dibangun:

–

QR2

–

QR1

–

GPU Jacobi

–

CPU Jacobi

•

Software

–

Cuda Toolkit 3.2

–

GCC 4.4+Linux 64 bit

–

Octave



single CPU,

gold standard

•

Hardware

–

GPU: GeForce 9500 GT, RAM DDR2 512 MB

(70)

Pengujian Validitas

•

Setiap babak mencakup pengujian hasil SVD

•

Persyaratan validitas

–

max

�

−

�



ortogonal

–

max

�

−

�



ortogonal

–

max

�

− �

(71)

Pencatatan Waktu

•

GPU Timer

dari manajemen event CUDA

•

Fungsi clock_gettime(2) untuk rutin CPU

(72)

Running Time (1)

0 500 1000 1500 2000 2500 3000

0 500 1000 1500 2000 2500 3000 3500 4000

Waktu

QR2 QR1 Jacobi CJacobi Octave

(73)

Running Time (2)

0 10 20 30 40 50 60

0 500 1000 1500 2000 2500 3000 3500 4000

Waktu

(74)

Running Time (3)

0 500 1000 1500 2000 2500 3000

0 500 1000 1500 2000 2500 3000 3500 4000

Waktu

(75)

Hasil Pengujian (4)

0 500 1000 1500 2000 2500

0 500 1000 1500 2000 2500 3000 3500 4000

Waktu

(76)

Running Time (5)

Matriks: sparse, Variasi: jumlah baris, Kolom: 64

0 5 10 15 20 25 30 35 40 45 50

0 500 1000 1500 2000 2500 3000 3500 4000

Waktu

(77)

Running Time (6)

0 500 1000 1500 2000 2500

0 500 1000 1500 2000 2500 3000 3500 4000

Waktu

(78)

Running Time (7)

0 200 400 600 800 1000 1200 1400 1600 1800 2000

QR2 QR1 Jacobi CPU Jacobi Octave

Waktu (detik)

(79)

Running Time (8)

0 500 1000 1500 2000 2500 3000 3500

QR2 QR1 Jacobi CPU Jacobi Octave

Waktu (detik)

(80)

Pembahasan: Running Time

•

Waktu komputasi sangat bergantung pada kondisi matriks

sumber

•

Kode GPU Jacobi secara umum lebih cepat daripada kode CPU

•

Jacobi+QR pada matriks persegi lebih cepat dari Jacobi murni

pada GPU dan sebaliknya pada matriks square

•

Kode GPU lebih lambat untuk matriks kecil

×

karena overhead komunikasi CPU



GPU

•

Seperti diprediksi, rutin Jacobi murni sangat berpengaruh

terhadap jumlah sweep

•

Bagaimana memprediksi jumlah sweep ?

•

Octave mendapat kesulitan ketika mendapat banyak vektor tidak

(81)

Jumlah Sweep (Matriks Random)

Ukuran Metode

GPU Jacobi CPU Jacobi QR2 QR1

× 8 8 8 8

× 9 9 7 7

× 10 10 9 10

× 11 10 10 10

× 10 10 10 9

(82)

Jumlah Sweep (Matriks Hilbert)

Ukuran Metode

GPU Jacobi CPU Jacobi QR2 QR1

× 6 6 6 6

× 7 7 7 7

× 9 9 8 8

(83)

Speed-Up (1)

0 50 100 150 200 250 300

0 500 1000 1500 2000 2500 3000 3500 4000

Kolom

(84)

Speed-Up (2)

0 50 100 150 200 250 300

0 500 1000 1500 2000 2500 3000 3500 4000

Jumlah Baris

(85)

Speed-Up (3)

0 0,2 0,4 0,6 0,8 1 1,2 1,4

0 500 1000 1500 2000 2500 3000 3500 4000

Square

(86)

Pembahasan: Speed-Up

•

Kode GPU memiliki speed-up rendah untuk

jumlah baris kecil (

)



overhead

sinkronisasi CPU-GPU sangat besar

(87)

Throughput (1)

0 10 20 30 40 50 60 70

0 500 1000 1500 2000 2500 3000 3500 4000

Gfl

o

p

/s

Jumlah Kolom

QR2

QR1

(88)

Throughput (2)

0 10 20 30 40 50 60 70

0 500 1000 1500 2000 2500 3000 3500 4000

Gfl

o

p

s/s

Jumlah Baris

QR2

QR1

(89)

Throughput (3)

0 1 2 3 4 5 6 7 8 9

0 500 1000 1500 2000 2500 3000 3500 4000

(90)

Pembahasan: Throughput

•

Perbedaan karakteristik dalam throughput

QR2 dan QR1 tidak signifikan, namun QR2

membutuhkan memori lebih besar

•

Ketiga algoritma ini masih berada di bawah

batas throughput GPU (134 Gflop/s)

(91)

Bandwidth (1)

0,00 20,00 40,00 60,00 80,00 100,00 120,00 140,00 160,00 180,00

0 500 1000 1500 2000 2500 3000 3500 4000

(92)

Bandwidth (2)

0,00 20,00 40,00 60,00 80,00 100,00 120,00 140,00 160,00 180,00

0 500 1000 1500 2000 2500 3000 3500 4000

GB

/s

Baris

QR2

QR1

(93)

Bandwidth (3)

0,00 2,00 4,00 6,00 8,00 10,00 12,00

0 500 1000 1500 2000 2500 3000 3500 4000

GB

/s

Ukuran

QR2

QR1

(94)

Pembahasan (Bandwidth)

•

A o ali pada Ja o i erukura kurus :

bandwidth maksimal GPU adalah 32 GB/s.

•

Dugaan: efek

cache memory

dalam prosesor

namun transparan dari software

•

Perlu perubahan kode untuk eksploitasi cache

(95)

Hasil Validasi

•

Metode Jacobi dapat menghitung SVD secara

akurat, sesuai dengan akurasi mesin (presisi

tunggal)

•

Pengecualian: kasus rank-deficient (contoh:

gambar 2)

(96)

(97)

Kesimpulan

•

Metode Jacobi SVD dalam GPU dapat mengungguli

metode sebelumnya yang berbasis bidiagonalisasi,

terutama pada matriks berukuran besar

•

Penggunaan urutan ortogonalisasi paralel menurut

anti-diagonal mampu mencapai konvergensi

•

Perlakuan prekondisi dengan QR mampu mengurangi

waktu untuk metode Jacobi pada keadaan

m ≫

(98)

Saran

Masih terdapat ruang untuk perbaikan metode

Jacobi dalam GPU:

•

Eksploitasi bentuk matriks segitiga hasil

prekondisi dengan QR/LQ: metode

Kogbetliantz

•

Penanganan kasus

rank-deficient

(99)