CUDA. 7. Vorlesung GPU Programmierung. Danke an Hendrik Lensch

Transkript

1 CUDA 7. Vorlesung Thorsten Grosch Danke an Hendrik Lensch

2 Parallele l Programmierung mit der GPU Bisher: GPU = OpenGL Pipeline mit Shadern Alles orientiert sich am Rendering Programme für Eckpunkte und Pixel Oft muß man um die Ecke denken Jetzt: t Die GPU ist ein schneller Parallelrechner l für beliebige bi Aufgaben Verteile die Aufgabe in Form von parallelen s an die GPU Die Programmierung gist dabei ähnlich zur Programmierung g der CPU CUDA OpenCL 2

3 Literatur Die Vorlesung ist an folgendem Buch orientiert: J. Sanders, E. Kandrot: CUDA by Example, NVIDIA Mehrfach vorhanden in Bibliothek Beispielprogramme verfügbar Gut zum Einstieg Fortgeschrittene Programmierung D. Kirk: CUDA Programming Guide Programmierung mit OpenCL ist ähnlich 3

4 Massiv Parallele l Berechnungen PCIe CPU (4 cores) GPU (480 cores) 4

5 Warum Parallele l Prozessoren GPU = günstiger Parallelrechner in jedem handelsüblichen PC 200 GFLOPS/Sek GFLOPS/Sek. 5

6 Warum Parallele l Prozessoren Speicherbandbreite 40 GB/Sek. 170 GB/Sek. 6

7 Amdahls Gesetz Serieller Teil α des Algorithmus,,paralleler Anteil 1-α Erwarteter Speedup (Beschleunigung) S bei P Prozessoren falls α=0 perfekt parallelisierbar Smax = P falls α=1 S = 1 S = α + 1 ( 1 α) / P 7

8 CUDA Programmiermodell

9 GF GeForce 8800 Host Input Assembler 16 highly threaded SM s, >128 FPU s, 367 GFLOPS, 768 MB DRAM, 86.4 GB/S Mem BW, 4GB/S BW to CPU Execution Manager Texture Texture Texture Texture Texture Texture Texture Texture Load/store Load/store Load/store Load/store Load/store Load/store Global Memory 9

10 Abkürzungen SPA (Device) SM SP Streaming Processor Array (variable across GeForce 8-series) Streaming Multiprocessor (8 SP for 8800, 15 SP for GTX480) Multi-threaded processor core Fundamental processing unit for CUDA thread block Streaming Processor Scalar ALU for a single CUDA thread 10

11 Streaming Processor Array Host Input Assembler Execution Manager SPA Texture Texture Texture Texture Texture Texture Texture Texture Load/store Load/store Load/store Load/store Load/store Load/store Global Memory 11

12 Streaming Multiprocessor Host Input Assembler Execution Manager SM Texture Texture Texture Texture Texture Texture Texture Texture Load/store Load/store Load/store Load/store Load/store Load/store Global Memory 12

13 Streaming Processor Host Input Assembler SP Execution Manager Texture Texture Texture Texture Texture Texture Texture Texture Load/store Load/store Load/store Load/store Load/store Load/store Global Memory 13

14 Programmiermodell Der Programmierer schreibt eine Kernel Funktion (in C) für die durchzuführende Aufgabe Kernel = (kleine) Funktion, die von allen s parallel ausgeführt wird Host Kernel 1 Kernel 2 Device Grid 1 Block (0, 0) Block (1, 0) Block (2, 0) Block Block Block (0, 1) (1, 1) (2, 1) Grid 2 Host = CPU Device = GPU Block (1, 1) (0, 0) (1, 0) (2, 0) (3, 0) (4, 0) (0, 1) (1, 1) (2, 1) (3, 1) (4, 1) (0, 2) (1, 2) (2, 2) (3, 2) (4, 2) 14

15 Programmiermodell Host Device Aufteilung der s in einem 2-Level Gitter Kernel 1 Grid 1 Block (0, 0) Block (1, 0) Block (2, 0) Auf jd jedem innerhalb des Gitters läuft die gleiche Kernel Funktion Grid Gitter, aufgeteilt in Blöcke Block Aufgeteilt in s Kernel 2 Block (1, 1) (0, 0) (1, 0) Block Block Block (0, 1) (1, 1) (2, 1) Grid 2 (2, 0) (3, 0) (4, 0) (0, 1) (1, 1) (2, 1) (3, 1) (4, 1) Viele Probleme haben eine natürliche Blockstruktur (0, 2) (1, 2) (2, 2) (3, 2) (4, 2) 15

16 Gid Grid und dblocks Die Kernel Funktion wird in einem Gitter (grid) von thread blocks ausgeführt Alle threads teilen sich dabei den gleichen Adressraum Host Kernel 1 Device Grid 1 Block (0, 0) Block (1, 0) Block (2, 0) Block Block Block (0, 1) (1, 1) (2, 1) s innerhalb eines Blocks können kooperieren: Synchronisation ist möglich Benutzung von sehr schnellem, gemeinsamem Speicher ist möglich Kernel 2 Block (1, 1) (0, 0) (1, 0) Grid 2 (2, 0) (3, 0) (4, 0) Zwei s aus (0, 1) (1, 1) (2, 1) (3, 1) verschiedenen Blöcken können nicht kooperieren (!) (0, 2) (1, 2) (2, 2) (3, 2) (4, 2) (4, 1) 16

17 Blocks und s 17

18 Block und Id s und Blocks haben IDs Jeder kennt seine Position auf welche Daten muss ich zugreifen Block ID: 1D oder 2D ID: 1D, 2D, oder 3D Device Grid 1 Block Block Block (0, 0) (1, 0) (2, 0) Block Block Block (0, 1) (1, 1) (2, 1) Vereinfachter Speicherzugriff auf mehrdimensionale Daten, z.b. Bildverarbeitung Lösen von Differentialgleichungen Block (1, 1) (0, 0) (1, 0) (2, 0) (3, 0) (4, 0) (0, 1) (1, 1) (2, 1) (3, 1) (4, 1) (0, 2) (1, 2) (2, 2) (3, 2) (4, 2) 18

19 Speichertypen Auf der GPU gibt es verschiedene Arten von Speicher die sich unterscheiden in Grösse und Geschwindigkeit Grid Block (0, 0) Block (1, 0) Shared Memory Shared Memory Registers Registers Registers Registers (0, 0) (1, 0) (0, 0) (1, 0) Bei der Implementierung sollten häufig benötigte Daten immer im schnellsten Speicher liegen Host Local Memory Global Memory Local Memory Local Memory Local Memory Die Geschwindigkeit einer GPU Implementierung hängt oft vom Speicherlayout ab Constant t Memory Texture Memory 19

20 Speichertypen Global Memory Read-write per-grid Mehrere Hundert MB Sehr langsam (600 clocks) g ( ) Texture Memory Read-only per-grid Mehrere Hundert MB Langsamer erster Speicherzugriff, aber mit filtering, clamping Constant Memory Read-only per-grid 64 KB Langsamer erster Speicherzugriff, aber mit Kann schneller als Global l Memory sein Shared! Memory Read-write per-block 16 KB per block Sehr schnell (4 clocks) Se sc e ( coc s) Local Memory Read-write per thread Sehr langsam (ähnlich zu Global Memory) Registers Read-write per thread Sehr schnell (1 clock) Die CPU kann lesen/schreiben in Global Memory Texture Memory Constant Memory 20

21 CUDA Programmiermodell Die GPU wird als Berechnungseinheit betrachtet: Coprozessor für die CPU (Host) Eigener Speicher (DRAM, device memory) Bearbeitet viele s parallel Alle (Daten-) parallelen Anteile der Anwendung werden auf der GPU ausgeführt in Form von Kernels auf vielen, parallelen s Unterschiede zwischen GPU und CPU s GPU threads sind extrem leichtgewichtig g Können schnell erzeugt werden GPU braucht e von s, um effizient zu arbeiten Multi-core CPU braucht nur wenige s 21

22 Die GPU ist gut für datenparallele Berechnungen Die gleiche Berechnung wird auf vielen Datenelementen parallel ausgeführt viel Floating-Point Arithmetik Viele Berechnungen pro Speicherzugriff Speicherzugriff immer noch der Flaschenhals 22

23 CUDA Compute Unified Device Architecture Hardware und Software Spezifikation für parallele Berechnungen Einfache Erweiterung für C Möglichkeit, Code auf der GPU auszuführen NVIDIA (seit GeForce 8800 Serie) 23

24 CUDA Application i Programming Interface Die CUDA API ist eine Erweiterung zu C/C++ Eigener Compiler: nvcc Compiliervorgang in zwei Schritten z.b. nvcc in Kombination mit gcc CUDA Files enthalten hl sowohl GPU als auch CPU Funktionen 24

25 Zusätze für Funktionen und dvariablen Funktionen device global host Funktion läuft auf GPU und wird von GPU aufgerufen Funktion läuft auf GPU und wird von CPU aufgerufen Kernel Funktion, Rückgabetyp void Funktion läuft auf CPU und wird von CPU aufgerufen Einschränkungen für GPU Funktionen keine Rekursion, keine statischen Variablen Variablen device constant shared Global Memory (per grid, GPU) Constant Memory (per Grid, GPU) Shared Memory (per Block, GPU) 25

26 Host Eingebaute Variablen griddim : Größe des Gitters (in Blocks) griddim.x = Breite, griddim.y = Höhe blockdim : Größe eines Blocks blockdim.x = Breite, blockdim.y = Höhe blockidx : Index des Blocks (vom aktuellen ) blockidx.x = x-position, blockidx.y = y-position threadidx : Index (Position des s innerhalb des Blocks) threadidx.x = x-position, threadidx.y = y-position Kernel 1 Kernel 2 Block (1, 1) (0, 0) Device (1, 0) Grid 1 Block Block Block (0, 0) (1, 0) (2, 0) Block Block Block (0, 1) (1, 1) (2, 1) Grid 2 (2, 0) (3, 0) (4, 0) (0, 1) (1, 1) (2, 1) (3, 1) (4, 1) griddim = (3,2) blockdim = (5,3) blockidx = (1,1) threadidx = (2,0) (0, 2) (1, 2) (2, 2) (3, 2) (4, 2) 26

27 GPU Einfaches CUDA Beispiel: i Addition i auf der GPU { global void add( int a, int b, int *c ) { *c = a + b; } Kernel = kleines Programm auf der GPU (pro ) int main( void ) { int c; int *dev_c; cudamalloc( (void**)&dev_c, sizeof(int) ); Speicher auf GPU reservieren (global) CPU } add<<<1,1>>>( 2, 7, dev_ c ); cudamemcpy( &c, dev_c, sizeof(int), cudamemcpydevicetohost ) ); printf( "2 + 7 = %d\n", c ); cudafree( dev_c ) ; return 0; Kernel aufrufen Ergebnis zur CPU kopieren 27

28 GPU Speicher reservieren cudamalloc( (void**)&devptr, size ); size Bytes werden auf der GPU reserviert (Global Memory) Die Anfangsadresse steht in devptr Vorsicht, das ist eine GPU Adresse (!) cudafree( devptr ) ; Speicher auf der GPU wieder freigeben 28

29 GPU CPU Datenübertragung cudamemcpy( ptr, devptr, size, cudamemcpydevicetohost ) ); Kopieren von size Bytes von der GPU (Device) zur CPU (Host) CPU Adresse: ptr GPU Adresse: devptr cudamemcpy( devptr, ptr, size, cudamemcpyhosttodevice ) ); Kopieren von size Bytes von der CPU (Host) zur GPU (Device) CPU Adresse: ptr GPU Adresse: devptr Achtung: Parameterreihenfolge vertauscht! Es gibt auch cudamemcpydevicetodevice 29

30 KernelAufruf f g global void kernel( ) { } kernel<<<gridsize,blocksize>>>( ); Die Kernel-Funktion kernel wird in einem 1D Grid der Größe gridsize mit blocksize s pro Block aufgerufen insgesamt werden gridsize * blocksize s gestartet Der Kernel läuft auf der GPU und wird von der CPU aufgerufen global 30

31 KernelAufruf fbeispiel i add<<<1,1>>>( 2, 7, dev_c ); Die Kernel-Funktion add wird mit den Parametern ( 2, 7, dev_c ) aufgerufen Die Größe von Grid/Block wird durch die Werte innerhalb von <<< >>> angegeben <<<M,N>>> entspricht einem 1D Grid mit M Blöcken mit je N s pro Block Im Beispiel wird also nur 1 (in einem Block) gestartet 31

32 1. Sinnvolles Beispiel i Parallelität ausnutzen, viele s gleichzeitigg z.b. 2 Arrays gegeben Komponentenweise Addition c[i] = a[i] + b[i] Jeder (i=1..n) berechnet eine Addition Im Programm ändert sich hfolgendes Der Kernel Aufruf erfolgt jetzt mit einem größeren Grid (N, 1) Der Speicher für die Arrays wird auf der GPU reserviert Der Kernel ermittelt über den Index den richtigen Wert 32

33 Addition i von zwei Arrays auf der GPU int main( void ) { int a[n], b[n], c[n]; int *dev_a, *dev_b, *dev_c; CPU // allocate the memory on the GPU cudamalloc( (void**)&dev_a, N * sizeof(int) ); cudamalloc( (void**)&dev_b, N * sizeof(int) ); cudamalloc( dmll ((void**)&dev_c, N* sizeof(int) t)) ); // fill the arrays 'a' and 'b' on the CPU // copy the arrays 'a' and 'b' to the GPU cudamemcpy( dev_a, a, N * sizeof(int), cudamemcpyhosttodevice ) ); cudamemcpy( dev_b, b, N * sizeof(int), cudamemcpyhosttodevice ) ); add<<<n,1>>>( dev_a, dev_b, dev_c ); 33

34 Addition i von zwei Arrays auf der GPU // copy the array 'c' back from the GPU to the CPU cudamemcpy( c, dev_c, N * sizeof(int), cudamemcpydevicetohost ) ); CPU } // free the memory allocated on the GPU cudafree( dev_a ); cudafree( dev_b ); cudafree( df dev_c ); return 0; 34

35 Addition i von zwei Arrays auf der GPU: Kernel GP PU g global void add( int *a, int *b, int *c ) { } int tid = blockidx.x; c[tid] = a[tid] + b[tid]; Durch hden Aufruf fadd<<<n,1>>> wird idein Gid Grid mit N x 1 Blöcken angelegt (1 pro Block) Daher wird über den Blockindex auf das Array zugegriffen 35

36 Addition i von zwei Arrays auf der GPU: Kernel Was würde sich ändern, wenn der Kernel mit add<<<1,n>>> aufgerufen wird? Es wird ein Grid mit einem Block angelegt, in dem einen Block laufen N s Im Kernel muß daher mit int tid = threadidx.x auf das Array zugegriffen werden An der Laufzeit ändert sich in diesem Fall nichts 36

37 Gid Grid-und dblockgröße für 2D-Fall Fllfestlegen Eigener Typ dim3 Beschreibt praktisch Integer Vektor mit 3 Komponenten Bei einem 2D Grid/Block wird hier die 3. Komponente automatisch auf 1 gesetzt dim3 gridsize(gridwidth, idwidth gridheight) i dim3 blocksize(blockwidth, blockheight) kernel<<<gridsize, blocksize>>> Das 2D Grid besteht aus gridwidth x gridheight Blöcken jeder Block besteht aus blockwidth x blockheight s 37

38 2D-Grid Gid Aufteilung Grid in Blocks An welcher xy-position befindet sich der aktuelle? int x = threadidx.x + blockidx.x * blockdim.x; int y = threadidx.y + blockidx.y * blockdim.y; 38

39 Bsp. Kernelfür Fraktal global void fractalkernel( float *imageptr, int ticks ) { int pixelx = threadidx.x + blockidx.x * blockdim.x; int pixely = threadidx.y + blockidx.y * blockdim.y; int offset = pixelx + pixely * blockdim.x * griddim.x; float cx = 0.41 * sin(0.001 * float(ticks)); float cy = 0.77 * cos( * float(ticks)); } float x = 2.0f * (pixelx / (float)dim) - 1.0f; float y = 2.0f * (pixely / (float)dim) - 1.0f; inti= 0; int max = 256; float dist = x*x + y*y; while ((i < max) && (dist < 4.0)) { float newx = x*x - y*y + cx; y = 2*x*y + cy; x = newx; dist = x*x + y*y; i++; } imageptr[offset] = pow(float(i) / float(max), 0.25f); 39

40 Bildanzeigei Für die Anzeige von einem Bild verwenden wir zunächst folgendes kernel<<<gridsize, blocksize>>>(devptr ); cudamemcpy( pixels, devptr, size, cudamemcpydevicetohost ); gldrawpixels( width, height,, pixels ); Da sich die Pixeldaten bereits auf der GPU befinden sind dies zwei unnötige Kopiervorgänge Effizientere Lösung später 40

41 Wer ist das? siehe Übung 41

42 Asynchrone Kommandos Viele CUDA Kommandos arbeiten asynchron d.h. das CPU Programm läuft weiter Dies sind z.b. Kernel Aufrufe Kommandos zum Kopieren von Speicher, die auf Async() enden Device Device Speicherkopie 42

43 Fhl Fehlerabfrage static void HandleError( cudaerror_t err, const char *file, int line ) { if (err!= cudasuccess) { printf( "%s in %s at line %d\n", cudageterrorstring( err ), file, line ); exit( EXIT_ FAILURE ); } } #define HANDLE_ ERROR( err ) (HandleError(( err, FILE, LINE )) Mit HANDLE_ERROR(function) wird ein vorkommender Fehler direkt angezeigt und abgebrochen Ist evtl. eine Bremse, aber sicherer Alternative: cutilsafecall( ) 43

44 Zi Zeitmessung cudaevent_t start, stop; cudaeventcreate( &start ); cudaeventcreate( &stop ); cudaeventrecord( start, 0 );. cudaeventrecord( stop, 0 ); cudaeventsynchronize( stop ); float elapsedtime; cudaeventelapsedtime( &elapsedtime, start, stop ); printf( "Time to generate: %3.1f ms\n", elapsedtime ); cudaeventdestroy( start ); cudaeventdestroy( stop ); 44

45 GPU Eigenschaften abfragen cudadeviceprop prop; int count; HANDLE_ERROR( cudagetdevicecount( &count ) ); for (int i=0; i< count; i++) { HANDLE_ERROR( cudagetdeviceproperties( &prop, i ) ); printf( " --- General Information for device %d ---\n", i ); } printf( "Name: %s\n", prop.name p ); printf( "Compute capability: %d.%d\n", prop.major, prop.minor ); printf( "Clock rate: %d\n", prop.clockrate ); Wieviele CUDA-fähige Grafikkarten sind in meinem Rechner und was können die? 45

46 CUDA Compiler Der CUDA Compiler nvcc benötigt einen C-Compiler Aufruf z.b.: nvcc ccbin CompilerDirectory L LibraryDirectory mycudaprogram.cu o mycudaprogram.exe CompilerDirectory ist z.b. bei Visual Studio (cl.exe) : C:\Program Files\Microsoft Visual Studio 9.0\VC\bin 46

47 Device Properties von Laptop --- General Information for device Name: GeForce 9600M GT Compute capability: 1.1 Clock rate: Device copy overlap: Enabled Kernel execution timeout : Enabled --- Memory Information for device Ttl Total global lblmem: Total constant Mem: Max mem pitch: Texture Alignment: MP Information for device Multiprocessor count: 4 Shared mem per mp: Registers per mp: 8192 s in warp: 32 Max threads per block: 512 Max thread dimensions: i (512, 512, 64) Max grid dimensions: (65535, 65535, 1) CUDA Version Gleichzeitig MemCopy und Kernel ausführen Max. Zeit für Kernel Anzahl Streaming Multiprocessors (SMP) Shared Memory pro SMP Anzahl Register pro SMP s im Gleichschritt Max. Gesamtanzahl (!) s pro Block Max. Größe der Achsen von einem Block 47

48 Installation von CUDA 1. CUDA Toolkit installieren Wir nutzen CUDA 3.2 (Download) 2. Treiber aktualisieren Treiber muss zur CUDA Version passen (Download) 3. CUDA in Visual Studio 2008 integrieren Build Rules (*.rules) von \ NVIDIA GPU Computing Toolkit\CUDA\v3.2\extras\visual_studio_integration\rules studio integration\rules nach \Microsoft Visual Studio 9.0\VC\VCProjectDefaults kopieren fertig CUDA in Visual Studio 2010 integrieren Wir haben es nicht getestet, aber hier schon mal ein Anfang 48

49 CUDA Debugging Device Emulation CUDA Kernel läuft auf CPU (langsam) Dafür z.b. printf() im Kernel möglich nvcc -G -g -deviceemu file.cu 49

50 Zusammenfassung CUDA Erste Schritte Programmiermodell, Grids und Blocks Kernel Funktionen Nächstes Mal Speichertypen Synchronisation 50