Projet Assembleur
publicité
Projet Assembleur Jason JAMET L3 Informatique Jason JAMET Sommaire I. Introduction...............................................................................................................................3 1 Objectif principal..........................................................................................................................3 2 Contraintes....................................................................................................................................3 II. Mesure simpliste...................................................................................................................3 1 Explication....................................................................................................................................3 2 Étapes de cette traduction.............................................................................................................3 III. Mesure simpliste dépliage..............................................................................................4 1 Explication....................................................................................................................................4 2 Étapes de cette traduction.............................................................................................................4 IV. SSE.............................................................................................................................................5 1 Explication....................................................................................................................................5 2 Étapes de cette traduction.............................................................................................................5 V. SSE Dépliage...........................................................................................................................6 1 Explication....................................................................................................................................6 2 Étapes de cette traduction.............................................................................................................6 VI. Conclusion..............................................................................................................................7 VII. Bibliographie.......................................................................................................................7 2/7 15/10/13 Jason JAMET I.Introduction 1 Objectif principal Optimiser les performances d'une fonction écrite en « C » qui compare deux chaînes de caractères, et retourne le ratio de nombre de caractères communs. 2 Contraintes Le projet doit être écrit en assembleur x86 32 bits, en ce qui me concerne, j'ai utilisé les registres SSE (SSE2, SSE4...), ainsi que les registres standard. ATTENTION : J'ai divisé par 10 le nombre de répétition dans le main.cpp (1000). II. 1 Mesure simpliste Explication Pour commencer ce projet, j'ai utilisé le peu de connaissances que je possédais en assembleur afin d'effectuer ma première traduction de la fonction de comparaison. 2 Étapes de cette traduction • • • • • Initialisation des variables. Création d'un label « for » (correspondant a la boucle for). Comparaison d'un caractère avec un autre caractère (grâce à ah et al). Si égaux saut vers le label « incs » qui incrémente le compteur « ebx », sinon retour à « for ». Une fois la boucle terminée on divise le compteur par la taille totale des chaînes, grâce a des instructions coprocesseurs. reference simpliste 0 ; 16 ; 0.24 1 ; 16 ; 0.37 0 ; 255 ; 3.97 1 ; 255 ; 4.94 0 ; 511 ; 7.78 1 ; 511 ; 9.70 0 ; 1023 ; 15.79 1 ; 1023 ; 19.05 0 ; 2047 ; 31.14 1 ; 2047 ; 38.12 0 ; 4095 ; 63.06 1 ; 4095 ; 75.96 0 ; 8191 ; 125.59 1 ; 8191 ; 151.84 La traduction simpliste est moins performante que la fonction en C. 3/7 15/10/13 Jason JAMET III. Mesure simpliste dépliage 1 Explication Afin d'améliorer la fonction simpliste, le dépliage de boucle me semblais nécessaire. Grâce à cette méthode, un nombre significatif de « jump » peut être économisé, l'instruction « jump » étant très gourmande en ressources (obligation de push et pop tous les registres), c'est toute la fonction qui ce verrais fortement optimisée. Un dépliage par 4 me semble correct, au delà, l'optimisation est tellement faible qu'elle en deviens caduc. De plus l'instruction « cmove » (conditionnal move) me permet de ne pas passer par le label « incs » , cette opération économise 2 sauts par passage de boucle. 2 Étapes de cette traduction • • • • • • • Initialisation des variables. Création d'un label « for » (correspondant a la boucle for). Placement de compteur+1 dans edx. Comparaison d'un caractère avec un autre caractère (grâce à ah et al). Si égaux placement de edx dans compteur(ebx) Retour au for Une fois la boucle terminée on divise le compteur par la taille totale des chaînes, grâce a des instructions coprocesseurs. reference simpliste _depliage 0 ; 16 ; 0.24 2 ; 16 ; 0.16 0 ; 255 ; 3.97 2 ; 255 ; 2.04 0 ; 511 ; 7.78 2 ; 511 ; 4.09 0 ; 1023 ; 15.79 2 ; 1023 ; 8.26 0 ; 2047 ; 31.14 2 ; 2047 ; 16.24 0 ; 4095 ; 63.06 2 ; 4095 ; 32.95 0 ; 8191 ; 125.59 2 ; 8191 ; 64.52 Nous obtenons un rendement environ 2 fois supérieur a la fonction de référence. 4/7 15/10/13 Jason JAMET IV. SSE 1 Explication Pour encore améliorer l'optimisation de notre fonction, nous pouvons utiliser de la vectorisation grâce aux registres SSE. Chaque registre SSE peut stocker 128 bits (soit 16 octets), il y a donc beaucoup moins d'affectations et de sauts à faire. Si la taille des chaînes est inférieur à 16, l'utilisation des registres SSE n'est pas pertinente, nous utiliserons donc, lorsque la chaîne est trop petite, une mesure simpliste. 2 x4 Étapes de cette traduction • • • • • • • • Initialisation des variables. Création d'un label «sse» (correspondant a la boucle for du sse, size>=16). Placement des tableau dans les registres SSE (double quadruple mot aligné, 16 caractères) Compare octet par octet les équivalences entre les 2 registres Placement de 32 bits dans un registre standard Compte le nombre de 1 et divise par 8 pour retrouver le nombre de caractères Retour a sse si ecx>16 sinon on fait du simpliste Une fois la boucle terminée on divise le compteur par la taille totale des chaînes, grâce a des instructions coprocesseurs. reference simpliste _depliage 0 ; 16 ; 0.24 0 ; 16 ; 0.10 0 ; 255 ; 3.97 0 ; 255 ; 0.56 0 ; 511 ; 7.78 0 ; 511 ; 0.96 0 ; 1023 ; 15.79 0 ; 1023 ; 1.80 0 ; 2047 ; 31.14 0 ; 2047 ; 2.90 0 ; 4095 ; 63.06 0 ; 4095 ; 5.58 0 ; 8191 ; 125.59 0 ; 8191 ; 10.96 Nous obtenons un rendement environ 9.5 de 11 fois supérieur a la fonction de référence. 5/7 15/10/13 Jason JAMET V. 1 SSE Dépliage Explication Après les très bon résultats obtenu par la fonction « SSE », j'applique un dépliage pour tenter d'avoir des résultats encore meilleurs. 2 x2 x4 Étapes de cette traduction • • • • • • • • Initialisation des variables. Création d'un label «dep32» (correspondant a la boucle for du sse, size>=32). Placement des tableau dans les registres SSE (double quadruple mot aligné, 16 caractères) Compare octet par octet les équivalences entre les 2 registres Placement de 32 bits dans un registre standard Compte le nombre de 1 et divise par 8 pour retrouver le nombre de caractères Retour a sse si ecx>16 Une fois la boucle terminée on divise le compteur par la taille totale des chaînes, grâce a des instructions coprocesseurs. reference simpliste _depliage 0 ; 16 ; 0.24 1 ; 16 ; 0.10 0 ; 255 ; 3.97 1 ; 255 ; 0.56 0 ; 511 ; 7.78 1 ; 511 ; 0.97 0 ; 1023 ; 15.79 1 ; 1023 ; 1.78 0 ; 2047 ; 31.14 1 ; 2047 ; 3.43 0 ; 4095 ; 63.06 1 ; 4095 ; 6.76 0 ; 8191 ; 125.59 1 ; 8191 ; 13.54 Nous obtenons un rendement environ 9.5 fois supérieur a la fonction de référence, ce qui est moins performant que sans le dépliage, en effet, dans la grande majorité des traitements le dépliage d'une vectorisation ne seras pas plus performante que la vectorisation seule, voir dans certain cas, elle sera diminuée. 6/7 15/10/13 Jason JAMET VI. Conclusion Ce projet m'a permis de mieux me familiariser avec l'utilisation du langage assembleur, notamment les piles, directives coprocesseurs, registres SSE... Mon apprentissage de ce langue très bas niveau m'a permis de mieux me rendre compte du fonctionnement de ma machine (gestion de la mémoire, la façon dont est interprété mon code de haut niveau) VII. Bibliographie http://www.info.univ-angers.fr/~richer/ensl3i.php Cours et TD vu pendant le 1er Semestre de L3 Informatique. Connaissances personnelles. http://www.gladir.com/ 7/7 15/10/13
