Primeros pasos con CUDA. Clase 1

Transcripción

1 Primeros pasos con CUDA Clase 1

2 Ejemplo: suma de vectores Comencemos con un ejemplo sencillo: suma de vectores. Sean A, B y C vectores de dimensión N, la suma se define como: C = A + B donde C i = A i + B i Esta operación suma cada elemento de A y B se almacena en C.

3 A a 0 a 1 a 2 a 3 a N-1 B b 0 b 1 b 2 b 3 b N-1

4 A a 0 a 1 a 2 a 3 a N-1 + B b 0 b 1 b 2 b 3 b N-1 = c 0 C

5 A a 0 a 1 a 2 a 3 a N B b 0 b 1 b 2 b 3 b N-1 = c 0 c 1 C

6 A a 0 a 1 a 2 a 3 a N B b 0 b 1 b 2 b 3 b N-1 = c 0 c 1 c 2 C

7 A a 0 a 1 a 2 a 3 a N B b 0 b 1 b 2 b 3 b N-1 = c 0 c 1 c 2 c 3 c N-1 C

8 solución I /* Suma de vectores secuencial */ /* Suma de vectores (inplace) */ int vector_ops_suma_sec(float *v1, float *v2, int dim) { for (int i = 0; i < dim; i++) { v1[i] = v1[i] + v2[i]; } vector_ops.cu } return 1; vector_ops.cu

9 solución I /* Suma de vectores secuencial */ /* Suma de vectores (inplace) */ int vector_ops_suma_sec(float *v1, float *v2, int dim) { for (int i = 0; i < dim; i++) { v1[i] = v1[i] + v2[i]; } vector_ops.cu } return 1; Complejidad computacional lineal: O(N) donde N es la dimensión de los arreglos. vector_ops.cu

10 solución I Tiene orden de complejidad lineal, al aumentar el número de elementos aumenta linealmente la cantidad de operaciones.

11 solución I Tiene orden de complejidad lineal, al aumentar el número de elementos aumenta linealmente la cantidad de operaciones. Para vectores pequeños la solución es correcta.

12 solución I Tiene orden de complejidad lineal, al aumentar el número de elementos aumenta linealmente la cantidad de operaciones. Para vectores pequeños la solución es correcta. Para vectores muy grandes este tipo de solución puede ocasionar penalizaciones en el tiempo de cómputo.

13 Cómo sería una solución paralela? Se puede paralelizar la suma el cálculo de cada elemento del vector resultante es independiente de los demás elementos del vector: A a 0 a 1 a 2 a 3 a N-1 B b 0 b 1 b 2 b 3 b N-1

14 Cómo sería una solución paralela? Se puede paralelizar la suma el cálculo de cada elemento del vector resultante es independiente de los demás elementos del vector: A B a 0 a 1 a 2 a 3 a N-1 b 0 b 1 b 2 b 3 b N-1 Si en vez de un único procesador disponemos P procesadores, dividimos los cálculos entre los P procesadores.

15 Cómo sería una solución paralela? Se puede paralelizar la suma, el cálculo de cada elemento del vector resultante es independiente de los demás elementos del vector: A B a 0 a 1 a 2 a 3 a N b 0 b 1 b 2 b 3 b N-1 Si contamos con N procesadores, realizamos todos los cálculos al mismo tiempo. = C = c 0 c 1 c 2 c 3 c N-1

16 Cómo sería una solución paralela? Se puede paralelizar la suma, el cálculo de cada elemento del vector resultante es independiente de los demás elementos del vector: A B = C a 0 a 1 a 2 a 3 a N b 0 b 1 b 2 b 3 b N-1 c 0 c 1 c 2 c 3 c N-1 Si contamos con N procesadores, realizamos todos los cálculos al mismo tiempo. Y se resuelve en paralelo todos los resultados del vector. De orden lineal a orden constante

17 Entonces... Tengo una PC re linda...

18 Entonces... Tengo una PC re linda... Tengo una GPU que me dicen que es re linda...

19 Entonces... Tengo una PC re linda... Tengo una GPU que me dicen que es re linda... Tengo dos vectores para sumar... A B

20 Entonces... Tengo una PC re linda... Tengo una GPU que me dicen que es re linda... Tengo dos vectores para sumar... A B Cómo utilizo estas arquitecturas para solucionar mi problema??

21 CUDA (Compute Unified Device Architecture) En Noviembre de 2006 NVIDIA introduce CUDA que hace referencia tanto a un compilador como a un conjunto de herramientas de desarrollo creadas por NVIDIA. CUDA es una arquitectura de software y hardware que permite a GPUs ejecutar programas escritos en C, C++, Fortran, DirectCompute y otros lenguajes.

22 CUDA (Compute Unified Device Architecture) Un programa CUDA es un programa híbrido: Código secuencial se ejecuta en CPU Código paralelo se ejecuta en GPU

23 CUDA (Compute Unified Device Architecture) Un programa CUDA es un programa híbrido: Código secuencial se ejecuta en CPU Código paralelo se ejecuta en GPU Código secuencial Inicializaciones Lectura de datos de entrada. Código paralelo Modelo SIMD - STMD Código secuencial Muestra de resultados Almacenamiento de resultados.

24 CUDA Cómo es la parte paralela de la aplicación? Un programa CUDA invoca a funciones paralelas llamadas kernels. En CUDA: Kernel = función. Un kernel se ejecuta en paralelo a través threads paralelos.

25 CUDA Cómo es la parte paralela de la aplicación? Un programa CUDA invoca a funciones paralelas llamadas kernels. En CUDA: Kernel = función. Un kernel se ejecuta en paralelo a través threads paralelos. El programador decide: el kernel A será ejecutado por n threads A B = C Con n threads que cada uno sume un elemento del vector resultante, consigo ejecutar la suma de vectores en un único paso!!

26 CUDA Un programa CUDA invoca a kernels paralelos. Un kernel se ejecuta en paralelo a través threads paralelos. A B = C Múltiples threads ejecutando el mismo kernel.

27 CUDA Tenemos programas CUDA híbridos, que se ejecutan en CPU y GPU. Tenemos dos arquitecturas que se conectan mediante un conector PCI-Express (no comparten espacio de direccionamiento)

28 Cómo lo hacemos con CUDA? Este problema ahora implica: Inicialización de arreglos en CPU Transferencia de datos CPU GPU

29 Cómo lo hacemos con CUDA? Este problema ahora implica: Inicialización de arreglos en CPU Transferencia de datos CPU GPU Cálculo de la suma en paralelo.

30 Cómo lo hacemos con CUDA? Este problema ahora implica: Inicialización de arreglos en CPU Transferencia de datos CPU GPU Cálculo de la suma en paralelo. Transferencia de datos GPU CPU.

31 Cómo lo hacemos con CUDA? Este problema ahora implica: Inicialización de arreglos en CPU Transferencia de datos CPU GPU Cálculo en GPU. Transferencia de datos GPU CPU. Modelo de programación CUDA

32 Modelo de programación CUDA CUDA extiende al lenguaje C/C++ incluyendo dos características principales: - Organización y manejo de threads concurrentes. - Manejo de jerarquía de memorias instaladas en la GPU.

33 CUDA extiende al lenguaje C/C++ incluyendo dos características principales: - Organización y manejo de threads concurrentes. thread Jerarquía de threads: thread,

34 CUDA extiende al lenguaje C/C++ incluyendo dos características principales: - organización y manejo de threads concurrentes. thread Jerarquía de threads: thread, bloque, bloque 1, 2 o 3 dimensiones

35 CUDA extiende al lenguaje C/C++ incluyendo dos características principales: - organización y manejo de threads concurrentes. thread Jerarquía de threads: bloque 1, 2 o 3 dimensiones thread, bloque Grid 1 grilla. grilla Block (0,0) Block (1,0) Block (2,0) Grid 2 grilla Block (0,0) Block (1,0) Block (0,1) Block (1,1) 1, 2 o 3 dimensiones

36 CUDA extiende al lenguaje C/C++ incluyendo dos características principales: - Manejo de jerarquía de memorias instaladas en la GPU Memoria local de thread Memorias: Privada de cada thread.

37 CUDA extiende al lenguaje C/C++ incluyendo dos características principales: - Manejo de jerarquía de memorias instaladas en la GPU Memoria local de thread Memoria compartida de bloque Memorias: Privada de cada thread. Compartida por bloque.

38 CUDA extiende al lenguaje C/C++ incluyendo dos características principales: - Manejo de jerarquía de memorias instaladas en la GPU Memoria local de thread Memoria compartida de bloque Grid 1 Block (0,0) Block (1,0) Block (2,0) Memorias: Privada de cada thread. Compartida por bloque. Grid 2 Memoria global Global de toda la aplicación Block (0,0) Block (0,1) Block (1,0) Block (1,1)

39 - Manejo de jerarquía de memorias instaladas en la GPU CUDA ofrece distintas memorias con distintas características: Registros Memoria compartida Memoria global Memoria constante. Algunas de ellas están en caché.

40 Memoria Global: es la más grande y la más lenta. Puede ser leída y escrita por la CPU y por los threads de GPU. Permite comunicar datos entre CPU y GPU. El patrón de acceso a memoria por los threads puede afectar el rendimiento. Memoria Constante: es parte de la memoria global. CPU puede leer y escribir, y es sólo de lectura para GPU threads. Ofrece mayor ancho de banda cuando grupos de threads acceden al mismo dato. Memoria compartida: es pequeña y muy rápida y es compartida por todos los threads de un bloque. Es de lectura/escritura por los threads. Puede comunicar datos entre threads del mismo bloque. Puede verse afectada por el patrón de acceso de los threads. Registros: cada thread utiliza su propio conjunto de registros. El programador no tiene control explícito de los registros, y son utilizados para la ejecución de programas de la misma forma que los registros de propósito general de CPU. Memoria local: es usada por el compilador automáticamente para alojar variables cuando hace falta. Memoria de textura: es controlada por el programador y puede beneficiar aplicaciones con localidad espacial donde el acceso a memoria global es un cuello de botella.

41 /* Main.cu: suma de vectores. Código que se ejecuta en host. */ main.cu int main() { /* alocacion de memoria en host */ float *h_a = (float *) malloc(n * sizeof(float)); float *h_b = (float *) malloc(n * sizeof(float)); float *h_aux = (float *) malloc(n * sizeof(float)); /* alocacion de memoria en device */ float *d_a, *d_b; cudamalloc((void**)&d_a, sizeof(float) * N); cudamalloc((void**)&d_b, sizeof(float) * N); /* chequeo de alocacion de memoria */ if (!h_a!h_b!d_a!d_b!h_aux) { printf("error alocando vectores \n"); exit(-1); } main.cu

42 /* Main.cu: suma de vectores. Código que se ejecuta en host. */ main.cu int main() { /* alocacion de memoria en host */ float *h_a = (float *) malloc(n * sizeof(float)); float *h_b = (float *) malloc(n * sizeof(float)); float *h_aux = (float *) malloc(n * sizeof(float)); Alocación de memoria dinámica en host /* alocacion de memoria en device */ float *d_a, *d_b; cudamalloc((void**)&d_a, sizeof(float) * N); cudamalloc((void**)&d_b, sizeof(float) * N); /* chequeo de alocacion de memoria */ if (!h_a!h_b!d_a!d_b!h_aux) { printf("error alocando vectores \n"); exit(-1); }

43 /* Main.cu: suma de vectores. Código que se ejecuta en host. */ main.cu int main() { /* alocacion de memoria en host */ float *h_a = (float *) malloc(n * sizeof(float)); float *h_b = (float *) malloc(n * sizeof(float)); float *h_aux = (float *) malloc(n * sizeof(float)); /* alocacion de memoria en device */ float *d_a, *d_b; cudamalloc((void**)&d_a, sizeof(float) * N); cudamalloc((void**)&d_b, sizeof(float) * N); /* chequeo de alocacion de memoria */ if (!h_a!h_b!d_a!d_b!h_aux) { printf("error alocando vectores \n"); exit(-1); } Alocación de memoria en device Aloca n bytes en memoria global del device los cuales serán apuntados por d_a (d_b respectivamente)

44 /* Main.cu: suma de vectores. Código que se ejecuta en host. */ main.cu int main() { /* alocacion de memoria en host */ float *h_a = (float *) malloc(n * sizeof(float)); float *h_b = (float *) malloc(n * sizeof(float)); float *h_aux = (float *) malloc(n * sizeof(float)); /* alocacion de memoria en device */ float *d_a, *d_b; cudamalloc((void**)&d_a, sizeof(float) * N); cudamalloc((void**)&d_b, sizeof(float) * N); /* chequeo de alocacion de memoria */ if (!h_a!h_b!d_a!d_b!h_aux) { printf("error alocando vectores \n"); exit(-1); }

45 /* Continuación del código anterior */ main.cu /* inicializacion de vectores */ printf("inicializacion vector A \n"); vector_io_initializernd(h_a, N); printf("inicializacion vector B \n"); vector_io_initializernd(h_b, N); /* transferencia de datos cpu -> gpu (host -> device) */ cudamemcpy(d_a, h_a, sizeof(float) * N, cudamemcpyhosttodevice); cudamemcpy(d_b, h_b, sizeof(float) * N, cudamemcpyhosttodevice);

46 /* Continúa código anterior */ main.cu /* inicializacion de vectores */ printf("inicializacion vector A \n"); vector_io_initializernd(h_a, N); printf("inicializacion vector B \n"); vector_io_initializernd(h_b, N); /* transferencia de datos cpu -> gpu (host -> device) */ cudamemcpy(d_a, h_a, sizeof(float) * N, cudamemcpyhosttodevice); cudamemcpy(d_b, h_b, sizeof(float) * N, cudamemcpyhosttodevice);

47 /* Continúa código anterior */ main.cu /* inicializacion de vectores */ printf("inicializacion vector A \n"); vector_io_initializernd(h_a, N); printf("inicializacion vector B \n"); vector_io_initializernd(h_b, N); /* transferencia de datos cpu -> gpu (host -> device) */ cudamemcpy(d_a, h_a, sizeof(float) * N, cudamemcpyhosttodevice); cudamemcpy(d_b, h_b, sizeof(float) * N, cudamemcpyhosttodevice); CPU I/O GPU Memoria principal Memoria global

48 /* Continúa código anterior */ main.cu /* inicializacion de vectores */ printf("inicializacion vector A \n"); vector_io_initializernd(h_a, N); printf("inicializacion vector B \n"); vector_io_initializernd(h_b, N); /* transferencia de datos cpu -> gpu (host -> device) */ cudamemcpy(d_a, h_a, sizeof(float) * N, cudamemcpyhosttodevice); cudamemcpy(d_b, h_b, sizeof(float) * N, cudamemcpyhosttodevice); CPU I/O GPU Memoria principal Memoria global

49 /* Main.cu: suma de vectores. Código que se ejecuta en host. */ main.cu /* inicializacion de vectores */ printf("inicializacion vector A \n"); vector_io_initializernd(h_a, N); printf("inicializacion vector B \n"); vector_io_initializernd(h_b, N); /* transferencia de datos cpu -> gpu (host -> device) */ cudamemcpy(d_a, h_a, sizeof(float) * N, cudamemcpyhosttodevice); cudamemcpy(d_b, h_b, sizeof(float) * N, cudamemcpyhosttodevice); Copia datos de host a device CPU I/O GPU Memoria principal Memoria global

50 /* Main.cu: suma de vectores. Código que se ejecuta en host. */ main.cu /* inicializacion de vectores */ printf("inicializacion vector A \n"); vector_io_initializernd(h_a, N); printf("inicializacion vector B \n"); vector_io_initializernd(h_b, N); /* transferencia de datos cpu -> gpu (host -> device) */ cudamemcpy(d_a, h_a, sizeof(float) * N, cudamemcpyhosttodevice); cudamemcpy(d_b, h_b, sizeof(float) * N, cudamemcpyhosttodevice); Copia datos de host a device cudamemcpy(destino, origen, size, DIRECCION_COPIA) Copia size bytes desde la dirección origen a la dirección destino en la memoria global. DIRECCION_COPIA indica el sentido de la copia: - cudamemcpyhosttohost. - cudamemcpyhosttodevice. - cudamemcpydevicetohost. - cudamemcpydevicetodevice.

51 /* Main.cu: suma de vectores. Código que se ejecuta en host. */ main.cu /* inicializacion de vectores */ printf("inicializacion vector A \n"); vector_io_initializernd(h_a, N); printf("inicializacion vector B \n"); vector_io_initializernd(h_b, N); /* transferencia de datos cpu -> gpu (host -> device) */ cudamemcpy(d_a, h_a, sizeof(float) * N, cudamemcpyhosttodevice); cudamemcpy(d_b, h_b, sizeof(float) * N, cudamemcpyhosttodevice); CPU I/O GPU Tenemos los datos alocados en memoria principal de la CPU y en memoria global de GPU. Estamos listos para operar en device. Memoria principal Memoria global

52 /* Main.cu: continuación del código. */ main.cu /* suma secuencial */ printf("suma secuencial (CPU)\n"); suma_secuencial(h_a, h_b, N); /* suma paralela */ printf("suma paralela (GPU) \n"); suma_paralela(d_a, d_b, N); /* traigo los datos desde GPU a CPU para testear la suma */ cudamemcpy(h_aux, d_a, sizeof(float) * N, cudamemcpydevicetohost); if(vector_ops_iguales(h_aux, h_a, N)) printf("test pasado! \n"); else printf("test no pasado! \n"); /* liberacion de memoria */ free(h_a); free(h_b); free(h_aux); cudafree(d_a); cudafree(d_b); } return 0;

53 /* Main.cu: continuación del código. */ main.cu /* suma secuencial */ printf("suma secuencial (CPU)\n"); suma_secuencial(h_a, h_b, N); Función secuencial, ya vista /* suma paralela */ printf("suma paralela (GPU) \n"); suma_paralela(d_a, d_b, N); /* traigo los datos desde GPU a CPU para testear la suma */ cudamemcpy(h_aux, d_a, sizeof(float) * N, cudamemcpydevicetohost); if(vector_ops_iguales(h_aux, h_a, N)) printf("test pasado! \n"); else printf("test no pasado! \n"); /* liberacion de memoria */ free(h_a); free(h_b); free(h_aux); cudafree(d_a); cudafree(d_b); } return 0;

54 /* Main.cu: continuación del código. */ main.cu /* suma secuencial */ printf("suma secuencial (CPU)\n"); suma_secuencial(h_a, h_b, N); /* suma paralela */ printf("suma paralela (GPU) \n"); suma_paralela(d_a, d_b, N); Función paralela /* traigo los datos desde GPU a CPU para testear la suma */ cudamemcpy(h_aux, d_a, sizeof(float) * N, cudamemcpydevicetohost); if(vector_ops_iguales(h_aux, h_a, N)) printf("test pasado! \n"); else printf("test no pasado! \n"); /* liberacion de memoria */ free(h_a); free(h_b); free(h_aux); cudafree(d_a); cudafree(d_b); } return 0;

55 /* Función que invoca al kernel (desde CPU se invoca a kernel (GPU)) */ /* Suma de vectores. Resultado queda en el primer argumento */ int vector_ops_suma_par(float *v1, float *v2, int dim) { dim3 nthreads(512); dim3 nblocks((dim / nthreads.x) + (dim % nthreads.x? 1 : 0)); vector_ops.c kernel_suma<<<nblocks, nthreads>>>(v1, v2, dim); cudadevicesynchronize(); } return 1;

56 /* Función que invoca al kernel (desde CPU se invoca a kernel (GPU)) */ /* Suma de vectores. Resultado queda en el primer argumento */ int vector_ops_suma_par(float *v1, float *v2, int dim) { dim3 nthreads(512); dim3 nblocks((dim / nthreads.x) + (dim % nthreads.x? 1 : 0)); vector_ops.c Configuración del grid kernel_suma<<<nblocks, nthreads>>>(v1, v2, dim); cudadevicesynchronize(); } return 1; Variables de tipo dim3: vector de 3 enteros que se usa para especificar dimensiones. Componentes x, y, z. Si algún componente no se inicializa 1.

57 /* Función que invoca al kernel (desde CPU se invoca a kernel (GPU)) */ /* Suma de vectores. Resultado queda en el primer argumento */ int vector_ops_suma_par(float *v1, float *v2, int dim) { dim3 nthreads(512); dim3 nblocks((dim / nthreads.x) + (dim % nthreads.x? 1 : 0)); vector_ops.c Configuración del grid kernel_suma<<<nblocks, nthreads>>>(v1, v2, dim); cudadevicesynchronize(); } return 1; Variables de tipo dim3: vector de 3 enteros que se usa para especificar dimensiones. Componentes x, y, z. Si algún componente no se inicializa 1. nthreads especificará cantidad de threads por bloque. nblocks especificará cantidad de bloques en el grid

58 /* Función que invoca al kernel (desde CPU se invoca a kernel (GPU)) */ /* Suma de vectores. Resultado queda en el primer argumento */ int vector_ops_suma_par(float *v1, float *v2, int dim) { dim3 nthreads(512); dim3 nblocks((dim / nthreads.x) + (dim % nthreads.x? 1 : 0)); vector_ops.c Configuración del grid kernel_suma<<<nblocks, nthreads>>>(v1, v2, dim); cudadevicesynchronize(); } return 1; Variables de tipo dim3: vector de 3 enteros que se usa para especificar dimensiones. Componentes x, y, z. Si algún componente no se inicializa 1. nthreads especificará cantidad de threads por bloque (bloques de 1, 2 o 3 dimensiones). nblocks especificará cantidad de bloques en el grid (grids de 1, 2 o 3 dimensiones) Cómo queda configurado el grid?

59 Kernel 1: dim3 dimgrid(3,2) dim3 dimblock(5,3) Kernel 2: dim3 dimgrid(4,3) Dim3 dimblock(?,?,?)

60 /* Función (se ejecuta en CPU) que invoca al kernel (se ejecuta en GPU) */ /* Suma de vectores. Resultado queda en el primer argumento */ int vector_ops_suma_par(float *v1, float *v2, int dim) { dim3 nthreads(512); dim3 nblocks((dim / nthreads.x) + (dim % nthreads.x? 1 : 0)); kernel_suma<<<nblocks, nthreads>>>(v1, v2, dim); cudadevicesynchronize(); vector_ops.c Lanzamiento del kernel } return 1;

61 /* Función (se ejecuta en CPU) que invoca al kernel (se ejecuta en GPU) */ /* Suma de vectores. Resultado queda en el primer argumento */ int vector_ops_suma_par(float *v1, float *v2, int dim) { dim3 nthreads(512); dim3 nblocks((dim / nthreads.x) + (dim % nthreads.x? 1 : 0)); kernel_suma<<<nblocks, nthreads>>>(v1, v2, dim); cudadevicesynchronize(); vector_ops.c Lanzamiento del kernel } return 1; nombre_kernel<<<número de bloques, threads por bloque>>>(parámetros actuales);

62 /* Función (se ejecuta en CPU) que invoca al kernel (se ejecuta en GPU) */ /* Suma de vectores. Resultado queda en el primer argumento */ int vector_ops_suma_par(float *v1, float *v2, int dim) { dim3 nthreads(512); dim3 nblocks((dim / nthreads.x) + (dim % nthreads.x? 1 : 0)); vector_ops.c kernel_suma<<<nblocks, nthreads>>>(v1, v2, dim); cudadevicesynchronize(); } return 1; /* suma de cada elemento del vector */ global void kernel_suma(float *v1, float *v2, int dim) { int id = threadidx.x + (blockidx.x * blockdim.x); } if (id < dim) { v1[id] = v1[id] + v2[id]; } Kernel

63 vector_ops.c /* Main.cu: continuación del código. */ /* Suma de vectores. Resultado queda en el primer argumento */ int vector_ops_suma_par(float *v1, float *v2, int dim) { dim3 nthreads(512); dim3 nblocks((dim / nthreads.x) + (dim % nthreads.x? 1 : 0)); kernel_suma<<<nblocks, nthreads>>>(v1, v2, dim); cudadevicesynchronize(); } return 1; /* suma de cada elemento del vector */ global void kernel_suma(float *v1, float *v2, int dim) { int id = threadidx.x + (blockidx.x * blockdim.x); } if (id < dim) { v1[id] = v1[id] + v2[id]; } global : calificador de función

64 Calificadores de funciones: global : determina que es una función kernel, se ejecuta en el dispositivo y sólo puede ser invocada desde el host. Su invocación genera un grid de bloques con número fijo e igual de threads. device : es una función del dispositivo, se ejecuta en él y sólo puede ser invocada desde un kernel u otra función del dispositivo. host : determina que es una función del host, o simplemente una función de C tradicional a ejecutarse en host y que puede ser invocada desde host. Por omisión.

65 /* Main.cu: continuación del código. */ /* Suma de vectores. Resultado queda en el primer argumento */ int vector_ops_suma_par(float *v1, float *v2, int dim) { dim3 nthreads(512); dim3 nblocks((dim / nthreads.x) + (dim % nthreads.x? 1 : 0)); vector_ops.c kernel_suma<<<nblocks, nthreads>>>(v1, v2, dim); cudadevicesynchronize(); } return 1; /* suma de cada elemento del vector */ global void kernel_suma(float *v1, float *v2, int dim) { int id = threadidx.x + (blockidx.x * blockdim.x); } if (id < dim) { v1[id] = v1[id] + v2[id]; }

66 Variables reservadas: griddim: contiene las dimensiones del grid. blockidx : contiene el identificador del bloque en un grid. blockdim: contiene las dimensiones del bloque. threadidx: contiene el identificador del thread dentro del bloque. Todas tienen componentes x,y,z. Grids y bloques de 1, 2 o 3 dimensiones.

67 /* Main.cu: continuación del código. */ /* Suma de vectores. Resultado queda en el primer argumento */ int vector_ops_suma_par(float *v1, float *v2, int dim) { dim3 nthreads(512); dim3 nblocks((dim / nthreads.x) + (dim % nthreads.x? 1 : 0)); vector_ops.c kernel_suma<<<nblocks, nthreads>>>(v1, v2, dim); cudadevicesynchronize(); } return 1; /* suma de cada elemento del vector */ global void kernel_suma(float *v1, float *v2, int dim) { int id = threadidx.x + (blockidx.x * blockdim.x); } if (id < dim) { v1[id] = v1[id] + v2[id]; }

68 /* Main.cu: continuación del código. */ /* Suma de vectores. Resultado queda en el primer argumento */ int vector_ops_suma_par(float *v1, float *v2, int dim) { dim3 nthreads(512); dim3 nblocks((dim / nthreads.x) + (dim % nthreads.x? 1 : 0)); vector_ops.c kernel_suma<<<nblocks, nthreads>>>(v1, v2, dim); cudadevicesynchronize(); } return 1; /* suma de cada elemento del vector */ global void kernel_suma(float *v1, float *v2, int dim) { int id = threadidx.x + (blockidx.x * blockdim.x); } if (id < dim) { v1[id] = v1[id] + v2[id]; } Cada thread resuelve un único elemento del vector.

69 /* Main.cu: continuación del código. */ main.cu /* suma secuencial */ printf("suma secuencial (CPU)\n"); suma_secuencial(h_a, h_b, N); /* suma paralela */ printf("suma paralela (GPU) \n"); suma_paralela(d_a, d_b, N); /* traigo los datos desde GPU a CPU para testear la suma */ cudamemcpy(h_aux, d_a, sizeof(float) * N, cudamemcpydevicetohost); if(vector_ops_iguales(h_aux, h_a, N)) printf("test pasado! \n"); else printf("test no pasado! \n"); /* liberacion de memoria */ free(h_a); free(h_b); free(h_aux); cudafree(d_a); cudafree(d_b); } return 0;

70 /* Main.cu: continuación del código. */ main.cu /* suma secuencial */ printf("suma secuencial (CPU)\n"); suma_secuencial(h_a, h_b, N); /* suma paralela */ printf("suma paralela (GPU) \n"); suma_paralela(d_a, d_b, N); /* traigo los datos desde GPU a CPU para testear la suma */ cudamemcpy(h_aux, d_a, sizeof(float) * N, cudamemcpydevicetohost); if(vector_ops_iguales(h_aux, h_a, N)) printf("test pasado! \n"); else printf("test no pasado! \n"); /* liberacion de memoria */ free(h_a); free(h_b); free(h_aux); cudafree(d_a); cudafree(d_b); } return 0;

71 /* Main.cu: continuación del código. */ main.cu /* suma secuencial */ printf("suma secuencial (CPU)\n"); suma_secuencial(h_a, h_b, N); /* suma paralela */ printf("suma paralela (GPU) \n"); suma_paralela(d_a, d_b, N); /* traigo los datos desde GPU a CPU para testear la suma */ cudamemcpy(h_aux, d_a, sizeof(float) * N, cudamemcpydevicetohost); if(vector_ops_iguales(h_aux, h_a, N)) printf("test pasado! \n"); else printf("test no pasado! \n"); /* liberacion de memoria */ free(h_a); free(h_b); free(h_aux); cudafree(d_a); cudafree(d_b); } return 0;

72 /* Main.cu: continuación del código. */ main.cu /* suma secuencial */ printf("suma secuencial (CPU)\n"); suma_secuencial(h_a, h_b, N); /* suma paralela */ printf("suma paralela (GPU) \n"); suma_paralela(d_a, d_b, N); /* traigo los datos desde GPU a CPU para testear la suma */ cudamemcpy(h_aux, d_a, sizeof(float) * N, cudamemcpydevicetohost); if(vector_ops_iguales(h_aux, h_a, N)) printf("test pasado! \n"); else printf("test no pasado! \n"); /* liberacion de memoria */ free(h_a); free(h_b); free(h_aux); cudafree(d_a); cudafree(d_b); } return 0;

73 th 0 th 1 th 2 th 3 th N-1 A B a 0 a 1 a 2 a 3 a N b 0 b 1 b 2 b 3 b N-1 Y se resuelve en paralelo todos los resultados del vector. De orden lineal a orden constante!! = C c 0 c 1 c 2 c 3 c N-1

74 Modelo de programación CUDA No todos los problemas pueden ser resueltos usando placas de tipo GPU. Los más adecuados son los que aplican la misma secuencia de código a los datos de entrada.

75 Modelo de programación CUDA Ganaremos con GPU si: El algoritmo tiene orden de ejecución cuadrático o superior: compensar el tiempo de transferencia de datos CPU GPU. Gran carga de cálculo en cada thread (por lo mismo que el item anterior). Poca dependencia de datos. Independencia de cómputo. Puede llevar a acceso a su memoria local o compartida y evita acceder a la global (costosa). Mínima transferencia de datos CPU-GPU: óptimo: principio y final. Evitar tranferencias intermedias, ya sean para resultados parciales o datos de entrada intermedios. No existan secciones críticas: lecturas paralelas a datos, pero no escrituras: necesitamos mecanismos de acceso seguro secuencialización de accesos.

76 Resumen Hemos visto: - Alocación de memoria en device. - Transferencia de memoria host device. - Configuración de grid. - Lanzamiento de kernels. Todas estas operaciones las ofrece CUDA como una librería que extiende al lenguaje C (en este caso).

77 Probando el código 1) Copiar la carpeta /share/apps/codigos/suma-vectores a la carpeta personal: [mdenham@gpgpu-fisica ~]$ cp -a /share/apps/codigos/suma-vectores/. 2) Para compilar: los paquetes de compiladores/ bibliotecas se usan via el comando module. Para compilar con CUDA debemos cargar el módulo: [mdenham@gpgpu-fisica SUMA-Vectores]$ module load cuda Entrar a la carpeta local SUMA-Vectores y compilar: [mdenham@gpgpu-fisica SUMA-Vectores]$ cd SUMA-Vectores [mdenham@gpgpu-fisica SUMA-Vectores]$ make

78 Probando el código 3) Ejecutar la aplicación: encolamos el ejecutable main usando el script submit_gpuh.sh: ~]$ qsub submit_gpuh.sh 4) Para consultar el estado de los trabajos lanzados: SUMA-Vectores]$ qstat -f SUMA-Vectores]$ qstat -u '*' 5) Verificar resultados: ver los resultados en submit_gpuh.sh.o***** SUMA-Vectores]$ cat submit_gpuh.sh.o***