Version imprimable
Bonjour,
j'ai un __m128i qui contient 16 byte. Je souhaiterai trouver la valeur du plus petit/grand byte.
J'ai trouvé ce lien, mais je ne comprends pas comment fonctionne _mm_shuffle_epi*. J'ai aussi vu ce lien qui fait la même chose avec des float, mais même souci.
Questions :
- 1 - Est ce que quelqu'un pourrait m'expliquer comment fonctionne les opérations _mm_shuffle_epi* ?
- 2 - Quelle est la méthode la plus rapide pour extraire le plus grand/petit byte d'un __m128i ?
Merci par avance !
En règle générale, le plus simple, le plus sûr, et le plus exact, c'est de se référer à la documentation.
D'où vient ce __m128i?
_mm_min_epi8(A,B) retourne un __m128i contenant les valeurs minimum entre A et B https://msdn.microsoft.com/en-us/lib...v=vs.120).aspx
_mm_shuffle_epi8 permets de mélanger (Shuffle) un __int128i en sélectionnant les bytes voulus.
https://msdn.microsoft.com/fr-fr/lib...v=vs.110).aspx
https://msdn.microsoft.com/fr-fr/lib...v=vs.110).aspx
_mm_shuffle_epi8 créer l'instruction pshufb : Doc -> https://chessprogramming.wikispaces....uctions-PSHUFB
Type de base en SIMD.Citation:
Envoyé par ternel
Citation:
Envoyé par ternel
C'est ça mon souci, je ne comprends pas la doc pour mm_shuffle :-(Citation:
Envoyé par Astraya
https://software.intel.com/sites/lan..._1&expand=4743Citation:
Envoyé par ToTo13
Le masque est obscure, mais pour cet exemple :0x93 : 10 01 00 11 -> srcB[2] srcB[1] srcA[0] srcA[3]; ici srcA = srcB = maxval.Code:maxval = _mm_max_ps(maxval, _mm_shuffle_ps(maxval, maxval, 0x93));
tmp[0] = maxval[3];
tmp[1] = maxval[0];
tmp[2] = maxval[1];
tmp[3] = maxval[2];
maxval = tmp;
Ça permet de réorganiser les éléments dans un vecteur.
L'idée ici c'est de calculer le min / max (verticalement) entre 2 "rotations" du même vecteur, pour arriver à un résultat type :
v = [0, 1, 2, 3]
vMin = [0, 0, 0, 0]
vMax = [3, 3, 3, 3]
Aucune idée, mais si tu as besoin de faire des opérations horizontales au milieu de ton algo (ou pire, au milieu d'une boucle), généralement c'est mauvais signe (mauvaise approche).Citation:
Envoyé par ToTo13
Si c'est à la fin pour regrouper les 4/8/16 éléments sur lesquels tu travaillais en parallèle, alors c'est souvent négligeable (ça ne représente qu'une petite partie du traitement).
Attention Iradrille, tu parles de _mm_shuffle_ps qui n'a pas du tout le même comportement
_mm_shuffle_epi8 fonctionne de cette façon:
- en 1er paramètre tu rentres 16 bytes (int128)
- en 2nd paramètre tu rentres un mask de 16 bytes (int128)
- Chaque bytes est composé de 8 bits. (0000 0000) lié à leur index [0 à 15]
- Si le bit le plus haut est set ( 1XXX XXXX) la valeur sera setter à 0.
- Sinon la valeur du bytes correspond à l'index du bytes dans le 1er paramètre.
- Regarde l'exemple en bas, avec un papier, un crayon, la calculette en mode programmeur pour Hex->byte et tu comprendras : https://msdn.microsoft.com/zh-tw/lib...(v=vs.90).aspx
_mm_shuffle_ps fonctionne de cette façon:
- 2 Paramètre (A et B) int128 à mélanger ( soit 4 entiers continue en mémoire )
- 1 paramètre int qui est le mask
- Les 2 premiers bytes correspondent à l'index des entiers voulus de A
- Les 2 derniers bytes correspondent à l'index des entiers voulus de B
- Donc : le résultat sera A[0:3]A[0:3]B[0:3]B[0:3] soit int128 contenant 4 entiers ( 2 de A et 2 de B )