Linha de produção

SIMD

Single instruction, multiple data (SIMD) é uma forma de paralelismo ao nível do hardware. A mesma computação é realizada pela CPU sobre vários elementos ao mesmo tempo.

Considera, por exemplo, a soma elemento a elemento de dois arrays de quatro números de vírgula flutuante de 32 bits. 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 dá quatro vezes mais trabalho por instrução.

Em assembly x86-64, as instruções SIMD são normalmente executadas com registos xmm. Algumas dessas instruções operam sobre inteiros. Outras operam sobre números de vírgula flutuante.

Esses inteiros ou números de vírgula flutuante chamam-se empacotados. Cada um ocupa um espaço, a que se chama lane, dentro do mesmo registo. As instruções SIMD operam tipicamente em paralelo sobre valores que estão na mesma posição de lane em dois operandos de origem. O resultado de cada operação é guardado no lane que ocupa a mesma posição no 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. Consoante a 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 vírgula flutuante empacotados de precisão simples (4 bytes). Para esta instrução, cada bloco de 4 bytes de um operando é um lane diferente. Num 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. Isto porque esta instrução realiza uma multiplicação empacotada sobre valores de precisão dupla (8 bytes):

Neste conceito vamos focar-nos numa pequena seleção de instruções SIMD. Estas operam sobre valores de vírgula flutuante empacotados, usando registos xmm.

Instruções SIMD de vírgula flutuante

Como regra geral, as instruções SIMD que operam sobre valores de vírgula flutuante assumem uma forma com 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 escalar) (por exemplo, add, mul, etc.).
2. Um sufixo p para indicar que a instrução opera sobre dados empacotados, na mesma posição que antes era 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 obtém-se, por isso, a partir do nome escalar, substituindo o s (escalar) no meio da mnemónica por um p (empacotado). O nome da operação e o sufixo de tamanho mantêm-se 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

Existem também instruções SIMD para converter entre valores de vírgula flutuante empacotados de precisão simples e de precisão dupla. Seguem a mesma regra de nomenclatura, com cada s de escalar substituído por um p de empacotado:

Estas instruções ilustram o que foi dito antes: um lane é uma interpretação, não um limite rígido. Os operandos de origem e de destino têm tamanhos de lane diferentes, por isso têm um número diferente de lanes.

Em 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:

Em 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 postos a 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 apresentadas com operandos de registo para registo. Também podem ter 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 vírgula flutuante de precisão simples). cvtps2pd, em contrapartida, lê apenas 8 bytes (2 números de vírgula flutuante de precisão simples), porque é só isso que precisa de ler.

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, tem de estar alinhado a 16 bytes. Uma posição de memória alinhada é aquela cujo endereço é um múltiplo do tamanho da operação (16 bytes, neste caso).

Para declarar memória alinhada, podes usar a diretiva align na section .data e .rodata, ou alignb, na section .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

Os operandos de memória com menos de 16 bytes, como a origem de 8 bytes de cvtps2pd, não têm qualquer requisito de alinhamento.

Carregar e guardar valores

Há quatro instruções que copiam 128 bits de valores de vírgula flutuante empacotados. Operam entre dois registos xmm, ou entre um registo xmm e uma posição de memória:

Todas estas instruções podem ser usadas para copiar valores entre dois registos xmm.

Se a operação envolver uma posição de memória, movaps e movapd exigem que esta esteja alinhada. movaps e movapd provocam uma falha se receberem um endereço desalinhado. Servem também de verificação de segurança de que a disposição dos teus dados é aquela que pensas que é.

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

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

Extensões SIMD

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

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

Primeiro, o suporte para registos SIMD de 256 bits, chamados ymm. Estes ampliam os registos xmm correspondentes, tal como rax contém eax.

Segundo, incluem suporte para variantes de 3 operandos na maioria das instruções que operam sobre registos xmm (e ymm). Isto inclui não só as instruções SIMD, mas também as que operam sobre valores de vírgula flutuante escalares. Essas variantes seguem a mesma notação da sua equivalente SSE, com um v acrescentado à frente:

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 aos operandos de memória SIMD é mais flexível. Apenas os movimentos explicitamente alinhados, como vmovaps, exigem este alinhamento.

Neste track, limitámo-nos às instruções e aos registos das extensões SSE anteriores. Isto é suficiente para ensinar os fundamentos e garante compatibilidade com uma grande variedade de CPUs.

No entanto, o test-runner suporta totalmente AVX e AVX2, e até as extensões mais recentes que fazem parte do AVX-512. Podes usá-las à vontade.