Início / coding / Perguntas / 78973642
Accepted
HiroIshida
Asked: 2024-09-11 19:52:08 +0800 CST

Por que os compiladores modernos preferem SSE em vez de FPU para operações de ponto flutuante simples

  • 772

Recentemente, tentei ler assemblies do binário do meu código e descobri que muitas operações de ponto flutuante são feitas usando registradores XMM e instruções SSE. Por exemplo, o código a seguir:

float square(float a) {
    float b = a + (a * a);
    return b;
}

será compilado em

        push    rbp
        mov     rbp, rsp
        movss   DWORD PTR [rbp-20], xmm0
        movss   xmm0, DWORD PTR [rbp-20]
        mulss   xmm0, xmm0
        movss   xmm1, DWORD PTR [rbp-20]
        addss   xmm0, xmm1
        movss   DWORD PTR [rbp-4], xmm0
        movss   xmm0, DWORD PTR [rbp-4]
        pop     rbp
        ret

e o resultado é semelhante para outros compiladores. https://godbolt.org/z/G988PGo6j

E com -O3bandeira

        movaps  xmm1, xmm0
        mulss   xmm0, xmm0
        addss   xmm0, xmm1
        ret

Isso significa que as operações que usam registradores e instruções SIMD são geralmente mais rápidas do que usar registradores normais e a FPU?

Também estou curioso sobre casos específicos em que a decisão do compilador de usar SSE pode falhar.

c

1 respostas

  1. Best Answer

    O SSE foi desenvolvido como um substituto para a FPU x87, pois o design da FPU x87 é um pouco idiossincrático e difícil de gerar código. Os principais problemas são:

    • a geração de código para processadores baseados em pilha como o x87 FPU não é tão bem compreendida quanto para processadores baseados em registro, tornando o código gerado por muitos compiladores cheio de instruções extras fxch, fld, e ineficientes fst(p). Isso é muito mais fácil de acertar com uma arquitetura baseada em registro como SSE.
    • O SSE suporta a operação SIMD, acelerando muito as operações de ponto flutuante em matrizes, se usado. O X87 não suporta tal coisa
    • na FPU x87, o tipo de dados usado é o formato de ponto flutuante de 80 bits da Intel. A precisão das operações de ponto flutuante é configurada usando um registrador de controle e é cara para mudar. Portanto, os compiladores que geram código para a unidade x87 executariam todos os cálculos com precisão total, mesmo quando apenas precisão única é solicitada pelo programador. Isso altera o resultado ligeiramente e reduz o desempenho, pois operações de maior precisão podem levar mais tempo para serem concluídas. Além disso, cada carga e armazenamento de/para a unidade x87 envolve uma conversão implícita de tipo de dados. A unidade SSE, por outro lado, codifica a precisão na instrução usada, permitindo que o compilador use exatamente a precisão que o programador solicitou.
    • recentemente, os fabricantes de CPU reduziram os investimentos em melhorias na FPU x87 (ou até mesmo retiraram melhorias existentes, como fxchuma renomeação), levando a uma lacuna cada vez maior no desempenho entre x87 e SSE.

    Recomendo usar somente a FPU x87 se o tamanho do código for um problema ou se você precisar do formato de ponto flutuante de 80 bits. Caso contrário, fique com SSE ou (em processadores recentes) AVX.

    • 9

relate perguntas