Técnicas de Otimização de Código para Placas de ... - UFMG

__global__ void matMulUnroll ( f l o a t∗ B, f l o a t∗ C, f l o a t∗ Pd , i n t Width ) {
__shared__ f l o a t Bs [ TILE_WIDTH ] [ TILE_WIDTH ] ;
__shared__ f l o a t Cs [ TILE_WIDTH ] [ TILE_WIDTH ] ;
i n t t x = threadIdx . x ;
i n t t y = threadIdx . y ;
i n t Row = b l o c k I dx . x ∗ TILE_WIDTH + t x ;
i n t Col = b l o c k I d x . y ∗ TILE_WIDTH + t y ;
f l o a t Pvalue = 0;
for ( i n t m = 0; m < Width / TILE_WIDTH ; ++m) {
Bs [ t y ] [ t x ] = B [ Col ∗ Width + (m ∗ TILE_WIDTH + t x ) ] ;
Cs [ t y ] [ t x ] = C[Row + (m ∗ TILE_WIDTH + t y ) ∗ Width ] ;
__syncthreads ( ) ;
Pvalue += Bs [ t y ] [ 0] ∗ Cs [ 0 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 1] ∗ Cs [ 1 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 2] ∗ Cs [ 2 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 3] ∗ Cs [ 3 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 4] ∗ Cs [ 4 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 5] ∗ Cs [ 5 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 6] ∗ Cs [ 6 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 7] ∗ Cs [ 7 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 8] ∗ Cs [ 8 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 9] ∗ Cs [ 9 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 1 0 ] ∗ Cs [ 1 0 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 1 1 ] ∗ Cs [ 1 1 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 1 2 ] ∗ Cs [ 1 2 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 1 3 ] ∗ Cs [ 1 3 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 1 4 ] ∗ Cs [ 1 4 ] [ t x ] ;
Pvalue += Bs [ t y ] [ 1 5 ] ∗ Cs [ 1 5 ] [ t x ] ;
__syncthreads ( ) ;
}
Pd [ Col ∗ Width + Row] = Pvalue ;
}
Figura 1.26. Multiplicação de matrizes após
a aplicação do desenrolamento.
seja N 2 /2 o tamanho de cada ladrilho. Temos então, um total
de 2(N/(N/2)) 2 ladrilhos. Cada ladrilho é lido N/(N/2) vezes.
Portanto, temos 4N 2 leituras da memória global. Dadas as 2N 3
leituras do programa original, observamos uma redução substancial
destes acesso, com consequâncias não menos notáveis
para o desempenho da aplicação ladrilhada: o programa da figura
1.24 é cerca de 25% mais rápido que o programa da figura
1.22, quando executado em uma placa GPU 9400M.
Desenlaço. Aumentamos a taxa de trabalho útil realizado por
um kernel diminuindo a quantidade de instruções que não realizam
operações de ponto-flutuante – no caso de um programa
que produz saída neste formato. Entre estas instruções, destacam-se
as operações de acesso à memória e as operações que
controlam o fluxo do programa: desvios condicionais e incon-
30