Programmation système IFT-17584 Programmation système @Pierre Marchand, 2001

Programmation MMX Introduction MMX veut dire Multi Media Extension. La technologie MMX utilise la technique SIMD (single instruction multiple data, i.e. traitement vectoriel) pour effectuer des opérations arithmétiques et logiques sur des octets, des mots ou des doubles mots placés dans des registres MMX de 64 bits. @Pierre Marchand, 2001

Programmation MMX Registres 63 MM0 MM1 MM2 MM3 MM4 MM5 MM6 MM7 MM6 MM5 MM4 MM3 MM2 MM1 MM0 @Pierre Marchand, 2001

Programmation MMX + + + + + + + + Par exemple, l’instruction PADDB aditionne 8 octets signés de l’opérande source à 8 octets signés de l’opérande destination et stocke le résultat de 8 octets dans la destination. Ce sont 8 additions séparées, i.e. la retenue n’est pas propagée d’un octet à l ’autre. 10000000 01111111 00111000 + + + + + + + + 11111111 00010111 00000111 11111111 10010110 00111111 @Pierre Marchand, 2001

Programmation MMX Cette technologie s’adresse aux média modernes, les communications et les applications graphiques, qui utilisent souvent des algorithmes qui effectuent les mêmes opérations sur un grand nombre de petits éléments tels que des octets, des mots, des mots doubles. Par exemple, les données audio sont représentées par des quantités de 16 bits. Une instruction MMX peut agir sur 4 de ces mots simultanément @Pierre Marchand, 2001

Programmation MMX En effet, 1 pixel couleur = 24 bits Les données graphiques et video sont représentées par des quantités parallélisées de 8 bits. En effet, 1 pixel couleur = 24 bits = 3 couleurs RGB de 8 bits chacune Une instruction MMX peut agir sur 8 de ces octets simultanément. Les données audio sont représentées par des échantillons de 8 ou 16 bits. @Pierre Marchand, 2001

Programmation MMX Formats des données en mémoire Octet 7 Octet 6 63 56 55 48 47 40 39 32 31 24 23 16 15 8 7 Octet 7 Octet 6 Octet 5 Octet 4 Octet 3 Octet 2 Octet 1 Octet 0 Adresse 0x1007 Adresse 0x1000 63 48 47 32 31 16 15 Mot 3 Mot 2 Mot 1 Mot 0 Adresse 0x1006 Adresse 0x1000 63 32 31 Double mot 1 Double mot 0 Adresse 0x1004 Adresse 0x1000 @Pierre Marchand, 2001

Programmation MMX Arithmétique à saturation En mode wraparound, les résultats qui débordent vers le haut ou vers le bas sont tronqués et seuls les bits les moins significatifs du résultat sont retournés, i.e. la retenue est ignorée. Exemple : 80 + FF = 7F au lieu de (1)7F 80 + 80 = 00 au lieu de (1)00 En mode saturation, les résultats d’une opération qui déborde vers le haut ou vers le bas sont tronqués (saturés) à une limite de l’étendue des données pour le type de données. @Pierre Marchand, 2001

Programmation MMX Saturation Le résultat d’une opération qui déborde l’étendue du type de données sature à la valeur maximum de l’étendue. Le résultat d’une opération qui est inférieur à l’étendue de représentation sature à la valeur minimum de l’étendue. Exemples: 80 + 80 = FF au lieu de (1)00 pour un octet non signé 50 - 60 = 00 au lieu de F0 pour un octet non signé 70 + 70 = 7F au lieu de E0 pour un octet signé 90 + A0 = 80 au lieu de (1)30 pour un octet signé @Pierre Marchand, 2001

Programmation MMX Saturation Limites des étendues de données pour la saturation Le mode saturation ne s’applique pas aux doubles mots. @Pierre Marchand, 2001

Programmation MMX Syntaxe movd eax, mm0 // 32 bits movq mm2, qword ptr [ebp-8] // 64 bits movd eax, mm0 // 32 bits movd [edi+4], mm1 // 32 bits paddsb mm0, qword ptr [ebp-8] // 64 bits Dans Masm32, il faut ajouter .MMX au début du fichier .asm juste après l’identification du processeur. .686P .MMX option casemap:none … @Pierre Marchand, 2001

Programmation MMX Instructions Arithmétiques Wraparound Signed Unsigned Saturation Saturation Addition PADDB PADDSB PADDUSB PADDW PADDSW PADDUSW PADDD Soustraction PSUBB PSUBSB PSUBUSB PSUBW PSUBSW PSUBUSW PSUBD @Pierre Marchand, 2001

Programmation MMX Instructions Arithmétiques Wraparound Signed Unsigned Saturation Saturation Multiplication PMULL PMULH Multplication-Addition PMADDWD @Pierre Marchand, 2001

Programmation MMX + + + + + + + + PADDB, PADDSB, PADDUSB paddb paddsb 10000000 01111111 00111000 + + + + + + + + 11111111 00010111 00000111 01111111 10010110 00111111 paddb paddsb 10000000 01111111 paddusb 11111111 10010110 @Pierre Marchand, 2001

Programmation MMX     PMULHW Mot de poids fort Mot de poids fort 0111000111000111 0111000111000111     1000000000000000 0000010000000000 1100011100011100 0000000111000111 Mot de poids fort Mot de poids fort @Pierre Marchand, 2001

Programmation MMX     + + PMADDWD 0111000111000111 1000000000000000 0000010000000000 + + 110010001110001110011100000000000 @Pierre Marchand, 2001

Programmation MMX Instructions Comparaison Compare for PCMPEQB Equal PCMPEQW PCMPEQD Compare for PCMPGTPB Greater Than PCMPGTPW PCMPGTPD @Pierre Marchand, 2001

Programmation MMX == == == == == == == == Instructions Comparaison PCMPEQB 00000000 00000001 00000111 00001000 00000000 10000000 01111111 00111000 == == == == == == == == 00000000 00000000 00000111 00001000 01011011 11111111 00010111 00111000 True False True True False False False True 11111111 00000000 11111111 11111111 00000000 00000000 00000000 11111111 @Pierre Marchand, 2001

Programmation MMX Instructions Conversion Wraparound Signed Unsigned Saturation Saturation Pack PACKSSWB PACKUSWB PACKSSDW Unpack Hi PUNPCKHBW PUNPCKHWD PUNPCKHDQ Unpack Lo PUNPCKLBW PUNPCKLWD PUNPCKLDQ @Pierre Marchand, 2001

Programmation MMX Instruction PACKUSWB Compacte et sature 4 mots signés du premier opérande avec 4 mots signés du second opérande en 8 octets signés dans l’opérande destination. Si la valeur signée d’un mot est > FF ou < 00, la valeur FF ou 00 respectivement est stockée dans la destination. @Pierre Marchand, 2001

Programmation MMX Instructions Logiques Packed Full Quadword And PAND And Not PANDN Or POR Exclusive Or PXOR @Pierre Marchand, 2001

Programmation MMX Instructions Décalages Packed Full Quadword Left Logical PSLLW PSLLQ PSLLD Right logical PSRLW PSRLQ PSRLD Right arithmetic PSRAW PSRAD PSLLW 1111111111111100 0001000111000111 1111111111110000 0100011100011100 @Pierre Marchand, 2001

Programmation MMX Instructions Transferts de données 32 bits 64 bits Reg to Reg MOVD MOVQ Mem to Reg MOVD MOVQ Reg to Mem MOVD MOVQ EMMS Cette instruction vide l’état MMX et met le mot de tags de virgule flottante à 0. Cette instruction doit être utilisée à la fin d’un pro-gramme MMX avant que d’autres routines puissent utiliser les instructions de virgule flottante. @Pierre Marchand, 2001

Programmation MMX Programmation Avant de demander à un processeur d’exécuter des instructions MMX, il faut s’assurer qu’il possède bien les registres et les instructions pour le faire. On effectue cette vérification au moyen de l’instruction CPUID. On place un paramètre dans EAX qui peut être 0, 1, 2 ou plus. Si EAX = 0, CPUID retourne dans EAX la valeur maximum qu’on peut donner comme paramètre à CPUID. Pour le Pentium actuel, cette valeur est 2. De plus, on trouve alors dans EBX les caractères “Genu” et dans EDX et ECX respectivement les caractères “ineI” et “ntel”. @Pierre Marchand, 2001

Programmation MMX Programmation Si EAX = 1, CPUID retourne dans EAX de l’information sur la version du processeur et dans EDX de l’information sur les capacités du processeur. En particulier : • Le bit 23 de EDX indique si le processeur dispose de la technologie MMX. • Le bit 25 de EDX indique si le processeur dispose de l’extension SIMD (Pentium III). • Le bit 26 de EDX indique si le processeur dispose de l’extension SIMD2 (Pentium 4). @Pierre Marchand, 2001

Programmation MMX Programmation mov eax, 1 cpuid Donc, pour savoir si le processeur peut exécuter les instructions MMX, on exécute le code suivant : mov eax, 1 cpuid shr edx, 24 // on place le bit 23 dans CF jc ok // si CF = 1, on a le MMX @Pierre Marchand, 2001

Programmation MMX Exemples Addition de deux vecteurs Soit deux vecteurs (chaînes ou tableaux) x et y de short et de même longueur divisible par 4. Pour avoir y = x + y, on fait : lea esi, x lea edi, y mov ecx, longueur b: movq mm0,[esi] paddw mm0,[edi] movq [edi], mm0 add esi, 8 add edi, 8 sub ecx, 4 jnz b emms @Pierre Marchand, 2001

Programmation MMX Exemples Multiplication de deux vecteurs Soit deux vecteurs (chaînes ou tableaux) x et y de short et de même longueur divisible par 4, et d est un vecteur équivalent de long. lea esi, x lea edi, y lea edx, dest mov ecx, longueur b: movq mm0,[esi] movq mm1, mm0 pmullw mm0,[edi] pmulhw mm1,[edi] x * y dest @Pierre Marchand, 2001

Programmation MMX Exemples Multiplication de deux vecteurs movq mm2, mm0 punpcklwd mm0, mm1 punpckhwd mm2, mm1 movq [edx], mm0 movq [edx+8], mm2 add esi, 8 add edi, 8 add edx, 16 sub ecx, 4 jne b emms mm1 mm0 Hi Lo mm0 mm1 mm2 mm2 dest @Pierre Marchand, 2001

Programmation MMX Exemples Multiplication scalaire de deux vecteurs de shorts (au moins 16) mov eax, offset a mov ebx, offset b mov ecx, n mov edi, offset p boucle: movq mm0, [eax] movq mm1, [ebx] movq mm2, [eax+8] movq mm3, [ebx+8] movq mm4, [eax+16] movq mm5, [ebx+16] movq mm6, [eax+24] a3 a2 a1 a0 b3 b2 b1 b0 a7 a6 a5 a4 b7 b6 b5 b4 a11 a10 a9 a8 b11 b10 b9 b8 a15 a14 a13 a12 @Pierre Marchand, 2001

Programmation MMX Exemples Multiplication scalaire de deux vecteurs de shorts pmaddwd mm0, mm1 pmaddwd mm2, mm3 pmaddwd mm4, mm5 pmaddwd mm6, [ebx+24] paddd mm7, mm0 paddd mm7, mm2 paddd mm7, mm4 paddd mm7, mm6 add eax, 32 add ebx, 32 sub ecx, 16 jnz boucle a3b3+a2b2 a1b1+a0b0 a7b7+a6b6 a5b5+a4b4 a11b11+a10b10 a9b9+a8b8 a15b15+a14b14 a13b13+a12b12 Hi Lo @Pierre Marchand, 2001

Programmation MMX Exemples Multiplication scalaire de deux vecteurs de shorts movq mm0, mm7 shrlq mm7, 32 paddd mm7, mm0 movd [edi], mm0 Hi Lo Hi Hi Hi+Lo p @Pierre Marchand, 2001

Programmation MMX Exemples Multiplication d’une matrice par un vecteur Soit m une matrice de short et v un vecteur de short tels que v contient un nombre pair d’éléments et que m contient le même nombre de rangées que v d’éléments. Le produit p de m par v est : @Pierre Marchand, 2001

Programmation MMX Exemples v m Multiplication d’une matrice par un vecteur for ( i = 0; i < colonnes; i++ ) { accum = 0; for ( j = 0; j < rangées; j++ ) accum += v[ j ] * m[ j ][ i ]; produit[ i ] = accum; } v i 0, 1, 2, … , j - 1 m j @Pierre Marchand, 2001

Programmation MMX Exemples produit v = m Multiplication d’une matrice par un vecteur On peut décomposer le problème comme suit : long accum [4]; for ( i = 0; i < colonnes; i += 4 ) { for ( k = 0; k < 4; k++ ) accum[ k] = 0; for ( i = 0; j < rangées; j += 2 ) accum[ 0,… 3 ] += MULT4x2(&v[ j ], &m[ j ] [ i ]); produit [i+k ] = accum[ k ]; } produit v i = 0, 1 2, … , i - 1 0, 1 2, … , j - 1 m j @Pierre Marchand, 2001

Programmation MMX Exemples La fonction MULT4x2 mov esi, param1 mov edx, param2 mov ecx, colonnes movd mm7, [esi] punpckldq mm7, mm7 movq mm0, [edx] movq mm1, mm0 movq mm6, [edx + ecx * 2] punpcklwd mm0, mm6 punpckhwd mm1, mm6 mm7 v1 v0 mm7 v1 v0 v1 v0 mm0 m03 m02 m01 m00 mm1 m03 m02 m01 m00 mm6 m13 m12 m11 m10 mm0 m11 m01 m10 m00 mm1 m13 m03 m12 m02 @Pierre Marchand, 2001

Programmation MMX Exemples Multiplication d’une matrice par un vecteur pmaddwd mm0, mm7 pmaddwd mm1, mm7 paddd mm2, mm0 // accum[1, 0] paddd mm3, mm1 // accum[3, 2] mm7 v1 v0 v1 v0 mm0 m11 m01 m10 m00 mm1 m13 m03 m12 m02 mm0 m11v1+ m01v0 m10v1+ m00v0 mm1 m13v1+ m03v0 m12v1+ m02v0 @Pierre Marchand, 2001

Programmation MMX Exemples m00 m01 m02 m03 m10 m11 m12 m13 Transposée d’une matrice Soit une matrice 4 x 4 de short : En mémoire, on a : m00 m01 m02 m03 m10 m11 m12 m13 m20 m21 m22 m23 m30 m31 m32 m33 Si on fait movq mm0, m on aura dans mm0 : m03 m02 m01 m00 m00 m01 m02 m03 m10 m11 m12 m13 m20 m21 m22 m23 m30 m31 m32 m33 @Pierre Marchand, 2001

Programmation MMX Exemples Transposée d’une matrice On fait donc : m33 m32 m31 m30 m23 m22 m21 m20 m13 m12 m11 m10 m03 m02 m01 m00 punpcklwd punpcklwd m31 m21 m30 m20 m11 m01 m10 m00 punpckhdq punpckldq m31 m21 m11 m01 m30 m20 m10 m00 @Pierre Marchand, 2001

Programmation MMX Exemples Transposée d’une matrice Ensuite : m33 m32 m31 m30 m23 m22 m21 m20 m13 m12 m11 m10 m03 m02 m01 m00 punpckhwd punpckhwd m33 m23 m32 m22 m13 m03 m12 m02 punpckhdq punpckldq m33 m23 m13 m03 m32 m22 m12 m02 @Pierre Marchand, 2001

Programmation MMX a’ a b b’ Exemples Transposée d’une matrice Pour une matrice non carrée et plus grande que 4x4, on observe que chaque bloc de 4x4 peut être transposé : m00 m01 m02 m03 m04 m05 m06 m07 m10 m11 m12 m13 m14 m15 m16 m17 m20 m21 m22 m23 m24 m25 m26 m27 m30 m31 m32 m33 m34 m35 m36 m37 m00 m10 m20 m30 m01 m11 m21 m31 m02 m12 m22 m32 m03 m13 m23 m33 m04 m14 m24 m34 m05 m15 m25 m35 m06 m16 m26 m36 m07 m17 m27 m37 a’ a b b’ @Pierre Marchand, 2001

Programmation MMX a b c d e f a’ g’ m’ g h i j k l b’ h’ n’ Exemples Transposée d’une matrice On prend donc la transposée de chaque bloc de 4x4 : a b c d e f g h i j k l m n o p q r a’ g’ m’ b’ h’ n’ c’ i’ o’ d’ j’ p ’ e’ k’ q’ f’ l’ r’ @Pierre Marchand, 2001

Programmation MMX Autres exemples Voyez le site d’Intel : http://cedar.intel.com @Pierre Marchand, 2001

Programmation MMX Pour le TP2 Supposons que esi pointe sur les données suivantes : 01, 02, 03, 04, 05, 06, 07, 08, …. pxor mm0,mm0 movd mm1,[esi] punpcklbw mm1,mm0 movd mm2,[esi+1] punpcklbw mm2, mm0 movd mm3,[esi+2] punpcklbw mm3, mm0 mm0 mm1 mm2 00 00 00 00 00 00 00 00 00 00 00 00 04 03 02 01 00 04 00 03 00 02 00 01 00 00 00 00 05 04 03 02 00 05 00 04 00 03 00 02 @Pierre Marchand, 2001