@Pierre Marchand, 2001289 IFT-17584 Semaine 05 Programmation système.

Présentation au sujet: "@Pierre Marchand, 2001289 IFT-17584 Semaine 05 Programmation système."— Transcription de la présentation:

1 @Pierre Marchand, 2001289 IFT-17584 Semaine 05 Programmation système

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

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

4 @Pierre Marchand, 2001292 Virgule flottante Registres Opcode Registres de données MantisseExposant 79 78 64 63 0 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 15 0 470 100

5 @Pierre Marchand, 2001293 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 15140109 FPU Busy Top of Stack Pointer

6 @Pierre Marchand, 2001294 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 15120108 RCX Infinity Control Rounding Control Precision Control

7 @Pierre Marchand, 2001295 Virgule flottante Registres de données Pile de registres de données 079 0 1 2 3 4 5 6 7 Croissance de la pile ST(0) ST(1) ST(2) 011 Sommet

8 @Pierre Marchand, 2001296 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).

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

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

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

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

13 @Pierre Marchand, 2001301 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 15140109 C0C0 C1C1 C2C2 C3C3 15140109 FPU Status Word Registre AX CFCF 1 PFPF ZFZF Registre EFLAGS 08 8

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

34 @Pierre Marchand, 2001322 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,01000000000000… - 0,01000033334667… = - 0,00000033334667… mais si on ne garde que 8 chiffres significatifs, comme en virgule flottante de simple précision, on aura: 1,0000000E-2 - 1,0000333E-2 = -3,3300000E-7 au lieu de -3,3334667E-7. La précision est passée de 8 à 3 chiffres significatifs en une seule soustraction!

35 @Pierre Marchand, 2001323 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 = 3.875 E12, B = -3.875E12 et C = 2.123E-6, (A + B) + C = 2.123E-6 mais A + (B + C) = 0

36 @Pierre Marchand, 2001324 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 = 5.06414E303 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.

37 @Pierre Marchand, 2001325 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 10 -14 dans l’intervalle 0 - π/2.

38 @Pierre Marchand, 2001326 Virgule flottante Séries de puissances Sinus en assembleur Sinus x:qword.data a dq 1.6059044E-10, -2.5052108E-8, 0.0000027557319, dq -0.00019841270, 0.0083333333, -0.16666667, 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]

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

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

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

42 @Pierre Marchand, 2001330 Programmation MMX Registres MM7 630 MM6 MM5 MM4 MM3 MM2 MM1 MM0

43 @Pierre Marchand, 2001331 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. 100000000111111100111000 111111110001011100000111 ++++++++ 111111111001011000111111

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

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

46 @Pierre Marchand, 2001334 Programmation MMX Formats des données en mémoire Octet 7Octet 6Octet 5Octet 4Octet 3Octet 2Octet 1Octet 0 Adresse 0x1000Adresse 0x1007 63565548231587016474039323124 Mot 3Mot 2Mot 1Mot 0 Adresse 0x1000Adresse 0x1006 634815016473231 Double mot 1Double mot 0 Adresse 0x1000Adresse 0x1004 6303231

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

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

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

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

51 @Pierre Marchand, 2001339 Programmation MMX Instructions Arithmétiques WraparoundSignedUnsignedSaturation AdditionPADDBPADDSBPADDUSB PADDWPADDSWPADDUSW PADDD SoustractionPSUBBPSUBSBPSUBUSB PSUBWPSUBSWPSUBUSW PSUBD

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

53 @Pierre Marchand, 2001341 Programmation MMX PADDB, PADDSB, PADDUSB 100000000111111100111000 111111110001011100000111 ++++++++ 011111111001011000111111 10000000 paddsb 01111111 10010110 paddusb paddb 11111111

54 @Pierre Marchand, 2001342 Programmation MMX PMULHW 0111000111000111 10000000000000000000010000000000  11000111000111000000000111000111  Mot de poids fort Mot de poids fort

55 @Pierre Marchand, 2001343 Programmation MMX PMADDWD 0111000111000111 10000000000000000000010000000000  110010001110001110011100000000000  ++

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

57 @Pierre Marchand, 2001345 Programmation MMX Instructions Comparaison PCMPEQB 0000000000000001000001110000100000000000100000000111111100111000 00000000 000001110000100001011011111111110001011100111000 == 111111110000000011111111 00000000 11111111 TrueFalse True FalseTrue

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

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

60 @Pierre Marchand, 2001348 Programmation MMX Instructions Logiques PackedFull Quadword AndPAND And NotPANDN OrPOR Exclusive OrPXOR

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

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

63 @Pierre Marchand, 2001351 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”.

64 @Pierre Marchand, 2001352 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).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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