Desenrole o loop e faça soma independente com vetorização
Para o loop a seguir, o GCC somente vetorizará o loop se eu disser para usar a matemática associativa, por exemplo. com-Ofast
.
float sumf(float *x)
{
x = (float*)__builtin_assume_aligned(x, 64);
float sum = 0;
for(int i=0; i<2048; i++) sum += x[i];
return sum;
}
Aqui está a montagem com-Ofast -mavx
sumf(float*):
vxorps %xmm0, %xmm0, %xmm0
leaq 8192(%rdi), %rax
.L2:
vaddps (%rdi), %ymm0, %ymm0
addq $32, %rdi
cmpq %rdi, %rax
jne .L2
vhaddps %ymm0, %ymm0, %ymm0
vhaddps %ymm0, %ymm0, %ymm1
vperm2f128 $1, %ymm1, %ymm1, %ymm0
vaddps %ymm1, %ymm0, %ymm0
vzeroupper
ret
Isso mostra claramente que o loop foi vetorizado.
Mas esse loop também tem uma cadeia de dependência. Para superar a latência da adição, preciso desenrolar e fazer somas parciais pelo menos três vezes no x86_64 (excluindo Skylake, que precisa desenrolar oito vezes, e fazendo as instruções FMA, que precisam desenrolar 10 vezes em Haswell e Broadwell) . Tanto quanto eu entendo, eu posso desenrolar o loop com-funroll-loops
.
Aqui está a montagem com-Ofast -mavx -funroll-loops
.
sumf(float*):
vxorps %xmm7, %xmm7, %xmm7
leaq 8192(%rdi), %rax
.L2:
vaddps (%rdi), %ymm7, %ymm0
addq $256, %rdi
vaddps -224(%rdi), %ymm0, %ymm1
vaddps -192(%rdi), %ymm1, %ymm2
vaddps -160(%rdi), %ymm2, %ymm3
vaddps -128(%rdi), %ymm3, %ymm4
vaddps -96(%rdi), %ymm4, %ymm5
vaddps -64(%rdi), %ymm5, %ymm6
vaddps -32(%rdi), %ymm6, %ymm7
cmpq %rdi, %rax
jne .L2
vhaddps %ymm7, %ymm7, %ymm8
vhaddps %ymm8, %ymm8, %ymm9
vperm2f128 $1, %ymm9, %ymm9, %ymm10
vaddps %ymm9, %ymm10, %ymm0
vzeroupper
ret
O GCC desenrola o loop oito vezes. No entanto, ele não faz somas independentes. Faz oito somas dependentes. Isso é inútil e não é melhor do que sem desenrolar.
Como posso fazer com que o GCC desenrole o loop e faça somas parciais independentes?
Editar:
Clang desenrola a quatro somas parciais independentes, mesmo sem-funroll-loops
para SSE, mas não tenho certeza se o código AVX é tão eficiente. O compilador não deve precisar-funroll-loops
com-Ofast
de qualquer maneira, é bom ver que Clang está fazendo isso certo pelo menos para o SSE.
Clang 3.5.1 with-Ofast
.
sumf(float*): # @sumf(float*)
xorps %xmm0, %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
.LBB0_1: # %vector.body
movups (%rdi,%rax,4), %xmm2
movups 16(%rdi,%rax,4), %xmm3
addps %xmm0, %xmm2
addps %xmm1, %xmm3
movups 32(%rdi,%rax,4), %xmm0
movups 48(%rdi,%rax,4), %xmm1
addps %xmm2, %xmm0
addps %xmm3, %xmm1
addq $16, %rax
cmpq $2048, %rax # imm = 0x800
jne .LBB0_1
addps %xmm0, %xmm1
movaps %xmm1, %xmm2
movhlps %xmm2, %xmm2 # xmm2 = xmm2[1,1]
addps %xmm1, %xmm2
pshufd $1, %xmm2, %xmm0 # xmm0 = xmm2[1,0,0,0]
addps %xmm2, %xmm0
retq
ICC 13.0.1 com-O3
desenrola a duas somas parciais independentes. O ICC aparentemente assume matemática associativa apenas com-O3
.
.B1.8:
vaddps (%rdi,%rdx,4), %ymm1, %ymm1 #5.29
vaddps 32(%rdi,%rdx,4), %ymm0, %ymm0 #5.29
vaddps 64(%rdi,%rdx,4), %ymm1, %ymm1 #5.29
vaddps 96(%rdi,%rdx,4), %ymm0, %ymm0 #5.29
addq $32, %rdx #5.3
cmpq %rax, %rdx #5.3
jb ..B1.8 # Prob 99% #5.3