Projet Assembleur

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. Mesure simpliste
1 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 É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
x4