Linha de produção

SIMD

Instrução única, múltiplos dados (SIMD) é uma forma de paralelismo em nível de hardware. O mesmo cálculo é realizado pela CPU sobre vários elementos ao mesmo tempo.

Considere, por exemplo, a soma de dois arrays de quatro números de ponto flutuante de 32 bits, elemento por elemento. Uma implementação escalar emitiria quatro instruções addss separadas, uma por elemento. Uma implementação SIMD usa um único addps para fazer as quatro adições em paralelo. Isso significa quatro vezes mais trabalho por instrução.

Em assembly x86-64, as instruções SIMD normalmente são executadas usando registradores xmm. Algumas dessas instruções operam sobre inteiros. Outras operam sobre números de ponto flutuante.

Esses inteiros ou números de ponto flutuante são chamados de empacotados. Cada um ocupa um espaço, chamado de lane, dentro do mesmo registrador. As instruções SIMD normalmente operam em paralelo sobre valores na mesma posição de lane em dois operandos de origem. O resultado de cada operação é armazenado no lane na mesma posição do operando de destino.

Um lane não é um limite rígido. É uma interpretação que cada instrução dá a uma sequência de bytes. Um operando de 128 bits contém 16 bytes. Dependendo da instrução, esses bytes podem ser interpretados como 16 lanes de 1 byte, 8 lanes de 2 bytes, 4 lanes de 4 bytes, 2 lanes de 8 bytes, ou até um único lane de 16 bytes.

Por exemplo, a instrução addps soma valores de ponto flutuante empacotados de precisão simples (4 bytes). Para essa instrução, cada bloco de 4 bytes em um operando é um lane diferente. Em um operando de 128 bits de largura (16 bytes):

Por outro lado, um operando de 128 bits seria interpretado como tendo 2 lanes no caso de mulpd. Isso porque essa instrução realiza multiplicação empacotada sobre valores de precisão dupla (8 bytes):

Neste conceito, vamos nos concentrar em uma pequena seleção de instruções SIMD. Elas operam sobre valores de ponto flutuante empacotados usando registradores xmm.

Instruções SIMD de ponto flutuante

Como regra geral, as instruções SIMD que operam sobre valores de ponto flutuante têm a forma de dois operandos. O nome delas segue uma certa estrutura:

1. A operação realizada, com o mesmo nome da sua equivalente não SIMD (também chamada de escalar) (por exemplo, add, mul, etc.).
2. Um sufixo p para indicar que a instrução opera sobre dados empacotados, na mesma posição antes ocupada por um s (para dados escalares).
3. Um sufixo para indicar o tamanho de cada lane, seguindo a mesma semântica da sua equivalente não SIMD (s para precisão simples e d para precisão dupla).

O nome empacotado é, portanto, obtido a partir do nome escalar substituindo o s (escalar) no meio do mnemônico por um p (empacotado). O nome da operação e o sufixo de tamanho permanecem inalterados:

Aritmética

As instruções SIMD aritméticas seguem a regra acima. Alguns exemplos:

addps xmm0, xmm1 ; xmm0 = xmm0 + xmm1 (each 32-bit float at the same position)
subpd xmm2, xmm3 ; xmm2 = xmm2 - xmm3 (each 64-bit float at the same position)
mulps xmm4, xmm5 ; xmm4 = xmm4 * xmm5 (each 32-bit float at the same position)
divpd xmm6, xmm7 ; xmm6 = xmm6 / xmm7 (each 64-bit float at the same position)

Conversão entre precisões

Também existem instruções SIMD para converter entre valores de ponto flutuante empacotados de precisão simples e de precisão dupla. Elas seguem a mesma regra de nomenclatura, com cada s de escalar substituído por um p de empacotado:

Essas instruções ilustram o ponto anterior: um lane é uma interpretação, não um limite rígido. Os operandos de origem e de destino têm tamanhos de lane diferentes, então têm contagens de lanes diferentes.

Para cvtps2pd, a origem (ps) tem 4 lanes de precisão simples. O destino (pd) tem 2 lanes de precisão dupla. Apenas os 2 lanes inferiores da origem são lidos. Os 2 superiores são ignorados:

Para cvtpd2ps, a origem (pd) tem 2 lanes de precisão dupla. O destino (ps) tem 4 lanes de precisão simples. Os dois lanes da origem são convertidos e escritos nos 2 lanes inferiores do destino. Os 2 lanes superiores do destino são definidos como zero:

Alguns exemplos:

cvtps2pd xmm0, xmm1 ; xmm0 = xmm1 as 2 doubles (low 2 lanes of xmm1 are read)
cvtpd2ps xmm0, xmm1 ; xmm0 = xmm1 as 2 floats (in low 2 lanes; upper 2 zeroed)

Operandos de memória

As instruções SIMD acima foram todas mostradas com operandos de registrador para registrador. Elas também podem receber um operando de memória como origem (mas não como destino).

O número de bytes lidos da memória é determinado pela instrução. Por exemplo, addps lê 16 bytes (4 números de ponto flutuante de precisão simples). cvtps2pd, em contrapartida, lê apenas 8 bytes (2 números de ponto flutuante de precisão simples), porque é tudo o que ele precisa como entrada.

addps    xmm0, [rsi]      ; xmm0 = xmm0 + 4 floats at [rsi]
mulpd    xmm1, [rsi + 16] ; xmm1 = xmm1 * 2 doubles at [rsi + 16]
cvtps2pd xmm2, [rsi + 8]  ; xmm2 = (2 floats at [rsi + 8]) converted to 2 doubles

Quando o operando de memória tem 16 bytes de largura, ele deve estar alinhado em 16 bytes. Um local de memória alinhado é aquele cujo endereço é um múltiplo do tamanho da operação (16 bytes neste caso).

Para declarar memória alinhada, você pode usar a diretiva align na seção .data e .rodata, ou alignb, na seção .bss:

section .rodata
align 16
mem1: dd 4.0, 3.5, 2.0, -1.0

section .data
align 16
mem2: dq 6.0, 2.1

section .bss
alignb 16
mem3: resb 16

section .text
fn:
    movaps xmm0, oword [rel mem1] ; loads 4 packed 32-bit floats in xmm0
    movapd xmm1, oword [rel mem2] ; loads 2 packed 64-bit floats in xmm1
    movaps oword [rel mem3], xmm0 ; stores 4 packed 32-bit floats in mem3
    ret

Operandos de memória menores que 16 bytes, como a origem de 8 bytes de cvtps2pd, não têm exigência de alinhamento.

Carregar e armazenar valores

Existem quatro instruções que copiam 128 bits de valores de ponto flutuante empacotados. Elas operam entre dois registradores xmm, ou entre um registrador xmm e um local de memória:

Todas essas instruções podem ser usadas para copiar valores entre dois registradores xmm.

Se a operação envolver um local de memória, movaps e movapd exigem que ele esteja alinhado. movaps e movapd geram uma falha se receberem um endereço desalinhado. Elas também servem como uma verificação de segurança de que o layout dos seus dados é o que você imagina.

Por outro lado, movups e movupd podem ser usadas com qualquer local de memória, alinhado ou não.

O prefixo de tamanho para um valor de 16 bytes no NASM é oword.

Extensões SIMD

O SIMD tem sido alvo de desenvolvimento ativo no ecossistema x86-64 há décadas. Cada extensão da arquitetura traz novas instruções ou novos usos para instruções antigas.

Em particular, as extensões AVX e AVX2 introduzem algumas mudanças relevantes.

Primeiro, suporte a registradores SIMD de 256 bits, chamados de ymm. Eles estendem os registradores xmm correspondentes, assim como rax contém eax.

Segundo, elas incluem suporte a variantes de 3 operandos para a maioria das instruções que operam sobre registradores xmm (e ymm). Isso inclui não apenas instruções SIMD, mas também as que operam sobre valores de ponto flutuante escalares. Essas variantes seguem a mesma notação da sua equivalente SSE, com um v adicionado antes:

vaddsd xmm0, xmm1, xmm2   ; xmm0 = xmm1 + xmm2 (scalar sum of 64-bit floats)
vmulps xmm1, xmm3, xmm4   ; xmm1 = xmm3 * xmm4 (packed multiplication of 32-bit floats)
vmovupd ymm5, yword [mem] ; this copies 32 bytes from the location at mem to ymm5

Terceiro, o alinhamento exigido dos operandos de memória SIMD é relaxado. Apenas movimentos explicitamente alinhados, como vmovaps, exigem esse alinhamento.

Nesta trilha, nos limitamos a instruções e registradores até as extensões SSE anteriores. Isso é o suficiente para ensinar os fundamentos e garante compatibilidade com uma ampla variedade de CPUs.

No entanto, o test-runner tem suporte completo a AVX e AVX2, e até mesmo às extensões mais novas que fazem parte do AVX-512. Fique à vontade para usá-las.