Physikalische Simulationen mit. 9. Vorlesung GPU Programmierung Thorsten Grosch

Transkript

1 Physikalische Simulationen mit CUDA 9. Vorlesung g Thorsten Grosch

2 Übersicht Verschiedene physikalische Simulationen mit CUDA Deformationen Wärmeausbreitung Lichtausbreitung Können oft parallelisiert werden Verbindung CUDA mit OpenGL Quelle: NVIDIA 2

3 CUDA / OpenGL

4 Anzeige Bild Für die Anzeige haben wir bisher folgendes verwendet cudamemcpy( pixels, devptr, size, cudamemcpydevicetohost ); gldrawpixels( width, height,, pixels ); Da sich die Pixeldaten bereits auf der GPU befinden sind dies zwei unnötige Kopiervorgänge Kann durch Verwendung von PixelBufferObjects (PBOs) vermieden werden 4

5 CUDA-OpenGL GLKommunikation i durch hpixelbufferobjects Gemeinsamer Buffer für OpenGL und CUDA reservieren Unterschiedlicher Name für denselben Speicherbereich #include cuda_gl_interop.h GLuint bufferobj; cudagraphicsresource *resource; 5

6 GPU Device auswählen Wähle eine GPU mit CUDA Fähigkeit aus device cudadeviceprop prop; int dev; memset( &prop, 0, sizeof( cudadeviceprop ) ); prop.major =1; prop.minor = 0; cudachoosedevice( &dev, &prop ); CUDA GL Device setzen Diese GPU wird auch für OpenGL Anzeige verwendet cudaglsetgldevice( dev ); Danach GLUT Init 6

7 GPU Device auswählen Pixel Buffer Object (PBO) anlegen Speicher für Pixeldaten, ähnlich zu VBO usw. glgenbuffers( 1, &bufferobj ); glbindbuffer( GL_PIXEL_UNPACK_BUFFER_ARB, bufferobj ); glbufferdata( GL_PIXEL_UNPACK_BUFFER_ARB, sizeinbytes, NULL, GL_DYNAMIC_DRAW_ARB DRAW ARB ); glbindbuffer( GL_PIXEL_UNPACK_BUFFER_ARB, 0 ); Buffer bei CUDA anmelden: resource bufferobj cudagraphicsglregisterbuffer( &resource, bufferobj, cudagraphicsmapflagsnone ) ); 7

8 Drawpixels In der display Funktion Buffer Object mappen devptr für den Kernel cudagraphicsmapresources( 1, &resource, NULL ); cudagraphicsresourcegetmappedpointer( (void**)&devptr, &size, resource); kernelcall<<< >>>(devptr ); cudagraphicsunmapresources( 1, &resource, NULL ); Nach unmap unmap kann der Buffer gezeichnet werden Wenn PixelBufferObject gebunden ist, dann zeichnet gldrawpixels das aktuelle PBO (der data-pointer ist dann ein offset) Daten bleiben auf fgpu, keine Kopieraktionen i GPU CPU glbindbuffer( GL_PIXEL_UNPACK_BUFFER_ARB, bufferobj ); gldrawpixels( DIM, DIM, GL_LUMINANCE, LUMINANCE, GL_FLOAT, 0 ); 8

9 Freigabe Buffer Object und Resource löschen cudagraphicsunregisterresource(resource); gldeletebuffers(1, &bufferobj); Ähnliche Verknüpfung auch für Vertex Buffer Object möglich 9

10 Wärmeausbreitung

11 Wärmeausbreitung auf der GPU Die GPU eignet sich gut zum numerischen Lösen von Differentialgleichungen Einfache Operationen auf (2D) Gitter z.b. Wärmeausbreitung Hier vereinfachtes Modell, keine physikalische Korrektheit Raum = 2D Grid Einige Zellen sind (konstante) Wärmequellen Einige Zellen sind konstant kalt (Hindernisse) Die Übertragung der Wärme erfolgt zu den Nachbarzellen Wie sieht die resultierende Wärmeverteilung im Raum aus? 11

12 Wärmeausbreitung auf der GPU Die Wärmeübertragung ist dabei proportional zur Differenz der beiden benachbarten Werte z.b. Übertragung gnach rechts Δ f r = c ( f ( x + 1) f ( x)) c = c gibt dabei die Geschwindigkeit der Wärmeübertragung an BiB Bei Berücksichtigung ükihi aller vier Nachbarpixel ergibt sich Iteration Δ f = c ( f ( x + 1) + f ( x 1) + f ( y + 1) + f ( y 1) 4 f ( x )) Δf f Pro Pixel berechnen (parallel) und auf addieren 0 12

13 Wärmeausbreitung auf der GPU Konvergierter Zustand In jede Zelle fliesst genausoviel Wärme herein wie heraus c = Δf = Wird nach vielen Iterationen erreicht D Grid, Blockaufteilung beliebig Jeder Thread berechnet eine Zelle Umsetzung mit Texturspeicher (Cache ausnutzen) Ping-PongP Rendering 2. Iteration 13

14 KernelFunktion Blend global void blend_kernel( float *dst, bool dstout ) { // map from threadidx/blockidx to pixel position int x = threadidx.x + blockidx.x * blockdim.x; int y = threadidx.y + blockidx.y * blockdim.y; int offset = x + y * blockdim.x * griddim.x; // 1D Textur int left = offset - 1; // Randbehandlung int right = offset + 1; if (x == 0) left++; if (x == DIM-1) right--; int top = offset - DIM; int bottom = offset + DIM; if (y == 0) top += DIM; if (y == DIM-1) bottom -= DIM; 14

15 KernelFunktion Blend (2) } float t, l, c, r, b; if (dstout) { // Ping-Pong Rendering t = tex1dfetch(texin,top); // texin = source texture l = tex1dfetch(texin,left); c = tex1dfetch(texin,offset); r = tex1dfetch(texin,right); b = tex1dfetch(texin,bottom); } else { t = tex1dfetch(texout,top); // texout = source texture l = tex1dfetch(texout,left); c = tex1dfetch(texout,offset); r = tex1dfetch(texout,right); b = tex1dfetch(texout,bottom); } dst[offset] = c + SPEED * (t+b+r+l * c); // Übertragung 15

16 KernelFunktion CopyConstC // konstante Wärmequellen in jeder Iteration einfuegen global void copy_const_kernel( float *iptr ) { // map from threadidx/blockidx to pixel position int x = threadidx.x + blockidx.x * blockdim.x; int y = threadidx.y + blockidx.y * blockdim.y; int offset = x + y * blockdim.x * griddim.x; } float c = tex1dfetch(texconstsrc,offset); if (c!= 0) iptr[offset] = c; 16

17 Display Funktion void display() { if (dstout) { in = dev_insrc; // Speicheradresse fuer Textur1 out = dev_outsrc; // Speicheradresse fuer Textur2 } else { out = dev_insrc; in = dev_outsrc; } copy_const_kernel<<<blocks,threads>>>( in ); blend_kernel<<<blocks,threads>>>( out, dstout ); dstout =!dstout; // Ping-Pong } 17

18 Bi Beispiel ilwärmeausbreitung Zeit 18

19 N-Body Problem

20 N-Body Problem Gegeben: N Partikel Jedes Partikel hat eine Masse m und wirkt (Gravitations-)Kraft auf alle anderen Partikel aus Gesucht: Position und Geschwindigkeit der Partikel zu Zeitpunkt t Gravitation F = G ij m m i 2 ij r j G = Gravitationskonstante 20

21 Gesamtkraft als Vektor v F ij = G m m m m v r i j i j ij rij,0 = G = 2 2 ij rij rij r v G m m i r 3 ij j v r ij v N v F i = F ij j= 1 F v F v 1 12 F v 13 F v 14 Um die Singularität ität bei r = 0 zu vermeiden, kann z.b. eine Konstante im Nenner addiert werden 21

22 Physikalische h Größen Zur Bewegung gder Partikel benötigen wir einige physikalische Grundgesetze v F = v a = v = v ma v dv dt dx v dt Kraft = Masse * Beschleunigung Beschleunigung g = Änderung Geschwindigkeit pro Zeit Geschwindigkeit = Änderung Position pro Zeit 22

23 Physikalische h Größen Die (Gesamt-)Kraft auf ein Partikel muß in eine Änderung der Position und Geschwindigkeit des Partikels umgerechnet werden v a ( t ) v F( t) m = Beschleunigung aus Kraft bestimmen v v v ( t + dt) = ( t) + a( t) dt Neue Geschwindigkeit v v v x ( t + dt) = x( t) + ( t) dt Neue Position (hier kann auch schon v(t+dt) verwendet werden) 23

24 N-Body einfacher Pseudocode d calcforces for all particles i { F_i = 0 for all particles j{ F_ij = G * m_i * m_j / (r*r) F_i += F_ij } } integrate for all particles i { a_i = F_i / m_i v_i = v_i + a_i * dt x_i = x_i + v_i * dt } Die Dauer des Zeitschritts dt wird durch den Benutzer vorgegeben main for (t = 1.. numtimesteps) { calcforces integrate draw } v ( t 2 ) v ( t 1 ) v x v ( t 1 ) x(t 0 ) x v ( t 2 ) 24

25 N-Body erste Idee calcforces: Ersetze die äußere Schleife (for all particles i ) durch N parallele Threads Jeder Thread wertet die innere Schleife aus, im Idealfall ll gilt dann O(N*N) O(N) integrate: ebenfalls durch N parallele Threads berechnen 1D Grid, N Threads, Blockaufteilung (zunächst) beliebig 25

26 Berechnung der Kräfte (einfache Version) global void calcforcessimple(float4* positions, float4* forces, float mass, int numbodies) { int index = blockidx.x * blockdim.x + threadidx.x; float4 pos = positions[index]; float4 force = make_float4(0.0f, 0.0f, 0.0f, 0.0f); float4 r; float G = 1.0f / f; // set G to arbitrary constant float softeningsquared = 0.01; for (int j = 0 ; j < numbodies ; j++) { r.x = positions[j].x - pos.x; r.y = positions[j].y - pos.y; r.z = positions[j].z - pos.z; float distsqr = r.x * r.x + r.y * r.y + r.z * r.z; distsqr += softeningsquared; float invdist = 1.0f / sqrtf(distsqr); float invdistcube = invdist * invdist * invdist; float scale = mass * mass *G G; force.x += scale * invdistcube * r.x; force.y += scale * invdistcube * r.y; force.z += scale * invdistcube * r.z; } forces[index].x = force.x; forces[index].y = force.y; forces[index].z = force.z; GPU } Programmierung v F ij = G m m i 3 ij r j v r Leider keine Vektor-Operatoren in CUDA Aber: Operatoren können überladen werden ij 26

27 Berechnung neue Positionen i /Geschwindigkeiten i global void integratebodies(float4* newposdev, float4* newveldev, float4* oldposdev, float4* oldveldev, float4* forcesdev, float mass, float deltatime) { int index = blockidx.x * blockdim.x + threadidx.x; float4 pos = oldposdev[index]; float4 vel = oldveldev[index]; float4 force = forcesdev[index]; } v F ) m float4 newvel, accel; accel.x = force.x / mass; v F ( t accel.y = force.y / mass; a( t) = accel.z = force.z / mass; newvel.x = vel.x + accel.x * deltatime; newvel.y = vel.y + accel.y * deltatime; newvel.z = vel.z + accel.z * deltatime; newveldev[index].x = newvel.x; newveldev[index].y VlD = newvel.y; Vl newveldev[index].z = newvel.z; newposdev[index].x = pos.x + newvel.x * deltatime; newposdev[index].y ]y= pos.y + newvel.y * deltatime; newposdev[index].z = pos.z + newvel.z * deltatime; v v v ( t + dt) = ( t) + a( t) dt v v x ( t + dt ) = x ( t ) + v ( t ) dt 27

28 N-Body Verbesserung Problem bei einfacher Variante: Es funktioniert, aber: Zu viele (langsame) Speicherzugriffe Jeder der N Threads liest die gleichen N Positionen aller Partikel N*N Speicherzugriffe iff [Nyland et al. GPU Gems 3] Verwende 1D Grid der Größe N / p, also p Threads pro Block Jeder Thread hat Schleife über alle Blöcke Pro Schleifendurchlauf: Jeder Thread berechnet nur die Interaktionen mit den p Partikeln des aktuellen Blocks Die Positionen der p Partikel werden dazu im Shared Memory eingetragen (jeder Thread kopiert einen Wert paralleles Lesen möglich, siehe nächste Vorlesung) Danach kommt der nächste Block dran (sync!) 28

29 N-Body Verbesserung schematisch h [Nyland et al. GPU Gems 3] 1. Lade Partikel 1-4 in Shared Memory (jeder Thread kopiert ein Partikel) 2. Sync 3. Berechne Kräfte der Partikel 1 4 (auf alle Partikel parallel) 4. Sync 5. Lade Partikel 5 8 ins Shared Memory (jeder Thread kopiert ein Partikel) 6. Sync 7. Berechne Kräfte der Partikel 5 8 (auf alle Partikel parallel) 8. Sync 29

30 Berechnung der Kräfte mit Shared Memory Kernel enthält Schleife über alle Blöcke (tiles) Shared Memory wird mit Positionen gefüllt Berechnung der Kräfte von Partikeln aus Shared Memory global void calcforces(float4* positions, float4* forces, float mass, int numbodies) { shared float4 positioncache[blocksize]; int index = blockidx.x * blockdim.x + threadidx.x; float4 pos = positions[index]; float4 force = make_float4(0.0f, 0f 0.0f, 0f 0.0f, 0f 0.0f); 0f); float4 r; float G = 1.0f / f; // set G to arbitrary constant float softeningsquared = 0.01; for (int tile = 0 ; tile < griddim.x ; tile++) { positioncache[threadidx.x] = positions[tile * blockdim.x + threadidx.x]; syncthreads(); 30

31 Berechnung der Kräfte mit Shared Memory for (int j = 0 ; j < blockdim.x ; j++) { r.x = positioncache[j].x - pos.x; r.y = positioncache[j].y - pos.y; r.z = positioncache[j].z - pos.z; float distsqr = r.x * r.x + r.y * r.y + r.z * r.z; distsqr += softeningsquared; float invdist = 1.0f / sqrtf(distsqr); float invdistcube = invdist * invdist * invdist; float scale = mass * mass * G; v F ij = G m im j 3 r ij v r ij force.x += scale * invdistcube * r.x; force.y += scale * invdistcube * r.y; force.z += scale * invdistcube * r.z; } } syncthreads(); } forces[index].x = force.x; forces[index].y ]y= force.y; forces[index].z = force.z; forces[index].w = 0.0f; 31

32 Zi Zeitmessung Laptop, NV 9600M GT 4096 Partikel Messung für Kernel Aufruf von calcforces & integrate Ohne Shared Memory: ~58 ms Mit Shared Memory: ca 8 x schneller Genauere Untersuchung: siehe [Nyland et al. GPU Gems 3] BlockSize Zeit (ms) mit Shared Memory Viele Sync Aufrufe nicht alle Multiprozessoren ausgelastet 32

33 NB Body Partikel [Nyland et al. GPU Gems 3] Partikel 2^28 = 256 Millionen Interaktionen NV 8800 GPU: ca. 10 Billionen Interaktionen pro Sekunde NV 8800 GPU ca. 50x schneller als CPU 33

34 Erweiterungen Die hier verwendete Integration ist eine einfache Euler- Integration Es muss ein kleiner Zeitschritt gewählt werden, sonst driften die berechneten Positionen immer weiter von der exakten Lösung weg Schlauere Integrationsverfahren Predictor-Corrector, Runge-Kutta, Bei der Berechnung der Kräfte müssen nicht unbedingt alle N*N Kombinationen berechnet werden Verschiedene Ansätze, durch hcluster-bildung die Anzahl zu reduzieren (ersetze Gruppe von M entfernten Partikeln durch ein Partikel mit Gesamtmasse nur kleiner Fehler) [Yokota and Barba, GPU Computing Gems 2011][Barnes and Hut 1986][Greengard and Rokhlin 1987] 34

35 Masse-Feder System

36 Masse-Feder Fd Systeme Deformierbare Oberfläche/Volumen aus Punkten Kräfte zwischen benachbarten Massepunkten Feder Federkraft prop. Auslenkung (Hooke sches Gesetz) Vergleich zu N-Body Nur direkte Nachbarn (z.b. 4) Kraft prop. r (statt 1/r*r) Gleiche Integration Beispiel: Stoff siehe Übung, oder Wasseroberfläche 36

37 Fd Federkraft Die Feder hat eine Originallänge g r0 Die Kraft ist proportional zur Auslenkung r - r0 Die Gesamtkraft auf Partikel i ergibt sich durch Summe über alle Kräfte der anhängenden Federn: v v F i = F ij j NachbarnN F v ij F x ij i = r ij,0 k ( r r 0) ij ij, F v x r ij r ij,0 ji k: Federkonstante j v F i = v m a i Umrechnung in Position, Geschwindigkeit: siehe N-Body (gleiche integrate-funktion) i v F ij x j x i = x j xi v v F ji = F ij F ij 37

38 Zusätzliche Kräfte Reibung: FR Wirkt entgegen zum Geschwindigkeitsvektor F v Proportional zum Betrag der ij Geschwindigkeit Dämpfung, sonst endlose F v Ri x i Schwingung v F R Gravitation: FG v = μ Konstante t Kraft nach unten F v F G = 0 0 mg v F G v r i x j 38

39 Bi Beispiel: ilcloth hsimulation i Federkräfte, Dämpfung, Gravitation (außer an zwei Eckpunkten, hier wird dastuch festgehalten) Siehe Übung 39

40 Micro Rendering

41 Vergleich hlokale l globale l Beleuchtung Globale Beleuchtung Simulation aller Lichtwege von der Lichtquelle bis zum Auge Indirektes Licht, Spiegelungen, weiche Schatten, Ziele: Photorealistische Darstellung Echtzeitdarstellung, also mind. 25 Bilder / sek. Virtuelle 3D Szene, keine Beleuchtung Lokale Beleuchtung: Nur direktes Licht Schnell, aber künstlich Globale Beleuchtung: Photorealistisch, aber zeitaufwändig 41

42 Globale l Beleuchtung Direktes Licht Lichtquelle Reflexion an Oberfläche Auge Einfach zu berechnen Indirektes Licht Lichtquelle mehrfach an Oberfläche reflektiert Auge Schwierig zu berechnen Licht an einem Punkt hängt L o von Licht an allen anderen b v v ω i Punkten ab ωo Integralgleichung x L o v ( x, ω ) o v v v v v = L ( x, ω ) + f ( x, ω, ω ) cosθ L ( x, ω ) dω e o 2π sr r Das Licht an einem Punkt x in Richtung des Betrachters ergibt sich aus der Eigenemission i i an x plus dem Licht aus allen einfallenden Richtungen, das in Richtung des Betrachters reflektiert wird Siehe Master-Vorlesung Photorealistische Computergrafik i o f r i i y L i i 42

43 Indirektes Licht kann man z.b. so berechnen Pro Pixel im Bild wird die Szene mit direkte Licht aus der Sicht des zugehörigen 3D-Punkts tsgezeichnet ec et( (Blickrichtung c = Flächennormale) ae) Für den Punkt y (vorige Folie) wird also nur das direkte Licht berechnet Das indirekte Licht (1 x reflektiert) am 3D-Punkt ergibt sich dann als Summe der Pixelhelligkeiten 43

44 Indirektes Licht mit CUDA Idee: Parallel pro Pixel das Bild zeichnen (1 Thread pro Pixel) Direktes Rendering mit CUDA schwierig Also: alternative Darstellung der Szene 44

45 QSplat Schnelles Rendering von grossen Punkt-Modellen Punkthierarchie Genauer: oriented disks Berechne Cut durch Punkthierarchie Wenn ein innerer Knoten auf nur ein Pixel abgebildet wird, keine weitere Traversierung des Teilbaums Cut QSplat: Insgesamt 127 Mio Punkte Nur ~300k gezeichnet 5-10 fps Szymon Rusinkiewicz and Marc Levoy: QSplat: A Multiresolution Point Rendering System for Large Meshes SIGGRAPH 2001 Michelangelo: St. Mathew (unfinished) Before

46 Indirektes Licht mit CUDA Idee: Verwende beleuchtete Punkthierarchie mit direktem Licht Jeder Thread traversiert die Hierarchie Splatting in eigenen, kleinen Framebuffer pro Pixel (= 2D Array im Thread) Danach hberechnet jeder Thread ddie Summe aller Werte im 2D Array (= Reduce) 46

47 Micro Rendering Pro Pixel im Bild wird das direkte Licht aus der Sicht des zugehörigen 3D- Punkts in den Micro coframebuffer e gezeichnet e et (mit z-buffer) Dazu wird die beleuchtete Punkthierarchie traversiert Das indirekte Licht am 3D-Punkt ergibt sich dann als Summe der Micro-Pixel [Ritschel, Engelhardt, Grosch, Seidel, Kautz, Dachsbacher] SIGGRAPH ASIA

48 Traversierung Hierarchie Keine Rekursion auf der GPU Baumtraversierung schwierig Alternative: ti Baumtraversierung durch eigenen Stack Oder: Child- und Skip-Pointer 48

49 Child / Skip Pointer Traversierung ohne Stack möglich Child: linkes Kind Skip: Knoten, bei dem die Traversierung fortsetzt, wenn der Teilbaum unterhalb des aktuellen Knotens übersprungen wird Knoten werden in 1D Array gespeichert Vorberechnung (CPU), Baum bleibt statisch Traversierung kompletter Baum: falls Child!= NULL : verfolge Child-Pointer sonst: verfolge Skip-Pointer QSplat Falls Projektion von aktuellem Knoten > 1 Pixel : Verfolge Child-Pointer Sonst : Zeichne Pixel Verfolge Skip-Pointer 49

50 Micro Rendering Video 50

51 Micro Rendering Hierarchie 51

52 Glossy Final Gather Photon Mapping Simulation (CPU, offline) Export von beleuchteten (diffusen) Surfels Glossy Final Gather mit Micro Rendering, 2 fps 52

53 Micro Rendering Vergleich Micro Rendering Path Tracing Referenzlösung, Minuten-Stunden (Monte-Carlo-Simulation) 53

54 Zusammenfassung Diverse physikalische Simulationen: Heat, N-Body, Masse- Feder, Lichtsimulation (Microrendering) CUDA-OpenGL Nächste Woche: Ki Keine Vorlesung (Pfingsten), aber Übung In zwei Wochen: letzte reguläre Vorlesung: z.b. GPU Sortierverfahren In drei Wochen: Keine Vorlesung Danach noch eine Vorlesung mit Wiederholung & Fragen zur Klausur 54