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

Größe: px

Ab Seite anzeigen:

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

Tobias Hofmann
vor 6 Jahren
Abrufe

1 CUDA Seminar Multi-Core Architectures and Programming 1

2 Übersicht Einleitung Architektur Programmierung 2

3 Einleitung Computations on GPU 2003 Probleme Hohe Kenntnisse der Grafikprogrammierung nötig Unterschiedliche Terminologie GPGPU (General Purpose Computation on Graphics Processing Unit) wird populärer (z.b. durch BrookGPU) CUDA (Compute Unified Device Architecture) wird 2007 von Nvidia veröffentlicht 3

4 Einleitung CUDA ermöglicht leichten Einstieg in GPGPU Programmierung in C/C++ Hohe Zugänglichkeit Hochleistungsberechnungen mit modernen Grafikkarten 4

5 Einleitung Anwendungsbeispiele: Arithmetische Berechnungen Lineare Algebra Partielle Differentialgleichungen Hohe Bandbreite Sortierungsalgorithmen Visuelle Berechnungen Grafik Bildbearbeitung Tomografie 5

6 Einleitung Peak Performance 6

7 Architektur Bei der GPU wird ein erheblicher Teil der Chipfläche für ALUs genutzt Durch intelligente Speicherorganisation benötigt eine GPU keinen allzu großen Cache 7

8 Architektur Host CPU Device GPU Kernel: Eine vom Host aufgerufene Funktion, die auf dem Device ausgeführt wird. 8

9 Architektur Ein Kernel wird von einem Grid ausgeführt Ein Grid besteht aus mehreren Blöcken Ein Block fasst mehrere Threads zusammen Blöcke werden je nach Ressourcen sequentiell oder parallel verarbeitet ( alter Code auch auf aktuellen GPUs nutzbar) 9

10 Architektur Thread Block Thread ID (2D, 3D) Threads kommunizieren über Shared Memory (nur innerhalb eines Blocks) Ein Thread kann auf Register zugreifen falls diese nicht ausreichen, steht auch Local Memory zur Verfügung 10

11 Architektur Grid of Thread Blocks Block ID (2D) Global, Constant und Texture Memory können vom Host gelesen und beschrieben werden Blöcke (Threads) können in Global Memory schreiben jedoch vom Constant und Texture Memory nur lesen 11

12 Architektur Aufbau eines Multiprozessors 8 Streamprozessoren auf einem Multiprozessor (auf neuesten Architekturen bereits 32) 32 Threads werden als Warp zusammengefasst Blockgröße wird daher normalerweise als vielfaches eines Warps gewählt 12

13 Architektur SIMD Architektur Single Instruction Multiple Data Prozessoren führen in einem Takt den gleichen Befehl aus, jedoch auf unterschiedlichen Daten Multiprozessor kann mehrere Blöcke bearbeiten Device Memory umfasst Global, Local, Constant und Texture Memory 13

14 Programmierung CUDA-API Runtime API: High-level-API Aufrufe werden in Grundbefehle zerlegt und von der Driver API verwaltet Driver API: Low-level-API Komplexer, dafür vielseitiger 14

Programmierung Programmierer muss sich für eine der beiden APIs entscheiden, da gleichzeitige Verwendung der APIs nicht möglich Libraries

15 Programmierung Programmierer muss sich für eine der beiden APIs entscheiden, da gleichzeitige Verwendung der APIs nicht möglich Libraries CUBLAS: Grundbausteine für lineare Algebra-Berechnungen auf der GPU CUFFT: Berechnung von Fourier-Transformationen (Signalbearbeitung) 15

16 Programmierung CUDA aus Softwaresicht Mehrere Erweiterungen im C-Sprachstil Normalerweise Programmierung in C, durch Wrapper auch andere Programmiersprachen nutzbar 16

17 Programmierung Funktionstypen in CUDA global : Deklariert eine Funktion als Kernel Wird auf dem Device ausgeführt Nur vom Host aufrufbar device : Wird auf dem Device ausgeführt Nur von Device aufrufbar host : Optionaler Qualifizierer Wird auf dem Host ausgeführt Kann nur vom Host aufgerufen werden 17

18 Programmierung Variablentypen in CUDA device : optional Variable liegt im Global Memory Lebensdauer über die gesamte Programmausführung Steht allen Threads innerhalb eines Grids und dem Host über die Runtime Library zur Verfügung constant : Variable liegt im Constant Memory Lebensdauer und Verfügbarkeit wie bei device shared : Variable liegt im Shared Memory eines Thread Blocks Lebensdauer des Blocks Steht nur den Threads innerhalb des Blocks zu Verfügung 18

19 Programmierung Built-In Variablen griddim : Dimension des Grids griddim.x, griddim.y blockidx : Blockindex innerhalb des Grids blockidx.x, blockidx.y blockdim : Dimension des Blocks blockdim.x, blockdim.y, blockdim.z threadidx : Threadindex innerhalb des Blocks threadidx.x, threadidx.y, threadidx.z warpsize : Größe eines Warps 19

20 Programmierung Programmbeispiel : Quadrieren jedes Elements eines Arrays int main() { Code für CPU int i = 0; float *zahlen_host; const int anzahl=1024; // Speicher reservieren zahlen_host = (float*)malloc( anzahl *sizeof(float) ); // Zahlen quadrieren for( i=0 ; i<anzahl ; i++ ) zahlen_host[i]=(float)i * (float)i; // Speicher freigeben free( zahlen_host); } 20

21 Programmierung global void quadrieren(float*zahlen){ int idx = blockidx.x * blockdim.x + threadidx.x; // Zahl quadrieren zahlen[idx] = zahlen[idx] * zahlen[idx]; } Code für GPU int main() { int i = 0; float *zahlen_host, *zahlen_device; const int anzahl = 1024; // Speicher auf dem Host reservieren und ablegen zahlen_host = (float*)malloc( anzahl *sizeof(float) ); for( i=0 ; i < anzahl ; i++ ) zahlen_host[i] = (float)i; // Speicher auf dem Device reservieren und kopieren der Zahlen zum Device cudamalloc( (void**) &zahlen_device, anzahl *sizeof(float) ); cudamemcpy( zahlen_device, zahlen_host, anzahl *sizeof(float), cudamemcpyhosttodevice); 21

22 Programmierung Code für GPU // Dimensionierung von Grid und Block dim3 griddim (16,1); dim3 blockdim (64,1,1); // Quadrieren der Zahlen auf dem Device quadrieren<<<griddim,blockdim>>>( zahlen_device ); // Kopieren der Zahlen zum Host cudamemcpy( zahlen_host, zahlen_device, anzahl *sizeof(float), cudamemcpydevicetohost); } // Speicher freigeben free( zahlen_host ) ; cudafree( zahlen_device); 22

23 Programmierung Kompilierung Der NVCC trennt Device Code von Host Code und kompiliert den Device Code Der Host Code wird als C-Code ausgegeben, der dann mit einem C- Compiler kompiliert werden kann Mit einem C-Compiler werden dann die beiden Dateien zusammen gelinkt CPU Code CUDA C-Code kompilieren linken Ausführbare Datei GPU Code 23

24 Noch Fragen?? 24

Ähnliche Dokumente

Programmierung von Graphikkarten

Programmierung von Graphikkarten Stefan Lang Interdisziplinäres Zentrum für Wissenschaftliches Rechnen Universität Heidelberg INF 368, Raum 532 D-69120 Heidelberg phone: 06221/54-8264 email: Stefan.Lang@iwr.uni-heidelberg.de