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

__global__ void matMulCoalesced ( f l o a t∗ B, f l o a t∗ C, f l o a t∗ A, i n t W) {
f l o a t Pvalue = 0 . 0 ;
i n t t x = b l o c k I d x . x ∗ blockDim . x + threadIdx . x ;
i n t t y = b l o c k I d x . y ∗ blockDim . y + threadIdx . y ;
for ( i n t k = 0; k < W; ++k ) {
Pvalue += B [ t y ∗ W + k ] ∗ C[ k ∗ W + t x ] ;
}
A [ t x + t y ∗ W] = Pvalue ;
}
Figura 1.22. Modificação do programa da
figura 1.21 para usar acessos agrupados à
memória global.
vamente supondo (tx,ty) = (0,0),(1,0),...,(15,0), e W = 600, as
posições lidas da matrix B serão sempre as mesmas para todas
as threads em meio warp e as posições lidas da matriz C serão
consecutivas e portanto contidas em um segmento de dados.
Esta simples modificação de código nos dá um programa que
é quase 10 vezes mais rápido que aquele programa visto na
figura 1.21, quando executado em uma placa GPU 9400M!
A memória global e a memória compartilhada. Uma boa maneira
de medirmos o desempenho de uma função em C para
CUDA é contarmos quantas operações de ponto-flutuante esta
função realiza por segundo [32]. Este número é conhecido por
(FLOPS) e para obtê-lo, faz-se conveniente observarmos o programa
PTX produzido pelo laço mais interno do programa na
figura 1.22, o qual é mostrado na figura 1.23. Aproximadamente
1/8 das instruções dentro do laço deste programa são
operações de ponto flutuante: existem 16 instruções, uma delas,
multiply-add, equivale a duas operações. Considerando-se
que uma placa GTX 8800 realiza 172.8 bilhões de operações
de ponto-flutuante por segundo, então temos, neste hardware,
uma taxa de trabalho de 21.6 GFLOPS. Entretanto, ao medir-se
o desempenho deste programa em tal placa, percebeu-se que
a taxa de trabalho real é bem menor: 10.58 GFLOPS [32]. O
gargalo, neste caso, é a forma de utilização da memória.
26