< CUDA implementation>

Präsentation zum Thema: "< CUDA implementation>"—  Präsentation transkript:

1 < CUDA implementation>
2D-Heat equation < CUDA implementation>

2 Überblick Definition Diskretisierung Iterationsverfahren
Mapping auf Cuda Implementierung Optimierung Performance Vergleiche Probleme Demo

3 Definition Mathematische Definition (2D):
Beschreibt den Temperaturverlauf der - Fläche über der Zeit . Anwendungen in: Finanz Mathematik Statistik Physik, Chemie heat equation: zu Deutsch: Wärmeleitungsgleichung partielle DGL, weil partielle Ableitungen nach mehreren Argumenten vorkommen (Vgl. gewöhnliche DGL: Ableitungen nach nur einer Variablen) wie die meisten partiellen DGL dient sie zur Modellierung physikalischer Vorgänge -> sie beschreibt den Temperaturverlauf einer 2D-Ebene über der Zeit (heat source vorausgesetzt, also eine bestimmte Anfangsbedingung) Anwendung in der Physik selbst oder Maschinenbau, um den Temperaturverlauf eines Körpers (3D), einer Fläche (2D) oder eines Stabes (1D) zu simulieren (im Prinzip beliebige Dimensionen möglich, aber in der Praxis unüblich, weil wir uns kein 4-dimensionales Objekt vorstellen können in dem sich die Temperatur verteilt) k~ fungiert dabei als Materialkonstante auch möglich in der Bildverarbeitung, weil ein Smoothing der Werte erzeugt wird 3

4 Überblick Definition Diskretisierung Iterationsverfahren
Mapping auf Cuda Implementierung Optimierung Performance Vergleiche Probleme Demo 4

5 Diskretisierung Diskretisierung des Gebietes
Finite Differenzen Methode (FDM) Die Lösung dieser partiellen Differenzialgleichung ergibt eine Formel, die mir die Temperatur für die 2D-Fläche in Abhängigkeit von der Zeit berechnet (Anfangsbedingung vorausgesetzt) Lösungstheorie von partiellen Differentialgleichungen: für lineare Gleichungen weitgehend mathematisch erforscht für nichtlineare Gleichungen enthält die mathematische Theorie noch große Lücken praktische Berechnung von Lösungen werden in der Regel mit numerischen Verfahren durchgeführt numerische Verfahren: finite Elemente Methode finite Differenzen Methode finite Volumina Methode -> all diese Verfahren basieren auf einer Diskretisierung der partiellen DGL und die Lösung wird dann mit Hilfe eines endlichdimensionalen Gebildes approximiert (auch Gitter genannt) das Gebiet (wo die DGL gelten soll, also Def.Bereich) wird in eine endliche (finite) Zahl von Gitterpunkten zerlegt Schrittweite k auf der Zeitachse Schrittweite h auf der x- u. y-Achse Finite Differenzen Methode: Vorwärtsdifferenz Rückwärtsdifferenz zentrale Differenz (beste numerische Stabilität) für 2. Ableitung nach y analog 5

6 Überblick Definition Diskretisierung Iterationsverfahren
Mapping auf Cuda Implementierung Optimierung Performance Vergleiche Probleme Demo 6

7 Iterationsverfahren Einsetzen in die DGL ergibt finiten Differenzenstern Filtern des „Bildes“ mit diesem Filterkernel ergibt einen Zeitschritt Berechnungsverfahren: Jacobiverfahren  gut parallelisierbar Gauß-Seidel Verfahren  schlecht parallelisierbar Einsetzen der finiten Differenzen in die Differenzialgleichung und auflösen nach dem Wert für den nächsten Zeitschritt mit dem entstehenden Differenzenstern muss man dann nur noch über das Bild filtern und erhält die Werte für den nächsten Zeitschritt iteratives Vorgehen zur Berechnung des konvergenten Verhaltens bei einer heat-source (sonst Ausgleichen) Jacobiverfahren (Pixel können unabhängig voneinander berechnet werden) rechnet aktuelle Werte unabhängig von zuvor berechneten Werten aus -> gute Parallelisierbarkeit, da keine Datenabhängigkeiten (aber schlechteres Konvergenzverhalten, als Gauß-Seidel) Gauß-Seidel Verfahren (Pixel sind abhängig voneinander) bezieht gerade berechnete Werte in die Berechnung der folgenden Werte mit ein -> konvergiert schneller als Jacobi, aber schlecht parallelisierbar, da Datenabhängigkeiten 7

8 Überblick Definition Diskretisierung Iterationsverfahren
Mapping auf Cuda Implementierung Optimierung Performance Vergleiche Probleme Demo 8

9 Mapping auf Cuda Durch Jacobiverfahren können viele Pixel unabhängig voneinander berechnet werden Kernel (Thread) berechnet ein gefiltertes Pixel Benötigt 4 umliegende Werte und sich selbst Grid berechnet eine Iteration (einen Filterdurchlauf) Bild wird in Blöcke zerlegt Anzahl der Iterationen (Filteraufrufe) bestimmt die simulierte Zeit der zu lösenden heat equation „Bild“ ist quasi die Anfangsbedingung (Randbedingung) der heat-equation, die heat-source, die nur am Rand ist und erhalten bleiben soll, deshalb darf der Rand nicht überschrieben werden nach endlichen vielen Iterationen konvergieren die inneren Werte (hoffentlich ;)) 9

10 Überblick Definition Diskretisierung Iterationsverfahren
Mapping auf Cuda Implementierung Optimierung Performance Vergleiche Probleme Demo 10

11 heat.cu void heat() { // Kernel Konfiguration
dim3 block(BLOCK_SIZE_X, BLOCK_SIZE_Y, 1); dim3 grid(width / block.x, height / block.y, 1); // Filteraufruf for(i = 0; i < iterations; i++) { filter<<<grid, block>>>(d_src, d_dst, width, height); // Pointeraustausch tmp = d_src; d_src = d_dst; d_dst = tmp; }

12 heat_kernel.cu (global)
__global__ void filter_global(float* d_src, float* d_dst, int width, int height) { // Referenz ist linke obere Ecke des Filter Kernels int x = blockIdx.x * blockDim.x + threadIdx.x; int y = blockIdx.y * blockDim.y + threadIdx.y; int i = y * width + x; if(x < width - 2 && y < height - 2) { float sum = 0.0; // oben sum += 0.25 * d_src[i + 1]; // links sum += 0.25 * d_src[i + width]; // rechts sum += 0.25 * d_src[i + width + 2]; // unten sum += 0.25 * d_src[i + 2 * width + 1]; // Mitte schreiben d_dst[i + width + 1] = sum; }

13 heat_kernel.cu (shared)
__shared__ float img_block[BLOCK_SIZE_X + 2][BLOCK_SIZE_Y + 2]; img_block[tx + 1][ty + 1] = d_src[i]; // Mitte lesen __syncthreads(); if(x > 0 && x < width - 1 && y > 0 && y < height - 1) {//Bildrand nicht if(tx == 0) { verändern img_block[tx][ty + 1] = d_src[i - 1]; // links } else if(tx == blockDim.x - 1) { img_block[tx + 2][ty + 1] = d_src[i + 1]; // rechts } if(ty == 0) { img_block[tx + 1][ty] = d_src[i - width]; // oben } else if(ty == blockDim.y - 1) { img_block[tx + 1][ty + 2] = d_src[i + width]; // unten // Rechnen float sum = 0.0; sum += 0.25 * img_block[tx][ty + 1]; sum += 0.25 * img_block[tx + 2][ty + 1]; sum += 0.25 * img_block[tx + 1][ty]; sum += 0.25 * img_block[tx + 1][ty + 2]; d_dst[i] = sum; // Zurückschreiben

14 Überblick Definition Diskretisierung Iterationsverfahren
Mapping auf Cuda Implementierung Optimierung Performance Vergleiche Probleme Demo 14

15 Optimierung Speicherzugriffe zw. Host u. Device
Durch umbiegen der Zeiger minimiert Shared memory verwendet Coalscaled Speicherzugiff 32 * 4 Byte = 128 Byte werden pro Warp linear gelesen Startadresse des source-images ist ganzzahliges Vielfaches von 128 Rechnen auf Shared Memory schneller Occupancy maximiert Beste Kernel Konfiguration für unser Problem gefunden - Branching bei Shared verschlechtert, da mehr if-Abfragen als bei global memory

16 Überblick Definition Diskretisierung Iterationsverfahren
Mapping auf Cuda Implementierung Optimierung Performance Vergleiche Probleme Demo 16

17 Messungen Global Memory
8X – 8Y Bildgröße Zeit [ms] 64 x 64 0.0139 128 x 128 0.0532 256 x 256 0.2200 512 x 512 0.9000 1024 x 1024 3.6000 2048 x 2048 16X – 8Y Bildgröße Zeit [ms] 64 x 64 0.0129 128 x 128 0.0478 256 x 256 0.1897 512 x 512 0.7576 1024 x 1024 3.0500 2048 x 2048 16X – 16Y Bildgröße Zeit [ms] 64 x 64 0.0130 128 x 128 0.0500 256 x 256 0.1900 512 x 512 0.7560 1024 x 1024 3.0300 2048 x 2048

18 Messungen Shared Memory
8X – 8Y Bildgröße Zeit [ms] 64 x 64 0.0083 128 x 128 0.0280 256 x 256 0.1160 512 x 512 0.4540 1024 x 1024 1.8000 2048 x 2048 7.3000 16X – 8Y Bildgröße Zeit [ms] 64 x 64 0.0044 128 x 128 0.0096 256 x 256 0.0260 512 x 512 0.0940 1024 x 1024 0.3690 2048 x 2048 1.4700 16X – 16Y Bildgröße Zeit [ms] 64 x 64 0.0044 128 x 128 0.0100 256 x 256 0.0270 512 x 512 0.0980 1024 x 1024 0.3800 2048 x 2048 1.5540

19 Global vs. Shared Global Memory (16X – 8Y) Shared Memory (16X – 8Y)
Bildgröße Zeit [ms] 64 x 64 0.0129 128 x 128 0.0478 256 x 256 0.1897 512 x 512 0.7576 1024 x 1024 3.0500 2048 x 2048 Shared Memory (16X – 8Y) Bildgröße Zeit [ms] 64 x 64 0.0044 128 x 128 0.0096 256 x 256 0.0260 512 x 512 0.0940 1024 x 1024 0.3690 2048 x 2048 1.4700

20 GPU vs. CPU Single Core (faui07g) : Intel Pentium 4 → 2.4 GHz
Dual Core (faui08) : AMD Opteron → 2.2 GHz Quad Core (faui06i): Intel Q6600 → 2.4 GHz Device GFLOPS Single Core ~ 0.084 Dual Core ~ 0.384 Quad Core ~ 0.225 GPU ~ 22.78

21 Überblick Definition Diskretisierung Iterationsverfahren
Mapping auf Cuda Implementierung Optimierung Performance Vergleiche Probleme Demo 21

22 Probleme Bildgrößen nur als Vielfaches von Blockgröße möglich
Zeiten messen Timer in cuda hat inkonsistente Zeiten geliefert Profiler liefert bessere Ergebnisse Teilweise Branching und Bankkonflikte nicht vermeidbar

23 Überblick Definition Diskretisierung Iterationsverfahren
Mapping auf Cuda Implementierung Optimierung Performance Vergleiche Probleme Demo 23

24 Demo Sascha …

25 → → ? →