Rechnerarchitektur (RA)

Transkript

1 12 Rechnerarchitektur (RA) Sommersemester 2015 Foliensatz 6: Grafikprozessoren und GPGPU-Programmierung Michael Engel Informatik 12 Tel.: /04/23 Diese Folien enthalten Grafiken mit Nutzungseinschränkungen. Das Kopieren der Grafiken ist im Allgemeinen nicht erlaubt.

2 3D Grafikpipeline (OpenGL) Erzeugung von Bildern üblicherweise Fließbandartig organisiert. Beispiel: OpenGL F Siehe Vorlesungen des LS7 zu den einzelnen Grafikoperationen 12, 2015 M. Wawro, Digital Medics,

3 Struktur früher Grafikbeschleuniger [Müller-Schloer, Schmitter: RISC-Workstation- Architekturen, Springer- Verlag,1991] Neuere Grafikbeschleuniger stärker programmierbar 12,

4 Beispiel: Abbildung einer Vektormultiplikation Grid Thread Block 0. Thread Block 15 SIMD Thread 0 SIMD Thread 15 SIMD Thread 0 SIMD Thread 15 A[ 0] = B[ 0] * C[ 0] A[ 1] = B[ 1] * C[ 1].. A[ 31] = B[ 31] * C[ 31] A[ 480] = B[ 480] * C[ 480] A[ 481] = B[ 481] * C[ 481].. A[ 511] = B[ 511] * C[ 511] A[7680] = B[7680] * C[7680] A[7681] = B[7681] * C[7681].. A[7711] = B[7711] * C[7711] A[8160] = B[8160] * C[8160] A[8161] = B[8161] * C[8161].. A[8191] = B[8191] * C[8191] Verteilung einer Multiplikation von Vektoren mit 8192 Elementen. Der thread block scheduler weist thread blocks multithreaded SIMD Prozessoren zu. Der Hardware thread scheduler wählt aus, welcher thread als nächstes ausgeführt wird. 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

5 Vereinfachtes Block Diagram eines Multithreaded SIMD-Prozessors thread scheduling kann unter 48 unabhängigen threads einen ausführbereiten auswählen Effiziente Speicherzugriffe entstehen erst durch Zusammenfassen von benachbarten Speicherzugriffen 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

6 Layout der Fermi GTX 480 GPU 16 Multithreaded SIMD-Prozessoren GDDR5 port PCI Express 2.0 x 16 GDDR5 ports Thread block scheduler GDDR5 port 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

8 Auswahl von ausgeführten threads durch den SIMD thread scheduler Beispiel einer Ausführung von threads: Annahme: durch scheduling innerhalb der multithreaded SIMD-Prozessoren lässt sich die Speicherlatenzzeit verstecken, ausreichend viele vorhandene threads vorausgesetzt. 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

9 Vergleich von Bezeichnungen Treffende Bezeichn. Außerhalb GPUs CUDA/Nvidia Bedeutung Vectorizable Loop Vectorizable Loop Grid Vektorisierbare Schleife Body of vectorizable loop Sequence of SIMD Lane Operations Thread of SIMD intructions Body of (strip-mined) vectorizable loop One iteration of a loop Thread of vector instructions Thread block CUDA Thread Warp Gruppe von threads SIMD instruction Vector instruction PTX instruction PTX Hardwarebef. Multithreaded SIMD processor (Multithreaded) vector processor Streaming multiprocessor Thread block scheduler Scalar processor Giga Thread Engine SIMD thread scheduler Thread scheduler in multithreaded CPU WARP scheduler SIMD Lane Vector Lane Thread processor 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

10 Beispiel Multiplikation zweier Vektoren der Länge 8192 Code, der alle Elemente erfasst, heißt grid SIMD-Befehl erfasst 32 Elemente (threads) (Werden bei obigem Prozessor auf 16 lanes ausgeführt) Ein thread block umfasst 512 Elemente Das Grid enthält mithin 16 Blöcke Durch den thread block scheduler wird jedem Block ein multithreaded SIMD Prozessor zugewiesen 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

11 Nvidia PTX GPU Befehle, Auswahl (1) Gruppe Befehl Bedeutung Kommentar Arithmetik type {.s32,.u32,.f32,.s64,.u64,.f64} Datentypen Spezialbefehle add.type d,a,b mad.type d,a,b,c min.type d,a,b d=a+b d=a*b+c d=(a<b)?a:b selp.type d,a,b d=p? a:b select with predicate type {.f32,.f64 (teilweise)} sqrt.type d,a rsqrt.type d,a sin.type d,a lg2.type d,a ex2 d,a d=sqrt(a) d=1/sqrt(a) d=sin(a) d=log 2 (a) d=2^a Datentypen Logik type={.pred,.b32,.b64} Datentypen and.type or.type shl.type d= a b d= a b d=a <<b 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

12 Nvidia PTX GPU Befehle, Auswahl (2) Gruppe Befehl Bedeutung Kommentar Speicher space {.global,.shared,.local,.const} Datentypen ld.space.type d[a+offset] d=mem[a+offset] st.space.type d[a+offset] d=mem[a+offset] tex.nd.dtyp,btyp d=text2d(a,b) atom.spc.op.type d=mem[a], Mem[a]=d op b Atomare Operation Kontrolle branch t if (p) goto t Bedingter Sprung call Funktionsaufruf ret Rückkehr vom Funktionsaufruf bar.sync Warte auf threads Barrier Synchronisation exit Beende thread PTX=Parallel Thread Execution PTX-ISA ist eine Abstraktion des Hardwarebefehlssatzes Übersetzung in Hardware-ISA erfolgt durch Software PTX benutzt virtuelle Register 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

13 Beispiel: DAXPY in PTX shl.s32 R8, blockidx, 9 ; Thread Block ID * Block size (512 or 2 9 ) add.s32 R8, R8, threadidx ; R8 = i = my CUDA thread ID ld.global.f64 RD0, [X+R8] ; RD0 = X[i] ld.global.f64 RD2, [Y+R8] ; RD2 = Y[i] mul.f64 RD0, RD0, RD4 ; Product in RD0 = RD0 * RD4 (scalar a) add.f64 RD0, RD0, RD2 ; Sum in RD0 = RD0 + RD2 (Y[i]) st.global.f64 [Y+R8], RD0 ; Y[i] = sum (X[i]*a + Y[i]) 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

14 Realisierung von IF-Statements GPUs benutzen Masken zur Realisierung von IF-Statements Masken: Einträge enthalten Masken für jede SIMD lane Legen fest, welche threads Ergebnisse abspeichern (alle threads werden ausgeführt) Pro thread-lane 1-bit predicate register, durch Programmierer angegeben. 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

15 Beispiel if (X[i]!= 0) X[i] = X[i] Y[i]; else X[i] = Z[i]; ld.global.f64 RD0, [X+R8] ; RD0 = X[i] setp.neq.s32 P1, RD0, #0 ; P1 is predicate register bra ELSE1, *Push ; Push old mask, set new mask bits ; if P1 false, go to ELSE1 ld.global.f64 RD2, [Y+R8] ; RD2 = Y[i] sub.f64 RD0, RD0, RD2 ; Difference in RD0 st.global.f64 [X+R8], RD0 ; X[i] = bra ENDIF1, *Comp ; complement mask bits ; if P1 true, go to ENDIF1 ELSE1: ld.global.f64 RD0, [Z+R8] ; RD0 = Z[i] st.global.f64 [X+R8], RD0 ; X[i] = RD0 ENDIF1: <next instruction>, *Pop ; pop to restore old mask 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

16 Verschiedene Speicher Treffende Bezeichnung Außerhalb GPUs CUDA/Nvidia Bedeutung GPU memory Main memory Global memory (Teilweise o. Cache) Private memory Thread or stack local storage (OS) Local memory Im Hauptspeicher (!), nur innerhalb eines threads nutzbar Local memory Local memory Shared Memory Schneller lokaler Speicher für einen SIMD-Prozessor, Zur Kommunikation innerhalb von blocks CPU memory Texture memory SIMD Lane registers Vector lane registers Thread processor registers Gecachter CPU- Hauptspeicher Durch CPU zum GPU-Speicher kopierbar, durch GPU zum CPU-Speicher kopierbar. 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

17 Nvidia GPU Speicherstrukturen 1. Private memory: privater Abschnitt im off-chip-dram- Speicher. Für Stack, private Variablen, ausgelagerte Register 2. Local Memory: von threads innerhalb eines multithreaded SIMD-Prozessors gemeinsam nutzbarer Speicher 3. GPU-Memory: Off-Chip- Speicher, der von allen thread- Blöcken und auch von der CPU genutzt werden kann. 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

19 Nvidia GPU Architektur Ähnlichkeiten zu Vektormaschinen: Beide sind geeignet für datenparallele Anwendungen Beide enthalten gather/scatter-unterstützung Beide enthalten Maskenregister Beide haben große Registerfiles Unterschiede: Kein Skalarprozessor bei GPUs GPU benutzt Multithreading zum Verstecken von Speicherlatenz GPU hat viele funktionelle Einheiten, statt wenigen mit vielen Fließbandstufen 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

20 Vergleich Grafikprozessor/CPU mit dem Roofline-Modell 78 GF/sec Die höchste Rechenleistung bei Core i7 ist nur bei Verwendung aller 4 Cores und SSE- Befehlen mit gleicher Anzahl Multiplikationen und Additionen erreichbar Für die GTX 280 benötigt man kombinierte multiplyadd Instruktionen auf allen multithreaded SIMD-Prozessoren Die maximale DP FP Performance ist zum Vergleich in der unteren Zeile dargestellt 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

21 Zusammenfassung Stärkere Programmierbarkeit von Grafikprozessoren erlaubt deren Einsatz für allgemeines Rechnen, v.a. für Vektor-orientiertes Rechnen Einheit der Parallelausführung ist ein thread threads werden in Blöcke zusammengefasst Die Blöcke machen eine parallelisierbare Schleife aus thread Blöcke werden den multithreaded SIMD- Prozessoren zugewiesen Innerhalb der Prozessoren werden die auszuführenden threads dynamisch per Hardware ausgewählt Lokalität zwischen threads wg. Speicherzugriffen wichtig 12, 2015 Aus Hennessy/Patterson: Computer Architecture, 5. Aufl., Kap.4; Copyright 2012, Elsevier Inc. All rights reserved

22 12 GPGPU-Programmierung 2014/04/23 Diese Folien enthalten Graphiken mit Nutzungseinschränkungen. Das Kopieren der Graphiken ist im Allgemeinen nicht erlaubt.

23 Motivation (1) General Purpose Computing on Graphics Processing Units (GPGPU) Wurde eingeführt um (bei Spielen) die CPU zu entlasten Physikalische Berechnungen Künstliche Intelligenz Medizinische Bildverarbeitung 12, & fr.wikipedia

24 Motivation (2) GPUs haben eine große Anzahl von parallelen Rechenkernen Gut für datenparallele Programme (30 in total ) (240 in total) Nvidia GeForce GTX Titan hat z.b Prozessoren Wie können diese effizient programmiert werden? 12, 2015 Nvidia Best Practice Guide

25 Motivation (3) Was sollte bzgl. GPGPU-Applikationen beachtet werden? Threads sollten möglichst unabhängig voneinander sein Zusätzlicher Kopier-Overhead für Daten GPU GPU CPU CPU 12,

26 Geschichte der GPGPU-Programmierung (1) Bis zirka Shader-Sprachen wurden zur Programmierung benutzt Vertex- und Fragment-Shader-Programme void main(void) { gl_fragcolor = vec4 (0.0, 1.0, 0.0, 1.0); } David Kirk/Nvidia and Wen-mei W. Hwu, 12, , University of Illinois

27 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 add_vector(float in1<>, float in2<>, out float out<>) { out = in1 + in2; } float in1<100> = {1.0f, 2.0f,...}; float in2<100> = {2.0f, 3.0f,...}; float out<100>; add_vector(in1,in2,out); Vektoraddition in BrookGPU Code 12,

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

29 CUDA Adaptiert das stream processing-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 id = 0; id < N; id++ ) { out[id] = in1[id] + in2[id] ; } } Vektoraddition in C global void add_vector(int* in1, int* in2, int* out) { int id = (blockidx.x*blockdim.x)+threadidx.x; out[id] = in1[id] + in2[id]; } add_vector<<<n,1>>>( in1, in2, out ); Vektoraddition in Cuda 12,

30 CUDA Entwicklungsprozess Mehrstufig und kompliziert Programmierung von Code für einen Thread Spezifikation der Parallelität per Hand Einige statisch vorgegebene Größen müssen beachtet werden 12,

31 CUDA Kompilierung Mehrstufigen Verfahren für die Kompilierung von CUDA-Programmen GPU- und Host-Code werden getrennt kompiliert GPU-Binaries werden in Host- Code eingebettet Neuester Compiler von Nvidia basiert auf der LLVM Compiler Infrastruktur 12,

32 CUDA Elemente des Frameworks Thread Block Grid Instanz eines Kernels Gruppe von Threads Gesamtheit aller Blocks Host Kernel 1 Device Grid 1 Block (0, 0) Block (0, 1) Block (1, 0) Block (1, 1) Grid 2 Für Thread (2,1) in Block (1,1): threadidx.x: 2 threadidx.y: 1 blockidx.x: 1 blockidx.y: 1 blockdim.x: 4 blockdim.y: 2 griddim.x: 2 griddim.y: 2 Kernel 2 Block (1, 1) Thread (0,0) Thread (0,1) Thread (1,0) Thread (1,1) Thread (2,0) Thread (2,1) Thread (3,0) Thread (3,1) 12, 2015 Nvidia

33 CUDA Abbildungsbeispiel Ein Kernel benötigt z.b. folgende Ressourcen Grid size: 8x8 Blöcke Block size: 16x16 Threads (ergibt insgesamt 128x128 Threads) 1024 Bytes Shared Memory per Block (z.b. 1 Float Variable pro Thread) Beispiel Grafikkarte Max. 8 Blocks, 24 Warps (Warpgröße 32), 768 Threads Max. 16 Kilobytes Scratchpad-Speicher Auslastung der Grafikkarte 3 Blocks, 24 Warps, 768 Threads, 3072 Bytes Shared Memory (768/32) (3*16*16) (3*1024) 12,

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

35 CUDA - Speichertransfers Kopieren in/aus/im globalen Speicher Vom Host zur Grafikkarte int*devmemx; int* hostmemx = malloc(1024*sizeof(int)); for(int i=0; i<1024; i++) { hostmemx[i] = rand() % 100; // Initialize with random numbers } cudamalloc((void**) &devmemx, 1024*sizeof(int)); cudamemcpy(devmemx, &hostmemx, 1024*sizeof(int), cudamemcpyhosttodevice); Von der Grafikkarte zum Host cudamemcpy(&hostmemx, devmemx, 1024*sizeof(int), cudamemcpydevicetohost); Auf der Grafikkarte cudamemcpy(devmemx, devmemy, 1024*sizeof(int), cudamemcpydevicetodevice); 12,

36 CUDA Speicherzugriff Globaler/Shared Memory-Speicherzugriff Zugriff auf globalen/shared Speicher ist nicht synchronisiert! Ergebnis von Schreib-/Leseoperationen auf gemeinsamen Speicher? Lösung: Atomare Operationen Vorsicht: Die Ausführungsreihenfolge ist immer noch undefiniert! global void add_up_vector (int* out) { *out+=5; } add_vector_gpu<<<1,5>>>(out); global void add_up_vector (int* out) { atomicadd(out,5); } add_vector_gpu<<<1,5>>>(out); Ergebnis? => out = {5,10,15,20,25}? Ergebnis? => out = 25 12,

37 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 id = threadidx.x + ; if (id == 0) *x += 5; syncthreads(); if (id == 1) *y = *x; } global void kern(int* x, int* y) { int id = threadidx.x + blockdim.x * blockidx.x; if (id == 0) asm("ld.global.s32 %r9, [%0+0];" "add.s32 %r9, %r9, 5;" "st.global.s32 [%0+0], %r9;" : :"r"(x)); syncthreads(); if (id == 1) *y = *x; } 12,

38 CUDA Thread Divergenz (1) Ablauf der Threads Vorhersage der tatsächlichen Reihenfolge ist nicht möglich! Programmierer kann aber Synchronisationspunkte setzen global void update(int* x, int* y) { int id = threadidx.x + blockdim.x * blockidx.x; if (id == 5){ sharedx = *x; sharedx = 1; } syncthreads(); if (id == 0) *y = sharedx; } update <<<2,512>>>(in,out); Ergebnis? => *out = 1;? 12,

39 CUDA Thread Divergenz (2) Synchronisation über Blockgrenzen Keine globale Synchronisation innerhalb eines Kernels! Lösung: Kernel aufsplitten und nacheinander ausführen global void update(int* update_1(int* x, int* x, int* y) { y) { int id = threadidx.x + blockdim.x * blockidx.x; if (id == 5) *x = 1; } *x = 1; global syncthreads(); void update_2(int* x, int* y) { if int (id == = threadidx.x 0) + blockdim.x * blockidx.x; if (id == 0) *y = *x; } update_1 <<<2,512>>>(in,out); update_2 <<<2,512>>>(in,out); Ergebnis? => *out =?; 1; 12,

40 Open Compute Language - OpenCL 12,

41 OpenCL für heterogene Systeme OpenCL ist auf verschiedensten Plattformen zu finden ZiiLabs Tablets Samsung SnuCore 12, 2015 ZiiLabs & Samsung

42 CUDA vs. OpenCL Unterschied zum CUDA-Ansatz Taskparallelität kann modelliert werden OpenCL-Programme werden online kompiliert Unterstützung von heterogenen Systemen (GPUs, CPUs, Cell,...) Ausführung auf Nvidia-GPU Nur anderes Frontend + API OpenCL kann nicht alle CUDA Spezialbefehle nutzen 12, 2015 Nvidia

43 CUDA vs. OpenCL: Speichermodell CUDA Global memory Constant memory Shared memory Local memory OpenCL Global memory Constant memory Local memory Private memory 12, 2015 Nvidia & Patrick Cozzi, GPU Programming and Architecture, University of Pennsylvania

44 CUDA vs. OpenCL: Ausführungs/Progr.-modell CUDA Kernel Host program Thread Block Grid global void add_vector ( int* in1, int* in2, int* out) { int id = (blockidx.x*blockdim.x)+threadidx.x; out[id] = in1[id] + in2[id]; } Vektoraddition in Cuda OpenCL Kernel Host program Work item Work group NDRange (index space) kernel void add_vector ( global int in1, global int in2, global int out) { int id = get_global_id(0); out[id] = in1[id] + in2[id]; } Vektoraddition in OpenCL 12, 2015 Nvidia & Patrick Cozzi, GPU Programming and Architecture, University of Pennsylvania

45 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 12,

46 Lokalen Speicher effizient füllen (1) 64 work items in einer work group 8x8 Threads laden einen 10x10 großen lokalen Speicher 12,

47 Lokalen Speicher effizient füllen (2) Thread id 14 (x=6, y=1) 8x8 Threads laden einen 10x10 großen lokalen Speicher 12,

48 Lokalen Speicher effizient füllen (3) x8 Threads laden einen 10x10 großen lokalen Speicher 12,

53 Lokalen Speicher effizient füllen (8) Natürlichstes Zugriffsmuster , 2015 Zugriffsmuster mit den wenigsten Branches Effizientestes Zugriffsmuster (bei Nvidia GPU)

54 Beispiel: Addition von Vektorelementen Summiert eine Menge von Elementen eines Vektors Host-Anwendung in C/C++ 1. Anfrage einer cl_device_id für jedes Device, das einen Kernel ausführen soll add_numbers verwendet erstes GPU device der ersten platform (Nvidia, AMD): platform: erste platform der OpenCL runtime device structure: erstes Gerät der Platform Hier angefragt: CL_DEVICE_TYPE_GPU, also GPU (CPU auch möglich) 2. Erzeugen eines Kontextes für das angefragte device: 3. Einlesen des GPU-Codes für den compute kernel: 12,

55 Beispiel: Addition von Vektorelementen (2) 4. Übersetzen der OpenCL-Funktion für das allokierte device. Zusätzliche Parameter für Übersetzung für mehrere devices, Übersetzungsoptionen (z.b. Optimierung) und Callback-Funktionen: 5. Erzeugen eines Kernels aus der übersetzten Funktion: 6. Erzeugung der command queue für die Ausführung des Kernels (Optional: out-of-order kernel execution und/oder profiling, Setzen von Parametern): 7. Ausführen des Kernels auf dem device: clenqueuendrangekernel verteilt den Code auf Devices, legt die Anzahl der work items für die Ausführung des Kernels (global_size) und die Anzahl work items für jede work group (local_size) fest Kompletter Beispielcode verfügbar bei 12,

56 Beispiel: Addition von Vektorelementen Kernel Kernel: Acht work items für die Addition von 64 Zahlen Jeweils nach der Berechnung der Summe von 8 Zahlen werden Zwischenergebnisse summiert Adresse der Daten in globalem Speicher Kopieren der Daten in lokalen Speicher und Addition (wenn verfügbar, Summe als Vektoraddition) Speichern der Summe in lokalem Speicher Warten auf Beendigung aller parallelen Aufgaben Ein work item zur Summierung der Teilsummen Schreiben der Teilsumme in globalen Speicher für Zugriff aus Host-Anwendung Kompletter Beispielcode verfügbar bei 12,

57 Vorteile/Nachteile GPU Programmierung ist aufwändig Kleine Kernel in OpenCL-Code Große Mengen an C/C++ Host Code erforderlich Ca. 90% Overhead Bsp: Minimum/Maximum Berechnung eines Arrays In C++: 6 Zeilen In OpenCL/CUDA: 80 Zeilen OpenCL Code Zeilen C Host Code Dafür sehr schnell: 1.2 Millisekunden auf CPU Millisekunden auf GPU 12,

58 Zusammenfassung Grafikkarten können effizient zur Beschleunigung von parallelen Programmen eingesetzt werden Nvidia setzt auf CUDA und OpenCL GPGPU Programmierung ist zeitaufwendig OpenCL bietet Task- und Datenparallelität Eine offene Alternative zu CUDA Einen portablen Code für eine Vielzahl von Geräten 12,