Grundlagen von CUDA, Sprachtypische Elemente

Größe: px

Ab Seite anzeigen:

Download "Grundlagen von CUDA, Sprachtypische Elemente"

Kajetan Steinmann
vor 6 Jahren
Abrufe

1 Grundlagen von CUDA, Sprachtypische Elemente Stefan Maskanitz CUDA Grundlagen 1

2 Übersicht 1. Einleitung 2. Spracheigenschaften a. s, Blocks und Grids b. Speicherorganistion c. Fehlerbehandlung d. Sonstiges 3. Vergleich: CPU/GPU Code CUDA Grundlagen 2

3 EINLEITUNG CUDA Grundlagen 3

4 Voraussetzungen Es wird mindestens eine CUDA fähige Nvidia Grafikkarte benötigt. Dies sind alle Nvidia Modelle ab der G80 Reihe. Beispiele: Nvidia Geforce 8800 GTX Nvidia Geforce 9600 GT Nvidia Geforce 260 GTX CUDA Grundlagen - Einleitung 4

5 CUDA aktuell Zwei Wege, Code zu schreiben C für CUDA CUDA Driver API CUDA Grundlagen - Einleitung 5

6 CUDA zukünftig Mehrere Sprachen Anwendung C OpenCL C++ Fortran CUDA CUDA Grundlagen - Einleitung 6

7 C für CUDA Erweitert die Sprache C/C++ um einfache Sprachelemente, mit denen man Code für die Grafikkarte entwickeln kann Compiler: NVCC (gibt es mit dem SDK) Ermöglicht schnellen Einstieg CUDA Grundlagen - Einleitung 7

8 Trennung von Host und Device C Code wird auf dem Host (CPU) ausgeführt. CUDA Code wird auf einem physikalisch vom Host getrennten Device (GPU) ausgeführt. Host und Device verwalten ihren eigenen Speicher. Host muss die Device-Speicherverwaltung übernehmen Hierzu gehört Allokation, Deallokation und das Kopieren von Daten von und zum Device CUDA Grundlagen - Trennung Host/Device 8

9 CUDA Kernel Eine CUDA Funktion wird Kernel genannt. Ein Kernel muss so geschrieben sein, dass er von N verschiedenen s in beliebiger Reihenfolge ausgeführt werden kann. (SIMT) Dies ermöglicht eine einfache Skalierbarkeit Neuere GPU Modelle besitzen mehr Recheneinheiten, die den selben Code ausführen CUDA Grundlagen - Einleitung 9

10 s, Blocks und Grids SPRACHEIGENSCHAFTEN CUDA Grundlagen 10

11 s, Blocks und Grids CUDA Kernel werden von mehreren s ausgeführt. Grid Block Block CUDA Grundl. - s, Blocks und Grids 11

12 Konfiguration der Grids/Blocks Wird im Kernelaufruf festgelegt // Kernel definition global void VecAdd(float* A, float* B, float* C) { int main() { // Kernel invocation // <<<dimgrid, dimblock>>> VecAdd<<<1, N>>>(A, B, C); Max. 512 s pro Block o Technische Grenze: alle s eines Blocks sollen auf einem Prozessor ausgeführt werden Prozessorspeicher begrenzt CUDA Grundl. - s, Blocks und Grids 12

13 blockidx, blockdim, threadidx Kernel besitzen Variablen mit Informationen über den /Block, zu dem sie gehören // Kernel definition global void VecAdd(float* A, float* B, float* C) { int i = blockidx.x * blockdim.x + threadidx.x; C[i] = A[i] + B[i]; int main() { // Kernel invocation VecAdd<<<2, N/2>>>(A, B, C); CUDA Grundl. - s, Blocks und Grids 13

14 Beispiel für N = 4 Grid 0 Block 0 Block 1 0 (i=0) 1 (i=1) 0 (i=2) 1 (i=3) int i = blockidx.x * blockdim.x + threadidx.x; CUDA Grundl. - s, Blocks und Grids 14

15 Syncthreads() s in einem Block können ihre Speicherzugriffe verwalten Barriere, an der ein wartet, bis auch alle anderen s aus dem gleichen Block an ihr angekommen sind. global void VecAdd(float* A, float* B, float* C) { int i = blockidx.x * blockdim.x + threadidx.x; C[i] = A[i] + B[i]; syncthreads(); // CUDA Grundl. - s, Blocks und Grids 15

16 Speicherorganisation SPRACHEIGENSCHAFTEN CUDA Grundlagen 16

17 Lokaler Speicher 0 Lokaler Speicher global void foo(float* A, float* B) { int counter = 0; // CUDA Grundlagen - Speicherorganisation 17

18 Shared Speicher Block shared Speicher global void foo(float* A, float* B) { //... shared float As[BLOCK_SIZE][BLOCK_SIZE]; //... Schnell (ähnlich Registerzugriff bei CPU Code) Größe begrenzt: 16 KB CUDA Grundlagen - Speicherorganisation 18

19 Globaler Speicher Grid Grid globaler Speicher global void VecAdd(float* A, float* B, float* C) { //... int main() { //... cudamalloc((void **) &A_d, size); cudamemcpy(a_d,a_h,size,cudamemcpyhosttodevice); VecAdd<<<2, N/2>>>(A_d, B_d, C_d); Persistent über alle Kernel Aufrufe einer Anwendung CUDA Grundlagen - Speicherorganisation 19

20 Fehlerbehandlung SPRACHEIGENSCHAFTEN CUDA Grundlagen 20

21 cudagetlasterror() Ein Kernel gibt direkt keine Fehlermeldung aus. Man muss diese deshalb nach dem Aufruf mit cudagetlasterror() auslesen. int main() { //... VecAdd<<<2, N/2>>>(A_d, B_d, C_d); cudasynchronize(); printf("%s\n",cudageterrorstring(cudagetlasterror())); CUDA Grundlagen - Fehlerbehandlung 21

22 Device Emulation CUDA Code wird auf dem Host (CPU) ausgeführt Debugger des Hosts kann verwendet werden (z.b. für breakpoints, ) Device Code kann um Hostfunktionen ergänzt werden (z.b. printf, ) CUDA Grundlagen - Fehlerbehandlung 22

23 Sonstiges SPRACHEIGENSCHAFTEN CUDA Grundlagen 23

24 Device Funktion Kann zum Wiederverwenden von Code benutzt werden. Keine Rekursion möglich device int addiere(int a, int b) { return a+b; global void foo(float* A, float* B, float* C) { int a = 3; int b = 4; int c = addiere(a, b); // CUDA Grundlagen - Sonstiges 24

25 cudasynchronize() CUDA Kernel werden asynchron ausgeführt. Um auf Ergebnisse von Kernel Funktionen zu warten, kann man cudasynchronize() nutzen int main() { //... VecAdd<<<2, N/2>>>(A_d, B_d, C_d); cudasynchronize(); CUDA Grundlagen - Sonstiges 25

26 VERGLEICH: CPU/GPU CODE CUDA Grundlagen 26

27 Quadrieren // CPU Code int main() { int i = 0; float *zahlen_host; const int anz = 10; // Speicher reservieren zahlen_host = (float *)malloc( anz*sizeof(float) ); // Zahlen quadrieren for ( i=0; i<anz; i++ ) zahlen_host[i] = (float)i * (float)i; // GPU Code global void quadrieren(float *zahlen) { int idx = blockidx.x * blockdim.x + threadidx.x; // Zahl quadrieren zahlen[idx] = zahlen[idx] * zahlen[idx]; int main() { int i = 0; float *zahlen_host, *zahlen_device; const int anz = 10; // Speicher auf dem Host reservieren zahlen_host = (float *)malloc( anz*sizeof(float) ); // Zahlen im Host-Speicher ablegen for ( i=0; i<anz; i++ ) zahlen_host[i] = (float)i; // Speicher auf dem Device reservieren cudamalloc( (void **) &zahlen_device, anz*sizeof(float) ); // Kopieren der Zahlen zum Device cudamemcpy( zahlen_device, zahlen_host, anz*sizeof(float), cudamemcpyhosttodevice ); // Speicher freigeben free( zahlen_host ); // Quadrieren der Zahlen auf dem Device quadrieren<<< 2, 5 >>> ( zahlen_device ); // Kopieren der Zahlen zum Host cudamemcpy( zahlen_host, zahlen_device, anz*sizeof(float), cudamemcpydevicetohost ); // Speicher freigeben free( zahlen_host ); cudafree( zahlen_device ); CUDA Grundlagen - CPU/GPU Code 27

Ähnliche Dokumente

CUDA. Moritz Wild, Jan-Hugo Lupp. Seminar Multi-Core Architectures and Programming. Friedrich-Alexander-Universität Erlangen-Nürnberg

CUDA. Moritz Wild, Jan-Hugo Lupp. Seminar Multi-Core Architectures and Programming. Friedrich-Alexander-Universität Erlangen-Nürnberg CUDA Seminar Multi-Core Architectures and Programming 1 Übersicht Einleitung Architektur Programmierung 2 Einleitung Computations on GPU 2003 Probleme Hohe Kenntnisse der Grafikprogrammierung nötig Unterschiedliche