Chaîne de production

SIMD

Single instruction, multiple data (SIMD) est une forme de parallélisme au niveau matériel. Le même calcul est effectué par le processeur sur plusieurs éléments en même temps.

Prenons par exemple la somme, élément par élément, de deux tableaux de quatre nombres à virgule flottante de 32 bits. Une implémentation scalaire émettrait quatre instructions addss distinctes, une par élément. Une implémentation SIMD utilise une seule instruction addps pour effectuer les quatre additions en parallèle. On obtient ainsi quatre fois plus de travail par instruction.

En assembleur x86-64, les instructions SIMD s'effectuent généralement à l'aide de registres xmm. Certaines de ces instructions opèrent sur des entiers. D'autres opèrent sur des nombres à virgule flottante.

Ces entiers ou ces nombres à virgule flottante sont dits empaquetés. Chacun occupe un espace, appelé voie, au sein du même registre. Les instructions SIMD opèrent généralement en parallèle sur les valeurs situées à la même voie dans les deux opérandes sources. Le résultat de chaque opération est stocké dans la voie de même position de l'opérande destination.

Une voie n'est pas une limite stricte. C'est l'interprétation que chaque instruction donne à une suite d'octets. Un opérande de 128 bits contient 16 octets. Selon l'instruction, ces octets peuvent être interprétés comme 16 voies de 1 octet, 8 voies de 2 octets, 4 voies de 4 octets, 2 voies de 8 octets, voire une seule voie de 16 octets.

Par exemple, l'instruction addps additionne des valeurs à virgule flottante simple précision (4 octets) empaquetées. Pour cette instruction, chaque bloc de 4 octets d'un opérande constitue une voie distincte. Dans un opérande de 128 bits de large (16 octets) :

À l'inverse, un opérande de 128 bits serait interprété comme ayant 2 voies dans le cas de mulpd. En effet, cette instruction effectue une multiplication empaquetée sur des valeurs double précision (8 octets) :

Dans ce concept, on va s'intéresser à une petite sélection d'instructions SIMD. Elles opèrent sur des valeurs à virgule flottante empaquetées à l'aide de registres xmm.

Les instructions SIMD en virgule flottante

En règle générale, les instructions SIMD qui opèrent sur des valeurs à virgule flottante ont une forme à deux opérandes. Leur nom suit une structure précise :

1. L'opération effectuée, avec le même nom que son équivalent non SIMD (aussi appelé scalaire) (par exemple add, mul, etc.).
2. Un suffixe p pour indiquer que l'instruction opère sur des données empaquetées, à la position qu'occupait auparavant un s (pour des données scalaires).
3. Un suffixe indiquant la taille de chaque voie, avec la même sémantique que son équivalent non SIMD (s pour la simple précision et d pour la double précision).

Le nom empaqueté s'obtient donc à partir du nom scalaire en remplaçant le s (scalaire) situé au milieu de la mnémonique par un p (empaqueté). Le nom de l'opération et le suffixe de taille restent inchangés :

Arithmétique

Les instructions SIMD arithmétiques suivent la règle ci-dessus. Quelques exemples :

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)

Conversion entre précisions

Il existe également des instructions SIMD qui convertissent des valeurs à virgule flottante empaquetées entre simple et double précision. Elles suivent la même règle de nommage, chaque s de scalaire étant remplacé par un p d'empaqueté :

Ces instructions illustrent le point évoqué plus haut : une voie est une interprétation, pas une limite stricte. Les opérandes source et destination ont des tailles de voie différentes, donc des nombres de voies différents.

Pour cvtps2pd, l'opérande source (ps) comporte 4 voies en simple précision. La destination (pd) comporte 2 voies en double précision. Seules les 2 voies inférieures de la source sont lues. Les 2 voies supérieures sont ignorées :

Pour cvtpd2ps, la source (pd) comporte 2 voies en double précision. La destination (ps) comporte 4 voies en simple précision. Les deux voies de la source sont converties et écrites dans les 2 voies inférieures de la destination. Les 2 voies supérieures de la destination sont mises à zéro :

Quelques exemples :

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)

Opérandes mémoire

Les instructions SIMD ci-dessus ont toutes été présentées avec des opérandes registre-registre. Elles peuvent aussi prendre un opérande mémoire comme source (mais pas comme destination).

Le nombre d'octets lus en mémoire est déterminé par l'instruction. Par exemple, addps lit 16 octets (4 nombres à virgule flottante en simple précision). À l'inverse, cvtps2pd ne lit que 8 octets (2 nombres à virgule flottante en simple précision), car c'est tout ce dont il a besoin en entrée.

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

Lorsque l'opérande mémoire fait 16 octets de large, il doit être aligné sur 16 octets. Un emplacement mémoire aligné est un emplacement dont l'adresse est un multiple de la taille de l'opération (16 octets dans ce cas).

Pour déclarer de la mémoire alignée, tu peux utiliser la directive align dans les sections .data et .rodata, ou alignb dans la 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

Les opérandes mémoire de moins de 16 octets, comme la source de 8 octets de cvtps2pd, n'ont aucune contrainte d'alignement.

Chargement et stockage des valeurs

Quatre instructions copient 128 bits de valeurs à virgule flottante empaquetées. Elles opèrent entre deux registres xmm, ou entre un registre xmm et un emplacement mémoire :

Toutes ces instructions peuvent servir à copier des valeurs entre deux registres xmm.

Si l'opération implique un emplacement mémoire, movaps et movapd exigent qu'il soit aligné. movaps et movapd déclenchent une erreur si on leur donne une adresse non alignée. Elles font aussi office de contrôle de sécurité, en confirmant que l'agencement des données est bien celui que l'on croit.

À l'inverse, movups et movupd peuvent être utilisées avec n'importe quel emplacement mémoire, aligné ou non.

Dans NASM, le préfixe de taille d'une valeur de 16 octets est oword.

Les extensions SIMD

Le SIMD fait l'objet d'un développement actif dans l'écosystème x86-64 depuis des décennies. Chaque extension de l'architecture apporte de nouvelles instructions, ou de nouveaux usages pour des instructions existantes.

En particulier, les extensions AVX et AVX2 introduisent plusieurs changements notables.

D'abord, la prise en charge de registres SIMD de 256 bits, appelés ymm. Ils étendent les registres xmm correspondants, un peu comme rax contient eax.

Ensuite, elles prennent en charge des variantes à 3 opérandes pour la plupart des instructions qui opèrent sur des registres xmm (et ymm). Cela concerne non seulement les instructions SIMD, mais aussi celles qui opèrent sur des valeurs à virgule flottante scalaires. Ces variantes suivent la même notation que leur équivalent SSE, avec un v ajouté devant :

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

Enfin, les contraintes d'alignement des opérandes mémoire SIMD sont assouplies. Seuls les déplacements explicitement alignés, comme vmovaps, exigent cet alignement.

Dans ce parcours, on s'est limité aux instructions et aux registres des extensions SSE antérieures. C'est suffisant pour enseigner les bases et garantir la compatibilité avec un large éventail de processeurs.

Cependant, l'exécuteur de tests prend totalement en charge AVX et AVX2, et même les extensions plus récentes qui font partie d'AVX-512. Tu es libre de les utiliser.