SIMD : masques et conditions
Le code scalaire s'appuie sur des drapeaux positionnés par diverses instructions pour effectuer un branchement en réponse à une certaine condition.
Les valeurs empaquetées, quant à elles, ne représentent pas une seule valeur mais plusieurs, en parallèle.
Une même condition peut être fausse pour une voie et vraie pour une autre.
C'est pourquoi le code SIMD est branchless par défaut.
Au lieu de s'appuyer sur des drapeaux, les comparaisons empaquetées produisent généralement un masque dans l'opérande de destination.
Pour chaque voie, la comparaison remplit la voie entière de uns quand la condition est vraie, et de zéros quand elle est fausse.
Lue comme un entier signé, une voie vraie vaut -1 et une voie fausse vaut 0.
Ce masque peut ensuite être combiné avec des opérations bit à bit pour filtrer des voies précises.
Comparaisons empaquetées
Un cmp scalaire est générique en ce sens qu'il sert à positionner plusieurs drapeaux à la fois.
Une autre instruction peut ensuite utiliser ces drapeaux pour effectuer un branchement ou des calculs.
Cependant, comme une comparaison empaquetée vérifie une condition et calcule un masque à la fois, elle n'est pas générique.
Il faut indiquer à la comparaison la condition exacte testée.
Il y a deux façons de procéder :
- Les comparaisons d'entiers reçoivent la condition sous forme de suffixe :
eq pour l'égalité, et gt pour « supérieur à ».
Les autres variantes se construisent en combinant le résultat de l'une de ces comparaisons.
- Les comparaisons de nombres à virgule flottante reçoivent la condition encodée dans un immédiat.
Différentes valeurs de cet immédiat correspondent à différentes conditions testées.
À part l'emploi d'un suffixe conditionnel spécifique sur les comparaisons d'entiers, la syntaxe suit la même structure que celle que l'on a déjà vue :
- Pour les entiers,
p + cmp + condition + taille (b, w, d ou q).
- Pour les flottants,
cmp + p + taille (s ou d).
La condition est passée dans un immédiat en tant qu'opérande supplémentaire.
Comparaisons d'entiers
Comme mentionné, il n'existe que des comparaisons d'entiers pour l'égalité et « supérieur à » :
| instruction |
description |
pcmpeqb, pcmpeqw, pcmpeqd, pcmpeqq
|
égalité par voie |
pcmpgtb, pcmpgtw, pcmpgtd, pcmpgtq
|
« supérieur à » signé par voie |
movdqa xmm0, [rel scores]
pcmpgtd xmm0, [rel threshold] ; lane i = 0xFFFFFFFF (-1) if scores[i] > threshold[i], else 0
Pour créer une comparaison « inférieur à », utilise gt avec les opérandes inversés : a < b == b > a.
Note que la comparaison est signée.
Pour effectuer une comparaison non signée, inverse le bit de poids fort des deux opérandes.
On peut le faire avec un XOR avec un masque où seul le bit de poids fort est positionné.
Deux idiomes pratiques :
- Faire un XOR d'un registre avec lui-même pour obtenir une valeur tout en zéros.
- Comparer un registre avec lui-même pour obtenir une valeur tout en uns.
Par exemple :
pxor xmm4, xmm4 ; xmm4 = all zeros
pcmpeqd xmm7, xmm7 ; xmm7 = all ones
Les valeurs tout en zéros et tout en uns sont des masques courants pour encoder respectivement « faux partout » et « vrai partout ».
On peut aussi les utiliser pour représenter un 0 empaqueté ou un -1 empaqueté, qui sont des valeurs sentinelles courantes.
Par exemple, le NUL qui marque la fin d'une string est un 0.
Comparaisons de nombres à virgule flottante
Les voies flottantes utilisent une forme différente : une seule instruction, cmpps (et cmppd pour les voies 64 bits), avec la condition sous forme d'immédiat :
movaps xmm0, [rel readings]
cmpps xmm0, [rel limits], 1 ; condition 1 is "less than": lane i = all ones if readings[i] < limits[i]
NASM dispose aussi de pseudo-op qui correspondent au bon immédiat et sont plus faciles à retenir.
Dans tout ce qui suit, x dans px peut être s (flottants 32 bits) ou d (flottants 64 bits) :
| pseudo-op |
immédiat |
comparaison |
cmpeqpx |
0 |
a == b |
cmpltpx |
1 |
a < b |
cmplepx |
2 |
a <= b |
cmpunordpx |
3 |
a est NaN ou b est NaN |
cmpneqpx |
4 |
a != b |
cmpnltpx |
5 |
a >= b |
cmpnlepx |
6 |
a > b |
cmpordpx |
7 |
ni a ni b n'est NaN |
Sélectionner avec un masque
Un masque encode le résultat d'une condition.
On peut ensuite l'utiliser pour choisir, voie par voie, entre deux ensembles de valeurs selon cette condition.
On prend la voie d'une valeur là où le masque est vrai, et d'une autre là où il est faux :
; result = (a AND mask) OR (b AND NOT mask)
movdqa xmm2, xmm0 ; xmm0 holds the mask, keep a copy
pand xmm2, xmm3 ; xmm2 = a AND mask: lanes of a where mask is true
pandn xmm0, xmm4 ; xmm0 = NOT mask AND b: lanes of b where mask is false
por xmm2, xmm0 ; combine the two halves
Note que l'asymétrie de pandn est payante ici : le masque se trouve dans la destination, est nié, et sélectionne depuis b en une seule instruction.
Ce schéma est la forme empaquetée de la sélection sans branchement.
Chaque voie est calculée, et le masque seul décide quelle valeur survit, sans aucun jcc.
Instructions blend dédiées
Il existe des instructions qui effectuent directement cette même sélection, en lisant un bit par élément dans un registre de masque.
On les appelle les instructions blend :
| instruction |
élément |
source du masque |
pblendvb |
octet |
xmm0 implicite |
blendvps |
voie 32 bits |
xmm0 implicite |
blendvpd |
voie 64 bits |
xmm0 implicite |
Note que la première instruction suit la syntaxe des entiers, tandis que les deux autres suivent la syntaxe des flottants.
Cependant, comme ces instructions sélectionnent simplement des octets bruts, n'importe laquelle peut servir avec des entiers comme avec des flottants.
Pour chaque élément, le blend conserve la destination lorsque le bit de poids fort de l'élément de masque correspondant est à zéro, et prend la source lorsqu'il est positionné.
Seul ce bit de poids fort est consulté, ce qu'un masque de comparaison satisfait, puisque ses voies sont tout en uns ou tout en zéros.
Le registre de masque est toujours xmm0, qui est implicite :
movaps xmm0, [rel mask] ; the selecting mask must be in xmm0
movaps xmm1, [rel b] ; destination: kept where the mask bit is clear
blendvps xmm1, [rel a] ; source: taken where the mask bit is set
Il est aussi possible d'utiliser pblendvb pour sélectionner des voies à partir d'un masque de comparaison, pour n'importe quelle autre taille.
Comme tous les octets d'une voie vraie sont tout en uns, pblendvb les sélectionne tous.
Ces instructions ajoutent toutes un v après l'opération effectuée (blend).
Ce v signifie variable, car la sélection n'est pas statique : elle dépend d'un registre.
Il existe aussi des variantes sans v, qui sélectionnent selon un immédiat.
Elles suivent le même schéma, en sélectionnant une voie i si le bit i de l'immédiat est positionné.
Revenir du masque au scalaire
Bien que puissant, le code SIMD est loin d'avoir la souplesse du code scalaire.
Dans de nombreuses situations, il est nécessaire de repasser d'un registre empaqueté au monde des instructions scalaires.
La famille d'instructions movmsk fait le pont entre ces deux mondes.
Ces instructions extraient le bit de poids fort de chaque voie vers un registre à usage général :
| instruction |
rassemble |
largeur du résultat |
pmovmskb |
le bit de poids fort de chacun des 16 octets |
16 bits |
movmskps |
le bit de poids fort de chacun des 4 dwords |
4 bits |
movmskpd |
le bit de poids fort de chacun des 2 qwords |
2 bits |
S'il est utilisé après une comparaison, chaque bit positionné représente une voie « vraie » et chaque bit à zéro, une voie « fausse ».
Ce résultat peut ensuite être manipulé comme d'habitude avec des instructions scalaires.
Par exemple, un popcnt compte le nombre de correspondances, et tzcnt trouve la première.
Le registre à usage général peut faire 32 ou 64 bits de large.
Tester un vecteur entier
Il existe aussi une variante empaquetée de l'instruction scalaire test : ptest.
Elle est semblable à sa contrepartie scalaire en ce qu'elle effectue une opération AND entre deux opérandes, sans les modifier.
Contrairement à test, ptest effectue aussi une opération ANDN, qui nie le premier opérande.
Ainsi, on peut voir ptest comme une version non destructive de pand et pandn qui positionne des drapeaux selon le résultat.
De la même manière que ces deux instructions, ptest traite tout le registre SIMD comme une seule voie et ne prend donc pas de préfixe de taille.
Si le résultat d'une opération AND vaut 0, le ZF est positionné, et si l'opération ANDN donne 0, c'est le CF qui est positionné.
Cela signifie que ptest peut servir à vérifier à la fois un masque tout en uns et un masque tout en zéros :
- Utiliser
ptest sur un registre avec lui-même positionne ZF seulement si le registre est tout en zéros.
Cela imite l'idiome scalaire courant consistant à utiliser test sur un registre avec lui-même pour vérifier qu'il vaut 0.
- Utiliser
ptest sur un registre avec un masque tout en uns positionne CF seulement si le registre est tout en uns.
De plus, cela positionne ZF seulement si le registre est tout en zéros, ce qui permet de vérifier les deux masques d'un coup.
pxor xmm0, xmm0 ; all zeros
pcmpeqb xmm1, xmm1 ; all ones
pcmpeqb xmm2, xmm2
ptest xmm0, xmm0 ; ZF set: a register against itself detects all zeros
ptest xmm0, xmm1 ; ZF set, CF clear: xmm0 is all zeros, not all ones
ptest xmm2, xmm1 ; CF is set only if xmm2 is all ones
Le résultat d'un ptest peut servir à effectuer un branchement ou dans des instructions sans branchement telles que setcc ou cmovcc, comme d'habitude.
Exercice d'apprentissage
