Information Coding / Computer Graphics, ISY, LiTH CUDA. En lösning för generella beräkningar. En introduktion: Programmingsmodell och språk

Transkript

1 CUDA En lösning för generella beräkningar. En introduktion: Programmingsmodell och språk Minnesareor och minnesaccess Delat minne Exempel

2 CUDA = Compute Unified Device Architecture Utvecklat av NVidia Fungerar bara på NVidia-kort, G80 eller bättre GPU-arkitektur Designat för att dölja att hårdvarans egentligen är för grafik, och för att ge mer kontroll och flexibilitet

3 Liknar shader-baserade lösningar: 1. Ladda upp data till GPU 2. Exekvera beräkningskärna 3. Ladda ner resultat

4 Integrerad kod Källkoden till värdprogram och beräkningskärnor kan vara i samma källfil, skriva som ett enda program! Betydande skillnad mot shaders (och OpenCL) där kärnan är separat och explicit laddas och kompileras av värden. Beräkningskärnor indentifieras med speciella modifierare i koden.

5 CUDA Arkitektur och utvidgning av C för parallellbearbetning. Skapar ett stort antal trådar som körs parallellt /mer eller mindre). Mycket är precis som i grafik! Du kan inte anta att alla trådar körs parallelt. De körs ett antal i taget: en warp (varp, syftar på vävning). Men nu ser det mer ut som ett vanligt C-program. Inget trassel med data som lagras som pixlar, som i GLSL. Vi kan jobba med vanliga arrayer!

6 Enkelt CUDA-exempel Ett fungerande, kompilerbart, körbart exempel #include <stdio.h> const int N = 16; const int blocksize = 16; global void simple(float *c) { c[threadidx.x] = threadidx.x; } int main() { int i; float *c = new float[n]; float *cd; const int size = N*sizeof(float); } cudamalloc( (void**)&cd, size ); dim3 dimblock( blocksize, 1 ); dim3 dimgrid( 1, 1 ); simple<<<dimgrid, dimblock>>>(cd); cudamemcpy( c, cd, size, cudamemcpydevicetohost ); cudafree( cd ); for (i = 0; i < N; i++) printf("%f ", c[i]); printf("\n"); delete[] c; printf("done\n"); return EXIT_SUCCESS;

7 Enkelt CUDA-exempel Ett fungerande, kompilerbart, körbart exempel #include <stdio.h> const int N = 16; const int blocksize = 16; Kernel global void simple(float *c) { c[threadidx.x] = threadidx.x; } thread identifier int main() { int i; float *c = new float[n]; float *cd; const int size = N*sizeof(float); } cudamalloc( (void**)&cd, size ); dim3 dimblock( blocksize, 1 ); dim3 dimgrid( 1, 1 ); simple<<<dimgrid, dimblock>>>(cd); Call kernel cudamemcpy( c, cd, size, cudamemcpydevicetohost ); cudafree( cd ); for (i = 0; i < N; i++) printf("%f ", c[i]); printf("\n"); delete[] c; printf("done\n"); return EXIT_SUCCESS; Allocate GPU memory 1 block, 16 threads Read back data

8 Modifierare för kodtyper Tre modifierare anger hur kod skall användas: global körs på GPU, startas v CPU. Detta är berʼkningskärnans ingångspunkt. device är kod som körs på GPU host är kod som körs på CPU (default). CPU host myhostfunc() GPU device mydevicefunc(() global myglobalfunc(()

9 Minneshantering cudamalloc(ptr, datasize) cudafree(ptr) Liknar CPUns minnesallokering, men görs av CPUn för att allokera på GPU cudamemcpy(dest, src, datasize, arg) arg = cudamemcpydevicetohost or cudamemcpyhosttodevice

10 Körning av kärnan simple<<<griddim, blockdim>>>( ) (Mycket egendomlig syntax.) Grid är en grid av block. Varje block har nummer inom grid och varje tråd har nummer inom sitt block. Inbyggda variabler för kärnan: threadidx och blockidx blockdim och griddim (OBS, inget prefix som i GLSL.)

11 Kompilera Cuda nvcc nvcc är nvidias kompilator, /usr/local/cuda/bin/nvcc Källfiler har suffix.cu Enklast möjliga kommandorad: nvcc simple.cu -o simple (Fler parametrar finns för bibliotek mm.)

12 Kompilera Cuda för större tillämpningar nvcc och gcc i kombination nvcc för.cu-filer gcc för.c/.cpp etc Det går bra att blanda språk. Länkning måste inkludera C++-runtimebibliotek. Exempel: En C-fil, en CU-fil

13 Exempel på multi-fil-kompilering Källfiler: cudademokernel.cu och cudademo.c nvcc cudademokernel.cu -o cudademokernel.o -c gcc -c cudademo.c -o cudademo.o -I/usr/local/cuda/include g++ cudademo.o cudademokernel.o -o cudademo - L/usr/local/cuda/lib -lcuda -lcudart -lm Länka med g++ för att inkludera C++-runtime

14 C/CUDA program code.cu CUDA-kompilering bakom scenen nvcc CPU binary PTX code PTX to target Target binary code

15 Exekvering av Cuda-program Måste sätta environment-variabel för att hitta Cudas runtime. export DYLD_LIBRARY_PATH=/usr/local/cuda/lib:$DYLD_LIBRARY_PATH Sedan kör man som vanligt:./simple Problem när vi vill exekvera utan shell! Starta med execve()

16 Beräkningar med CUDA Organisation och åtkomst Blocks, threads...

17 Warps En warp är det minsta antal trådar som processas parallellt i en CUDA-kapabel enhet. Detta antal är satt till 32. Vi behöver normalt inte tänka så mycket på warps utan i första hand tänka på block och threads.

18 Processing organization 1 warp = 32 threads 1 kernel - 1 grid 1 grid - many blocks 1 block - 1 thread processor 1 block - many threads Använd många trådar och många block! > 200 blocks rekommenderas. Antal trådar bör vara multipel av 32

19 Fördelning av beräkningar över threads och blocks Hierarkisk modell Grid Block 0,0 Block 1,0 Block 2,0 Block 3,0 Block n,n Thread 0,0 Thread 1,0 Thread 2,0 Thread 3,0 Block 0,1 Block 1,1 Block 2,1 Block 3,1 Thread 0,1 Thread 1,1 Thread 2,1 Thread 3,1 Thread 0,2 Thread 1,2 Thread 2,2 Thread 3,2 griddim.x * griddim.y blocks Thread 0,3 Thread 1,3 Thread 2,3 Thread 3,3 BlockDim.x * blockdim.y threads

20 Indexera data med thread/block-ids Beräkna index via blockidx, blockdim, threadidx Enkelt exempel, beräkna kvadrat av varje element (enbart kärnan): // Kernel that executes on the CUDA device global void square_array(float *a, int N) { int idx = blockidx.x * blockdim.x + threadidx.x; if (idx<n) a[idx] = a[idx] * a[idx]; }

21 Värdprogram för kvadratexempel Sätt block size och grid size // main routine that executes on the host int main(int argc, char *argv[]) { float *a_h, *a_d; // Pointer to host and device arrays const int N = 10; // Number of elements in arrays size_t size = N * sizeof(float); a_h = (float *)malloc(size); cudamalloc((void **) &a_d, size); // Allocate array on device // Initialize host array and copy it to CUDA device for (int i=0; i<n; i++) a_h[i] = (float)i; cudamemcpy(a_d, a_h, size, cudamemcpyhosttodevice); // Do calculation on device: int block_size = 4; int n_blocks = N/block_size + (N%block_size == 0? 0:1); square_array <<< n_blocks, block_size >>> (a_d, N); // Retrieve result from device and store it in host array cudamemcpy(a_h, a_d, sizeof(float)*n, cudamemcpydevicetohost); // Print results and cleanup for (int i=0; i<n; i++) printf("%d %f\n", i, a_h[i]); free(a_h); cudafree(a_d); }