Computación en procesadores gráficos Programación con CUDA

Transcripción

1 Computación en procesadores gráficos Programación con CUDA José Jesús Fernández Rodriguez Ester Martín Garzón José Antonio Martínez García José Román Bilbao Castro Francisco M. Vázquez López

2 Contenidos y Actividades Arquitectura de las GPUs Modelo de programación SIMT Claves computacionales para la programación de GPUs CUDA Ejercicios Programación con CUDA 2

3 Arquitectura de las GPUs Thread Processor Streaming Multiprocessor: SMs Scalar Processor: SPs Memoria On-chip: Registros Shared Memory Off-chip: Memoria global o device memory Texture cache, constant cache Programación con CUDA 3

4 Arquitectura de las GPUs Thread Processor: Coordina la ejecución de los threads Streaming Multiprocessor SM: Contiene 8 Scalar Processor SP 4, 14, 16, 30 SMs según arquitectura (G80, G92,., GT200) GeForce GTX 285: 30 SM x 8 SP = 240 Cores GeForce GTX 295: Dual 30 SM x 8 SP x 2 GPUs = 480 Cores Tesla C1070: 30 SM x 8 SP x 4 GPUs = 960 Cores Fermi (GT300): 16 SM x 32 SP = 512 Cores Scalar Processor SP: Cores Unidades funcionales en coma flotante de simple precisión 2 Unidades en coma flotante de doble precisión IEEE Fermi: 4 Unidades conforme estándar IEEE Programación con CUDA 4

5 Arquitectura de las GPUs Memorias On-Chip: Baja latencia (varios ciclos) Registros (R/W): Almacenan las variables declaradas en los kernels Accesible por thread Tamaño: 16 K Registros de 32 bits Shared Memory (R/W): Almacenan arrays A compartir entre todos los threads del bloque Mecanismo para la comunicación entre todos los threads del bloque Tamaño: 16 Kb (Fermi: 48Kb + 16Kb configurable) Programación con CUDA 5

6 Arquitectura de las GPUs Memorias Off-Chip: Device memory (R/W) Tamaños: 512Mb, 1GB, 2GB, 4GB Alta latencia: ciclos por acceso aleatorio Mejorar acceso bajo condiciones de coalescencia Caché de texturas (R) 6Kb-8Kb por SM Zona ligada a device memory pero 8Kb dentro de cada SM Misma latencia que la de un registro en cache hit Misma latencia que device memory en cache miss Reserva dinámica Caché de constantes (R) 64Kb Mínima latencia cuando todos los threads acceden a la misma dirección Tamaño fijo. Reserva estática Programación con CUDA 6

7 Arquitectura de las GPUs Programación con CUDA 7

8 Arquitectura de las GPUs Programación con CUDA 8

9 Modelo de programación SIMT SIMT: Single Instruction Multiple Threads Extensión de SIMD (Single Instruction Multiple Data) Programación vectorial Paralelismo de grano fino Unidad mínima de ejecución: thread Agrupación en bloques y grid Cada thread es asignado a un SP Los distintos bloques se asignan a los SMs. Cola de bloques por SM. Para la ejecución, los bloques se dividen en agrupaciones de 32 threads: warp El acceso a memoria se realiza en grupos de 16 threads: half-warp Esta organización tiene el objetivo de aprovechar al máximo las posibilidades de paralelismo de la arquitectura, ocultando latencias mediante la ejecución concurrente de tareas. Programación con CUDA 9

10 Modelo de programación SIMT Operación y = α a, α = 2 threads a y Speed up* = 16x Programación con CUDA 10

11 Modelo de programación SIMT y = α a, α = 2 threads z = β b, β = a y GPU 1 b z Speed up* (2 GPUs) = 32x GPU 2 Programación con CUDA 11

12 Modelo de programación SIMT Bloques: Dimensiones: 1D, 2D, 3D Máximo 512 threads por bloque Dimensión máxima: 512 x 512 x 64 Grid: Dimensiones: 1D, 2D Dimensión máxima: x x 1 Programación con CUDA 12

13 Modelo de programación SIMT Cómo se determina la topología del bloque? Mapear los datos del problema a los threads Problemas: Situaciones en las que se accede a una misma estructura de distinta forma Limitados por las operaciones que definen el algoritmo Dependencias de datos Soluciones: Cambiar la forma de almacenar las estructuras Dividir en múltiples kernels Programación con CUDA 13

14 Modelo de programación SIMT Jerarquía de memoria Programación con CUDA 14

15 Modelo de programación SIMT Programación con CUDA 15

16 Modelo de programación SIMT Programación heterogénea CPU-GPU CPU: Host. Código secuencial GPU: Device. Kernels. Código paralelo Ejecución asíncrona Multi GPU: Cudathreads Etapas: Transferencia CPU -> GPU: PCIX Ejecución del kernel Transferencia GPU -> CPU: PCIX Programación con CUDA 16

17 Modelo de programación SIMT Multi GPU Memory Cache Quad Core Cores Cuda Threads Kernel 1 Kernel 2 Kernel 3 Kernel 4 GPUs Device memory Por aquí no hay comunicación. Volver a la CPU Programación con CUDA 17

18 Modelo de programación SIMT Modelo memoria distribuida: MPI Programación con CUDA 18

19 Modelo de programación SIMT Modelo memoria compartida: Posix- Threads, Open-MP Programación con CUDA 19

20 Modelo de programación SIMT Compute capability: 1.0, 1.1, 1.2, 1.3 Define características, operaciones, tamaños Compute capability 1.0: Máximo Threads/Bloque: 512. Bloque: 512 x 512 x 64 Máximo grid: x x 1 Registros por bloque: 8K-registros de 32 bits Shared memory por bloque: 16Kb Constant memory: 64Kb Texture memory: 6Kb-8Kb por SM Máximo bloques activos por SM: 8 Máximo warps activos por SM: 24 Máximo threads activos por SM: 768 Máximo instrucciones PTX por kernel: 2 millones Programación con CUDA 20

21 Modelo de programación SIMT Compute capability 1.1: Funciones atómicas en memoria global para palabras de 32 bits Compute capability 1.2: Funciones atómicas en shared memory para palabras de 32 bits Funciones atómicas en memoria global para palabras de 64 bits Registros por bloque: 16K-registros de 32 bits Máximo warps activos por SM: 32 Máximo threads activos por SM: 1024 Compute capability 1.3: Operaciones coma flotante de doble precisión IEEE Programación con CUDA 21

22 Claves computacionales para la programación de GPUs Coalescing. Acceso coalescente o fusionado a memoria global Capacidad de la arquitectura para obtener 16 palabras de memoria simultáneamente (en un único acceso) por medio de los 16 threads del half-warp Reduce la latencia de memoria a 16 veces menos Primera cuestión de eficiencia en el desarrollo del kernel Se consigue bajo ciertos patrones de acceso Estos patrones dependen de la capacidad de cómputo de la GPU Programación con CUDA 22

23 Claves computacionales para la programación de GPUs Coalescing compute capability 1.0, 1.1 El acceso a memoria de los threads de un half-warp puede realizarse en uno o dos accesos a memoria si: Los threads acceden a palabras de 4 bytes (float, int) con lo que resulta en una operación de 64 bytes Los threads acceden a palabras de 8 bytes (float2, int2) con lo que resulta en una operación de 128 bytes Los threads acceden a palabras de 16 bytes (float4, int4) con lo que resulta en dos operaciones de 128 bytes Las 16 palabras accedidas por los 16 threads del halfwarp han de estar en el mismo segmento de memoria Los threads han de acceder en secuencia a las 16 palabras de memoria. O sea, el k-th thread accede a la k- th palabra Qué pasa con el tipo double (8 bytes)? Programación con CUDA 23

24 Claves computacionales para la programación de GPUs 1 acceso 16 accesos Programación con CUDA 24

25 Claves computacionales para la programación de GPUs Coalescing compute capability 1.2, 1.3 El acceso a memoria de los threads de un half-warp puede realizarse en un acceso a memoria si: Los threads acceden a palabras dentro del mismo segmento de memoria, siendo éste de tamaño: 32 bytes, si los threads acceden a palabras de 1 byte 64 bytes, si los threads acceden a palabras de 2 bytes 128 bytes, si los threads acceden a palabras de 4 ó 8 bytes El tamaño de segmento ha de ser el doble de las palabras a las que se accede salvo en el caso en el que las palabras son de 8 bytes Cuando el patrón de acceso a memoria requiere el uso de n-segmentos distintos, se realizarán n-accesos Programación con CUDA 25

26 Claves computacionales para la programación de GPUs 1 acceso 2 accesos Programación con CUDA 26

27 Claves computacionales para la programación de GPUs Alineación de segmentos 1ª fila 2ª fila Matriz 2x10 float. Tamaño de fila = 40 bytes Cuantos accesos se realizan? Alineado Total Segmento = 64 bytes 40 bytes Padding 6x4 = 24 bytes Programación con CUDA 27

28 Claves computacionales para la programación de GPUs Registros / Shared memory Uso beneficioso al ser memorias de baja latencia A compartir entre todos los threads del bloque Estamos limitados por sus tamaños Si nos excedemos, se hace uso de una memoria especial gestionada sólo por el compilador: local memory La local memory está ubicada en la device memory, por lo que tiene alta latencia Cómo controlamos el espacio gastado en registros y shared memory? Mediante un flag al compilador: -Xptxas=-v Programación con CUDA 28

29 Claves computacionales para la programación de GPUs Uso de cachés: Constant cache, Texture cache Su uso es beneficioso siempre que se produzca un cache hit Ante un cache miss, la latencia es la misma que la del acceso a memoria global Válidas cuando el problema presente cierta reutilización de datos Limitaciones: Tamaño Sólo lectura Reserva estática en la caché de constantes La misma palabra de la caché de constantes ha de ser accedida por todos los threads del half-warp En la práctica, el uso de la caché de texturas produce un aumento considerable en el rendimiento final del algoritmo Programación con CUDA 29

30 Claves computacionales para la programación de GPUs Bandwidth Medida que define el buen uso que realizamos de la memoria global Cada GPU tiene un peak bandwith que representa el máximo teórico que se puede alcanzar Bandwidth teórico para Geforce GTX280: (1107 Mhz x 10 6 x (512/8) x 2)/10 9 =141,6 Gbps 512-bit: wide memory interface, DDR: Double Data Rate Bandwidth efectivo: ((Br + Bw) / 10 9 ) / time(secs) (Gbps) Br: Bytes leídos Bw: Bytes escritos por el kernel Para su cálculo no se tiene en cuenta el acceso a cachés Un valor bajo indica que el punto de partida en la optimización del kernel es revisar el cómo se realiza el acceso a memoria Programación con CUDA 30

31 Claves computacionales para la programación de GPUs Ejemplo: Kernel con un acceso aleatorio a uno de sus vectores, este se encuentra en caché de texturas: Qué indica un valor alto de Bandwidth? Qué indica un valor bajo? Y un valor muy bajo? Programación con CUDA 31

32 Claves computacionales para la programación de GPUs Divergencia Ocurre cuando se producen saltos condicionales en el código Uso de sentencias if condicion then else Serialización hasta que se acaba el if Se pierde paralelismo al estar muchos threads parados Intentar evitar situaciones de este tipo Programación con CUDA 32

33 Claves computacionales para la programación de GPUs Transferencias CPU <-> GPU La CPU se comunica con la GPU por medio del bus PCIX Alta latencia en comparación con el acceso a memoria GDDR4, GDDR5 Peak Bandwidth = 8Gbps con PCIX 16x Gen2 Optimizar las transferencias: Comunicación CPU->GPU Procesamiento Resultados GPU->CPU En ciertos problemas, los datos a procesar pueden generarse directamente en la GPU sin necesidad de la comunicación inicial Programación con CUDA 33

34 Claves computacionales para la programación de GPUs Ocupación Mide el grado en el que el kernel que se ejecuta mantiene ocupados a los SMs Ratio entre los warps activos por SM y el máximo posible La ejecución de un warp mientras otro está pausado o estancado es la única forma de ocultar latencias y mantener el hardware ocupado Situaciones: Divergencia Accesos memoria Una alta ocupación no implica siempre un alto rendimiento Una baja ocupación imposibilita la ocultación de latencias, por lo que resulta en una reducción del rendimiento Se calcula con: Cuda occupancy calculator (xls) Cuda visual profiler Programación con CUDA 34

35 Claves computacionales para la programación de GPUs Se indica: Threads por bloque Registros usados por thread Shared memory por bloque Se obtiene: Ratio de ocupación = 100% Cuál es el número máximo de warps activos por SM para compute capability 1.3? Programación con CUDA 35

36 Claves computacionales para la programación de GPUs Active warps=32 100% Para y 240 threads por bloque se obtiene tambien 100% ocupación Recomendable usar multiplos del warp Registros: Hasta 16 por thread Shared memory: Hasta 4Kb por bloque * Programación con CUDA 36

37 Claves computacionales para la programación de GPUs Reglas para determinar el tamaño de bloque Número de threads múltiplo del tamaño del warp (32): Facilita coalescencia. Por qué? Evitar warps incompletos Si existen suficientes bloques por SM comenzar con un tamaño mayor o igual a 64 threads por bloque Entre 128 y 256 threads por bloque es una buena elección Comprobar experimentalmente con 512 Programación con CUDA 37

38 Claves computacionales para la programación de GPUs Cuda visual profiler Herramienta para medir parámetros de rendimiento de un kernel # número de accesos coalescentes # saltos condicionales, divergencia bandwidth, Obtiene valores de la estadística sobre varios SMs, no sobre el total Extrapola los resultados al total de SMs. Es una aproximación Bandwidth incluye todas las estructuras de memoria, no sólo las relevantes para el algoritmo Programación con CUDA 38

39 Claves computacionales para la programación de GPUs Optimización en operaciones: +, *, add-multiply: 8 operaciones/ciclo / : 0.88 operaciones/ciclo Uso de operaciones fast_math: comprobar precisión requerida Programación con CUDA 39

40 CUDA Computed Unified Device Architecture NVIDIA, Nov 2006: Arquitectura para computación paralela de propósito general Conjunto de extensiones al lenguaje C Será válida para otros lenguajes de alto nivel: C++, OpenCL, Fortran, DirectX Programación con CUDA 40

41 CUDA Identificación de threads, bloques, grid: int threadidx.x, threadidx.y, threadidx.z Identificador (x, y, z) del thread dentro del bloque int blockidx.x, blockidx.y, blockidx.z Identificador (x, y, z) del bloque dentro del grid int blockdim.x, blockdim.y, blockdim.z Tamaño (x, y, z) del bloque Identificador único de thread threadidx.x: Número de thread dentro de un bloque 1-D threadidx.x + (blockidx.x * blockdim.x): Identificador de thread único entre todos los bloques 1-D (grid) (threadidx.x, threadidx.y): Coordenadas del thread dentro de un bloque 2-D (threadidx.x + (blockidx.x * blockdim.x), threadidx.y + (blockidx.y * blockdim.y): Coordenadas del thread dentro del grid (con bloques 2-D) Programación con CUDA 41

42 CUDA Bloques 1-D thid = threadidx.x + (blockidx.x * blockdim.x) threadidx.x blockidx.x = 0 blockidx.x = 1 blockidx.x = 2 0 blockdim.x -1 Grid (3, 1) Si blockdim.x = 10 Los identificadores únicos de los threads, son: Bloque 0: 0..9 Bloque 1: Bloque 2: Programación con CUDA 42

43 CUDA Bloques 2-D blockdim.y blockdim.x blockidx.x = 0 blockidx.y = 0 blockidx.x = 1 blockidx.y = 0 blockidx.x = 0 blockidx.y = 1 blockidx.x = 1 blockidx.y = 1 blockidx.x = 0 blockidx.y = 2 Grid (3, 1) blockidx.x = 1 blockidx.y = 2 griddim.x griddim.y Grid (2, 3) Programación con CUDA 43

44 CUDA Bloques 2-D blockdim.x = 2 blockdim.y = 5 (threadidx.x,threadidx.y) (0,0) (0,1) (0,2) (0,3) (0,4) (1,0) (1,1) (1,2) (1,3) (1,4) (blockidx.x, blockidx.y) = (1,2) (2,10) (2,11) (2,12) (2,13) (2,14) (3,10) (3,11) (3,12) (3,13) (3,14) thidx = threadidx.x + (blockidx.x * blockdim.x) thidy = threadidx.y + (blockidx.y * blockdim.y) Programación con CUDA 44

45 CUDA Identificadores Porqué la notación es distinta para el caso de bloques 1-D y 2-D? 1-D eje cartesiano 2-D fila, columna matriz Normalmente cuando se definen bloques 2-D es para simplificar la referenciación a los elementos de una matriz También se podían haber referenciado mediante un eje cartesiano x Programación con CUDA 45 y

46 CUDA Identificadores Ejemplo 1-D: dim3 blocksize(10,1); dim3 gridsize(3,1); Ejemplo 2-D: dim3 blocksize(2,5); dim3 gridsize(2,3); Programación con CUDA 46

47 CUDA Invocación a kernels dim3 blocksize(2,5); dim3 gridsize(2,3); example_kernel<<<gridsize,blocksize>>>(param1, param2,..) Opcionalmente se puede indicar el tamaño de la memoria shared (si su reserva es dinámica): size_t sharedmemsize=256; // bytes example_kernel<<<gridsize,blocksize,sharedmemsize>>>(params...) Programación con CUDA 47

48 CUDA Invocación a kernels En el ejemplo anterior sharedmemsize=256 bytes Cuantos bytes hay disponibles por thread? Código host: fichero.cu Código device: fichero_kernel.cu global void example_kernel(params..) {.. } Programación con CUDA 48

49 CUDA device Función que se ejecuta en el device Invocable solamente desde el device global Función que se ejecuta en el device Invocable solamente desde el host host Función que se ejecuta en el host Invocable solamente desde el host Limitación kernels: Recursividad Número variable de parámetros Declaración de variables estáticas Programación con CUDA 49

50 CUDA Manejo de memoria Normalmente: Reserva lineal y dinámica Ej. Array N elementos float CPU: Notación h_nombre size_t size=n*sizeof(float); float *h_a=malloc(size); GPU: Device memory. Notación d_nombre size_t size=n*sizeof(float); float *d_a; cudamalloc((void **), &d_a,size); Programación con CUDA 50

51 CUDA Manejo de memoria Cualquier memoria reservada en el dispositivo sólo es referenciable desde los kernels Depuración complicada: printf s en host o modo emulación Copia de datos CPU->GPU cudamemcpy(d_a, h_a,size, cudamemcpyhosttodevice); Copia de datos GPU->CPU cudamemcpy(h_a, d_a,size, cudamemcpydevicetohost); Programación con CUDA 51

52 CUDA Ejemplo: Suma de dos vectores Código device // Kernel global void VecAdd_kernel(float *d_a, float * d_b, float *d_c, int N) { int i = threadidx.x + (blockidx.x * blockdim.x); if (i < N) d_c[i] = d_a[i] + d_b[i]; } Porqué comprobar i < N? Cuantos threads se ejecutan? Ocurre divergencia? Programación con CUDA 52

53 CUDA Código host int main(){ int N = 1000; size_t size = N * sizeof(float); int MAX_BLOCKSIZE = 256; //.. Asignar valores a los vectores, etc // Reserva en device float *d_a; cudamalloc((void **) &d_a, size); float *d_b; cudamalloc((void **) &d_b, size); float *d_c; cudamalloc((void **) &d_c, size); Programación con CUDA 53

54 CUDA //Copiar datos a la GPU cudamemcpy(d_a, h_a, size, cudamemcpyhosttodevice); cudamemcpy(d_b, h_a, size, cudamemcpyhosttodevice); //Topología bloques, grid int BLOCKSX=ceil((float) N/MAX_BLOCKSIZE); //3.90 -> 4 dim3 blocksize(max_blocksize,1); dim3 gridsize(blocksx,1); //Llamada al kernel VecAdd_kernel<<<gridsize, blocksize>>>(d_a, d_b, d_c, N); Programación con CUDA 54

55 CUDA //Obtener resultados de la GPU cudamemcpy(h_c, d_c, size, cudamemcpydevicetohost); //Liberar memoria GPU cudafree(d_a); cudafree(d_b); cudafree(d_c); //Liberar memoria CPU free(h_a); free(h_b); free(h_c); } Programación con CUDA 55

56 CUDA Inicialización de memoria //Inicializa size bytes de d_a a 0 cudamemset(d_a, 0, size); //Inicializa size bytes de d_a a 1 cudamemset(d_a, 1, size); //d_a[1]= Sincronización Establece un punto de sincronización (barrier) entre un conjunto de threads: dependiendo de donde se sitúe La sincronización dentro de un warp es implícita Las operaciones cudamemcpy conllevan una sincronización implícita Programación con CUDA 56

57 CUDA Sincronización Host: cudathreadsynchronize(); Kernel: syncthreads(); // Kernel global void VecAdd_kernel(float *d_a, float * d_b, float *d_c, int N) { int i = threadidx.x + (blockidx.x * blockdim.x); if (i < N){ d_c[i] = d_a[i] + d_b[i]; syncthreads(); Qué ocurre aquí? } } Programación con CUDA 57

58 CUDA Ejercicio 1: ~ejercicios/cudamallocandmemcpy Ejemplo de transferencia host->device, device->device y device- >host cudamallocandmemcpy.cu nvcc cudamallocandmemcpy.cu o cudamalloc 1. Inicializar h_a a n 2. Declarar d_a, d_b 3. Transferir h_a -> d_a 4. Transferir d_a -> d_b 5. Inicializar h_a a 0 6. Transferir d_b -> h_a 7. Comprobar resultado Programación con CUDA 58

59 CUDA Ejercicio 2: ~ejercicios/myfirstkernel/a Ejemplo de asignación en memoria de un valor myfirstkernel.cu, myfirstkernel_kernel.cu nvcc myfirstkernel.cu o mykernel 1. Declaración h_a, d_a 2. Definición grid, bloques 3. Ejecución del kernel 4. Sincronización 4. Transferencia d_a -> h_a 5. Comprobar resultados De qué tamaño son los bloques? Qué hace cada thread? Porqué se realiza una sincronización? Programación con CUDA 59

60 CUDA Ejercicio 3: ~ejercicios/myfirstkernel/b Ejemplo de funcionamiento en modo emulación myfirstkernelemu.cu, myfirstkernelemu_kernel.cu nvcc myfirstkernelemu.cu o mykernel -deviceemu Programación con CUDA 60

61 CUDA Shared memory Reserva estática: Dentro del kernel shared float d_sdata[256]; //Cada bloque dispone de 256 floats Reserva dinámica: Desde el host (en la llamada al kernel) se indica el tamaño extern shared float d_sdata[]; Programación con CUDA 61

62 CUDA Texture memory //Host cudabindtexture(null,d_texture,d_a); cudaunbindtexture(d_texture); //Declaración en el kernel como variable global texture<float, 1> d_texture; //Acceso float value = tex1dfetch(d_texture, index); Programación con CUDA 62

63 CUDA Constant memory //Declaración en el kernel como variable global extern constant int d_cdata[256]; // Copiar desde el host size_t size=256 * sizeof(int); size_t offset=0; //Offset en bytes a partir de donde se copia en d_cdata cudamemcpytosymbol(d_cdata, h_a,size, offset, cudamemcpyhosttodevice); //Acceso temp = d_cdata[i]; Programación con CUDA 63

64 CUDA Medida de tiempos GPU timers Milisegundos Precisión de medio microsegundo cudaevent_t start, stop; float time; cudaeventcreate(&start); cudaeventcreate(&end); cudaeventrecord(start, 0); example_kernel<<<gridsize,blocksize>>> cudaeventrecord(stop, 0); cudaeventsynchronize(stop); cudaeventelapsedtime(&time, start, stop); cudaeventdestroy(start); cudaeventdestroy(stop); Programación con CUDA 64

65 CUDA Medida de tiempos C timers <sys/time.h> Microsegundos En la práctica ambos métodos son equivalentes Necesaria la sincronización de threads antes de poner start y de medir stop struct timeval start, stop; double usecs; cudathreadsynchronize(); gettimeofday(&start, NULL); example_kernel<<<gridsize,blocksize>>> cudathreadsynchronize(); gettimeofday(&stop, NULL); usecs=(stop.tv_sec-start.tv_sec)*1e6+ (stop.tv_usec-start.tv_usec); Programación con CUDA 65

66 CUDA Librería CUTIL <cutil.h> Incluída en la SDK de desarrollo Macros CUT_INIT_DEVICE Inicializa el primer device que se encuentra CUDA_SAFE_CALL(call) Realiza una llamada a una función cuda y muestra un texto con el tipo de error que se ha producido CUT_EXIT Finaliza la ejecución de un programa forzando a pulsar una tecla Funciones Parsing de los parámetros indicados en la línea de comandos Comparación de arrays para comparar CPU y GPU Timers Conflictos en shared memory Programación con CUDA 66

67 CUDA El toolkit de CUDA incluye Librería runtime de CUDA: cudart Librería FFT: cufft Librería BLAS (Algebra lineal): cublas Librerías de terceros cudpp: CUDA Data Parallel Primitives CULA: LAPACK (Algebra lineal) GPULib: Librerías matemáticas para IDL y MATLAB VSIPL: Procesamiento de señales cusparseblas: En desarrollo. Dpto. Arquitectura UAL Programación con CUDA 67

68 CUDA Compilación nvcc: Compilador de NVIDIA Flags -deviceemu: Modo emulación. Admite printf s en kernels -O2, -O3: Flags optimización gcc, sólo aplicables al código del host -use_fast_math: Usar implementación de funciones rápidas. El compilador las cambia automaticamente -Xptxas=-v. Ver ocupación de registros y shared memory -arch=sm11 sm12 sm13. Compilar para una determinada compute capability Si se compila < sm13, el tipo double se transforma en float dentro del kernel, pero no dentro del host scons Útil para linkar códigos C++, C, con.cu Necesita script cuda.py en phyton Programación con CUDA 68

69 Ejercicios Ejercicio 4: ~ejercicios/reversearray/singleblock reversearray_singleblock.cu, reversearraysb_kernel.cu nvcc reversearray_singleblock.cu o reversearray Cuantos bloques se ejecutan? De qué tamaño es el bloque? Cuantos SMs trabajan? Qué hace cada thread? d_out[255]=d_in[0] d_out[254]=d_in[1] d_out[253]=d_in[2] Se realiza un acceso coalescente en d_in y d_out? Para compute capability 1.0 y 1.1 Para compute capability 1.2 y 1.3 Programación con CUDA 69

70 Ejercicios Ejercicio 5: ~ejercicios/reversearray/multiblock reversearray_multiblock.cu, reversearraymb_kernel.cu nvcc reversearray_multiblock.cu o reversearray Tamaño de bloque? Número de bloques? Cuantos SMs trabajan? Qué valores toman inoffset y outoffset? Qué valores toman in y out? Coalescencia en d_in y d_out? Programación con CUDA 70

71 Ejercicios Ejercicio 6: ~ejercicios/reversearray/multiblockfast reversearray_multiblockfast.cu, reversearraymbf_kernel.cu nvcc reversearray_multiblockfast.cu o reversearray Qué se guarda en sdata? Se realiza la copia en d_out igual que en los ejercicios anteriores? sdata[9]=d_in[0] sdata[8]=d_in[1] sdata[0]=d_in[9] d_out[50]=sdata[0] // d_in[9] d_out[51]=sdata[1] // d_in[8] d_out[59]=sdata[9] // d_in[0] Programación con CUDA 71

72 Ejercicios Ejercicio 7: ~ejercicios/vecadd vecadd.cu, vecadd_kernel.cu nvcc vecadd.cu o vecadd./vecadd //N = 100, Tamaño bloque = 256, verbose = 1 Flags entrada: N: Tamaño vector, MAX_BLOCKSIZE: Tamaño de bloque, verbose: Salida por pantalla El programa realiza la suma de dos vectores: C = A + B Medir tiempos para: Copia datos GPU, ejecución kernel, copia datos CPU. Se necesita algún punto de sincronización? N = 10000, , 1e6 MAX_BLOCKSIZE = 16, 32, 64, 128, 256, 512 Un grupo con cudaeventcreate y otro con gettimeofday Porqué la duración del kernel no va en proporción al tamaño del vector? Calcular la ocupación mediante Cuda Occupancy Calculator Calcular el ancho de banda para cada configuración Programación con CUDA 72

73 Ejercicios Ejercicio 7: Resultados para 9500 GT sec 1e4 1e5 1e6 16 0,2477 1, , ,1823 1, , ,1781 1, , ,1766 1, , ,1721 1, , ,1860 1, ,5409 Programación con CUDA 73

74 Ejercicios Ejercicio 7: Resultados para GTX 285 sec 1e4 1e5 1e6 16 0,0808 0,4604 4, ,0600 0,2497 2, ,0506 0,1455 1, ,0513 0,1327 0, ,0510 0,1367 0, ,0533 0,1428 0,9559 Programación con CUDA 74

75 Ejercicios Ejercicio 7: Cuda Occupancy Calculator nvcc vecadd.cu o vecadd -Xptxas=-v 4 Registros + 44 bytes shared memory GT 33 % 33 % 67 % 100 % 100 % 67 % 285 GTX 25 % 25 % 50 % 100 % 100 % 100 % Programación con CUDA 75

76 Ejercicios Ejercicio 7: Peak Bandwidth=25.6 GDDR3, 16.0 GDDR2 Gbps 9500 GT 1e4 1e5 1e6 16 4,8446 6,2118 6, ,5826 8,9425 9, ,7378 9,1863 9, ,7950 9,2251 9, ,9727 9,2173 9, ,4516 9,1165 9,5687 Programación con CUDA 76

77 Ejercicios Ejercicio 7: Peak Bandwidth=159.0 Gbps GTX 285 1e4 1e5 1e , , , , , , , , , , , , , , , , , ,5361 Programación con CUDA 77

78 Ejercicios Ejercicio 7: Cuda Visual Profiler Parámetro gpu time cpu time occupancy grid size X branch divergent branch instructions gld request gst request 9500 GT GTX Programación con CUDA 78

79 Ejercicios Cuda Visual Profiler Gpu time stamp: Marca de tiempo para el kernel a ejecutar Method: Operación memcpy* o ejecución de un kernel GPU Time: Tiempo en GPU CPU Time: Tiempo en CPU occupancy: Ratio entre warps activos por SM y máximo gld uncoalesced: Número de lecturas de memoria no coalescentes gld coalesced: Número de lecturas de memoria coalescentes gld request: Número total de lecturas en memoria gst uncoalesced: Número de escrituras en memoria no coalescentes gst coalesced: Número de escrituras en memoria coalescentes gst request: Número total de escrituras en memoria gst_32/64/128b: Número de transacciones de escritura en memoria de 32, 64 ó 128 bytes Programación con CUDA 79

80 Ejercicios tlb hit: Aciertos en caché de constantes tlb miss: Fallos en caché de constantes sm cta launched: Número de bloques ejecutados en un SM branch: Número de saltos realizados por los threads en la ejecución de un kernel divergent branch: Número de saltos divergentes dentro de un warp warp serialize: Número de warps serializados debido a un conflicto de direccionamiento en la memoria shared o caché de constantes. cta launched: Número de bloques ejecutados grid size X, Y: Número de bloques en X, Y block size X, Y, Z: Número de threads por bloque en X, Y, Z dyn sm per block: Tamaño de memoria shared dinámica por bloque (bytes) sta smem per block: Tamaño de memoria shared estática por bloque (bytes) reg per thread: Número de registros por thread Programación con CUDA 80

81 Ejercicios Cuda Visual Profiler Desafortunadamente, no todos los valores están disponibles para todas las GPUs Saber interpretar los valores, ya que se corresponden con la ejecución de varios SMs, no del total Útil en la comparación de un mismo parámetro después de la optimización del código Parámetros resúmen: GPU usec CPU usec % GPU time Bandwidth read, write, overall Gbps Instruction throughput Programación con CUDA 81

82 Ejercicios Ejercicio 8 Producto matriz densa por vector: u = A v Dimensiones A: N x M, u: N, v: M Inicializar A y v aleatoriamente Con <stdlib.h>: srand48(time(null)) para establecer semilla drand48() genera un float [0, 1) Realizar código secuencial para comprobar que el kernel es correcto, comprobar con una matriz p.ej 5 x 5 Una vez comprobado, comprobar que la suma de los elementos del vector obtenido mediante la CPU es el mismo valor que se obtiene con la GPU Parámetros de entrada del programa: N: Número de filas M: Número de columnas BLOCKSIZE: Tamaño del bloque 1-D Verbose: Salida por pantalla si es 1 Iterations: Iteraciones del kernel Programación con CUDA 82

83 Ejercicios Ejercicio 8: Código secuencial for (i = 0; i < N; i++) { u[ i ]=0; for (j = 0; j < M; j++) u[ i ]+=A[ i*m+ j ] * v[ j ]; } Programación con CUDA 83

84 Ejercicios Medir tiempos para: Transferencia CPU->GPU Ejecución del kernel Transferencia GPU->CPU, recordar si es necesario usar puntos de sincronización Calcular ocupación y bandwidth Obtener la tabla de tiempos usando los dos mejores valores de BLOCKSIZE y para A=1000x2000, 2000x1000, 2000x5000 y 5000x5000 Preguntas: Para qué estructuras (u, A, v) se realiza un acceso coalescente a memoria? Comentar topología de bloques/threads usada: Cuantos threads calculan una fila? Se podría usar más de 1 thread por fila?. Ventajas/Inconvenientes Precisión en los resultados. Hay diferencias?, Por qué? Programación con CUDA 84

85 Ejercicios Mejoras a realizar: Usar la caché de texturas para almacenar el vector v Almacenar la matriz por columnas Qué se gana con esta optimización? Usar la memoria shared para realizar productos parciales de cada fila y usar más threads por fila Se te ocurre alguna optimización sobre la actualización de cada valor de u? Repetir el estudio de tiempos realizado para las optimizaciones planteadas y comparar con la versión inicial Obtener los ratios más importantes de cuda visual profiler Programación con CUDA 85

86 Ejercicios Ejercicio 8: Cuda Occupancy Calculator nvcc mv.cu o mv -Xptxas=-v 8 Registros + 48 bytes shared memory Occupancy GT 33 % 33 % 67 % 100 % 100 % 67 % Programación con CUDA 86

87 Ejercicios Ejercicio 8: Resultados para 9500 GT Iterations = 100, BLOCKSIZE = 128 N x M/sec 1000x x x x5000 CPU-GPU 0, , , , Kernel 2, , , , GPU-CPU 0, , , , Bandwith 0, , , , Programación con CUDA 87

88 Ejercicios Ejercicio 8: Resultados para 9500 GT Iterations = 100, BLOCKSIZE = 256 N x M/sec 1000x x x x5000 CPU-GPU 0, , , , Kernel 2, , , , GPU-CPU 0, , , , Bandwith 0, , , , Programación con CUDA 88

89 Ejercicios Ejercicio 8 Preguntas: Por qué se obtiene mejor rendimiento para 2000x1000 que para 1000x2000? Por qué el bandwidth es extremadamente bajo? Programación con CUDA 89

90 Ejercicios Ejercicio 8: Resultados para 9500 GT usando caché de texturas Iterations = 100, BLOCKSIZE = 128 N x M/sec 1000x x x x5000 CPU-GPU 0, , , , Kernel 1, , , , GPU-CPU 0, , , , Bandwith 1, , , , Programación con CUDA 90

91 Ejercicios Ejercicio 8: Resultados para 9500 GT usando caché de texturas Iterations = 100, BLOCKSIZE = 256 N x M/sec 1000x x x x5000 CPU-GPU 0, , , , Kernel 1, , , , GPU-CPU 0, , , , Bandwith 1, , , , Programación con CUDA 91

92 Ejercicios Ejercicio 8: Cuda Visual Profiler Iterations = 100, BLOCKSIZE = 256, 2000x5000 gputime cputime occupancy gridsizex gridsizey blocksizex blocksizey blocksizez StaSmemperblock 1ª versión caché Programación con CUDA 92

93 Ejercicios Ejercicio 8: Cuda Visual Profiler Iterations = 100, BLOCKSIZE = 256, 2000x5000 Registersperthread Sm_cta_launched branch divergentbranch instructions warp_serialize cta_launched 1ª versión caché Programación con CUDA 93