Folien des Vortrags auf der Parallel 2012 am 24.5.2012 in Karlsruhe.

1. GPU-Computing
mit CUDA und OpenCL
in der Praxis
24. Mai 2012
Jörn Dinkla

2. Motivation

3. Computer-Grafik
 Vom Modell zum Bild
Tomas Akenine-Mőller © 2002, Quelle: http://www.realtimerendering.com/

4. Echtzeit-Grafik
Vertex Pixel
Quelle: Tomas Akenine-Mőller © 2002

5. Rückblick
1992 … 1995 …

6. T&L in Hardware
Fixed pipelines
DirectX 7.0
1999 2000

7. Programmierbare Shader
DirectX 8.0 DirectX 9.0
2001 2002

8. Shader-Sprachen
GPGPU
HLSL, Cg, GLSL
2003 2004 2005

9. Unified Shader
DirectX 10.0
2006 2007

10. GPU-Computing
CUDA
OpenCL
CTM Stream SDK
DirectX 11.0
2006 2007 2008 2009

11. Massiv Parallel

12. Parallelisieren?
 Schneller, Größer, Besser
480p 576p 720p 1080p 4K2D / QFHD
  Höhere Geschwindigkeit

13. Entwicklungs-Methodik
1. Golden Code
 Sequentiell und korrekt
2. Golden Code parallelisieren
3. Zu GPU-Code transformieren

14. Parallelität finden
Eingabe Eingabe
Verarbeitung #1 #2 #3
Ausgabe Ausgabe

15. Parallelität finden
Eingabe E1 E2 E3
Verarbeitung #1 #2 #3
Ausgabe A1 A2 A3

16. SPMD / SIMT
 Parameter: Eindeutige ID
 Hole Daten anhand ID
 Verarbeitung
 Speichere Daten anhand ID
E1 E2 E3
#1 #2 #3
A1 A2 A3

17. SIMT: Lock-step
1 2 3 4
1 2 3 4 uchar4 p;
p.x = x+y;
p.y = x-y;
p.z = y;
p.w = 255;

18. Frameworks
Plattform-Unabhängigkeit ?
Komfortabel OpenACC ? C++ AMP?
PyCUDA /
Besser Thrust?
PyOpenCL ?
CUDA Runtime
Praktisch
API C++ cl.hpp
Low Level CUDA Driver API Open CL
Hardware

19. CUDA Runtime API
 HelloWorld.cu
Kernel
Host

20. Programm zu Code
Host Code Device Code
C/C++ (Kernel)
JIT?
Compiler Compiler
Assembler /
LLVM / PTX / IL
LLVM
JIT?
Assembler Assembler (*)
Cubin / Machine
Machine Code
Code

21. OpenCL
 Vorteile
 „Plattformunabhängig“
 CPU+GPU
 Vektorberechnungen
 Aber
 Performance von Device abhängig
 „Komiteesprache“

22. OpenCL / Driver API
Plattform
Device
Context
Command Queue
Program
Kernel
Aufruf

23. WebCL
Siehe http://webcl.nokiaresearch.com/kerneltoy/

24. Smoothing

25. Smoothing
 3x3 Fenster
0 1 2 3 4 0 1 2 3 4 0 1 2 3 4
0 0 0
1 1 1
2 2 2
3 3 3
4 4 4

26. Algorithmus
 Für alle x,y,z in vol
 sum = 0, c = 0
 Für alle dx,dy,dz in Nachbarschaft
 sum += vol[x+dx,y+dy,z+dz]
 c += 1
 vol‘[x,y,z] = sum / c Threads

27. Extent
 Extension / Größe
 width, height, depth
 index(x,y,z)
 inBounds(x,y,z)
0 1 2 3
0
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1
2
3

28. Accum
 Akkumulator 0 1 2 3 4
 add(value) 0
 Akkumuliert int4 1
 avg()
2
3
 Durchschnitt 4

29. Golden Code

30. Fermi (GTX 580)

31. Kernel-Konfiguration
 x*y*z Threads  Cores/SMs
 Thread-Block / Work group / Tile
 Grid / NDRange
0 1 2 3 4 5 6 7
0 T T T T T T T T
1 T T T T T T T T
2 T T T T T T T T
3 T T T T T T T T
4 T T T T T T T T
5 T T T T T T T T
6 T T T T T T T T
7 T T T T T T T T

32. Kernel-Konfiguration
 ExecConfig
 grid
 threads
 stream
 ExecConfig(Extent)

33. Host Überblick
Buffer Algorithmus Buffer‘ Buffer‘
Device
Buffer Kernel Buffer‘

34. Speicher-Management
 Device-Speicher
 cudaMalloc(), cudaFree()
 Host-Speicher
 cudaMallocHost(), cudaFreeHost()
 Transfer
 cudaMemcpy()

35. Host-Speicher
Virtueller
Speicher
Physikalischer
Speicher
cudaMallocHost()
malloc()
Device
Speicher

36. Buffer
 BaseBuffer
 malloc(), free()
 HostBuffer
 PinnedHostBuffer
 DeviceBuffer
 copyFrom(), copyTo()
 Versionierung

37. BufferPair
 Paar
Host
Buffer Buffer‘
 Host-Buffer
Device
Buffer Kernel Buffer‘
 Device-Buffer
 Methoden
 updateDevice()
 updateHost()

38. GPU-Code

40. Performance-Vergleich
Nur GPU Mit Kopien
Größe CPU GPU Speedup GPU+C Speedup
8 0 0 2 0,00
16 1 0 2 0,00
32 2 0 4 0,00
64 15 0 4 0,00
128 97 4 24,25 10 9,70
256 660 23 28,70 63 10,48
384 2216 78 28,41 204 10,86
512 5249 184 28,53 482 10,89
Und größer ?

41. Speicherplatz: N^3

42. Größere Volumen
 Swapping
Host
Device

43. Swapping
 BufferIterator
 Kernel: Anpassen
 BufferPair: Erweitern

44. Host
Auslastung
I O I O I O
Device
I K O I K O I K O
Last

45. Streams & Overlap
Schritt Ein Stream Stream 1 Stream 2 Stream 1 Stream 2
1 H2D H2D H2D
2 Kernel 1 Kernel 1 H2D Kernel 1 H2D
3 D2H D2H Kernel 2 D2H Kernel 2
4 H2D D2H H2D D2H
5 Kernel 2 H2D Kernel 3
6 D2H Kernel 3 D2H
7 H2D D2H
8 Kernel 3
9 D2H
Kernel + Kopie Kernel + Kopie und
überlappend H2D und D2H

46. Swapping & Streaming
 Initialisierung
 Parallel
 Für alle „ungeraden“ Partitionen p
 Kopiere H2D für p in s1
 Rufe Kernel auf für p in s1
Asynchron
 Kopiere D2H für p in s1
 Für alle „geraden“ Partitionen q
 Kopiere H2D für q in s2
 Rufe Kernel auf für q in s2
 Kopiere D2H für q in s2

47. Übersicht
 Asynchrone Kopien
Host
Buffer Buffer‘
Buf 1 Kernel Buf‘ 1
Device
Buf 2 Kernel Buf‘ 2

48. Double Buffering
Volumen Volumen
Input Output
Host
Buf 1 Buf 2 Out 1 Out 2
Buf 1 Kernel Out 1
Device
Buf 2 Kernel Out 2

49. Klasse
 HostBufferPair
 Analog zu BufferPair
 Buffer
 HostBuffer
 PinnedHostBuffer
 Unterschiedliche Größe
 updateFrom(), updateTo()

51. Performance-Vergleich
Größe CPU GPU Speedup
8 0 0
16 0 0
32 10 0
64 20 0
128 110 0
256 660 23 10,48
384 2233 80 10,86
512 5263 183 10,89
768 17707 1718 10,31
1024 42101 4079 10,32
1152 59156 5924 9,99

52. Theorie
 GTX 580
 1632,3 GFLOPS und 194,5 GB/s
 Wen es interessiert:
 GFLOPS
 #Cores * Shader-Takt * 2
 GB/s
 Breite [Byte] * Memory-Takt * x
 GDDR3: x = 2, GDDR5: x = 4

53. Pi mal Daumen
 Pro Kernel
 27 Laden, 1 Speichern
 638 Operationen
 Arithmetische Intensität
 Bei 512er Test
 467,93 GFLOPS
 20,54 GB/s
 Optimierungspotential vorhanden!

54. Optimierung
Maximiere …
1. Parallelität
2. Speicherdurchsatz
3. Berechnungsdurchsatz

55. Maximiere Parallelität
 Streams
 Asynchrone Kopien und Kernel
 Auslastung des Device
 Grid
 Auslastung der SMs
 Thread-Block
 „Occupancy“

56. Occupancy
 Mehrere Thread-Blöcke pro SM
 Speicherzugriffe verstecken
 O(1) Scheduler
SM TB TB TB TB TB -- -- --

57. Occupancy Calculator

58. Speicher-Architektur
GPU
Global Memory Global Memory
8-20 8-16
Constant Texture
Bus / Memory Controller
160-
L2 Cache
200
CPU 1 Prozessor (SM)
Core Core C C C C
8000
L1 / L2 L1 / L2
Registers
L3 Cache Local / Shared / L1 1600

59. Max. Speicherdurchsatz
 „Coalesced“ Zugriffe
 32, 64, oder 128-byte
 „Alignment“

60. Max. Speicherdurchsatz
 Pinned-Host-Speicher
 Minimiere Kopien
 Benutze On-Chip-Speicher
 Shared/Local, Register
 Konfiguriere Cache

61. Divergenz
1 2 3 4
1 2 3 4 int tid = treadIdx.x;
if (tid < 2) {
o[tid] = 1;
} else {
o[tid] = 2;
}

62. Max. Berechnungen
 Minimiere Divergenz
 Loop-Unrolling
 Berechnen statt Speichern
 Arithmetik
 Präzision vs. Geschwindigkeit
 Fusion von Kerneln

63. Synchronisation
 Innerhalb Thread-Block
 __syncthreads()
 Atomare Zugriffe
 atomicAdd()
 Speicher
 Zwischen Kernel-Aufrufen

64. Weiterführend …

65. JVM
 JNI
 JCuda
 Javacl, Jocl
 Eigenes API
 Aparapi, Java-GPU

66. JVM
Komfortabel
Besser
CUDA Runtime
Praktisch
API C++ cl.hpp
JCUDA
Low Level CUDA Driver API Open CL
JavaCL
Hardware

67. CUDA mit Java

68. Hello, Groovy CUDA!
JCUDA

69. Hello, Groovy OpenCL!
JavaCL

70. Hello, Scala + GPU
JavaCL

71. Fazit JVM
 Vorteile
 Entwicklungsgeschwindigkeit
 Host-Code
 Nachteile
 Datentypen
 Getrennt Debuggen

72. Fazit
 „Richtig“ eingesetzt unschlagbar!
 Folien & Code
 http://dinkla.net/parallel2012

73. Literatur: CUDA
 Sanders, Kandrot
CUDA by Example
 Kirk, Hwu
Programming Massively
Parallel Processors

74. Literatur: OpenCL
 Scarpino
OpenCL in Action
 Gaster et.al.
Heterogeneous Computing
With OpenCL

75. Literatur: CUDA
 Hwu (Ed.)
GPU Computing Gems
Emerald Edition
 Hwu (Ed.)
GPU Computing Gems
Jade Edition