Multi-Core Architectures and Programming. Bilateral Grid Filter

Transkript

1 Multi-Core Architectures and Programming Bilateral Grid Filter - Parallelisierung mit CUDA - C. Kugler und E. Sert

2 Inhalt Motivation Bilateral Filter (Exkurs) Bilateral Grid Filter Portierung auf Grafikkarte Verwendete Datenstrukturen Aufteilung der Threads Probleme Ergebnisse Fehlerabschätzung Zeitmessung Quellen 2

3 Motivation

4 Motivation Aufgenommene Bilder enthalten mehr oder weniger stark ausgeprägte Störungen/ Rauschen Möchte Bildqualität verbessern Rauschen entfernen und Kanten erhalten Echtzeit Anwendung (Medizin) Schnelligkeit 4

5 Bilateral Filter (Exkurs)

6 Bilateral Filter (Exkurs) Nonlinear Gaussian filter Gewichtung anisotrop Filter der Signale glättet und starke Kanten erhält Neben Nachbarschaft wird die Intensitätsdifferenz betrachtet Unterschied in Intensität Räumliche Entfernung s: Fenstergröße r: Gewichtung Intensitätsdifferenz Normalisierung [1] Seite 2 Bildquelle [4] 6

7 Bilateral Grid Filter (BGF)

8 Bilateral Grid Filter (3) Algorithmus in drei Schritten: 1) Aufbau des 3D-Gitters durch Down-Sampling der Daten 2) Glättung mit dreidimensionalem Kernel 3) Up-Sampling durch Interpolation und Dehomogenisierung Schnelligkeit durch Berechnung auf vermindertem Datensatz Interpolation führt zu gewissem Genauigkeitsverlust 8

9 3D-Gitter Erinnerung: s = Fenstergröße und r = Gewichtung Intensitätsdifferenz Anhand gegebener Werten für s und r werden die Gitterkoordinaten (xg, yg, zg) folgendermaßen aufgestellt: x + 0.5) s y = floor ( + 0.5) s I ( x, y) I min = floor ( + 0.5) r xg = floor ( yg zg Räumliche Dimension (x,y) wird s s große Zellen eingeteilt 9

10 Aufbau 3D-Gitter 3D Gitter (s = 2) 14 x 10 Pixel Sonderfall Rand Größe einer Zelle ½ * s 10

11 Aufbau 3D-Gitter 3D Gitter (s = 2) 14 x 10 Pixel Für jede Zelle wird Histogramm aus Intensitäten dieser erstellt werden entlang z-achse ausgelegt (3. Dimension) 11

12 Blur Entfernt Rauschen im Bild Gauss'scher Filter mit Kernel K der Größe 3x3x3 auf (x,y,z)- Dimensionen mit 2 Iterationen w=1 [ ] K= w=1 w=1 y z w=2 x w=1 w=1 w=1 (in 2D) (in 3D) Ergebnis entsteht durch iterative Ausführung des Filters Buffer muss nach jeder Iteration neu befüllt werden Bei der Parallelisierung ergibt sich dadurch eine Racing Condition 12

13 Interpolation und Dehomogenisierung Rekonstruktion von höher dimensionalen Daten (Ausgangsgröße des Bildes) trilineare Interpolation der Daten aus dem Gitter auf Basis der ursprünglichen Intensitäten Q = (1 Δz ) (Δ y (Δx P001 + (1 Δ x ) P101 ) + (1 Δy ) (Δx P (1 Δx ) P 111 )) + Δz (Δy (Δx P (1 Δx ) P 100 ) + (1 Δy ) (Δx P010 + (1 Δ x ) P110 )) mit Δx = x x0 y y 0 z z 0, Δy=, Δz=, P i ℕ3, Q ℕ2,. =Farbwert x1 x 0 y 1 y 0 z 1 z 0 Abschließende Normalisierung der Daten mit den Gewichten (z-komponente) aus dem vorherigen Schritt 13

14 Unterschied BGF und Gauss Gauss'scher Filter Filtergröße: 16x16 BGF s = 16 und r =

15 Portierung auf die Grafikkarte

16 Allgemeines (1) Verwendete Technologie: CUDA 5.0 / Nvidia Tesla C2050 Verwendete Datenstrukturen: CUDA Arrays und 3D-Texturen / -Surfaces (Surfaces ermöglichen Schreibzugriff auf Texturspeicher) Texturen / Surfaces müssen an Cuda Arrays gebunden werden 16

17 Allgemeines (2) Generelle Optimierungsstrategien: Minimierung von IO-Operationen (Bottleneck) Daten werden einmal hochgeladen und bleiben dort für den gesamten Berechnungszeitraum (Surface Textur) Vielfaches der Warp-Size als Blockgröße bei Kernel- Ausführung hier: keine Verbesserung der Performance Minimierung von arithmetischen Operationen und Fallunterscheidungen im Kernel 17

18 Datenstrukturen Reihenfolge Daten beachten 3. Dimension wird nur an dieser Stelle definiert Breite in Byte angeben (pitch) 18

19 Datenstrukturen Erstellte globale Surface-Referenz kann aus Kernel verwendet werden y Wert der float2 Variable wird sonst als int interpretiert Index x muss in Byte angegeben werden 19

20 Datenstrukturen Textur speichert Samples (nehmen keinen Raum ein im Gegensatz zu Pixeln) müssen Sample in Mitte abgreifen um exakten Pixel Wert zu erhalten 20

21 Verteilung der Threads Die Anzahl der gestarteten Threads wird auf die Dimension des Ausgabe-Bildes /-Gitters angepasst Gitter Aufbau (Down-Sampling): Thread pro Zelle im 2D-Raster des Gitters (pro Thread s s Pixel im Original Bild) Daten werden in einem 3D-Surface gespeichert Alternative: Thread pro Pixel und Atomics zur Synchronisation Unvorteilhaft, da hohe Konkurrenz zwischen Threads 21

22 Verteilung der Threads Glättung: Ein Thread pro Zelle im 3D Gitter Jede Dimension wird nacheinander 2 mal aufgerufen (wegen 2-facher Iteration) Vermeidung von Racing Condition Interpolation und Dehomogenisierung: Ein Thread pro Pixel Automatische Trilineare Interpolation wird durch Texturspeicher gewährleistet Wichtige Optimierung für die Performance Randbetrachtung fällt weg, da durch Texturkonfiguration festgelegt 22

23 Blockzuteilung im Kernel Down-Sampling (Glättung analog mit zusätzlicher Dimension) Aufteilung: ( width height) Blocks. x = T (width height ) Blocks. y = T (width+ Blocks. x 1) Blocks. x, T = max. Anzahl (height + Blocks. y 1) Threads pro Block Threads. y = Blocks. y Threads. x = Zugriff (Bestimmung von Array-Indices im Kernel): x T = (blockidx. x blockdim. x) + threadidx.x y T = (blockidx. y blockdim. y) + threadidx.y Ermöglicht einfache Berechnung der (x,y)-indices Achtung: Es werden fast immer zu viele Threads gestartet Grenzen prüfen 23

24 Probleme

25 Problem (1): Falscher Surface-Zugriff Gelesene und geschriebene Werte werden auf Int's gecastet erzeugt Artefakte Lösung: surf3dwrite<type> 25

26 Problem (2): Reihenfolge im 3D-Array Vertauschen der x- und z-dimension 26

27 Ergebnisse

28 Output im Vergleich Input 1600 x 1200 Pixel s=4 r = 0.1 s=8 r = 0.1 s = 16 r = 0.1 CPU GPU 28

29 Output im Vergleich s = 4 und r = 0.1 auf CPU s = 4 und r = 0.1 auf GPU Vergleichsbild mit ImageMagick (Fehler in Rot ) Differenzbild mit Gimp 29

30 Output im Vergleich s = 8 und r = 0.1 auf CPU s = 8 und r = 0.1 auf GPU Vergleichsbild mit ImageMagick (Fehler in Rot ) Differenzbild mit Gimp 30

31 Output im Vergleich s = 16 und r = 0.1 auf CPU s = 16 und r = 0.1 auf GPU Vergleichsbild mit ImageMagick (Fehler in Rot ) Differenzbild mit Gimp 31

32 Fehlervergleich Absolute Anzahl der Fehler und Mittlerer quadratischer Fehler (MSE) m 1 n 1 MSE= 1 2 [I i, j K i, j ] mn i=0 j=0 #Pixel MSE s= s= s = [5] 32

33 Mögliche Gründe für die Fehler Float Instruktionsreihenfolge (GPU vs. CPU) Eventuelle Probleme bei kommutativen Operationen Float Instruktionsart ( Fused Multiply-Add ) Erlaubt Berechnung der Art (X*Y + Z) ohne Rundung nach der Multiplikation höhere Genauigkeit des Ergebnisses Texturfilterungskoeffizienten interne Interpolations-Koeffizienten werden nur in einem 9-Bit Festkomma- Format verwaltet 33

34 Laufzeiten im Vergleich Verwendete Hardware: Tesla C2050 / Intel Xeon E5640 4x2,67 Ghz Tesla C2050: ~ 2,6 GB globalen Hauptspeicher, 448 Cuda Kerne Bildgröße beläuft sich auf: 1600 x 1200 Pixel (~ 2 MP) BGF CPU BGF GPU BGF CPU BGF GPU BGF CPU BGF GPU (s = 4, r = 0.1) (s = 4, r = 0.1) (s = 8, r = 0.1) (s = 8, r = 0.1) (s = 16, r = 0.1) (s = 16, r = 0.1) - ~ 60 ms - ~ 60 ms - ~ 60 ms Downsampling ~ 106 ms ~ 6.8 ms ~ 93 ms ~ 3.6 ms ~ 89 ms ~ 5.4 ms Glättung ~1105 ms ~ 7.1 ms ~ 280 ms ~ 2.1 ms ~ 72 ms ~ 0.7 ms Slicing ~ 850 ms ~ 4.2 ms ~ 862 ms ~ 4.2 ms ~ 862 ms ~ 4.2 ms Ʃ ~ 2063 ms ~ 18.5 ms ~ 1235 ms ~ 10.0 ms ~ 1023 ms ~ 10.5 ms Datenupload Speed-Up ~26x ~18x ~15x 34

35 Quellen

36 Quellen (1) Paris, Sylvain, and Frédo Durand. "A fast approximation of the bilateral filter using a signal processing approach." Computer Vision ECCV Springer Berlin Heidelberg, (2) (3) (4) (5) 36

37 Anhang

38 Blockzuteilung im Kernel Interpolation und Dehomogenisierung (linear) Aufteilung: Threads. x = T, Blocks. x = ceil (width height / T ) T = k WARP_SIZE, k ℕ Zugriff: idx = (blockidx. x blockdim. x + threadidx. x) x = floor (idx / height ) y = idx x height 38