Línea de producción

SIMD

Una instrucción, múltiples datos (SIMD) es una forma de paralelismo a nivel de hardware. La CPU realiza el mismo cálculo sobre varios elementos al mismo tiempo.

Considera, por ejemplo, sumar dos arrays de cuatro números de punto flotante de 32 bits elemento por elemento. Una implementación escalar emitiría cuatro instrucciones addss separadas, una por elemento. Una implementación SIMD usa un solo addps para hacer las cuatro sumas en paralelo. Eso da cuatro veces más trabajo por instrucción.

En ensamblador x86-64, las instrucciones SIMD normalmente se realizan usando registros xmm. Algunas de esas instrucciones operan sobre enteros. Otras operan sobre números de punto flotante.

Esos enteros o números de punto flotante se denominan empaquetados. Cada uno ocupa un espacio, llamado carril, dentro del mismo registro. Las instrucciones SIMD normalmente operan en paralelo sobre valores que están en la misma posición de carril en dos operandos fuente. El resultado de cada operación se guarda en el carril que está en la misma posición en el operando destino.

Un carril no es un límite estricto. Es una interpretación que cada instrucción le da a una secuencia de bytes. Un operando de 128 bits contiene 16 bytes. Según la instrucción, esos bytes se pueden interpretar como 16 carriles de 1 byte, 8 carriles de 2 bytes, 4 carriles de 4 bytes, 2 carriles de 8 bytes, o incluso un único carril de 16 bytes.

Por ejemplo, la instrucción addps suma valores de punto flotante empaquetados de precisión simple (4 bytes). Para esta instrucción, cada fragmento de 4 bytes en un operando es un carril distinto. En un operando de 128 bits de ancho (16 bytes):

Por otro lado, un operando de 128 bits se interpretaría como si tuviera 2 carriles en el caso de mulpd. Esto se debe a que esta instrucción realiza una multiplicación empaquetada sobre valores de precisión doble (8 bytes):

En este concepto nos vamos a centrar en una pequeña selección de instrucciones SIMD. Operan sobre valores de punto flotante empaquetados usando registros xmm.

Instrucciones SIMD de punto flotante

Como regla general, las instrucciones SIMD que operan sobre valores de punto flotante tienen una forma de dos operandos. Su nombre sigue cierta estructura:

1. La operación que se realiza, con el mismo nombre que su contraparte no SIMD (también llamada escalar) (por ejemplo, add, mul, etc.).
2. Un sufijo p para indicar que la instrucción opera sobre datos empaquetados, en la misma posición que antes ocupaba una s (de datos escalares).
3. Un sufijo para indicar el tamaño de cada carril, con la misma semántica que su contraparte no SIMD (s para precisión simple y d para precisión doble).

Por lo tanto, el nombre empaquetado se obtiene del nombre escalar sustituyendo la s (escalar) en medio del mnemónico por una p (empaquetado). El nombre de la operación y el sufijo de tamaño no cambian:

Aritmética

Las instrucciones SIMD aritméticas siguen la regla anterior. Algunos ejemplos:

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)

Conversión entre precisiones

También hay instrucciones SIMD para convertir entre valores de punto flotante empaquetados de precisión simple y de precisión doble. Siguen la misma regla de nombres, con cada s de escalar reemplazada por una p de empaquetado:

Estas instrucciones ilustran el punto anterior de que un carril es una interpretación, no un límite estricto. Los operandos fuente y destino tienen tamaños de carril distintos, así que tienen distinta cantidad de carriles.

Para cvtps2pd, la fuente (ps) tiene 4 carriles de precisión simple. El destino (pd) tiene 2 carriles de precisión doble. Solo se leen los 2 carriles inferiores de la fuente. Los 2 superiores se ignoran:

Para cvtpd2ps, la fuente (pd) tiene 2 carriles de precisión doble. El destino (ps) tiene 4 carriles de precisión simple. Ambos carriles de la fuente se convierten y se escriben en los 2 carriles inferiores del destino. Los 2 carriles superiores del destino se ponen a cero:

Algunos ejemplos:

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 memoria

Las instrucciones SIMD anteriores se han mostrado todas con operandos de registro a registro. También pueden tomar un operando de memoria como fuente (pero no como destino).

La cantidad de bytes que se leen de la memoria la determina la instrucción. Por ejemplo, addps lee 16 bytes (4 números de punto flotante de precisión simple). cvtps2pd, en cambio, lee solo 8 bytes (2 números de punto flotante de precisión simple), porque es todo lo que necesita 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

Cuando el operando de memoria es de 16 bytes de ancho, debe estar alineado a 16 bytes. Una ubicación de memoria alineada es aquella cuya dirección es múltiplo del tamaño de la operación (16 bytes en este caso).

Para declarar memoria alineada, puedes usar la directiva align en la sección .data y .rodata, o alignb, en la sección .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

Los operandos de memoria menores de 16 bytes, como la fuente de 8 bytes de cvtps2pd, no tienen requisito de alineación.

Carga y almacenamiento de valores

Hay cuatro instrucciones que copian 128 bits de valores de punto flotante empaquetados. Operan entre dos registros xmm, o entre un registro xmm y una ubicación de memoria:

Todas esas instrucciones se pueden usar para copiar valores entre dos registros xmm.

Si la operación involucra una ubicación de memoria, movaps y movapd requieren que esté alineada. movaps y movapd generan un fallo si se les da una dirección desalineada. También sirven como una verificación de seguridad de que la disposición de tus datos es la que crees que es.

Por otro lado, movups y movupd se pueden usar con cualquier ubicación de memoria, esté alineada o no.

El prefijo de tamaño para un valor de 16 bytes en NASM es oword.

Extensiones de SIMD

SIMD ha sido objeto de desarrollo activo en el ecosistema x86-64 durante décadas. Cada extensión de la arquitectura trae nuevas instrucciones o nuevos usos para instrucciones antiguas.

En particular, las extensiones AVX y AVX2 introducen algunos cambios relevantes.

Primero, compatibilidad con registros SIMD de 256 bits, llamados ymm. Extienden los registros xmm correspondientes, de forma parecida a como rax contiene a eax.

Segundo, incluyen compatibilidad con variantes de 3 operandos para la mayoría de las instrucciones que operan sobre registros xmm (y ymm). Esto incluye no solo instrucciones SIMD, sino también las que operan sobre valores de punto flotante escalares. Esas variantes siguen la misma notación que su equivalente en SSE, con una v agregada al principio:

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

Tercero, se relaja la alineación requerida por los operandos de memoria SIMD. Solo los movimientos con alineación explícita, como vmovaps, requieren esta alineación.

En este track, nos hemos limitado a las instrucciones y los registros hasta las extensiones SSE anteriores. Esto es suficiente para enseñar los fundamentos y garantiza la compatibilidad con una amplia variedad de CPU.

Sin embargo, el test-runner es totalmente compatible con AVX y AVX2, e incluso con las extensiones más nuevas que forman parte de AVX-512. Puedes usarlas libremente.