@Pierre Marchand, IFT Semaine 05 Programmation système

@Pierre Marchand, Plan de la rencontre Retour sur la semaine précédente Programmation virgule flottante Programmation MMX

@Pierre Marchand, Retour sur la semaine précédente Comparaisons Branchements Opérations logiques Opérations arithmétiques

@Pierre Marchand, Virgule flottante Registres Opcode Registres de données MantisseExposant R7 R6 R5 R4 R3 R2 R1 R0 Signe Pointeur d'instruction de FPU Pointeur d'opérande de FPU Registre de contrôle Registre d'état Registre Étiquette

@Pierre Marchand, Virgule flottante Détail des registres Registre d’état Codes condition Error Summary Status Stack Fault Exception Flags Precision Underflow Overflow Zero Divide Denormalized Operand Invalid Operation IEIE DEDE ZEZE OEOE UEUE PEPE SFSF ESES C0C0 C1C1 C2C2 TOP C3C3 B FPU Busy Top of Stack Pointer

@Pierre Marchand, Virgule flottante Détail des registres Registre de contrôle Exception masks Precision Underflow Overflow Zero Divide Denormalized Operand Invalid Operation IMIM DMDM ZMZM OMOM UMUM PMPM PC RCX Infinity Control Rounding Control Precision Control

@Pierre Marchand, Virgule flottante Registres de données Pile de registres de données Croissance de la pile ST(0) ST(1) ST(2) 011 Sommet

@Pierre Marchand, Virgule flottante Il s’agit d’une pile à 8 niveaux. Par exemple, l’instruction : flda met la quantité a dans le registre de virgule flottante ST(0) (registre 4). Si on fait maintenant fldb la quantité b ira dans le registre 3, mais le pointeur de pile ST(0) pointe maintenant sur ce registre. La valeur a est donc passée à ST(1).

@Pierre Marchand, Virgule flottante Comparaisons Les comparaisons et les registres d’état sont plus compliqués en virgule flottante qu’avec les entiers pour trois raisons principales: la présence de NaN et d’infinis ; on veut représenter les nombres réels avec un nombre fini de bits ; les sources d’erreur sont plus nombreuses.

@Pierre Marchand, Virgule flottante Comparaisons ordonnées et non ordonnées En effet, lors de la comparaison de réels, on a quatre résultats possibles au lieu de trois : et non ordonné Le résultat est dit non ordonné si l’une des deux valeurs à comparer est un NaN ou dans un format non défini. On a donc 2 familles d’instructions de comparaison : FCOM et FUCOM

@Pierre Marchand, Virgule flottante Comparaisons Remarquez qu’il est possible de comparer des nombres de virgule flottante avec les instructions d’entiers. On peut sans problème détecter si A = B ou si A B. Il faut utiliser dans ce cas les test signés : jg(e), jl(e). Cependant, si les deux nombres sont négatifs, le résultat sera inversé, c ’est-à-dire > donnera <, etc.

@Pierre Marchand, Virgule flottante Comparaisons Lors d’une comparaison, les codes condition sont affectés comme suit :

@Pierre Marchand, Virgule flottante Indicateurs On copie le registre dans ax avec l’instruction fstswax Puis on copie, si désiré, les codes condition dans EFLAGS avec l’instruction : sahf IEIE DEDE ZEZE OEOE UEUE PEPE SFSF ESES C0C0 C1C1 C2C2 TOP C3C3 B C0C0 C1C1 C2C2 C3C FPU Status Word Registre AX CFCF 1 PFPF ZFZF Registre EFLAGS 08 8

@Pierre Marchand, Virgule flottante Comparaisons if(a == 0.1) {flda (qword ptr [ebp+…] ) … if1: fcompdata …fstswax andah, 5 cmpah, 1 jneendif1 }… … endif1:

@Pierre Marchand, Virgule flottante Comparaisons (Depuis les Pentium Pro et Pentium II) if(a == 0.1) {flda (qword ptr [ebp+…] ) … if1: fcomipdata …jneendif1 }… … endif1:

@Pierre Marchand, Virgule flottante Programmation Exemple: Évaluons y = 3x 2 - 7x + 4 xdd? ydd? constdd? fldx; charger x fldst(0); copie de x fmulst(0); x 2 au sommet de la pile movconst, 3; multiplicateur entier const = 3 fimulconst; 3x 2 movconst, 7

@Pierre Marchand, Virgule flottante Programmation Exemple: Évaluons y = 3x 2 - 7x + 4 fildconst; empiler 7 fmulpst(2), st; st(2) = x*7, pop fsubrpst(1), st; st(1) = st - st(1) movconst, 4 fiaddconst; 3x - 7x + 4 fstpy ret

@Pierre Marchand, Virgule flottante Programmation x st(0) x x x x2x2 fld st(0)fmul st(0) fld x

@Pierre Marchand, Virgule flottante Programmation x st(0) fimulp st(2),st fildfimul const x st(0) 3x 2 7 7x 7 3x 2 fsubrp st(1),st 3x 2 -7x 7 3x 2

@Pierre Marchand, Virgule flottante Programmation st(0) fiadd 3x 2 -7x+4 7 3x 2 fstp st(0) 3x 2 -7x+4 7 3x 2

@Pierre Marchand, Virgule flottante Instructions Instructions de chargement d’une constante FLDZCharger +0.0 FLD1Charger +1.0 FLDPICharger π FLDL2TCharger log 2 10 FLDL2ECharger log 2 e FLDLG2Charger log 10 2 FLDLN2Charger ln 2

@Pierre Marchand, Virgule flottante Instructions Instructions arithmétiques de base FADD/FADDPAdditionner réels FIADDAdditionner entier à réel FSUB/FSUBPSoustraire réels FISUBSoustraire entier de réel FSUBPR/FSUBRPSoustraire réels intervertis FISUBRSoustraire réel d’entier FMUL/FMULPMultiplier réels FIMULMultiplier entier par réel FDIV/FDIVPDiviser réels FIDIVDiviser réel par entier

@Pierre Marchand, Virgule flottante Instructions Instructions arithmétiques de base FDIVR/FDIVRPDiviser réels intervertis FIDIVRDiviser entier par réel intervertis FABSValeur absolue FCHSChanger de signe FSQRTRacine carrée FPREMReste partiel FPREM1Reste partiel IEEE FRNDINTArrondir vers entier FXTRACTExtraire exposant et mantisse

@Pierre Marchand, Virgule flottante Instructions Instructions de comparaison et de classification FCOM/FCOMP/FCOMPPComparer des réels et affecter FPSW FUCOM/FUCOMP/FUCOMPPComparaison non ordonnée de réels FICOM/FICOMPComparer réel avec entier FCOMI/FCOMIPComparer réels et affecter EFLAGS FUCOM/FUCOMPIdem non ordonnée FTSTCompare un réel avec 0.0 FXAMExamine contenu de ST et affecter FPSW

@Pierre Marchand, Virgule flottante Instructions Instructions trigonométriques FSINSinus FCOSCosinus FSINCOSSinus et cosinus FPTANTangente FPATANArctangente Logarithmes et exponentielles FYL2Xlog(y * log 2 x) FYL2XP1log  (y * log 2 (x+1)) où  -> 0 F2XM1e ^ (2 x - 1) FSCALEMultiplier par une puissance de 2

@Pierre Marchand, Virgule flottante Instructions Instructions de contrôle FINIT/FNINIInitialiser le FPU FLDCWCharger le mot de contrôle FSTCW/FNSTCWStocker le mot de contrôle FSTSW/FNSTSWStocker le mot d’état FCLEX/FNCLEXMettre les indicateurs à 0 FLDENVCharger environnement FPU FSTENV/FNSTENVStocker environnement FPU FRSTORRestaurer l’état du FPU FSAVE/FNSAVEStocker l’état du FPU

@Pierre Marchand, Virgule flottante Instructions Instructions de contrôle FINCSTPIncrémenter le pointeur de pile FDECSTPDécrémenter le pointeur de pile FFREELibérer un registre du FPU FNOPPas d’opération WAIT/FWAITTester et traiter les exceptions non masquées

@Pierre Marchand, Virgule flottante FLD/FILD/FBLDLoad Empile l’opérande spécifié sur la pile de virgule flottante. L’opé- rande est d’abord converti en virgule flottante s’il y a lieu. fldregfldst(3) fldmemrealfldlongreal fldshortreal fildmemintfilemem16 fildmemintfilddword ptr [ebx] fbldmembcdfbldpackbcd

@Pierre Marchand, Virgule flottante FCMOVccFloating-Point Conditional Move Teste les bits d’état dans EFLAGS et copie la source dans la destination si la condition est vraie. fcmovbst(0), st(1) fcmovest(2), st(0) fcmovbest(1), st(2)

@Pierre Marchand, Virgule flottante FCOM/FCOMP/FCOMPP/FICOM/FICOMP Compare Compare l’opérande source spécifié à ST et positionne les codes condition du status word en conséquence. L’instruction soustrait la source de ST sans changer l’un ou l’autre des opérandes. Les opérandes mémoire peuvent être des nombres réels de 32 ou 64 bits. Si aucun opérande n’est spécifié ou si deux pops sont spécifiés, ST est comparé à ST(1) et la pile est dépilée. Si un pop est spécifié avec un opérande, l’opérande est comparé à ST. Si un des opérandes est un NAN, une exception d’opération invalide se produit.

@Pierre Marchand, Virgule flottante FCOM/FCOMP/FCOMPP/FICOM/FICOMP fcom[[reg]]fcomst(2) fcom fcomp[[reg]]fcompst(7) fcomp fcompp fcommemrealfcomshortreal fcomlongreal fcompmemrealfcompshortreal fcomplongreal

@Pierre Marchand, Virgule flottante FCOM/FCOMP/FCOMPP/FICOM/FICOMP ficommemintficomdouble ficomword ficompmemintficompword ptr ficomp[ebp+6]

@Pierre Marchand, Virgule flottante Sources d’erreur Débordement de capacité Sous-débordement de capacité Opérations inexactes: par exemple, 2  3 est une opération exacte, mais 2  3 est inexacte; 0,1 10 n’a pas de représentation finie en base 2, donc la conversion du décimal au binaire sera inexacte. Opérations invalides: par exemple: ∞ - ∞, ∞  ∞, 0  0, ∞  0, racine d’un nombre négatif, opération sur un NaN, etc. Erreurs créées par troncage lors d’un arrondi.

@Pierre Marchand, Virgule flottante Sources d’erreurs Il est important de réaliser qu’on a une perte importante de chiffres significatifs lorsqu’on soustrait des nombres pratiquement égaux. Si on évalue par exemple x - tan(x) à x = 0,01, on a: 0, … - 0, … = - 0, … mais si on ne garde que 8 chiffres significatifs, comme en virgule flottante de simple précision, on aura: 1, E-2 - 1, E-2 = -3, E-7 au lieu de -3, E-7. La précision est passée de 8 à 3 chiffres significatifs en une seule soustraction!

@Pierre Marchand, Virgule flottante Sources d’erreur Si on ne fait pas attention, la virgule flottante semble violer certains théorèmes mathématiques. Par exemple, (A + B) + C ≠ A + (B + C) En effet, si A = E12, B = E12 et C = 2.123E-6, (A + B) + C = 2.123E-6 mais A + (B + C) = 0

@Pierre Marchand, Virgule flottante Sources d’erreur De la même façon, (A  B)  C ≠ A  (B  C) Par exemple, si A = 3.075E-6, B = 3.875E154 et C = 4.25E154, (A  B)  C = E303 mais A  (B  C) = Débordement de capacité. Dans le cas de l’addition, il s’agit d’un problème d’arrondi, tandis que dans celui de la multiplication, il s’agit d’un problème de débordement de l’exposant.

@Pierre Marchand, Virgule flottante Séries de puissances Exemple : calcul d’un sinus On calcule cette série en la factorisant de la façon suivante: Soit a 1 = 1/13!, a 2 = - 1/11!, … a 6 = -1/3! et a 7 = 1. sin x ≈ ((((((a 1 * x 2 + a 2 ) * x 2 + a 3 ) * x 2 + a 4 ) * x 2 + a 5 ) * x 2 + a 6 ) * x 2 + a 7 ) * x Évidemment, x est exprimé en radians. Pour avoir x en degrés, il faut le multiplier par π/180. Avec les 7 termes ci-dessus, on a une précision de dans l’intervalle 0 - π/2.

@Pierre Marchand, Virgule flottante Séries de puissances Sinus en assembleur Sinus x:qword.data a dq E-10, E-8, , dq , , , 1.code leaesi, a fldx// fld[ebp+8] fldz// 0.0 sur la pile fldst(1)// pousse copie de x fmulst(0), st(2)// st(0) = x 2 fstst(1)// x 2 dans st(1) fmulqword ptr [esi]// *a[0] faddqword ptr [esi+8]// a[1]

@Pierre Marchand, Virgule flottante fmulst(0), st(1) faddqword ptr [esi+16]// a[2] fmulst(0), st(1) fadd qword ptr [esi+24]// a[3] fmulst(0), st(1) fadd qword ptr [esi+32]// a[4] fmulst(0), st(1) fadd qword ptr [esi+40]// a[5] fmulst(0), st(1) fadd qword ptr [esi+48]// a[6] fmulst(0), st(2)// * x fstpst(2)// st(2) = st(0) + pop fstpst(0)// pop ret x2x2 x st(0) sinus x2x2 st(0) x 2 *a[0]+a[1]

@Pierre Marchand, Virgule flottante Sources d’erreurs Dans l’évaluation de séries alternantes, il faut prendre garde, si la convergence n’est pas assez rapide, d’avoir des erreurs d’arrondi cumulatives. Une solution consiste à évaluer d’abord tous les termes positifs, puis tous les termes négatifs, et d’effectuer la soustraction des deux totaux.

@Pierre Marchand, 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, Programmation MMX Registres MM7 630 MM6 MM5 MM4 MM3 MM2 MM1 MM0

@Pierre Marchand, 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

@Pierre Marchand, 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, Programmation MMX 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, Programmation MMX Formats des données en mémoire Octet 7Octet 6Octet 5Octet 4Octet 3Octet 2Octet 1Octet 0 Adresse 0x1000Adresse 0x Mot 3Mot 2Mot 1Mot 0 Adresse 0x1000Adresse 0x Double mot 1Double mot 0 Adresse 0x1000Adresse 0x

@Pierre Marchand, 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 = 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, 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: = FF au lieu de (1)00 pour un octet non signé = 00 au lieu de F0 pour un octet non signé = 7F au lieu de E0 pour un octet signé 90 + A0 = 80 au lieu de (1)30 pour un octet signé

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

@Pierre Marchand, Programmation MMX Syntaxe movqmm2, qword ptr [ebp-8]// 64 bits movdeax, mm0// 32 bits movd[edi+4], mm1// 32 bits paddsbmm0, 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, Programmation MMX Instructions Arithmétiques WraparoundSignedUnsignedSaturation AdditionPADDBPADDSBPADDUSB PADDWPADDSWPADDUSW PADDD SoustractionPSUBBPSUBSBPSUBUSB PSUBWPSUBSWPSUBUSW PSUBD

@Pierre Marchand, Programmation MMX Instructions Arithmétiques WraparoundSignedUnsignedSaturation MultiplicationPMULL PMULH Multplication-AdditionPMADDWD

@Pierre Marchand, Programmation MMX PADDB, PADDSB, PADDUSB paddsb paddusb paddb

@Pierre Marchand, Programmation MMX PMULHW   Mot de poids fort Mot de poids fort

@Pierre Marchand, Programmation MMX PMADDWD   ++

@Pierre Marchand, Programmation MMX Instructions Comparaison Compare forPCMPEQB Equal PCMPEQW PCMPEQD Compare forPCMPGTPB Greater ThanPCMPGTPW PCMPGTPD

@Pierre Marchand, Programmation MMX Instructions Comparaison PCMPEQB == TrueFalse True FalseTrue

@Pierre Marchand, Programmation MMX Instructions Conversion WraparoundSignedUnsignedSaturation PackPACKSSWBPACKUSWB PACKSSDW Unpack HiPUNPCKHBW PUNPCKHWD PUNPCKHDQ Unpack LoPUNPCKLBW PUNPCKLWD PUNPCKLDQ

@Pierre Marchand, 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, Programmation MMX Instructions Logiques PackedFull Quadword AndPAND And NotPANDN OrPOR Exclusive OrPXOR

@Pierre Marchand, Programmation MMX Instructions Décalages PackedFull Quadword Left LogicalPSLLWPSLLQ PSLLD Right logicalPSRLWPSRLQ PSRLD Right arithmeticPSRAW PSRAD PSLLW

@Pierre Marchand, Programmation MMX Instructions Transferts de données 32 bits64 bits Reg to RegMOVDMOVQ Mem to RegMOVDMOVQ Reg to MemMOVDMOVQ 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, 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, 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, Programmation MMX Programmation Donc, pour savoir si le processeur peut exécuter les instructions MMX, on exécute le code suivant : moveax, 1 cpuid shredx, 24// on place le bit 23 dans CF jcok// si CF = 1, on a le MMX

@Pierre Marchand, 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 : leaesi, x leaedi, y movecx, longueur b:movqmm0,[esi] paddwmm0,[edi] movq[edi], mm0 addesi, 8 addedi, 8 subecx, 4 jnzb emms

@Pierre Marchand, 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. leaesi, x leaedi, y leaedx, dest movecx, longueur b:movqmm0,[esi] movqmm1, mm0 pmullwmm0,[edi] pmulhwmm1,[edi] x y dest *

@Pierre Marchand, Programmation MMX Exemples Multiplication de deux vecteurs movqmm2, mm0 punpcklwdmm0, mm1 punpckhwdmm2, mm1 movq[edx], mm0 movq[edx+8], mm2 addesi, 8 addedi, 8 addedx, 16 subecx, 4 jneb emms mm0mm1 mm0 mm2mm1 mm2 dest Hi Lo

@Pierre Marchand, Programmation MMX Exemples Multiplication scalaire de deux vecteurs de shorts (au moins 16) mov eax, offset a mov ebx, offset b mov ecx, n movedi, offset p boucle:movqmm0, [eax] movqmm1, [ebx] movqmm2, [eax+8] movqmm3, [ebx+8] movqmm4, [eax+16] movqmm5, [ebx+16] movqmm6, [eax+24] a 3 a 2 a 1 a 0 b 3 b 2 b 1 b 0 a 7 a 6 a 5 a 4 b 7 b 6 b 5 b 4 a 11 a 10 a 9 a 8 b 11 b 10 b 9 b 8 a 15 a 14 a 13 a 12

@Pierre Marchand, Programmation MMX Exemples Multiplication scalaire de deux vecteurs de shorts pmaddwdmm0, mm1 pmaddwdmm2, mm3 pmaddwdmm4, mm5 pmaddwdmm6, [ebx+24] padddmm7, mm0 padddmm7, mm2 padddmm7, mm4 padddmm7, mm6 addeax, 32 addebx, 32 subecx, 16 jnzboucle a 3 b 3 +a 2 b 2 a 1 b 1 +a 0 b 0 a 7 b 7 +a 6 b 6 a 5 b 5 +a 4 b 4 a 11 b 11 +a 10 b 10 a 9 b 9 +a 8 b 8 a 15 b 15 +a 14 b 14 a 13 b 13 +a 12 b 12 Hi Lo

@Pierre Marchand, Programmation MMX Exemples Multiplication scalaire de deux vecteurs de shorts movqmm0, mm7 shrlqmm7, 32 padddmm7, mm0 movd[edi], mm0 Hi Lo 0 Hi Hi+Lo p

@Pierre Marchand, 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, Programmation MMX Exemples 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 m 0, 1, 2, …, j - 1 i j

@Pierre Marchand, Programmation MMX Exemples 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 ]); for ( k = 0; k < 4; k++ ) produit [i+k ] = accum[ k ]; } v m i j 0, 1 2, …, j - 1 produit 0, 1 2, …, i - 1 =

@Pierre Marchand, Programmation MMX Exemples La fonction MULT4x2 movesi, param1 movedx, param2 movecx, colonnes movdmm7, [esi] punpckldqmm7, mm7 movqmm0, [edx] movqmm1, mm0 movqmm6, [edx + ecx * 2] punpcklwdmm0, mm6 punpckhwdmm1, mm6 v1v1 v0v0 v1v1 v0v0 v1v1 v0v0 mm7 m 01 m 00 m 03 m 02 mm0 m 11 m 10 m 13 m 12 mm6 m 10 m 00 m 11 m 01 mm0 m 12 m 02 m 13 m 03 mm1 m 01 m 00 m 03 m 02 mm1

@Pierre Marchand, Programmation MMX Exemples Multiplication d’une matrice par un vecteur pmaddwdmm0, mm7 pmaddwdmm1, mm7 padddmm2, mm0// accum[1, 0] padddmm3, mm1// accum[3, 2] m 10 m 00 m 11 m 01 mm0 m 12 m 02 m 13 m 03 mm1 v1v1 v0v0 v1v1 v0v0 mm7 m 11 v 1 + m 01 v 0 m 10 v 1 + m 00 v 0 mm0 m 13 v 1 + m 03 v 0 mm1 m 12 v 1 + m 02 v 0

@Pierre Marchand, Programmation MMX Exemples Transposée d’une matrice Soit une matrice 4 x 4 de short : En mémoire, on a : m 00 m 01 m 02 m 03 m 10 m 11 m 12 m 13 m 20 m 21 m 22 m 23 m 30 m 31 m 32 m 33 Si on fait movqmm0, m on aura dans mm0 : m 03 m 02 m 01 m 00 m 00 m 01 m 02 m 03 m 10 m 11 m 12 m 13 m 20 m 21 m 22 m 23 m 30 m 31 m 32 m 33

@Pierre Marchand, Programmation MMX Exemples Transposée d’une matrice On fait donc : m 33 m 32 m 31 m 30 m 13 m 12 m 11 m 10 m 23 m 22 m 21 m 20 m 03 m 02 m 01 m 00 punpcklwd m 31 m 21 m 30 m 20 punpcklwd m 11 m 01 m 10 m 00 punpckhdq m 31 m 21 m 11 m 01 punpckldq m 30 m 20 m 10 m 00

@Pierre Marchand, Programmation MMX Exemples Transposée d’une matrice Ensuite : m 33 m 32 m 31 m 30 m 13 m 12 m 11 m 10 m 23 m 22 m 21 m 20 m 03 m 02 m 01 m 00 punpckhwd m 33 m 23 m 32 m 22 punpckhwd m 13 m 03 m 12 m 02 punpckhdq m 33 m 23 m 13 m 03 punpckldq m 32 m 22 m 12 m 02

@Pierre Marchand, Programmation MMX 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é : m 00 m 01 m 02 m 03 m 04 m 05 m 06 m 07 m 10 m 11 m 12 m 13 m 14 m 15 m 16 m 17 m 20 m 21 m 22 m 23 m 24 m 25 m 26 m 27 m 30 m 31 m 32 m 33 m 34 m 35 m 36 m 37 m 00 m 10 m 20 m 30 m 01 m 11 m 21 m 31 m 02 m 12 m 22 m 32 m 03 m 13 m 23 m 33 m 04 m 14 m 24 m 34 m 05 m 15 m 25 m 35 m 06 m 16 m 26 m 36 m 07 m 17 m 27 m 37 ab a’ b’

@Pierre Marchand, Programmation MMX 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, Programmation MMX Autres exemples Voyez le site d’Intel :