Presentación de PowerPoint - Iniciofisica.cab.cnea.gov.ar/gpgpu/images/charlas/partec... · •...

PARTE C – Programación II 3EAGPGPU

3EAGPGPU

Pablo Ezzatti

CUDA Básico


Parte C


Contenido

• Continuamos programando

• Acceso Coalesced a Memoria Global

• Memoria compartida

• Reduce

• Algunas recomendaciones de performance


Continuamos programando


Programación en CUDA

Lanzamiento del kernel (2)

// configuración de la ejecución

int bloques = N / 128;

dim3 tamGrid(1, bloques); //Grid dimensión

dim3 tamBlock(1, 128, 1); //Block dimensión

// lanzamiento del kernel

MatrixSumKernel<<<tamGrid, tamBlock>>>( M, Md, Nd);

Hay que hacer cambios en el Kernel !!!!



Kernel (2)

// Suma por columnas de una matriz

__global__ void SumaColMatrizKernel(int M, float* Md, float* Nd){

//

float Pvalue = 0;

int aux = blockIdx.y*blockDim.y + threadIdx.y;

int aux2 = aux*M;

for (int k = 0; k < M; ++k) {

Pvalue = Pvalue + Md[aux2+k];

}

Nd[aux] = Pvalue;

}



Vamos a la máquina 2

• Trasladar los códigos para hacer el kernel 2.

• Compilar.

• Ejecutar.




int bloques = N / 128;

dim3 tamGrid(1, bloques); //Grid dimensión

dim3 tamBlock(1, 128, 1); //Block dimensión


MatrixSumKernel<<<tamGrid, tamBlock>>>( M, Md, Nd);



//

float Pvalue = 0;

int aux = blockIdx.y*blockDim.y + threadIdx.y;

int aux2 = aux*M;

for (int k = 0; k < M; ++k) {

Pvalue = Pvalue + Md[aux2+k];

}

Nd[aux] = Pvalue;

}





int chunk = 32;

dim3 tamGrid(1, N); //Grid dimensión

dim3 tamBlock(M/chunk,1,1); //Block dimensión


SumaColMatrizKernel<<<tamGrid, tamBlock>>>(M, Md, Nd);




• Hacer el kernel 3 utilizando atomicAdd().

atomicAdd(float* address, float val);

• Compilar.

• Ejecutar.



Kernel (3)



//

float Pvalue = 0;

int aux = blockIdx.y*M + threadIdx.x*(M/blockDim.x);

int aux2 = aux + (M/blockDim.x);

for (int k = aux; k < aux2; ++k) {

Pvalue = Pvalue + Md[k];

}

atomicAdd(&(Nd[blockIdx.y]), Pvalue);

}

atomicAdd() funciona a partir de compute capabilities 2.0 !!!



Lanzamiento del kernel (4a - 40)


int chunk = 32;

dim3 tamGrid(1, N/chunk); //Grid dimensión

dim3 tamBlock(M/chunk,chunk,1); //Block dimensión


SumaColMatrizKernel<<<tamGrid, tamBlock>>>(M, N, Md, Nd);

Si quiero otro balance



Kernel (4a-40)


__global__void SumaColMatrizKernel (int M,int N,float*Md,float* Nd){

//

float Pvalue = 0;

int aux = blockIdx.y* (N/gridDim.y)*M + threadIdx.y*M+

threadIdx.x * (M/blockDim.x);




}

atomicAdd(&(Nd[blockIdx.y*(N/gridDim.y)+threadIdx.y]), Pvalue);

}




• Que pasa si tenemos más de 1024 columnas y filas ?!

• Hacer un kernel 4 que cubra esta problemática.

• Compilar.

• Ejecutar.





int chunk = 32;

dim3 tamGrid(chunk, N/chunk); //Grid dimensión




Si tengo más de 1024 filas:



Kernel (4)



//

float Pvalue = 0;

int aux = blockIdx.y* (N/gridDim.y)*M + blockIdx.x*M+

threadIdx.x * (M/blockDim.x);




}

atomicAdd(&(Nd[blockIdx.y*(N/gridDim.y)+ blockIdx.y]), Pvalue);

}


Acceso Coalesced a Memoria Global



• 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.

• Simplificando ….

hilos consecutivos tienen que acceder a espacios de memoria consecutivos !



• 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-warp se fusionan en una o más transacciones según características que dependen de las compute capability de la tarjeta.



• 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.



• Ejemplo 1:

– Lanzando 10000 veces 320 bloques de 128 hilos en una 9800 GTX+ (Comp. Cap 1.1, 512 MB, 128 CUDA cores)

__global__ void CopiaOffset(float *output, float *input, int offset) {

int idx = blockIdx.x * blockDim.x + threadIdx.x + offset;

output[idx] = input[idx];

}



• Ejemplo 2 (gentileza de Robert Strzodka):

struct NormalStruct {

Type1 comp1;

Type2 comp2;

Type3 comp3;

};

typedef NormalStruct

AoSContainer[SIZE];

AoSContainer container;

Array of Structs (AoS)

struct SoAContainer{

Type1 comp1[SIZE];

Type2 comp2[SIZE];

Type3 comp3[SIZE];

};

SoAContainer container;

Struct of Arrays (SoA)



• Ejemplo 2 (gentileza de Robert Strzodka):

container[1].comp3;

container[2].comp3;

container[3].comp3;

container[4].comp3;

Array of Structs (AoS):

Struct of Arrays (SoA): container.comp3[1];

container.comp3[2];

container.comp3[3];

container.comp3[4];




• Apliquemos la idea de acceso coalesced al kernel 3 !!, haciendo un kernel 5

• Compilar.

• Ejecutar.





Int chunk=32;







Kernel (5)



//

float Pvalue = 0;

int aux = blockIdx.y* M + threadIdx.x;

for (int k = aux; k < M+aux; k += blockDim.x) {


}

atomicAdd(&(Nd[blockIdx.y]), Pvalue);

}


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 coalesced a 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.


Grid

Global

Memory

Block (0, 0)‏

Shared Memory

Thread (0, 0)‏

Registers

Thread (1, 0)‏

Registers

Block (1, 0)‏

Shared Memory

Thread (0, 0)‏

Registers

Thread (1, 0)‏

Registers

Host

Memoria Compartida

Grid

Global

Memory

Block (0, 0)‏

Shared Memory

Thread (0, 0)‏

Registers

Thread (1, 0)‏

Registers

Block (1, 0)‏

Shared Memory

Thread (0, 0)‏

Registers

Thread (1, 0)‏

Registers

Host


Memoria Compartida


• Hagamos un kernel (kernel 6) que utilice memoria compartida para sumar matrices

__shared __float Nds[DIMBLOCKX];

__syncthreads();

• Compilar.

• Ejecutar.


Memoria Compartida

Lanzamiento del kernel memoria compartida


int chunk = 32;




SumaColMatrizKernel<<<tamGrid, tamBlock>>>(M, Md, Nd);


Memoria Compartida


__shared __float Nds[DIMBLOCKX];

float Pvalue = 0;

int aux = blockIdx.y*M + threadIdx.x*(M/blockDim.x);




}

Nds[threadIdx.x] = Pvalue;

__syncthreads();

if (threadIdx.x == 0){

for (int i = 1; i < blockDim.x; ++i) {

Nds[0] = Nds[0]+Nds[i];

}

Nd[blockIdx.y] = Nds[0];

}

}


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:

• 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);

#define CANT_HILOS 128

__global__ void reduction(float * output, float * input) {

__shared__ float intermedio[CANT_HILOS];

…

};

reduction <<<N_BLOCK,CANT_HILOS>>> (output,input);


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];

__syncthreads();

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

Primer enfoque

• Bloques 5000

• Hilos 128

• Ejecutado en loop 5000 x 128 veces en una 9800 GTX+ (Comp. Cap 1.1, 512 MB, 128 CUDA cores – una reliquia !-), el tiempo de ejecución es aproximadamente 505 s.

• La implementación tiene varios problemas.

• El más importante es la divergencia de warps.


Reduce

Segundo enfoque


Reduce Segundo enfoque

__global__ void reduction(float * output, float * input){


int step = 1;



__syncthreads();

while (step < blockDim.x) {

if (threadIdx.x < blockDim.x/step)

intermedio[2*step*threadIdx.x] =

intermedio[2*step*threadIdx.x]+intermedio[2*step*threadIdx.x+step];

__syncthreads();

step = step * 2;

}

__syncthreads();

if (threadIdx.x==0)


}


Reduce

• Bloques 5000

• Hilos 128

• Ejecutado en loop 5000 x 128 veces en una 9800 GTX+ (Comp. Cap 1.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.

Segundo enfoque


Reduce

Tercer enfoque


Reduce

Tercer enfoque __global__ void reduction(float * output, float * input){




__syncthreads();

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)


}


Reduce

• Bloques 5000

• Hilos 128

• Ejecutado en loop 5000 x 128 veces en una 9800 GTX+ (Comp. Cap 1.1, 512 MB, 128 CUDA cores), el tiempo de ejecución es aproximadamente 153 s. (mejora 3.30).

Tercer enfoque


Reduce

Otras optimizaciones …

• loop unrolling

• leer más de una palabra de la memoria global

• lower occupancy


Algunas recomendaciones adicionales sobre performance


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).


Gracias !

Pablo Ezzatti

[email protected]

CUDA Básico - 3EAGPGPU

Presentación de PowerPoint - Iniciofisica.cab.cnea.gov.ar/gpgpu/images/charlas/partec... · •...

Documents

Transcript of Presentación de PowerPoint - Iniciofisica.cab.cnea.gov.ar/gpgpu/images/charlas/partec... · •...