OpenCL Implementierung von OpenCV Funktionen

Transkript

1 Multi-Core Architectures and Programming OpenCL Implementierung von OpenCV Funktionen Hardware/Software Co-Design August 18,

2 Table of content 1 OpenCL - Überblick 2 OpenCL - Programmierung 3 Funktion: Imageresize 4 Fazit 2

3 Khronos OpenCL = Open Computing Language. Spezifiziert durch die Khronos Gruppe. 3

4 Modell Sichtweisen Plattform-Modell. 4

5 Modell Sichtweisen Ausführungs-Modell. 5

6 Modell Sichtweisen Speicher-Modell. 6

7 Framework Zusammenhänge: 7

8 Table of content 1 OpenCL - Überblick 2 OpenCL - Programmierung 3 Funktion: Imageresize 4 Fazit 8

9 Parallelität N-dimensionaler Berechnungsraum(N <= 3). Berechnungsraum definiert die Anzahl der parallel ausführbaren Kernel. Bsp. Bildverarbeitung N=2 mit 1024 x 1024 image: = 1 Kernel pro Pixel: 1,048,576 Kernel. 9

10 Initialisierungs-Objekte Setup: Devices GPU, CPU, Cell/B.E. Contexts Erzeugen des Kontextes. Queues Kommunikation zwischen Host und Kernel Instanzen. Memory: Buffers 1D Speicherblöcke. Images 2D oder 3D Texturen. Execution: Programs Eigentlicher Code. Kernels Threads auf der HW. Synchronization: Events - z.b. Verschränkte Speicherzugriffe, Laufzeitanalyse. 10

11 Probleme bei der Implementierung Relativ großer Overhead für die Initialisierung (Codegröße der Initialisierungsdatei inklusive Fallunterscheidung für 3 verschiedene Kernel ca. 600 Codelines). OpenCL Man-Pages nicht immer aufschlussreich. Korrektes Anlegen und Freigeben der einzelnen Objekte, z.b: - Fehlerquelle: Allozierung von Speicherplatz mittels GlobalworkSize oder Anzahl der Pixel. - Fehlerquelle: Beachten der maximalen Workgroupgröße. Kernel Code entspricht Textstring - Kompilierung zur Laufzeit. 11

12 Probleme bei der Implementierung Was passiert bei Compiler Fehlern? Implementierung von zusätzlichen Funktionen notwendig. 1 cierr1 = clbuildprogram ( cpprogram, 0, NULL, NULL, NULL, NULL) ; p r i n t f ( clbuildprogram... \ n ) ; 3 i f ( cierr1!= CL SUCCESS) { 5 c l b u i l d s t a t u s b u i l d s t a t u s ; cierr1 = clgetprogrambuildinfo ( cpprogram, cddevice, CL PROGRAM BUILD STATUS, s i z e o f ( c l b u i l d s t a t u s ), &b u i l d s t a t u s, NULL) ; 7 / / i f program b u i l t f a i l s, p r i n t out e r r o r messages i f ( build status!= CL SUCCESS) { 9 char bu il d lo g ; s i z e t r e t v a l s i z e ; 11 cierr1 = clgetprogrambuildinfo ( cpprogram, cddevice, CL PROGRAM BUILD LOG, 0, NULL, & r e t v a l s i z e ) ; i f ( cierr1!= CL SUCCESS) { 13 Cleanup ( EXIT FAILURE ) ; }

13 Probleme bei der Implementierung b u i l d l o g = new char [ r e t v a l s i z e + 1 ] ; 3 cierr1 = clgetprogrambuildinfo ( cpprogram, cddevice, CL PROGRAM BUILD LOG, ret val size, build log, NULL) ; i f ( cierr1!= CL SUCCESS) { 5 Cleanup ( EXIT FAILURE ) ; } 7 / / there s no information in the reference whether the string is 0 terminated or not b u i l d l o g [ r e t v a l s i z e ] = \0 ; 9 std : : cout << BUILD LOG: << std : : endl ; std : : cout << b u i l d l o g << std : : endl ; 11 delete [ ] bu ild lo g ; } 13 Cleanup ( EXIT FAILURE ) ; } 15 / / Create the k e r n e l ckkernel = clcreatekernel ( cpprogram, cexecutablename, &c i E r r 1 ) ; 17 p r i n t f ( clcreatekernel (%s )... \ n, cexecutablename ) ; i f ( cierr1!= CL SUCCESS) 19 { p r i n t f ( E r r o r i n clcreatekernel, Line %u i n f i l e %s!!! \ n\n, LINE, F I L E ) ; 21 Cleanup ( EXIT FAILURE ) ; } 13

14 Probleme bei der Implementierung Kernel Programmcode: Double-precission Berechnungen benötigen spezielle pragama Definitionen. / / enable double datatype 2 #pragma OPENCL EXTENSION cl khr fp64 : enable Arbeiten mit Texturen, zugriff auf Elemente. / / sampler : V a r i a b l e die Verarbeitung der Bilddaten s p e z i f i z i e r t 2 c1 = read imageui ( img, sampler, ( x, y ) ). x ; 14

15 Table of content 1 OpenCL - Überblick 2 OpenCL - Programmierung 3 Funktion: Imageresize 4 Fazit 15

16 Variante 1: Sequentiell Bilineare Interpolation. Details Implementierung: - 2 geschachtelte Schleifen. - Benötigt Daten des Ursprungsbildes sowie Dimensionen/Speicherallokation des Zielbildes. - Ursprungsbild: Nur Lese-Operationen. - Zielbild: Schreiboperationen unabhängig voneinander. > Schleifen theoretisch gut parallelisierbar. void resize seq ( const Mat &img, const Mat &img1 ) { 2... f o r ( i n t i = 0; i < s i z e x ; i ++) { 4... f o r ( i n t j = 0; j < s i z e y ; j ++) { 6... img1. at <i n t >( j, i ) = i n t e r p o l v a l u e ; 8 } } 10 } 16

17 Variante 2: Parallel-Buffer 1-dimensionaler Datentyp. Relativ einfache Implementierung, weil der Zugriff auf die Datenstruktur wie in C/C++ erfolgt. Problem: GPU-HW-Memory - schlechtes Alignment, je nach Bildgröße. / / Kernel Programmcode 2 k e r n e l void p a r a l l e l r e s i z e ( g l o b a l const unsigned char img, g l o b a l unsigned char img1, i n t img h, i n t img w, i n t img1 h, i n t img1 w ) { 4 / / get index i n t o g l o b a l data array i n t i = g e t g l o b a l i d ( 0 ) ; 6 i n t j = g e t g l o b a l i d ( 1 ) ;... 8 img1 [ j img1 w + i ] = ( unsigned char ) i n t e r p o l v a l u e ; } 17

18 Variante 3: Parallel-Image 2-dimensionaler Datentyp (Texturobjekt). Vorteile gegenüber Buffer: - Alignment. - Special Instructions (HW-Filtering). Variante 3a/b: Ohne/mit Nutzung des HW-Filtering. 1 / / Kernel Programmcode k e r n e l void p a r a l l e l r e s i z e ( g l o b a l const image2d t img, g l o b a l unsigned char img1, i n t img1 h, i n t img1 w ) 3 { } 1 / / I n i t i a l i s i e r u n g im Host img2dformat = { CL R, CL UNSIGNED INT8 } ; img = clcreateimage2d ( cxgpucontext, CL MEM READ ONLY,& img2dformat, ( s i z e t ) img w, ( s i z e t ) img h, 0,NULL,& c i E r r 1 ) ;

19 Vergleich Variante 3a/b 1 / / Kernel Programmcode Parallel Image, Variante a k e r n e l void p a r a l l e l r e s i z e ( g l o b a l const image2d t img, g l o b a l unsigned char img1, i n t img1 h, i n t img1 w ) 3 { / / Z u g r i f f auf 4 Elemente notwendig. c1 = read imageui ( src, sampler a, ( f l o o r x, f l o o r y ) ). x ; 7 c2 = read imageui ( src, sampler a, ( f l o o r x, c e i l y ) ). x ; c3 = read imageui ( src, sampler a, ( c e i l x, f l o o r y ) ). x ; 9 c4 = read imageui ( src, sampler a, ( c e i l x, c e i l y ) ). x ; } 1 / / Kernel Programmcode Parallel Image, Variante a k e r n e l void p a r a l l e l r e s i z e ( g l o b a l const image2d t img, g l o b a l unsigned char img1, i n t img1 h, i n t img1 w ) 3 {... 5 / / Einmaliger Zugriff, alles andere uebernimmt die HW. c = read imageui ( img, sampler b, ( x, y ) ). x ; 7... } 19

20 Performance Gesamtlaufzeiten der verschiedenen Implementierungen im Rahmen statistischer Schwankungen. Grund: Imageresize macht nur einen kleinen Teil des eigentlichen Rechenaufwandes aus. Separate Betrachtung der Laufzeiten des Imageresize Algorithmus. 20

21 Performance Fermi: Lenna.png, Workgroup size = 16x16 Vergleich: CPU vs. GPU Varianten Zeit in [ms] x x x x101 69x69 47x47 32x32 385x x x x123 84x84 57x57 39x39 27x27 cpu buffer image image_hw_filter Aufloesung in Pixel Fermi: Lenna.png, Workgroup size = 16x16 Vergleich: GPU Varianten Zeit in [ms] x x x x101 69x69 47x47 32x32 385x x x x123 84x84 57x57 39x39 27x27 buffer image image_hw_filter Aufloesung in Pixel 21

22 Performance Fermi: Lenna.png, Workgroup size = 32x8 Vergleich: CPU vs. GPU Varianten Zeit in [ms] x x x x101 69x69 47x47 32x32 385x x x x123 84x84 57x57 39x39 27x27 cpu buffer image image_hw_filter Aufloesung in Pixel Fermi: Lenna.png, Workgroup size = 32x8 Vergleich: GPU Varianten Zeit in [ms] x x x x101 69x69 47x47 32x32 385x x x x123 84x84 57x57 39x39 27x27 buffer image image_hw_filter Aufloesung in Pixel 22

23 Performance Fermi: 10MP Bild Vergleich: CPU vs. GPU Varianten Zeit in [ms] x x x x x x152 57x86 32x x x x x x x202 76x114 43x64 cpu buffer image image_hw_filter Aufloesung in Pixel Fermi: 10MP Bild Vergleich: GPU Varianten Zeit in [ms] x x x x x x152 57x86 32x x x x x x x202 76x114 43x64 buffer image image_hw_filter Aufloesung in Pixel 23

24 Table of content 1 OpenCL - Überblick 2 OpenCL - Programmierung 3 Funktion: Imageresize 4 Fazit 24

25 Ergebnisse Imageresize-Funktion: Gut parallelisierbares Szenario. Erfolge bei Betrachtung der reinen Berechnungszeit. Probleme: - Initialisierungsoverhead ca. 1s (einmalig). - Kommunikations und Allokationsoverhead. Nur bei großen Bildern sinnvoll. 25

26 ... Vielen Dank für Ihre Aufmerksamkeit 26

27 Quellen Intel: Uni Muenster: Prof. Sergei Gorlatch, Michel Steuwer: pvs.unimuenster.de/pvs/lehre/ss11/mgpp/folien/mgpp4.pdf 27