GPGPU – CUDA 2.

CUDA Libraries cuBLAS-XT: Lineáris algebrai műveletek megoldása több GPU-val. cuFFT: Fourier-transzformációk gyors számolása NPP: Kép-, videó- és jelfeldolgozási algoritmusok gyűjteménye. cuSPARSE: Ritka mátrixok feldolgozásására lineáris algebrai algoritmusok. Stb.

OpenGL with CUDA 1.0-… Texture memory 2.0-… Surface memory A device memóriában vannak. A globális memória is a device memóriában van, és bár annak elérése kb. 100-szor lassabb, mint a lokális memória olvasása. A texture, és a surface memória a cache-elés miatt lényegesen gyorsabb.

VBO A Vertex Buffer Object (VBO) egy OpenGL feature, ami lehetővé teszi vertexek feltöltését a videó device-ra. Vertex adatok: Pozíció Normálvektor Szín Stb.

Grid-es feldolgozás dim3 block(n, m, o); n * m * k szálat fog tartalmazni egy blokk dim3 grid(i, j, k); i * j * k blokkot fog tartalmazni a grid.

Grid indexelés kernelen belül blockIdx.x, blockIdx.y – A blokk pozíciója a griden belül. blockDim.x, blockDim.y – Egy blokk mérete threadIdx.x, threadIdx.y – A szál pozíciója a blokkon belül.

Aktuális szál pozíciója a griden X koordináta: blockIdx.x*blockDim.x + threadIdx.x Y koordináta: blockIdx.y*blockDim.y + threadIdx.y

simpleGL projekt Projekt link: http://cg.elte.hu/~gpgpu/cuda/02/01_simpleGL.zip Egyszerű OpenGL – CUDA interakció. VBO kezelése CUDA-n keresztül.

simple_vbo_kernel Aktuális szál indexe unsigned int x = blockIdx.x*blockDim.x + threadIdx.x; unsigned int y = blockIdx.y*blockDim.y + threadIdx.y;

simple_vbo_kernel Egyszerű szinuszos hullám. UV koordináták float u = x / (float) width; float v = y / (float) height; u = u*2.0f - 1.0f; v = v*2.0f - 1.0f;

simple_vbo_kernel Egyszerű szinuszos hullám. Magasság kiszámolása. float freq = 4.0f; float w = sinf(u*freq) * cosf(v*freq) * 0.5f;

simple_vbo_kernel Egyszerű szinuszos hullám. Vertex végső pozíciója. pos[y*width+x] = make_float4(u, w, v, 1.0f);

simple_vbo_kernel Egyszerű szinuszos hullám. Hullámoztatás. Új globális változó: float g_fAnim = 0.0; Kernel módosítása: simple_vbo_kernel(…, float time) Kernelhívás módosítása: simple_vbo_kernel<<<grid, block>>>(…, g_fAnim)

simple_vbo_kernel Egyszerű szinuszos hullám. Hullámoztatás. Time változtatása (timerEvent fv.): g_fAnim += 0.01f; Magasság számolása: float w = sinf(u*freq + time) * cosf(v*freq + time) * 0.5f;

Dobozszűrő (Box filter) 3*3-as átlagszűrő: [1 1 1] Alkalmazva konvolúcióval a kép minden pixelére:

boxFilter projekt Projekt linkje: http://cg.elte.hu/~gpgpu/cuda/02/02_boxFilter.zip OpenGL – CUDA interakció. Textúra kezelés CUDA-n keresztül. Egyszerű doboszűrő megvalósítása.

boxFilter.cpp CUDA kernel meghívása Display függvénybe a megfelelő helyre: boxFilterRGBA(d_result, width, height, filter_radius, nthreads, kernel_timer);

boxFilter_kernel.cu boxFilterRGBA függvény checkCudaErrors( cudaBindTextureToArray(rgbaTex, d_array) ); double dKernelTime; dKernelTime = 0.0; checkCudaErrors(cudaDeviceSynchronize()); sdkResetTimer(&timer); d_boxfilter_rgba<<< (width * height) / nthreads, nthreads, 1 >>>(d_dest, width, height, radius); dKernelTime += sdkGetTimerValue(&timer); return dKernelTime/1000.;

boxFilter_kernel.cu d_boxfilter_rgba függvény Aktuális pixel indexének kiszámolása: unsigned int idx = blockIdx.x*blockDim.x + threadIdx.x; Túlindexelés esetén ne hajtódjon végre a kód if (idx < w*h) { … }

boxFilter_kernel.cu d_boxfilter_rgba függvény Skála kiszámolása float scale = 1.0f / ((2*r + 1)*(2*r + 1)); X koordináta unsigned int x = idx / w; Y koordináta unsigned int y = idx % w;

boxFilter_kernel.cu d_boxfilter_rgba függvény if (y <= r || y >= h-r || x <= r || x >= w-r) return; float4 t = make_float4(0.0f); float2 center = make_float2(x,y); for (int y = -r; y <= r; y++) for (int x = -r; x <= r; x++) t += tex2D(rgbaTex, center.y + y, center.x + x); od[idx]= rgbaFloatToInt(t * scale);

boxFilter.cpp Animáció TimerEvent függvénybe: filter_radius = filter_radius % 9 + 1;

Köszönöm a figyelmet