GPU Programozs s prhuzamos rendszerek labor GPU Graphics
GPU Programozás és párhuzamos rendszerek labor
GPU = Graphics Processing Unit �A számítógépes grafika inkrementális képszintézis algoritmusának hardver realizációja �Teljesítménykövetelmények: Animáció: néhány nsec / képpont �Masszívan párhuzamos Pipeline (stream processzor) Párhuzamos ágak
Modern GPU csővezeték
Adatfolyam feldolgozás �Nincs szinkronizáció és kommunikáció �Csővezeték alkalmazása �Párhuzamosítás Proc 1 Proc 2 Csővezeték Proc 21 Proc 1 Párhuzamosság Proc 22
Adatfolyam feldolgozás Alapműveletek Map Amplify Reduce Sum
Adatfolyam feldolgozás CPU Vertexek + tulajdonságok: Bemenő adatfolyam: 13 x 4 float Vertex Shader Geometria shader Tesszelációs shader Vágás Textúra memória Framebuffer Leképzés (Mapping): Az adatfolyam elemeinek átalakítása Bővítés (amplification) Feltételes redukció Háromszög előkészítés + raszterizáció + lineáris interpoláció Bővítés (amplification) Pixel Shader Leképzés (Mapping) Kompozitálás Összegzés + redukció
Példa vektor feldolgozásra: Attraktorok „Teljes képernyős” téglalap (CPU): gl. Viewport(0, 0, HRES, VRES) gl. Bind. Vertex. Array(vao); gl. Draw. Arrays(GL_TRIANGLES, 0, 6); Vertex shader (GLSL): in vec 4 position; in vec 2 tex. Coord; out vec 2 f. Tex. Coord; Geometria: „háromszögek” Az eredménytömb melyik elemeit számítjuk ki ? void main (void) { gl_Position = position; f. Tex. Coord = tex. Coord; } Fragment shader (GLSL): in vec 2 f. Tex. Coord; out vec 4 out. Color; void main (void) { out. Color = F(f. Tex. Coord); } Eredmény tömb Képszintézis Minden kimeneti tömbelemre ugyanaz az algoritmus, más adatokra: SIMD Kimeneti kép Textúra vagy rasztertár
Open. GL: Geometria �Primitívek Pont (GL_POINTS) Szakasz (GL_LINES) Háromszög (GL_TRIANGLES) (x, y, z) (x 1, y 1, z 1) (x 2, y 2, z 2) (x 3, y 3, z 3) (x 1, y 1, z 1)
Open. GL: Geometria �Vertex Array Adat bufferek ▪ 0. . GL_MAX_VERTEX_ATTRIBS 4 komponensű vektor tömbök Nincs meghatározott értelmezés Vertex Array Textúra koordináta Normál vektor Szín Pozíció
Open. GL: Geometria GLfloat vertices[18] = { -1. 0 f, 1. 0 f, -1. 0 f, GLfloat tex. Coords[12] = { 0. 0 f, 1. 0 f, 1. 0 f, 0. 0 f, 1. 0 f, 0. 0 f }; 0. 0 f, 0. 0 f }; V: (1, 1) UV: (1, 1, 0) V: (-1, 0) UV: (0, 0)
Open. GL: Geometria GLuint vertex. Array; gl. Gen. Vertex. Arrays(1, &vertex. Array); // Leíró generálása gl. Bind. Vertex. Array(vertex. Array); // Leíró bekötése GLuint vertex. Buffer; gl. Gen. Buffers(1, &vertex. Buffer); // Leíró generálása gl. Bind. Buffer(GL_ARRAY_BUFFER, vertex. Buffer); // Leíró bekötése gl. Buffer. Data(GL_ARRAY_BUFFER, sizeof(GLfloat) * v. Count, vertices, GL_STATIC_DRAW); // Adatok feltöltése gl. Enable. Vertex. Attrib. Array(0); // Attribútum tömb engedélyezése gl. Vertex. Attrib. Pointer((GLuint)0, 3, GL_FLOAT, GL_FALSE, 0, 0); // Attribútum tulajdonságok megadása. . . gl. Bind. Vertex. Array(0); gl. Bind. Vertex. Array(vertex. Array); gl. Draw. Arrays(GL_TRIANGLES, 0, v. Count); gl. Bind. Vertex. Array(0); // Leíró bekötése // A VAO egy részének renderelése
Open. GL/GLSL �Shader program Egybe fogja a rendereléshez használt shadereket Az Open. GL driver fordítja Összeköti a shader változókat Shader program Vertex shader Geometria Shader Tesszelációs shader Fragmens shader
Open. GL/GLSL � Shaderek létrehozása GLuint shader; shader = gl. Create. Shader(GL_VERTEX_SHADER); gl. Shader. Source(shader, 1, (const char**)&shader. Source, &length); gl. Compile. Shader(shader); GLuint error. Flag; gl. Get. Shaderiv(shader, GL_COMPILE_STATUS, &error. Flag); if(!error. Flag){ gl. Get. Shader. Info. Log(. . . ); } � Shader program GLuint shader. Program; shader. Program = gl. Create. Program(); gl. Attach. Shader(shader. Program, shader); . . . gl. Bind. Attrib. Location(shader. Program, 0, „v. Position”); . . . gl. Link. Program(shader. Program); gl. Get. Programiv(shader. Program, GL_LINK_STATUS, &error. Flag); if(!error. Flag){ gl. Get. Program. Info. Log(. . . ); }
Open. GL/GLSL �Program engedélyezése gl. Use. Program(shader. Program); �Program tiltása gl. Use. Program(0); �Vertex attribútumok (linkelés után érvényes) gl. Enable. Vertex. Attrib. Array(vertex. Array); gl. Bind. Attrib. Location(shader. Program, 0, „v. Position”); gl. Bind. Attrib. Location(shader. Program, 1, „v. Tex. Coord”); �Uniform paraméterek (bármikor változtatható) GLuint location = gl. Get. Uniform. Location(shader. Program, name); gl. Uniform 1 f(location, float. Val); gl. Uniform 3 f(location, float. Val. X, float. Val. Y, float. Val. Z);
GLSL �Adattípusok Egyszerű típusok ▪ bool, integer, float Vektor típusok ▪ vec 2 tex. Coord ▪ vec 3 position ▪ vec 4 color. RGBA ▪ bvec, ivec Mátrix típusok ▪ mat 2, mat 3, mat 4 ▪ mat[2, 3, 4]x[2, 3, 4]
GLSL �Minősítők const: fordítási idejű konstans változó ▪ const float max. Iteration uniform: globális változó a primitívre ▪ uniform vec 2 viewport. Size in: bemenő változó az előző shader lépcsőből ▪ in vec 2 tex. Coord out: kimenő változó a következő lépcsőnek ▪ out vec 3 position
GLSL �Operátorok Aritmetika és bitműveletek ▪ +, -, *, /, %, <<, >>, &, ^, |, . . . Adatkonverzió ▪ (int)float, (float)bool, . . . Vektor és mátrix konstruktor ▪ vec 3(float), vec 4(float, vec 3), mat 2(float) Swizzle operátor ▪. {xyzw}, . {rgba}, . {stpq} ▪ vec 2 v 2 = vec 3(1. 0, 1. 0). xy
GLSL �Beépített függvények Trigonometria és szögfüggvények ▪ radians, degrees, sin, cos, atan, . . . Geometriai függvények ▪ length, distance, dot, cross, normalize, . . . Exponenciális függvények ▪ pow, exp, log, sqrt, . . . Általános függvények ▪ abs, sign, floor, ceil, mix, smoothstep, min, max, . . . Mátrix függvények ▪ transpose, determinant, inverse, . . .
GLSL �Vertex shader in vec 4 v. Position; in vec 2 v. Tex. Coord; out vec 2 f. Tex. Coord; // bemenő pozíció // bemenő textúra koordináták // interpolálandó textúra koordináták void main (void) { gl_Position = position; f. Tex. Coord = tex. Coord; } // pozíció a pipeline további részére // textúra koordináta a fragmens shadernek �Fragmens shader in vec 2 f. Tex. Coord; out vec 4 out. Color; // interpolált textúra koordináta // a rasztertárba írandó szín void main (void) { out. Color = vec 4(f. Tex. Coord, 0. 0, 1. 0); }
Példa vektor feldolgozásra: Iterált függvények attraktorai F z = x + iy • Egy pontba konvergál • Divergál • Egy tartományon ugrándozik: Attraktor
z 2 z z = r e i r r 2 2 divergens konvergens 1 Attraktor: H = F(H)
Attraktor előállítása �Attraktor a labilis és a stabil tartomány határa �Kitöltött attraktor = amely nem divergens z n+1 = z n 2 : ha |z |< akkor fekete
Julia halmaz: 2 z z +c
Kitöltött Julia halmaz: algoritmus Im z Filled. Julia. Draw ( ) FOR Y = 0 TO Ymax DO FOR X = 0 TO Xmax DO Viewport. Window(X, Y x, y) z=x+jy FOR i = 0 TO n DO z = z 2 + c IF |z| > “infinity” THEN WRITE(X, Y, white) ELSE WRITE(X, Y, black) ENDFOR END (X, Y) Re z
Vektor feldolgozás �Julia halmaz Nem divergens
Mandelbrot halmaz Azon c komplex számok, amelyekre a z z 2 + c Julia halmaza összefüggő
Mandelbrot halmaz, algoritmus Mandelbrot. Draw ( ) FOR Y = 0 TO Ymax DO FOR X = 0 TO Xmax DO Viewport. Window(X, Y x, y) c=x+jy z=0 FOR i = 0 TO n DO z = z 2 + c IF |z| > “infinity” THEN WRITE(X, Y, white) ELSE WRITE(X, Y, black) ENDFOR END
Vektor feldolgozás �Mandelbrot halmaz Nem divergens
GPGPU: GPU mint vektorprocesszor Geometria: „háromszögek” Az eredménytömb melyik elemeit számítjuk ki? Bemeneti adat Bemeneti kép Textúrák Eredmény tömb Képszintézis Kimeneti kép Minden kimeneti tömbelemre ugyanaz az algoritmus, más adatokra: SIMD Textúra vagy rasztertár
„Teljes képernyős” téglalap (CPU): gl. Viewport(0, 0, HRES, VRES) gl. Bind. Vertex. Array(vao); gl. Draw. Arrays(GL_TRIANGLES, 0, 6); GPGPU: GPU mint vektorprocesszor Vertex shader (GLSL): in vec 4 position; in vec 2 tex. Coord; out vec 2 f. Tex. Coord; void main (void) { gl_Position = position; f. Tex. Coord = tex. Coord; } Fragment shader (GLSL): uniform sampler 2 D bem. Adat; in vec 2 f. Tex. Coord; out vec 4 out. Color; Bemeneti adat void main (void) { out. Color = Bemeneti képből számított adat a tex 2 D(bem. Adat, f(Tex)) alapján; } Melyik kimeneti tömbelemet számítjuk Eredmény tömb
Open. GL: Textúrák � Textúra definíció GLuint texture; gl. Gen. Textures(1, &texture); gl. Bind. Texture(GL_TEXTURE_2 D, texture); gl. Tex. Parameteri(GL_TEXTURE_2 D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); gl. Tex. Parameteri(GL_TEXTURE_2 D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); gl. Tex. Parameteri(GL_TEXTURE_2 D, GL_TEXTURE_WRAP_S, GL_REPEAT); gl. Tex. Parameteri(GL_TEXTURE_2 D, GL_TEXTURE_WRAP_T, GL_REPEAT); gl. Tex. Image 2 D(GL_TEXTURE_2 D, 0, GL_RGBA 32 F, w, h, 0, GL_RGBA, GL_FLOAT, 0); � Shader paraméter GLuint location = gl. Get. Uniform. Location(shader. Program, „texture. Map”); gl. Active. Texture(GL_TEXTURE 0); gl. Bind. Texture(GL_TEXTURE_2 D, texture); gl. Uniform 1 i(location, 0); � Shaderbeli elérés uniform sampler 2 D texture. Map; vec 4 tex. Color = texture(texture. Map, tex. Coord);
Párhuzamos sémák �Szórás (Scatter) �Gyűjtés (Gather)
Példa vektor feldolgozásra: Képfeldolgozás �Fényességi transzformációk CIE Luminancia
Képfeldolgozás �Küszöbözés
Képszűrés �Adatgyűjtés (Gather) Egy-egy elem módosítása a környezete alapján Konvolúciós szűrés (lehetne bármi más is) ▪ Kép transzformáció: ▪ Képfeldolgozási műveletek konvolúció
Képszűrés �Élkeresés 150 155 154 28 28 28 Gradiens alapján detektáljuk az éleket Central differences
Képszűrés �Élkeresés
Képszűrés �Élkeresés Prewitt operátor Sobel operátor
Képszűrés �Élkeresés Laplace operátor
Képszűrés �Élkiemelés A képből vonjuk ki a második deriváltját
Képszűrés �Gauss szűrő
- Slides: 41