Benjamin Herrmann computer graphics & visualization Physics Based Simulation on GPUs

Benjamin HerrmannBenjamin Herrmann

computer graphics & visualizationcomputer graphics & visualization

Physics Based Simulation on GPU‘s



TechnologieTechnologie

MemoryObjects (OpenGL):MemoryObjects (OpenGL):- TexturTextur

- Render TargetRender Target

- Vertex ArrayVertex Array

Verwendungsunabhängiger Speicherblock auf Verwendungsunabhängiger Speicherblock auf Graphikkarte Graphikkarte

Hauptprogrammlogik in Fragment-ProgrammHauptprogrammlogik in Fragment-Programm

Simulation (praktisch) ohne Simulation (praktisch) ohne Datentransfer CPU GPUDatentransfer CPU GPU



KörperdarstellungKörperdarstellung

- Körper als Massenpunkte (Partikel) mit Distanz-Körper als Massenpunkte (Partikel) mit Distanz-Bedingung zwischen je zwei PartikelnBedingung zwischen je zwei Partikeln

- Entspricht ungerichtetem Graphen mit Knoten- und Entspricht ungerichtetem Graphen mit Knoten- und KantenbelegungKantenbelegung



Partikel-SystemPartikel-System

- Hier besteht ein Partikel-System ausHier besteht ein Partikel-System aus- Partikeln mit den Attributen:Partikeln mit den Attributen:

- Masse (tatsächlich wird deren Reziprokes gespeichert)Masse (tatsächlich wird deren Reziprokes gespeichert)- Position (3 Freiheitsgrade pro Partikel)Position (3 Freiheitsgrade pro Partikel)- Alte Position (für Verlet Integrations Schema)Alte Position (für Verlet Integrations Schema)- Beschleunigung (ergibt sich als Summe aller externen Kräfte Beschleunigung (ergibt sich als Summe aller externen Kräfte

auf den Partikel unter Berücksichtigung seiner Masse)auf den Partikel unter Berücksichtigung seiner Masse)- Normalen Vektor (3 Komponenten, zum Rendern und für Normalen Vektor (3 Komponenten, zum Rendern und für

einige Collision Responses)einige Collision Responses)

- Constraints mit den Attributen:Constraints mit den Attributen:- Index des Start PartikelsIndex des Start Partikels- Index des End PartikelsIndex des End Partikels- (Anfangs-) Länge(Anfangs-) Länge



InhaltInhalt

Grobe Gliederung (Komponenten):Grobe Gliederung (Komponenten):- Verlet IntegrationVerlet Integration

- Constraint SolverConstraint Solver

- Collision-Detection und Collision-ResponseCollision-Detection und Collision-Response



Verlet IntegrationVerlet Integration

- Unabhängig für jeden Partikel (unconstrained Unabhängig für jeden Partikel (unconstrained dynamics)dynamics)

- Speichere zum Zeitpunkt t pro Partikel: Speichere zum Zeitpunkt t pro Partikel: xx(t) und (t) und xx(t-(t-t)t)

- Nur implizite Geschwindigkeit (vgl. Euler: Nur implizite Geschwindigkeit (vgl. Euler: Geschwindigkeit und Position separat aktualisiert)Geschwindigkeit und Position separat aktualisiert)

- Damit Geschwindigkeit immer an tatsächliche Damit Geschwindigkeit immer an tatsächliche Bewegung angepasstBewegung angepasst



Intuitiv:Intuitiv:

Fehlerentwicklung (für xFehlerentwicklung (für x11,x,x22 und x und x33, x, x00=0)=0)

2)(2

1)()()()( tttttttt axxxx


v

t

0 = t0t

t1 t2 t3v0

v2

v1

v3

12 xx 01 xx

212

1ta

222

1ta

202

1t a 2

02

1t a

212

1t a




Korrekt:Korrekt:

Fehlerentwicklung (für xFehlerentwicklung (für x11,x,x22 und x und x33, x, x00=0)=0)

v

t0 = t0 t

t1 t2 t3v0

v2

v1

v3

12 xx 01 xx

21 ta

22 ta

20 ta

202

1ta 2

12

1ta 2

22

1ta

2)()()()()( tttttttt axxxx



Verlet Integration - ImplementierungVerlet Integration - Implementierung

Texture coordinate (si,ti)identifying particle i

GL_

QU

AD

Ver

tex

shad

er

rast

eriz

atio

n

Fragment shader

Out

put o

f ra

ste

rizat

ion

Ren

der

Tar

get

Constants:

Time-interval

Verlet-drag-factor d

old positions)( ttii xo

oix oi

y oiz 1/mi ci

x ciy ci

z 1/mi

current positions)(tii xc

aix ai

y aiz

accelerations)(tia 2)( taocdcr yyyyy

i

2)( taocdcr xxxxxi

2)( taocdcr zzzzzi

rix riy riz 1/mi



Verlet Integration - ImplementierungVerlet Integration - Implementierung

- Benötige MemoryObjects für folgende Benötige MemoryObjects für folgende Partikelattribute:Partikelattribute:- „„Aktuelle“ Positionen aller PartikelAktuelle“ Positionen aller Partikel

- „„Alte“ Positionen aller PartikelAlte“ Positionen aller Partikel

- Beschleunigungen aller PartikelBeschleunigungen aller Partikel

- Massen aller Partikel (kann in beliebiger der obigen Massen aller Partikel (kann in beliebiger der obigen Texturen gespeichert werden)Texturen gespeichert werden)

- Zusätzliches MemoryObject für Ping-PongZusätzliches MemoryObject für Ping-Pong

- Zeigervertauschung, um die Partikelattribute für Zeigervertauschung, um die Partikelattribute für den nächsten Simulationsschritt zu aktualisieren:den nächsten Simulationsschritt zu aktualisieren:- Aktuelle Positionen <-> Alte PositionenAktuelle Positionen <-> Alte Positionen

- Aktuelle Positionen <-> Ergebnis der IntegrationAktuelle Positionen <-> Ergebnis der Integration




- WorldBox (AA): WorldBox (AA): wwminmin=(w=(wxx,w,wyy,w,wzz), ), wwmaxmax=(W=(Wxx,W,Wyy,W,Wzz))=> Projektion: => Projektion: minmin( ( maxmax((wwminmin,,xx(t)), (t)), wwmax max ))

- Reibung:Reibung:- Projektionstiefe berücksichtigenProjektionstiefe berücksichtigen

- Faktor d um Luftwiederstand zu simulierenFaktor d um Luftwiederstand zu simulieren

- Demo 1Demo 1



ConstraintsConstraints

- Hinzufügen topologischer Informationen, um Hinzufügen topologischer Informationen, um Festkörper zu simulierenFestkörper zu simulieren=> Distanz-Bedingungen zwischen je 2 Partikeln=> Distanz-Bedingungen zwischen je 2 Partikeln

- Lokale Lösung:Lokale Lösung:

Massen abhängig (Massen abhängig (xxjj analog): analog):

cij

pi

pj

cij

pi

pj

cij

pi

pj

ij

ij

ji

ijij

iii

mm

c

m xx

xxxxxx

)(

11

1'




- Globale Lösung für Distanz-Bedingungen durch:Globale Lösung für Distanz-Bedingungen durch:- Auflösen der lokalen Distanz-Bedingungen in fester Auflösen der lokalen Distanz-Bedingungen in fester

Reihenfolge (berücksichtigt aktuelle Positionen)Reihenfolge (berücksichtigt aktuelle Positionen)=> Es können nur unabhängige Constraints parallel => Es können nur unabhängige Constraints parallel verarbeitet werden (Matching):verarbeitet werden (Matching):

mindestens h interne Render Passes, wobei h der mindestens h interne Render Passes, wobei h der maximale Knotengrad ist.maximale Knotengrad ist.

v0

v3

v6 v7

v4

v1 v2

v5

v8

v0

v3

v6 v7

v4

v1 v2

v5

v8

v0

v3

v6 v7

v4

v1 v2

v5

v8

v0

v3

v6 v7

v4

v1 v2

v5

v8

v0

v3

v6 v7

v4

v1 v2

v5

v8

v0

v3

v6 v7

v4

v1 v2

v5

v8




- Paralleles Lösen aller lokalen Distanz-Bedingungen, indem Paralleles Lösen aller lokalen Distanz-Bedingungen, indem für jeden Constraint cfür jeden Constraint cijij der Ausgleichsvektor der Ausgleichsvektor

ermittelt wird. Aufsummieren und Mitteln (Stabilität) aller ermittelt wird. Aufsummieren und Mitteln (Stabilität) aller ddijij für die an einen Partikel angrenzende Kanten ergibt den für die an einen Partikel angrenzende Kanten ergibt den nötigen Offset pro Partikel (vgl. Feder-Masse System)nötigen Offset pro Partikel (vgl. Feder-Masse System)

=> „Durchhängen“ im=> „Durchhängen“ imGleichgewichtszustand:Gleichgewichtszustand:

ij

ij

ji

ijijij

mm

c

xx

xxxxd

)(

11

p3 (fixiert)

p2

p1

p0

g




- Datenstrukturen zur Speicherung der TopologieDatenstrukturen zur Speicherung der Topologie- Knotenbasiert:Knotenbasiert:

h Nachbarschafts-Texturen Nh Nachbarschafts-Texturen Nkk (1 (1kkh).h).Sei (sSei (sii,t,tii) die Textur Koordinate für Partikel i, dann ) die Textur Koordinate für Partikel i, dann

speichert Nspeichert Nkk in Texel (s in Texel (sii,t,tii) das Tupel (s) das Tupel (sjj,t,tjj,l,lijij), falls ), falls Partikel j Partikel j der k-te Nachbar von Partikel i ist.der k-te Nachbar von Partikel i ist.

- Kantenbasiert:Kantenbasiert:- Kantentextur, die für Kante cKantentextur, die für Kante cijij das Tupel (s das Tupel (sii,t,tii,s,sjj,t,tjj) speichert.) speichert.- Textur, die die Länge aller Kanten speichert.Textur, die die Länge aller Kanten speichert.

- Nachfolgend implementiert und besprochen:Nachfolgend implementiert und besprochen:- Knotenbasiert: unter Berücksichtigung der aktuellen Knotenbasiert: unter Berücksichtigung der aktuellen

PositionPosition

- Paralleles Auflösen der Constraints:Paralleles Auflösen der Constraints:- Kantenbasiertes GatheringKantenbasiertes Gathering- Kantenbasiertes ScatteringKantenbasiertes Scattering



Constraints – KnotenbasiertConstraints – Knotenbasiert

- Mit aktualisierten Positionen nur mit h internen Rendering Mit aktualisierten Positionen nur mit h internen Rendering Passes möglich!Passes möglich!

- Pro Pass müssen genau wPro Pass müssen genau wh Fragmente generiert werden, h Fragmente generiert werden, wobei w,h die Breite und Höhe der Partikel-Texturen sind.wobei w,h die Breite und Höhe der Partikel-Texturen sind.

- Pro Pass k und pro Partikel i:Pro Pass k und pro Partikel i:- 1 direkter Texture-fetch für die eigene Position1 direkter Texture-fetch für die eigene Position

- 1 dependant Texture-fetch für die Position des k-ten Nachbarn 1 dependant Texture-fetch für die Position des k-ten Nachbarn (aus N(aus Nkk))

- Berechnung der aktuellen Position von Partikel iBerechnung der aktuellen Position von Partikel i

- (1(1kkh): Nh): Nkk besteht nur aus vollständigen Kanten eines besteht nur aus vollständigen Kanten eines Matchings.Matchings.

- Zwischen zwei Rendering Passes: Ping-Pong, damit immer die Zwischen zwei Rendering Passes: Ping-Pong, damit immer die aktualisierten Positionen benutzt werden.aktualisierten Positionen benutzt werden.

- ddijij wird pro Kante zweimal berechnet => Kantenbasiert wird pro Kante zweimal berechnet => Kantenbasiert



Constraints – Kantenbasiert (Gathering)Constraints – Kantenbasiert (Gathering)

- 1. Rendering Pass rendert ein Fragment pro Kante 1. Rendering Pass rendert ein Fragment pro Kante ccijij und berechnet aus zwei dependant texture- und berechnet aus zwei dependant texture-fetches den Vektor fetches den Vektor ddijij..=> Offset Textur=> Offset Textur

- 2. Rendering Pass rendert ein Fragment pro 2. Rendering Pass rendert ein Fragment pro Partikel. Für alle Partikel i:Partikel. Für alle Partikel i:- Summiere die maximal h Offsetvektoren zu den zu i Summiere die maximal h Offsetvektoren zu den zu i

inzidenten Kanten. Dazu sind h Inzidenz-Texturen inzidenten Kanten. Dazu sind h Inzidenz-Texturen notwendig (vgl. Nachbarschafts-Texturen) sowie h notwendig (vgl. Nachbarschafts-Texturen) sowie h dependant texture-fetches.dependant texture-fetches.

- Teile den Gesamt-Offsetvektor durch den Grad des Teile den Gesamt-Offsetvektor durch den Grad des Partikels (entweder immer h oder mit in Inzidenz-Texturen Partikels (entweder immer h oder mit in Inzidenz-Texturen speichern).speichern).



Constraints – Kantenbasiert (Scattering)Constraints – Kantenbasiert (Scattering)

- 1. Rendering Pass wie vorher => Offset-Textur1. Rendering Pass wie vorher => Offset-Textur

- 2. Rendering Pass benutzt Kantentextur als 2. Rendering Pass benutzt Kantentextur als VertexArray und das Positions MemoryObject als VertexArray und das Positions MemoryObject als Render Target.Render Target.Clip Space Koordinaten entsprechend dem Start-Clip Space Koordinaten entsprechend dem Start-Knoten einer Kante generiert.Knoten einer Kante generiert.

- 3. Rendering Pass: wie 2. Pass aber mit End-Knoten.3. Rendering Pass: wie 2. Pass aber mit End-Knoten.

Anmerkung:Anmerkung:Clamping => Rendering Passes 2pos/2neg und- Clamping => Rendering Passes 2pos/2neg und- 3pos/3neg, welche positive/negative Komponenten 3pos/3neg, welche positive/negative Komponenten der Offset Vektoren in seperate Texturen blenden.der Offset Vektoren in seperate Texturen blenden.



Constraint - DemosConstraint - Demos

- Demo2:Demo2: ebenso wie Demo1 nur diesmal mit ebenso wie Demo1 nur diesmal mit eingeschaltetem Constraint Solvereingeschaltetem Constraint Solver

- Demo3: Demo3: KnotenbasiertKnotenbasiert

- Demo4: Demo4: Kantenbasiert – GatheringKantenbasiert – Gathering

- Demo5: Demo5: Scattering - ScatteringScattering - Scattering



Collision DetectionCollision Detection

- Partikelbasierte Kollisionserkennung => O(n²) Partikelbasierte Kollisionserkennung => O(n²) VergleicheVergleiche

- Binning der AABB des PartikelsystemsBinning der AABB des Partikelsystems- Reduziert die Anzahl der notwendigen PartikelvergleicheReduziert die Anzahl der notwendigen Partikelvergleiche

- Ggf. JitteringGgf. Jittering

- Größe der BinsGröße der Bins



Collision Detection - AABBCollision Detection - AABB

- Berechnung der AABB (Berechnung der AABB (BBminmin//BBmaxmax) auf GPU:) auf GPU:

- 2 Rendering Passes je aller Partikelpositionen auf ein 2 Rendering Passes je aller Partikelpositionen auf ein einzelnes Fragment mit blenden (Komponentenweise min einzelnes Fragment mit blenden (Komponentenweise min bzw. max)bzw. max)

- 2ln(max(w,h)) Rendering Passes über je (1/4)2ln(max(w,h)) Rendering Passes über je (1/4)kkwwh (k=1,...) h (k=1,...) Partikel:Partikel:

x10 x1

1

x12x1

3

x00 x0

1

x02x0

3

x = min(x , x , x , x )0

0 0 0 0

0 1 2 3

1

Candidate-fragments

...

w

h



Collision Detection – ImplementierungCollision Detection – Implementierung

1.1. Rendering Pass:Rendering Pass:Ordne jedem Partikel eine BinID zu =>Zuordnungs- Ordne jedem Partikel eine BinID zu =>Zuordnungs- MemoryObject. Texel ist Tupel (sMemoryObject. Texel ist Tupel (sii,t,tii,id),id)

2.2. Rendering Pass:Rendering Pass:- Benutze Zuordnungs-MemoryObject als VertexArrayBenutze Zuordnungs-MemoryObject als VertexArray

- Dereferenziere VertexArry als GL_POINTS.Dereferenziere VertexArry als GL_POINTS.

- Rendere in Bin MemoryObject (Einsortieren der Partikel).Rendere in Bin MemoryObject (Einsortieren der Partikel).

3.3. Rendering Pass:Rendering Pass:Benutze Bin MemoryObject und Zuordnungs Benutze Bin MemoryObject und Zuordnungs MemoryObject als Textur und rendere über alle MemoryObject als Textur und rendere über alle Partikel => Kontrolliere für jeden Partikel, ob Partikel => Kontrolliere für jeden Partikel, ob zugeordneter Bin bereits belegt ist.zugeordneter Bin bereits belegt ist.



Collision Detection – ImplementierungCollision Detection – Implementierung

1.1. Rendering Pass:Rendering Pass:Ordne jedem Partikel eine BinID zu =>Zuordnungs- Ordne jedem Partikel eine BinID zu =>Zuordnungs- MemoryObject. Texel ist Tupel (sMemoryObject. Texel ist Tupel (sii,t,tii,id),id)

2.2. Rendering Pass:Rendering Pass:- Benutze Zuordnungs-MemoryObject als VertexArrayBenutze Zuordnungs-MemoryObject als VertexArray

- Dereferenziere VertexArry als GL_POINTS.Dereferenziere VertexArry als GL_POINTS.

- Rendere in Bin MemoryObject (Einsortieren der Partikel)Rendere in Bin MemoryObject (Einsortieren der Partikel)..

3.3. Rendering Pass:Rendering Pass:Benutze Bin MemoryObject und Zuordnungs Benutze Bin MemoryObject und Zuordnungs MemoryObject als Textur und rendere über alle MemoryObject als Textur und rendere über alle Partikel => Kontrolliere für jeden Partikel, ob Partikel => Kontrolliere für jeden Partikel, ob zugeordneter Bin bereits belegt ist.zugeordneter Bin bereits belegt ist.



Collision Detection – Boolean BinningCollision Detection – Boolean Binning

- Bin MemoryObject hat GL_RGBA8 FormatBin MemoryObject hat GL_RGBA8 Format

- Jede 8-bit Komponente repräsentiert einen Bin Jede 8-bit Komponente repräsentiert einen Bin (Maske) und speichert die Anzahl der Partikel darin.(Maske) und speichert die Anzahl der Partikel darin.

- Alles größer 1 zählt als KollisionAlles größer 1 zählt als Kollision

- Rendern in Bin MemoryObject durch normales Rendern in Bin MemoryObject durch normales BlendingBlending

- Platzverbrauch ideal, aber kleine Bins nötigPlatzverbrauch ideal, aber kleine Bins nötig

- Nur Kollision Ja/Nein, keine Information über Nur Kollision Ja/Nein, keine Information über „Kollisions-Partner“„Kollisions-Partner“



Collision Detection – Stencil RoutingCollision Detection – Stencil Routing

- Implementiert für maximal 4 Partikel pro Bin Implementiert für maximal 4 Partikel pro Bin (beliebig auf x² Partikel erweiterbar)(beliebig auf x² Partikel erweiterbar)

- Bin MemoryObject benutzt Fließkomma-GenauigkeitBin MemoryObject benutzt Fließkomma-Genauigkeit

- Je 4 Texel entsprechen einem BinJe 4 Texel entsprechen einem Bin

- Statt einzelner Fragmente werden ‚Fat Points‘ Statt einzelner Fragmente werden ‚Fat Points‘ gerendert (hier: glPointSize(2.0f))gerendert (hier: glPointSize(2.0f))

- StencilBuffer vor Pass 2 (Einsortieren) vorbelegt mit StencilBuffer vor Pass 2 (Einsortieren) vorbelegt mit Muster:Muster:

-- Stencil-Test testet auf Stencil-Test testet auf Gleichheit mit 3Gleichheit mit 3

- - Stencil-Wert immer Stencil-Wert immer umum

1 erhöht1 erhöht

0

2

0

2

1

3

1

3

0

2

0

2

1

3

1

3




- Beispielablauf (Fragmentreihenfolge a priori unbekannt):Beispielablauf (Fragmentreihenfolge a priori unbekannt):

- Speichert Textur-Koordinaten der bis zu 4 Partikel pro Speichert Textur-Koordinaten der bis zu 4 Partikel pro Bin => beliebige Attribute des „Kollisions Partners“ Bin => beliebige Attribute des „Kollisions Partners“ zugreifbarzugreifbar

- 16 Mal größeres Bin MemoryObject als bei Boolean 16 Mal größeres Bin MemoryObject als bei Boolean Binning (sogar 64 Mal so viel Speicher)Binning (sogar 64 Mal so viel Speicher)

(0,0,0,0)(0,0,0,0)

(0,0,0,0) (s,t,0,0)

1 2

3 4

(0,0,0,0)(0,0,0,0)

(0,0,0,0) (0,0,0,0)

0 1

2 3

...




- Partikel i kollidiert mit Partikel j, falls:Partikel i kollidiert mit Partikel j, falls:- Textur-Koordinaten von beiden befinden sich im gleichen Textur-Koordinaten von beiden befinden sich im gleichen

BinBin

- Ihr Abstand ist geringer als eine vorgegebene Grenze Ihr Abstand ist geringer als eine vorgegebene Grenze (wichtig, wenn mehrere Bins auf den gleichen Fat-Point (wichtig, wenn mehrere Bins auf den gleichen Fat-Point gerendert werden)gerendert werden)

- Komplexere Kollisions-Bestimmung => Stencil Komplexere Kollisions-Bestimmung => Stencil Routing ist langsamer als Boolean BinningRouting ist langsamer als Boolean Binning

- Aber komplexere Collision-Responses möglich, die Aber komplexere Collision-Responses möglich, die Attribute des „Kollisions-Partners“ einbeziehen.Attribute des „Kollisions-Partners“ einbeziehen.Zum Beispiel:Zum Beispiel: - Position- Position

- (implizite) Geschwindigkeit- (implizite) Geschwindigkeit



Collision Detection – DemosCollision Detection – Demos

- Demo 6:Demo 6: Self-Collision bei Cloth (Nur Kollision-Self-Collision bei Cloth (Nur Kollision-erkennung, keine Response)erkennung, keine Response)

- Demo 7:Demo 7: Self-Collision bei Cloth (Collision-Self-Collision bei Cloth (Collision- Response Response stößt stößt Partikel ab)Partikel ab)

- Demo 8:Demo 8: Self-Collision bei Cloth (Collision-Self-Collision bei Cloth (Collision- Response Response ändert relativeändert relative

Geschwindigkeit)Geschwindigkeit)

- Demo 9:Demo 9: Kollision vieler Objekte (Collision-Kollision vieler Objekte (Collision-Response ändert Partikelpositionen)Response ändert Partikelpositionen)

- Demo 10:Demo 10: Kollision vieler Objekte (s.o., aberKollision vieler Objekte (s.o., aberanderer Kollisionsabstand)anderer Kollisionsabstand)

- Demo 11: Demo 11: Massenabhängigkeit (schwere Würfel)Massenabhängigkeit (schwere Würfel)

- Demo 12: Demo 12: Massenabhängigkeit (leichte Würfel)Massenabhängigkeit (leichte Würfel)



BemerkungenBemerkungen

- NormalenberechnungNormalenberechnung

- Wind: Skalarprodukt des (unnormalisierten) Wind-Wind: Skalarprodukt des (unnormalisierten) Wind-Vektors mit dem (unnormalisierten) Normalenvektor Vektors mit dem (unnormalisierten) Normalenvektor jedes Dreiecks.jedes Dreiecks.

- PerformancePerformance- Ping Pong vs. UnrollPing Pong vs. Unroll

- Taylorapproximation der Wurzelfunktion bei Constraint Taylorapproximation der Wurzelfunktion bei Constraint SolvernSolvern

- Index MemoryObject vs. system memory Index ArrayIndex MemoryObject vs. system memory Index Array

- Vertex Programm Bandbreite reduzieren: Bilineare Vertex Programm Bandbreite reduzieren: Bilineare Interpolations Textur (Geschwindigkeitsgewinn durch Interpolations Textur (Geschwindigkeitsgewinn durch geringere Auflösung wg. größerer Lokalität -> Caching)geringere Auflösung wg. größerer Lokalität -> Caching)

- GPU basiertes PickingGPU basiertes Picking



Letzte DemosLetzte Demos

- Demo 13:Demo 13: Fahne (Wind und Picking)Fahne (Wind und Picking)

- Demo 14:Demo 14: Performance LayoutPerformance Layout



128x128GPU

128x128CPU

256x256GPU

256x256CPU

512x512GPU

512x512CPU

Scattering 0.4fps - - - - -

Gathering 186fps 48.45fps 58fps 12.43fps 16.45fps 0.15fps

Knoten 282fps 76fps 108fps 19.38 28.25fps 0.18fps

+AABB 212fps 74fps 84fps 18.83 22.6fps 0.17fps

+BB 174fps 32fps 62fps 7.52fps 15.5fps -

+SR 116fps 32Fps 40.7fps 7.52fps 9.69fps -

PerformancePerformance

Alle Tests ohne Rendern und auf- Pentium 3.2 GHz mit 1.5 GB RAM- ATI X600 mit 256 MB TRAM



ZusammenfassungZusammenfassung

++ Weit schneller als die CPU-Implementierung der Weit schneller als die CPU-Implementierung der AlgorithmenAlgorithmen

++ Graphik Hardware Entwicklung verdreifacht Moore‘s Graphik Hardware Entwicklung verdreifacht Moore‘s LawLaw

–– Algorithmen stark vereinfachtAlgorithmen stark vereinfacht–– Partikelsystem, das unabhängig aktualisiert werden Partikelsystem, das unabhängig aktualisiert werden

kann ist sehr gut auf GPU zugeschnitten, ebenso kann ist sehr gut auf GPU zugeschnitten, ebenso sind komplexere Algorithmen mit zugeschnittenen sind komplexere Algorithmen mit zugeschnittenen Datenstrukturen denkbar bei denen eine CPU Datenstrukturen denkbar bei denen eine CPU Lösung (noch) besser abschneidetLösung (noch) besser abschneidet

=> => In Anbetracht der Entwicklung sind GPU In Anbetracht der Entwicklung sind GPU basierte basierte Simulationen allerdings sehr interessantSimulationen allerdings sehr interessant



Danke für die Aufmerksamkeit!Danke für die Aufmerksamkeit!

Fragen?Fragen?

Documents

Benjamin Herrmann computer graphics & visualization Physics Based Simulation on GPUs