27 iunie 2011

Optimizari

Asa cum am relatat in postarea precedenta, algoritmul paralel implementat se dovedeste a fi foarte ineficient (cel putin la prima vedere).


Pentru a-l imbunatati, primii pasi vor fi sa:

  • - elimin recrearea contextului de fiecare data
  • - elimin recompilarea programului de fiecare data (+ 0.1-0.3 la fiecare apelare)
  • - incearc sa inlantuiesc mai multe seturi de kernel-uri in acelasi context (folosind event)
  • - evit daca pot interschimbarea haotica de date (e rau mai ales pe GPU)
  • - bitonic sort e un mod de a sorta datele foarte potrivit pentru arhitecturi paralele (inclusiv GPU-uri), sugestie in loc de bubble sort in kernel-uri
  • - incearc sa elimin/reduc acele loop-uri din kernel cumva (cu cat sunt mai multe branch-uri conditionale cu atat e mai rau)
  • - reduc alocarile/eliberarile de memorie, folosind eventual o memorie tampon prealocata.

Cod: se poate gasi aici: http://dl.dropbox.com/u/24465060/K_elem_v3.zip

Observatii: timpul de executie s-a imbunatatit considerabil doar urmand cateva dintre sugestii, desi sortarile in kernels au ramas bubble sort (= multe bucle, multe ramificatii, interschimbari haotice).

------------------------- Teste -----------------------------------------------


n = 2400
k = 2000

[1] GeForce 8600 GT (4 cu) = 0.50s
[2] GeForce 210 (2 cu) = 0.91s
[3] Cedar Radeon 5470 (2 cu) = 0.57s
[5] ATI RV730 (8 cu) = 0.69s

==================

n = 2000
k = 1282

[0] Intel(R) Core(TM)2 Duo CPU = 0.09s
[1] GeForce 8600 GT (4 cu) = 0.34s
[2] GeForce 210 (2 cu) = 0.65s
[3] Cedar Radeon 5470 (2 cu) = 0.54s
[4] Intel(R) Core(TM) i3 CPU = 0.13s
[5] ATI RV730 (8 cu) = 0.69s

==================

n = 1000
k = 333

[0] Intel(R) Core(TM)2 Duo CPU = 0.09s
[1] GeForce 8600 GT (4 cu) = 0.14s
[2] GeForce 210 (2 cu) = 0.32s
[3] Cedar Radeon 5470 (2 cu) = 0.56s
[4] Intel(R) Core(TM) i3 CPU = 0.13s
[5] ATI RV730 (8 cu) = 0.71s

==================

n = 443
k = 89

[0] Intel(R) Core(TM)2 Duo CPU = 0.10s
[1] GeForce 8600 GT (4 cu) = 0.14s
[2] GeForce 210 (2 cu) = 0.17s
[3] Cedar Radeon 5470 (2 cu) = 0.55s
[4] Intel(R) Core(TM) i3 CPU = 0.12s
[5] ATI RV730 (8 cu) = 0.67s

Concluzii:


  • nu este un algoritm care sa demonstreze eficienta calculului pe GPU comparativ cu calculul pe CPU – ceea ce intareste ideea ca DOAR anumite probleme pot fi executate mai rapid pe placa grafica si anume cele pe seturi mari de date cu aplicarea unor operatii repetitive (specific SIMD)
  • principale dezavantaje GPU: latenta mare de transfer a datelor din RAM catre VRAM (memoria placii grafice) si invers; aceasta poate fi acoperita prin executia rapida si repetata a unor task-uri
  • in cazul de fata, datorita memoriei locale limitate de pe GPU si a structurii algoritmului, valoarea lui n nu poate trece de un prag (aici, 2500) – posibil ca programul sa dea rezultate foarte bune in favoarea GPU pentru valori mult mai mari ale lui n
  • algoritmul a trebuit regandit de mai multe ori pentru a da rezultate cat mai bune atat pe CPU cat si pe GPU – programarea in OpenCL cere totusi cunoasterea arhitecturii platformelor

Niciun comentariu: