GPGPU-Programming. Constantin Timm Informatik 12 TU Dortmund 2012/04/09. technische universität dortmund. fakultät für informatik informatik 12

Größe: px

Ab Seite anzeigen:

Download "GPGPU-Programming. Constantin Timm Informatik 12 TU Dortmund 2012/04/09. technische universität dortmund. fakultät für informatik informatik 12"

Ewald Bachmeier
vor 7 Jahren
Abrufe

1 12 GPGPU-Programming Constantin Timm Informatik 12 TU Dortmund 2012/04/09 Diese Folien enthalten Graphiken mit Nutzungseinschränkungen. Das Kopieren der Graphiken ist im Allgemeinen nicht erlaubt.

2 Motivation (1) General Purpose Computing on Graphics Processing Units (GPGPU) Einführung um CPU (bei Spielen) zu entlasten Physikalische Berechnungen Künstliche Intelligenz & fr.wikipedia - 2 -

3 Motivation (2) GPUs haben eine große Anzahl von parallelen Rechenkernen Wie kann man diese effizient programmieren? Gut für datenparallele Programme void add_vector(int* in1, int *in2, int *out) { for ( int i = 0; i < N; ++i ) { out[i] = in1[i] + in2[i] ; Nvidia Best Practice Guide - 3 -

4 Motivation (3) Was sollte man bzgl. GPGPU-Applikationen beachten? Parallele Applikationen mit möglichst unabhängigen Operationen Kopier-Overhead für Daten GPU GPU CPU CPU - 4 -

5 Geschichte der GPGPU-Programmierung (1) Bis zirka Benutzung von Shader-Sprachen zur Programmierung Vertex- und Fragmentshaderprogramme void main(void) { gl_fragcolor = vec4(0.0, 1.0, 0.0, 1.0); David Kirk/NVIDIA and Wen-mei W. Hwu, , University of Illinois - 5 -

6 Geschichte der GPGPU-Programmierung (2) Ab 2004 Einführung von Sprachen zum Streamprocessing, z.b. BrookGPU Von der Stanford University Nutzung von GPUs als Coprocessor / Beschleuniger Versteckt Komplexität kernel void foo (float a<>, float b<>, out float result<>) { result = a + b; float a<100>; float b<100>; float c<100>; foo(a,b,c); - 6 -

7 Geschichte der GPGPU-Programmierung (3) Ab 2004 BrookGPU Komplexer Kompilervorgang Plattform-unabhängig BrookGPU-Kompilervorgang brcc : S2S-Compiler brt : Runtime Stanford University Graphics Lab - 7 -

8 Geschichte der GPGPU-Programmierung (4) Ab 2007 Einführung von CUDA Compute Unified Device Architecture Framework für Streamprocessing auf Nvidia Grafikkarten Ursprünglich nur für Datenparallelität konzipiert Ab 2008 Einführung von OpenCL Allgemeines Framework für Streamprocessing auf Multi- und Manycore- Architekturen Für Daten- und Taskparallelität konzipiert Spezifikation durch Khronos: AMD, Apple, ARM, Creative, Google, Intel, TI, Samsung, Nvidia - 8 -

9 CUDA Adaptiert das Streamprocessing-Konzept Elementare Programmierkomponente => Kernel Keine Rekursion Parameteranzahl ist nicht variabel Unterscheidung von Host- und GPU-Code void add_vector(int* in1, int *in2, int *out) { for ( int i = 0; i < N; ++i ) { out[i] = in1[i] + in2[i] ; Vektoraddition in C global void add_vector (int* in1, int *in2, int *out) { int i = (blockidx.x*blockdim.x)+threadidx.x; out[i] = in1[i] + in2[i]; add_vector<<<n,1>>>( in1, in2, out ); Vektoraddition in Cuda - 9 -

10 CUDA Entwicklungsprozess Mehrstufig und kompliziert Programmierung von Code für einen Thread Spezifikation der Parallelität per Hand Viele statisch vorgegebene Größen

11 CUDA Elemente des Frameworks Thread Instanz eines Kernels Block Gruppe von Threads Grid Gesamtheit aller Blocks Host Kernel 1 Device Grid 1 Block (0, 0) Block (0, 1) Block (1, 0) Block (1, 1) Grid 2 global void add_vector (int* in1, int *in2, int *out) { int i = (blockidx.x*blockdim.x)+threadidx.x; out[i] = in1[i] + in2[i]; Kernel 2 Block (1, 1) (0,0,1) (1,0,1) (2,0,1) (3,0,1) Thread (0,0,0) Thread (0,1,0) Thread (1,0,0) Thread (1,1,0) Thread (2,0,0) Thread (2,1,0) Thread (3,0,0) Thread (3,1,0) Nvidia

12 CUDA Kompilierung CUDA-Programme werden in einem mehrstufigen Verfahren kompiliert GPU- und Host-Code getrennt kompiliert GPU-Binaries in Host-Code eingebettet Neuster Compiler von Nvidia basiert auf LLVM

13 CUDA Abbildungsbeispiel Kernel benötigt folgende Ressourcen 5 Register pro Thread 1052 Bytes Shared Memory per Block Grid size: 64 Blocks Block size: 256 Threads Grafikkarte (1 Streaming-Multiprocessor) 8152 Register Bytes Scratchpad-Speicher Max 768 Threads, 8 Blocks und 24 Warps Auslastung der Grafikkarte 768 Threads, 3 Blocks, 4608 Bytes Shared Memory und 3840 Register

14 CUDA - Speicherallokation cudamalloc() Allokiert globalen Speicher auf der Grafikkarte cudafree() Gibt allokierten Speicher auf der Grafikkarte frei Grid Block (0, 0) Shared Memory Block (1, 0) Shared Memory cudamemcpy() Kopiert in/aus/im globalen Speicher auf der Grafikkarte Registers Thread (0, 0) Registers Thread (1, 0) Registers Thread (0, 0) Registers Thread (1, 0) Host Global Memory Nvidia

15 CUDA - Speichertransfers Kopieren in/aus/im globalen Speicher Vom Host zur Grafikkarte int *d_x; cudamalloc((void**) &d_x, sizeof(int)); int x=0; cudamemcpy(d_x, &x, sizeof(int), cudamemcpyhosttodevice); Von der Grafikkarte zum Host int *d_y; cudamalloc((void**) &d_y, sizeof(int)); int y=0; cudamemcpy(&y, d_y, sizeof(int), cudamemcpydevicetohost); Auf der Grafikkarte int *d_x,d_y; cudamalloc((void**) &d_x, sizeof(int)); cudamalloc((void**) &d_y, sizeof(int)); cudamemcpy(d_x, d_y, sizeof(int), cudamemcpydevicetodevice);

16 CUDA Speicherzugriff Globaler/Shared Memory-Speicherzugriff Zugriff auf globalen/shared Speicher nicht synchronisiert Ausgang von Schreibe-/Leseoperationen auf gemeinsamen Speicher? Lösung: Atomare Operationen global void add_vector_gpu (int* out) { *out+=5; add_vector_gpu<<<1,5>>>(out); global void add_vector_gpu (int* out) { atomicadd(out,5); add_vector_gpu<<<1,5>>>(out); Ergebnis? => out = 5 Ergebnis? => out =

17 CUDA Thread Divergence (1) Ablauf der Threads Vorhersage der tatsächlichen Reihenfolge schwierig Kann von Programmierer erzwungen werden global void update(int* x, int* y) { int i = threadidx.x + blockdim.x * blockidx.x; if (i == 60){ sharedx = *x; sharedx = 1; syncthreads(); if (i == 100) *y = sharedx; update <<<2,512>>>(in,out); Ergebnis? => *out =? 1;

18 CUDA Thread Divergence (2) Synchronisation über Blockgrenzen Problemlos, wenn Blocks auf gleichem SM allokiert Sonst Synchronisation problematisch global void update_1(int* update(int* x, int* x, int* y) y) { { int i = threadidx.x + blockdim.x * blockidx.x; if (i == 600) *x = 1; *x = 1; global syncthreads(); void update_2(int* x, int* y) { if int(i i == = threadidx.x 0) + blockdim.x * blockidx.x; if (i == *y 0) = *y *x; = *x; update_1 <<<2,512>>>(in,out); update_2 <<<2,512>>>(in,out); Ergebnis? => *out =?; 1;

19 CUDA Inline Assembly PTX-Code kann direkt im Kernel benutzt werden Code meist effizienter PTX-Instruktionen keine Hardwarebefehle global void kern(int* x, int* y) { int i = threadidx.x + ; if (i == 0) *x += 1; syncthreads(); if (i == 1) *y = *x; global void kern(int* x, int* y) { int i = threadidx.x + blockdim.x * blockidx.x; if (i == 0) asm("ld.global.s32 %r9, [%0+0];" "add.s32 %r9, %r9, 1;" "st.global.s32 [%0+0], %r9;" : :"r"(x)); syncthreads(); if (i == 1) *y = *x;

20 Open Compute Language - OpenCL

21 OpenCL: Vergleich zu CUDA Unterschied zum CUDA-Ansatz Taskparallelität kann modelliert werden OpenCL-Programme werden online compiliert Unterstützung von heterogenen Systemen Befehle, kleinster Nenner Ausführung auf Nvidia-GPU Nur anderes Frontend + API Leider schlechterer Compiler Nvidia

22 OpenCL für heterogene Systeme OpenCL auf verschiedensten Plattformen zu finden ZiiLabs Tablets Samsung SnuCore ZiiLabs & Samsung

23 OpenCL vs. CUDA: Platform Model Compute Device CUDA: Nvidia Grafikkarte IBM CELL Board Compute Unit CUDA: Streaming Multiprozessor IBM CELL PPU Processing Element CUDA: Streaming Prozessor IBM CELL SPU AMD

24 OpenCL vs. CUDA: Memory Model CUDA Global memory Constant memory Shared memory Register OpenCL Global memory Constant memory Local memory Private memory Nvidia & Patrick Cozzi, GPU Programming and Architecture, University of Pennsylvania

25 OpenCL vs. CUDA: Execution/Program. Model CUDA Kernel Host program Thread Block Grid global void vecadd(float *a, float *b, float *c) { int i = blockidx.x* blockdim.x + threadidx.x; c[i] = a[i] + b[i]; OpenCL Kernel Host program Work item Work group NDRange (index space) kernel void vecadd( global const float *a, global const float *b, global float *c) { int i = get_global_id(0); c[i] = a[i] + b[i]; Nvidia & Patrick Cozzi, GPU Programming and Architecture, University of Pennsylvania

26 OpenCL vs. CUDA: Task-Parallelität Einsortierung von OpenCL-Kernel in Command Queue Synchrone Ausführung Asynchrone Ausführung Kernel A Kernel B Kernel C Kernel D

27 Zusammenfassung Grafikkarten können effizient zur Beschleunigung von parallelen Programmen eingesetzt werden NVIDIA setzt auf CUDA und OpenCL CUDA Programmierung ist zeitaufwendig OpenCL bietet Alternative zu CUDA Portablen Code Unterstützt Taskparallelität direkt

Ähnliche Dokumente

GPGPU-Programmierung

12 GPGPU-Programmierung 2013/04/25 Diese Folien enthalten Graphiken mit Nutzungseinschränkungen. Das Kopieren der Graphiken ist im Allgemeinen nicht erlaubt. Motivation (1) General Purpose Computing on