1 / 71

G eneral P urpose Computation on

G eneral P urpose Computation on. G raphics P rocessing U nit. Inhalt. Motivation Hardware Design aktueller GPUs GPGPU mit Standard APIs Anwendungsbeispiele GPGPU a la Nvidia GPGPU a la AMD/ATI. Motivation. GPUs sind äußerst leistungsfähige Parallelrechner

tilly
Download Presentation

G eneral P urpose Computation on

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. General Purpose Computation on GraphicsProcessingUnit

  2. Inhalt Motivation Hardware Design aktueller GPUs GPGPU mit Standard APIs Anwendungsbeispiele GPGPU a la Nvidia GPGPU a la AMD/ATI Stefan Auer

  3. Motivation • GPUs sind äußerst leistungsfähige Parallelrechner • Beispiel: NvidiaGeForce 8800 GTX • 128 Stream Prozessoren • ~690 millionen Transistoren • 1350 MHz Shaderclockspeed • 86 GB/s Speicherbandbreite (Peak) • 345 GflopsFloatingpoint-Leistung (Peak, Multiply-ADD) • Vergleich: Intel Core 2 Quad Q6600 • 4 Kerne (zwei Doppelkernprozessoren) • ~580 millionen Transistoren • 2400 MHz Takt • ~5 GB/s Speicherbandbreite (gemessen) • ~40 Gflops FPU-Leistung (gemessen, Whetstone) Stefan Auer

  4. Motivation Vergleich der Floatingpointleistung Gflops Stefan Auer Quelle: behardware.com

  5. Motivation • Leistungszuwachs war bei GPUs in letzter Zeit größer als bei CPUs (GPUs profitieren mehr als CPUs von Verbesserungen der Fertigung) 503% 1355% 100% 100% Stefan Auer Quelle: tomshardware.com

  6. Motivation • Einsatzzweck von GPUs ist das Rendering von interaktiven 3D Anwendungen -> GPUs sind vergleichsweise preiswert (Videospiele sind Massenmarkt) • GeForce 8800 GTX aktuell ~ 450.- € Stefan Auer

  7. Motivation Programmierbare Rendering Pipeline CPU GPU Geometrie Shader (DX10) Vertex Shader Pixel Shader Vertices Primitive (z.B. Dreiecke) Fragmente („Pre-Pixels“) Pixel (Farbe, Tiefe) Stefan Auer

  8. Inhalt Motivation Hardware Design aktueller GPUs GPGPU mit Standard APIs Anwendungsbeispiele GPGPU a la Nvidia GPGPU a la AMD/ATI Stefan Auer

  9. Hardware Design aktueller GPUs Host / FW / VTF Nvidia G70 Architektur (GeForce 7800) 8 vertexshader pipelines Cull / Clip / Setup Z-Cull Shader Instruction Dispatch 24 pixelshaderpipelines L2 Tex 16 raster operationpipelines 32 ppc Fragment Crossbar Memory Partition Memory Partition Memory Partition Memory Partition Stefan Auer Quelle: Nvidia DRAM(s) DRAM(s) DRAM(s) DRAM(s)

  10. Hardware Design aktueller GPUs Wenig Geometrie Lastverteilung Viel Geometrie Unified shader (1) Höhere Flexibilität • geometryshader, Spielphysik ?, generalpurpose Bessere Ausnutzung der Hardware Stefan Auer Quelle: Nvidia

  11. Hardware Design aktueller GPUs Vertex Shader Vertex Shader Heavy Geometry Pixel Shader Pixel Shader Idlehardware Idlehardware Heavy Pixel Unified shader (2) Stefan Auer Quelle: Nvidia

  12. Hardware Design aktueller GPUs Unified Shader Unified Shader Heavy Geometry Vertex workload Pixelworkload Heavy Pixel Vertexworkload Pixel workload Unified shader (3) Stefan Auer Quelle: Nvidia

  13. SP SP SP SP SP SP SP SP SP SP SP SP SP SP SP SP TF TF TF TF TF TF TF TF Host L1 L1 L1 L1 L1 L1 L1 L1 Data Assembler Setup / Rstr / ZCull Vtx Thread Issue Geom Thread Issue Pixel Thread Issue Thread Processor L2 L2 L2 L2 L2 L2 FB FB FB FB FB FB Hardware Design aktueller GPUs 128 unifiedshaderpipelines Nvidia G80 Architektur (GeForce 8800) 6 ROPs 192 ppc Stefan Auer Quelle: Nvidia

  14. Hardware Design aktueller GPUs CPU vs. GPU: CPU Architektur CPUs implementieren Von Neumann Architektur Von Neumann Flaschenhals • Teilung von ALU und Speicher schafft Bandbreitenprobleme • heutige ALUs sind wesentlich schneller als die Datenverbindungen • cachemanagement notwendig > großer Kontroll-Overhead • > für rechenintensive Anwendungen verbleibt weniger Leistung Stefan Auer

  15. Hardware Design aktueller GPUs CPU vs. GPU: GPU Architektur GPUs entsprechen annähernd Stream Processing Architektur Anwendung organisiert in Streams und Kernel • fördert Lokalität der Daten und Parallelität ihrer Verarbeitung Stefan Auer

  16. Hardware Design aktueller GPUs CPU vs. GPU: Gegenüberstellung • CPU: profitiert hauptsächlich von Aufgabenparallelität • schnelle (aber kostspielige) Caches • Pipelines auf Sprünge optimiert • wenige Ausführungseinheiten (1,2,4,...) • hohe Leistung bei Bearbeitung einzelner Threads • GPU: profitiert zusätzlich von Datenparallelität • sehr viele ALUs, spezialisiert auf floating-point Arithmetik • sehr hohe Speicherbandbreite (aber hohe Latenz) • tausende Threads mit gleichem Kernel Stefan Auer

  17. Inhalt Motivation Hardware Design aktueller GPUs GPGPU mit Standard APIs Anwendungsbeispiele GPGPU a la Nvidia GPGPU a la AMD/ATI Stefan Auer

  18. GPGPU mit Standard APIs VertexTextureFetch RendertoTexture TextureSampling(Gather) Fragment Prozessor 2 1 VertexProzessor Rasterisierer „screen“ 2 0 1 TextureBuffer FrameBuffer(s) Stefan Auer „Standard“-Verwendung der Pipeline bei GPGPU

  19. GPGPU mit Standard APIs Texturen als computationalgrids (ein) typischer GPGPU Programmierstil Texturen repräsentieren Streams (Texel = Datenelement) Fragmentprogramme (pixelshader) repräsentieren Kernel Zeichnen eines Full-Screen-Rechtecks repräsentiert Berechnungschritt Stefan Auer

  20. GPGPU mit Standard APIs viele Berechnungen lassen sich gut auf Grids abbilden: • Matrix Algebra • Bild- und Volumenverarbeitung • Physiksimulationen • Global Illumination • raytracing, photonmapping, radiosity Streams die keinen Grids entsprechen lassensich meist darauf abbilden Stefan Auer

  21. GPGPU mit Standard APIs GPGPU „Hello World“ (1) Bildverarbeitung: 3x3 Faltung • Input: Bild, Gewichtungen • Output: „geblurrtes“ Bild CPU Version: image = loadImage(WIDTH, HEIGHT); blurImage = allocZeros(WIDTH, HEIGHT); for (x=0; x < WIDTH; x++) for (y=0; y < HEIGHT; y++) for (i=-1; i <= 1; i++) for (j=-1; j <= 1; j++) float w = computeWeight(i,j); blurImage[x][y] += w * image[x+i, y+j]; Stefan Auer

  22. GPGPU mit Standard APIs GPGPU „Hello World“ (2) GPU Version: 1) Lade image als Textur 2) erstelle blurImage Texturwelche das Ergebnis aufnimmt Stefan Auer

  23. GPGPU mit Standard APIs GPGPU „Hello World“ (3) GPU Version: 3) Lade Fragment-Programm (Kernel)Beispielcode in CG: float4 blurKernel(uniform samplerRECTimage, float2 winPos : WPOS, out float4 blurImage ) { blurImage = float4(0,0,0,0); for (i=-1; i <= 1; i++) { for (j=-1; j <= 1; j++) { float2 texCoord = winPos + float2(i,j); float w = computeWeight(i,j); blurImage += w * texRECT( image, texCoord ); } } } Stefan Auer

  24. GPGPU mit Standard APIs GPGPU „Hello World“ (4) GPU Version: 4) wähle Viewport-Größe entsprechend Bildgrößekonfiguriere Vertex Pipeline so dass sie „nichts“ tutBeispielcode für OpenGl: glMatrixMode( GL_PROJECTION ); glLoadIdentity(); gluOrtho2D(0, 1, 0, 1); glViewport(0, 0, WIDTH, HEIGHT ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); Stefan Auer

  25. GPGPU mit Standard APIs 2 1 „screen“ 0 1 2 GPGPU „Hello World“ (5) GPU Version: 5) binde image als Textur, blurKernel als Fragment-Programm und blurImage als Render-Target 6) zeichne ein Full-Screen-Rechteck glBegin( GL_TRIANGLES ); glVertex2f(0, 0); glVertex2f(2, 0); glVertex2f(0, 2); glEnd(); Stefan Auer

  26. GPGPU mit Standard APIs Was passiert? blurKernel wird für jedes Fragment einmal ausgeführt • das Rendering ersetzt die äußeren beiden Schleifen der CPU-Version blurKernel führt für jedes Fragment9 Gather (p=a[i]) Operationen durch undgewichtet jeden Wert die „geblurrten“ Ergebnis-Pixel werdenin den Framebuffer bzw. in dieblurImage Textur geschrieben Stefan Auer

  27. GPGPU mit Standard APIs GPGPU Techniken (1) • Scatter Nachbildung • Problem: a[i]=p • indirektes Schreiben • Position des Fragments kannim Pixel-Shader nicht mehrgeändert werden • Lösung 1: Auf Gather abbilden • erster Schritt: Kernel 1 ermitteltWerte und speichert inZwischenergebnis • zweiter Schritt: Kernel 2 sammeltZwischenergebnisse an derpassenden Stelle ein 1 2 Stefan Auer

  28. GPGPU mit Standard APIs GPGPU Techniken (2) • Scatter Nachbildung • Lösung 2: Adresssortierung • erster Schritt: Kernel 1 ermitteltWerte und speichert sie gemeinsammit Zieladresse in Zwischenergebnis • zweiter Schritt: Kernel 2 führt aufdem Zwischenergebnis bitonic-sortnach Adressen durch • dritter Schritt: Kernel 3 findet diepassenden Werte durch binäreSuche 2 1 1+1 1 1 1 9 3+3 5 3 8 3 1 5+5 5 3 6 5 3 6 8 6 8 9 9 5 3 Stefan Auer

  29. GPGPU mit Standard APIs GPGPU Techniken (3) • Scatter Nachbildung • Lösung 3: Vertex Shader • führe Rechnung im Vertex Shader durch • Zeichne Punkte • Vertex Position = Adresse • führe Rechnung im Pixel Shader durch • schreibe Adresse und Wert in Textur • Zeichne Punkte • lies Textur im Vertex Shader (Vertex TextureFetch)und passe Position an Adresse an Stefan Auer

  30. GPGPU mit Standard APIs GPGPU Techniken (4) • Reduce • Problem: Reduktion der Wertanzahl durch Zusammenfassung • Lösungen: Zeilen-/Spaltenweise, Blockweiseimmer mehrere Passes notwendig • Filtering • Problem: Reduktion der Wertanzahl durch entfernen bestimmter Werte • Sortierung • Lösung: Sorting Networks Stefan Auer

  31. GPGPU mit Standard APIs GPGPU Techniken (5) • Suche • Problem: Suche nach bestimmten Werten, Werten die bestimmte Eigenschaften erfüllen oder Nachbarn von bestimmten Werten • sinnvoll auf GPU bei vielen parallelen Suchen • Datenstrukturen • Arrays und Matrizen (dicht- und dünnbesetzt) • adaptive Datenstrukturen (adp. shadowmaps, octrees,…) Stefan Auer

  32. GPGPU mit Standard APIs GPGPU Techniken (6) • Branching • statisch • vermeiden von Branches, wenn vorab bekannt ist welche Elemente betroffen sind • Nutzung des z-Buffers • bedingte writes • Nutzung mathematischer Konstrukte als Branch-Ersatz • sinnvolle Verwendung der Branching-Unterstützung in shader-model 3 und 4 Stefan Auer

  33. Inhalt Motivation Hardware Design aktueller GPUs GPGPU mit Standard APIs Anwendungsbeispiele GPGPU a la Nvidia GPGPU a la AMD/ATI Stefan Auer

  34. Anwendungsbeispiele Grundlegende (aus der Mathematik): Differentielle Gleichungen & … • gewöhnliche (ODE), z.B. für Partikel Systeme • partielle (PDE), z.B. für Fluid Simulationen (Navier Stokes) … Lineare Algebra • z.B. für numerische Simulation, Ray tracing, realtimeShading & Lighting Stefan Auer

  35. Anwendungsbeispiele Allgemeine (1): Relationale Datenbanken • Query-Beschleunigung z.B. durch beschleunigtes Join Simulation physikalischer Phänomene • finite Differenzen & finite Elemente • z.B. für Fluide (Flüssigkeiten, Gase) Signal- und Bildverarbeitung • Segmentierung: Erkennen von „Objekten“(z.B. Tumor in medizinischen Scans) • Computer Vision • ... Stefan Auer

  36. Anwendungsbeispiele Allgemeine (2): Global Illumination • Ray tracing • Photon mapping • Radiosity • Subsurfacescattering Stefan Auer

  37. Anwendungsbeispiele Havok FX entstanden durch Zusammenarbeit von Havok und Nvidia Nutzung der GPU für Effekt Physik in Spielen Stefan Auer

  38. Inhalt Motivation Hardware Design aktueller GPUs GPGPU mit Standard APIs Anwendungsbeispiele GPGPU a la Nvidia GPGPU a la AMD/ATI Stefan Auer

  39. GPGPU alla Nvidia Nachteile von Grafik APIs: sehr hohe Lernkurve für Nicht-Grafik-Entwickler • Pipeline? • Texturen? (sampler, filtering, blending) • Framebuffer? unpassende Abstraktionen für Nicht-Grafik-Programme • Vertices/Primitive/Fragmente + jeweils spezielle Programme dafür unflexibler Speicherzugriff • fehlendes Scatter zuwenig Kontrolle • (Grafik-) Treiber + API treffen wichtige Entscheidungen • Treiber ändern sich • Grafik-Optimierungen teilweise kontrapoduktiv Stefan Auer

  40. SP SP SP SP SP SP SP SP SP SP SP SP SP SP SP SP TF TF TF TF TF TF TF TF Host L1 L1 L1 L1 L1 L1 L1 L1 Data Assembler Setup / Rstr / ZCull Vtx Thread Issue Geom Thread Issue Pixel Thread Issue Thread Processor L2 L2 L2 L2 L2 L2 FB FB FB FB FB FB GPGPU alla Nvidia Nvidia G80 als GPU Stefan Auer Quelle: Nvidia

  41. Texture Texture Texture Texture Texture Texture Texture Texture Texture Host Input Assembler Thread Execution Manager Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Load/store Load/store Load/store Load/store Load/store Load/store Global Memory GPGPU alla Nvidia Nvidia G80 als GPGPU Stefan Auer Quelle: Nvidia

  42. GPGPU alla Nvidia CUDA ComputeUnified Device Architecture Plattform für GPGPU auf Nvidia G80 (und höher) nutzt das C Subset von C++ (mit ein paar Erweiterungen) als Programmiersprache ersetzt (für GP-Anwendungen) Grafik API und Treiber CUDA und Grafik Anwendungen parallel möglich (OS-Multitasking) Stefan Auer

  43. GPGPU alla Nvidia CPU (Host) Anwendung CUDA Libraries CUDA Runtime CUDA Driver GPU CUDA Software Stack Stefan Auer

  44. GPGPU alla Nvidia CUDA aus Compiler-Sicht NVCC ist compilerdriver (ähnlich gcc) NVCC verarbeitet CUDA Programme (.cu) • Host-Code wird entweder extrahiert (-> .cpp) odersofort kompiliert (z.B. Visual Studio Kompilier) • Device Code wird für PTX kompiliert PTX Code wird zur Installationszeit für dasjeweilige Device (z.B. G80) kompiliert Stefan Auer

  45. GPGPU alla Nvidia PTX PTX: parallel threadexecution • virtuelle Maschine und ISA • Programmiermodell • Abstraktion von Ressourcen und State ISA: instructionsetarchitecture • formale Spezifikation des Verhaltens eines Prozessors aus Sicht des Programmierers PTX-Übersetzter ist optimizingcompiler • übersetzt PTX in Zielmaschinencode (z.B. für G80) • wird zur Installationszeit ausgeführt CUDA Treiber implementiert die virtuelle Maschine • stellt Übersetzer zur Verfügung Stefan Auer

  46. GPGPU alla Nvidia CUDA Programmiermodell GPU ist Coprozessor der CPU (CPU = Host) datenparallele Programmteile werden für die GPU kompiliert und dort als Kernel ausgeführt implizites Multithreadding: derselbe Kernel wird auf der GPU (hundertfach) parallel von (tausenden) Threads auf unterschiedlichen Daten (SIMD) ausgeführt eigener Speicher für CPU (hostmemory) und GPU (devicememory); Hin-und-Her-Kopieren durch DMA indirekte Ressourcenverteilung (Threads, Register, Shared-Memory) durch Programmierer notwendig Stefan Auer

  47. GPGPU alla Nvidia Grid Grid Grid 65535 Block (0,0) Block (0,1) Block (0,2) Block (0,3) Block 512 512 Block (1,0) Block (1,1) Block Block Thread (0,0) Thread (0,1) Thread (0,2) 65535 512 Thread (1,0) Thread (1,1) Thread (1,2) Block (2,0) Block (2,1) Block Block 64 Thread (2,0) Thread (2,1) Thread (2,2) Thread Thread Thread Block … Block … Block … Block … Stefan Auer Zahlen gelten für GeForce 8800 CUDA Threadmanagement Grid • alle Threads führen denselben Kernel aus • alle Blöcke haben die selben Dimensionen Block • zu jeder Zeit nur ein Block aktiv auf jedem Multiprozessor • alle Threads teilen sich Register (per Thread) und Shared Memory (per Block) • Synchronisation zwischen Threads möglich

  48. Texture Texture Texture Texture Texture Texture Texture Texture Texture GPGPU alla Nvidia Streaming Multiprocessor (SM) • ein Multiprozessor führt zu jeder Zeit nur einen aktiven Block aus • ein Multiprozessor kann 8 Blöcke ausführen (scheduling) • die Threads eines Blocks werden ausgeführt als „Warps“ a 32 Threads • ein Multiprozessor kann insgesamt 24 Warps ausführen (scheduling) • eine Instruktion benötigt pro Warp je nach Art zwischen 4 (z.B. FMADD) und 32 (z.B. IMUL) clockcycles Instruction Fetch Instruction L1 Cache Thread / InstructionDispatch Shared Memory SFU SP 0 SP 4 SFU RF 0 RF 4 SP 1 SP 5 RF 1 RF 5 SP 2 SP 6 RF 2 RF 6 Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache SP 3 SP 7 RF 3 RF 7 GPU Constant L1 Cache Stefan Auer Zahlen gelten für GeForce 8800 CUDA Threadausführung

  49. Texture Texture Texture Texture Texture Texture Texture Texture Texture GPGPU alla Nvidia Streaming Multiprocessor (SM) Jeder Thread kann: • pro Thread Register Lesen/Schreiben • pro Thread Local Memory L/S • pro Block Shared Memory L/S • pro Grid Global Memory L/S • pro Grid Constant Memory nur L • pro GridTexture Memory nur L Device Memory Instruction Fetch Instruction L1 Cache Thread / InstructionDispatch Constants (cached) Shared Memory SFU SP 0 SP 4 SFU RF 0 RF 4 Textures (cached) SP 1 SP 5 RF 1 RF 5 SP 2 SP 6 RF 2 RF 6 Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache SP 3 SP 7 RF 3 RF 7 Global (uncached) GPU Constant L1 Cache Local (uncached) CUDA Speicherbereiche (1) Stefan Auer

  50. Texture Texture Texture Texture Texture Texture Texture Texture Texture GPGPU alla Nvidia Streaming Multiprocessor (SM) Alle Threads eines Blocks teilen sich Shared Memory (per Block) und Register (per Thread) -> verfügbare Registerzahl = Register pro SM / Threads pro Block Kernel die mehr Register verwenden können nicht gestartet werden Device Memory Instruction Fetch Instruction L1 Cache Thread / InstructionDispatch Constants (cached) Shared Memory SFU SP 0 SP 4 SFU RF 0 RF 4 SP 1 SP 5 RF 1 RF 5 Textures (cached) SP 2 SP 6 RF 2 RF 6 Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache Parallel DataCache SP 3 SP 7 RF 3 RF 7 Global (uncached) GPU Constant L1 Cache Local (uncached) CUDA Speicherbereiche (2) Stefan Auer

More Related