Computación de Propósito General en Unidades de Procesamiento Gráfico GPGPU. Clase 5 Programación Avanzada y Optimización

Transcripción

1 Computación de Propósito General en Unidades de Procesamiento Gráfico () P. Ezzatti, M. Pedemontey E. Dufrechou Clase 5 Programación Avanzada y Optimización Contenido Memoria compartida Conflicto de bancos Reduce Transferencias a memoria Código PTX Errores en tiempo de ejecución Algunas recomendaciones de performance 1

2 El acceso a memoria global es por segmentos. Incluso cuando solamente se quiere leer una palabra. Si no se usan todos los datos de un segmento, se está desperdiciando ancho de banda. Los segmentos están alineados a múltiplos de 32, 64 o 128 bytes. El acceso no alineado es más costoso que el acceso alineado. Coalesced access: Según Merriam-Webster to unite into a whole (unir en un todo). Podríamos traducirlo como acceso unido o fusionado. Cada solicitud de acceso a memoria global de un warp: se parte en dos solicitudes una para cada half-warp ambas solicitudes son atendidas (issued) independientemente. Los accesos a memoria de hilos de un half-warpse fusionan en una o más transacciones según características que dependen de las compute capability de la tarjeta. 2

3 Compute capabilities 1.0 y 1.1: Para lograr acceso fusionado en el half-warp se debe cumplir: o Los hilos deben acceder a la memoria en secuencia (i-ésimohilo accede a la i-ésima palabra). o Si el tamaño de palabra al que se accede es de 4 bytes, las 16 palabras deben estar en el mismo segmento de 64 bytes. o Si el tamaño de palabra al que se accede es de 8 bytes, las 16 palabras deben estar en el mismo segmento de 128 bytes. o Si el tamaño de palabra al que se accede es de 16 bytes, las 16 palabras deben estar en dos segmento contiguos de 128 bytes. Compute capabilities 1.0 y 1.1: Cuando se cumplen las condiciones: o Si el tamaño de palabra al que se accede es de 4 bytes, se hace una única transacción de 64 bytes. o Si el tamaño de palabra al que se accede es de 8 bytes, se hace una única transacción de 128 bytes. o Si el tamaño de palabra al que se accede es de 16 bytes, se hacen dos transacciones de 128 bytes. Si no se cumplen las condiciones, se realizan 16 transacciones separadas de 32 bytes cada una. Compute capabilities 1.2 y 1.3: Los hilos del half-warp pueden acceder a las palabras en cualquier orden, incluyendo la misma palabra, y solamente se realizará una transacción para cada segmento. El procedimiento de acceso del half-warp es el siguiente: o Se busca el segmento correspondiente al hilo con el id más chico. o El tamaño del segmento depende del tamaño de la palabra al que se quiere acceder: 32 bytes (palabras de 1 byte), 64 bytes (palabras de 2 bytes) y 128 bytes (palabras de 4, 8 y 16 bytes). o Se buscan los otros hilos que deban acceder a direcciones del mismo segmento. o Se intenta reducir el tamaño de la transacción y se realiza. o Se repite el proceso hasta que se atienda a todos los hilos del half-warp. 3

4 Compute capabilities 1.2 y 1.3: La reducción del tamaño de la transacción: o Si el tamaño es 128 bytes y solamente se usa la mitad superior o inferior, se reduce el tamaño a 64 bytes. o Si el tamaño es 64 bytes y solamente se usa la mitad superior o inferior, se reduce el tamaño a 32 bytes. Compute capabilities 2.x: Las transacciones a memoria global son cacheadas. Hay un caché L1 para cada multiprocesador y un caché L2 compartido por todos los multiprocesadores. La misma memoria física se usa como memoria compartida y caché L1 (se puede configurar 48 KB y 16 KB o 16 KB y 48 KB). El tamaño del caché L2 es 768 KB. Los accesos a memoria caché en L1 y L2 usan transacciones de 128 bytes. Los accesos a memoria caché solamente en L2 usan transacciones de 32 bytes. Compute capabilities 2.x: Si el tamaño de la palabra es de 8 bytes, se realizan dos solicitudes de 128 bytes, una para cada half-warp. Si el tamaño de la palabra es de 16 bytes, se realizan cuatro solicitudes de 128 bytes, una para cada quarter-warp. Cada solicitud se particiona en cache-lines. Si se produce un miss, se accede a la memoria global. Los hilos pueden acceder a las palabras en cualquier orden, incluso a las mismas palabras. 4

5 5

6 Ejemplo 1: global void CopiaOffset(float *output, float *input, int offset) { int idx = blockidx.x * blockdim.x + threadidx.x + offset; output[idx] = input[idx]; Lanzando veces 320 bloques de 128 hilos en una 9800 GTX+ (Comp. Cap1.1, 512 MB, 128 CUDA cores) Ejemplo 2 (gentileza de Robert Strzodka): Arrayof Structs(AoS) struct NormalStruct { Type1 comp1; Type2 comp2; Type3 comp3; ; typedef NormalStruct AoSContainer[SIZE]; Structof Arrays(SoA) struct SoAContainer{ Type1 comp1[size]; Type2 comp2[size]; Type3 comp3[size]; ; SoAContainer container; AoSContainer container; Ejemplo 2 (gentileza de Robert Strzodka): Arrayof Structs(AoS): container[1].comp3; container[2].comp3; container[3].comp3; container[4].comp3; Struct of Arrays(SoA): container.comp3[1]; container.comp3[2]; container.comp3[3]; container.comp3[4]; 6

7 Memoria Compartida Memoria Compartida Es cientos de veces más rápida que la memoria global. Puede usarse como una especie de caché para reducir los accesos a memoria global. Permite que los hilos de un mismo bloque puedan cooperar. Se puede usar para evitar accesos no coalesceda la memoria global: Los datos se guardan en forma intermedia en la memoria compartida. Se reordena el acceso a los datos para que cuando se copien de memoria compartida a memoria global el acceso sea coalesced. Memoria Compartida La memoria compartida se divide en módulos del mismo tamaño llamados bancos. Palabras de 32 bits contiguas están en bancos contiguos. Los bancos pueden ser accedidos simultáneamente. Si las lecturas o escrituras caen todas en bancos distintos, pueden ser atendidas simultáneamente. Cada banco puede atender una solicitud por ciclo. En general, si dos solicitudes caen en el mismo banco de memoria, se produce un conflicto (bankconflict) y el acceso al banco es serializado. Solamente se produce a nivel de half-warp. 7

8 Memoria Compartida Memoria Compartida Memoria Compartida No hay conflicto y el acceso es rápido cuando: Todos los hilos del half-warp acceden a diferentes bancos. Todos los hilos del half-warp leen la misma dirección (broadcast). El acceso es más lento cuando: Varios hilos del half-warp acceden al mismo banco. Se produce un conflicto y se debe serializar el acceso. Se requieren tantos ciclos como el máximo número de accesos al mismo banco. 8

9 Reduce Reduce Reducción en paralelo de la suma. Los datos se copian inicialmente de la memoria global a la memoria compartida. Solamente se realiza la primera etapa de la reducción. La suma de subtotales podría ser en: - GPU: haciendo más etapas de reducción. - CPU: transfiriendo a CPU los resultados intermedios y haciendo una iteración en CPU. Reduce Para declarar la memoria compartida se puede usar una constante: #define CANT_HILOS 128 global void reduction(float * output, float * input) { shared float intermedio[cant_hilos]; ; reduction <<<N_BLOCK,CANT_HILOS>>> (output,input); Para declarar la memoria compartida se puede hacer en forma dinámica con extern: global void reduction(float * output, float * input) { extern shared float intermedio[]; ; reduction <<<N_BLOCK,CANT_HILOS, CANT_HILOS*sizeof(float)>>> (output,input); 9

10 Reduce Primer enfoque Reduce Primer enfoque global void reduction(float * output, float * input){ extern shared float intermedio[]; int step = 1; int idx = blockidx.x * blockdim.x + threadidx.x; intermedio[threadidx.x] = input[idx]; while (step < blockdim.x) { if (threadidx.x%(2*step)==0) intermedio[threadidx.x] = intermedio[threadidx.x] + intermedio[threadidx.x + step]; syncthreads(); step = step * 2; syncthreads(); if (threadidx.x==0) output[blockidx.x] = intermedio[0]; Reduce Bloques 5000 Hilos 128 Primer enfoque Ejecutado en loop5000 x 128 veces en una 9800 GTX+ (Comp. Cap1.1, 512 MB, 128 CUDA cores), el tiempo de ejecución es aproximadamente 505 s. La implementación tiene varios problemas. El más importante es la divergencia de warps. 10

11 Reduce Segundo enfoque Reduce Segundo enfoque global void reduction(float * output, float * input){ extern shared float intermedio[]; int step = 1; int idx = blockidx.x * blockdim.x + threadidx.x; intermedio[threadidx.x] = input[idx]; while (step < blockdim.x) { if (threadidx.x < blockdim.x/step) intermedio[threadidx.x] = intermedio[threadidx.x] + intermedio[threadidx.x + step]; syncthreads(); step = step * 2; syncthreads(); if (threadidx.x==0) output[blockidx.x] = intermedio[0]; Reduce Segundo enfoque Bloques 5000 Hilos 128 Ejecutado en loop5000 x 128 veces en una 9800 GTX+ (Comp. Cap1.1, 512 MB, 128 CUDA cores), el tiempo de ejecución es aproximadamente 182 s. (mejora 2.77) Hay conflictos de bancos en el acceso a memoria compartida. 11

12 Reduce Tercer enfoque Reduce Tercer enfoque global void reduction(float * output, float * input){ extern shared float intermedio[]; int idx = blockidx.x * blockdim.x + threadidx.x; intermedio[threadidx.x] = input[idx]; int i = blockdim.x/2; while (i!= 0) { if (threadidx.x < i) intermedio[threadidx.x] = intermedio[threadidx.x] + intermedio[threadidx.x + i]; syncthreads(); i = i / 2; syncthreads(); if (threadidx.x==0) output[blockidx.x] = intermedio[0]; Reduce Tercer enfoque Bloques 5000 Hilos 128 Ejecutado en loop5000 x 128 veces en una 9800 GTX+ (Comp. Cap1.1, 512 MB, 128 CUDA cores), el tiempo de ejecución es aproximadamente 153 s. (mejora 3.30). Y si movemos el primer syncthreads()para adentro del if, así solamente sincronizamos los hilos que suman?? -Ojo!!! Son todos los hilos!!! 12

13 Transferencias a Memoria Transferencias a memoria Memoria no paginable Optimización de transferencias - Agrupar transferencias - Evitar transferencia de poca memoria cudahostalloc() - Mayor ancho de banda - Posibilidad de mapear memoria del host en el device. - Es un recurso limitado - Evita copia de paginable a no paginable. Transferencias a memoria Transferencias asincrónicas Utilizan streams(no entraremos en detalles) cudastreamcreate( &stream [ i ] ); cudamallochost( (void )& hostptr, NUM STREAMS size) ; cudamemcpyasync ( inputdevptr + i size, hostptr + i size, size, cudamemcpyhosttodevice, stream [ i ] ); Permiten solapar cálculos con transferencias. Ojo! Ahora las transferencias no sincronizan! 13

14 Código PTX Código PTX Recordemos la compilación El código PTX puede obtenerse Puede dar pistas de posibles optimizaciones del código C/C++ CUDA Application NVCC PTX Code PTX to Target Compiler CPU Code G80 GPU Target code Código PTX El código PTX se puede obtener compilando con la flag ptx: nvcc ptx algo.cu Se genera el archivo algo.ptx El código PTX permite hilar muy fino en aspectos del código CUDA que impactan en la performance. 14

15 Código PTX global void CopiaRara(float * output, float * input){ int idx = blockidx.x * blockdim.x + threadidx.x; output[idx] = input[idx] * 2.27; Inspeccionemos el código resultante (ver archivo1.ptx). ld.global.f32 %f1, [%rd4+0]; // id:17 cvt.f64.f32 %fd1, %f1; // mov.f64 %fd2, 0d400228f5c28f5c29; // 2.27 mul.f64 %fd3, %fd1, %fd2; // cvt.rn.f32.f64 %f2, %fd3; // Código PTX global void CopiaRara(float * output, float * input){ int idx = blockidx.x * blockdim.x + threadidx.x; output[idx] = input[idx] * 2.27f; Inspeccionemos el código resultante (ver archivo2.ptx). El mismo fragmento de programa se transformó en: ld.global.f32 %f1, [%rd4+0]; // id:17 mov.f32 %f2, 0f401147ae; // 2.27 mul.f32 %f3, %f1, %f2; Errores en tiempo de ejecución 15

16 Errores en tiempo de ejecución CUDA no avisa cuando se produce un error. Veamos un ejemplo: int main(int argc, char *argv[]){ float * input = NULL; int size = 1000 * sizeof(float); float * inputcpu = NULL; inputcpu = (float*) malloc (size); for (int j=0;j<1000);j++) { inputcpu[j]=j+1.1f; cudamemcpy(input,inputcpu,size, cudamemcpyhosttodevice); return 0; input no tiene memoria reservada y no da error!!!! Errores en tiempo de ejecución CUDA SDK provee macros en cutil.h para revisar errores. Cada llamada a la biblioteca CUDA se puede envolver con CUDA_SAFE_CALL() Luego de la ejecución de cada kernelpodemos revisar los errores con CUT_CHECK_ERROR() Errores en tiempo de ejecución A ver #include "cutil.h" int main(int argc, char *argv[]){ float * input = NULL; int size = 1000 * sizeof(float); float * inputcpu = NULL; inputcpu = (float*) malloc (size); for (int j=0;j<1000);j++) { inputcpu[j]=j+1.1f; cudamemcpy(input,inputcpu,size, cudamemcpyhosttodevice); CUDA_SAFE_CALL(cudaFree(input)); return 0; Sigue sin fallar!!!! y entonces???? 16

17 Errores en tiempo de ejecución Los errores de CUDA son asíncronos. El fallo se produce en cudamemcopy. La llamada a cudafree se realiza pero sin ejecutarse. Sugerencias: Envolver todas las llamadas la biblioteca CUDA con CUDA_SAFE_CALL() Después de un kernel cudathreadsychronize()para forzar que termine su ejecución Revisar los errores del kernel con CUT_CHECK_ERROR() Errores en tiempo de ejecución Ahora si!!! #include "cutil.h" int main(int argc, char *argv[]){ float * input = NULL; int size = 1000 * sizeof(float); float * inputcpu = NULL; inputcpu = (float*) malloc (size); for (int j=0;j<1000);j++) { inputcpu[j]=j+1.1f; CUDA_SAFE_CALL(cudaMemcpy(input,inputCPU,size, cudamemcpyhosttodevice)); CUDA_SAFE_CALL(cudaFree(input)); return 0; Cudaerror in file'error.cu' in line 32 : invaliddevicepointer. Algunas recomendaciones adicionales sobre performance 17

18 Algunas recomendaciones adicionales sobre performance Evitar la divergencia de hilos dentro de un warp. El número de bloques debe ser mayor al número de multiprocesadores: - De forma de mantener a todos los multiprocesadores ocupados. - Para permitir ocultar latencias cuando un bloque está trancado con un syncthreads()debe ser mayor al doble del número de multiprocesadores. El número de hilos por bloque debe ser un múltiplo de 32 (tamaño de warp). 18