Resultat de la vitesse des : Registre, instruction, calcul, et mémoire ! ! !

Question

Voici la liste que j'ai créé :

    asm : ( inc ) = 0.065
    asm : ( and ) = 0.08
    asm : ( or ) = 0.08
    asm : ( xor ) = 0.08
    asm : ( not ) = 0.08
    asm : ( mov ) = 0.08

    asm : ( + ) = 0.08
    asm : ( - ) = 0.08
    asm : ( * ) = 1.54
    asm : ( / ) = 3.63
    asm : ( SHR ou SHL ) = 0.07

    asm : ( push/pop ) = 0.14  alors que [esp]=0.13 ou 0.68 celon l'emplacment ESP ?!!
    ecrire mov [ESP],eax est plus lent que push eax, alors que là il y a en plus un sub esp,4 ?
    c'est pas logique mais réelle, j'ai testé plusieurs fois ??!

    asm : ( cmp ) = 0.08
    asm : ( je oui ) = 0.26
    asm : ( je non ) = 0.07
    asm : ( jb non ) = 0.06
    asm : ( cmp + je non ) = 0.15
    asm : ( cmp + jb non ) = 0.14
    asm : ( jmp ) = 0.30
    la conclusion à cela c'est qu'un branchement sur ligne est lent !  

    boucle1:
     add eax,2
     inc edx 
   cmp edx,3000
    jb boucle1
 
    est plus lent que :

    boucle1:
     add eax,2
     add eax,2
     add eax,2
     inc edx 
    cmp edx,1000
    jb boucle1

    différence de vitesse par registre grace à plusieurs "mov" :
    asm : ( eax ) = 0.13
    asm : ( ebx ) = 0.13
    asm : ( ecx ) = 0.13
    asm : ( edx ) = 0.13
    asm : ( esi ) = 0.13
    asm : ( edi ) = 0.14    ??!! un peu plus lent on dirait !
    asm : ( esp ) = 0.13
    asm : ( eax2 ) = 0,29 donc [esp]
    asm : ( eax2 ) = 1,20 donc [esp] si on fait un calcul !!!!!

tout les resultats on était fait et refait
avec des 200 000 000 million de répétition à chacun !

...

Par contre comme vous pouvez le voir il y a un hic ! ! !
selon la position esp mes variable sont plus ou moins rapide avec des ecart enorme !
exemple : 
sub esp,18
mov eax,32 : mov [ESP],eax : mov ebx,[ESP]
mov eax,32 : mov [ESP],eax : mov ebx,[ESP]
mov eax,32 : mov [ESP],eax : mov ebx,[ESP]
mov eax,32 : mov [ESP],eax : mov ebx,[ESP]
add esp,18
dans ma boucle donne le résultat de 0.13 Seconde
alors que :
sub esp,8
mov eax,32 : mov [ESP],eax : mov ebx,[ESP]
mov eax,32 : mov [ESP],eax : mov ebx,[ESP]
mov eax,32 : mov [ESP],eax : mov ebx,[ESP]
mov eax,32 : mov [ESP],eax : mov ebx,[ESP]
add esp,8
donne 1,33 secondes 
même avec sub esp,100 ou 88, ou 50 ??!

c'est trés bizarre vous avez une idée ?!!

BruNews · Answer

Une serie d'instructions se mesure en ticks avec RDTSC, autrement n'amène qu'à du grand nimporte quoi.

mov [ESP], eax
ou
mov [ESP + xxx], eax
doit s'exécuter exactement pareil, seule la longueur (encodage) de l'instruction change. L'offset sur adresse est déjà résolu par le prefetch (chargeur d'instructions) avant d'arriver à l'unité d'exécution.

Les perfs dépendent beaucoup plus, à algo identique, au bon alignement des instructions et leur entrelacement (éviter les 'stall') qu'aux instructions elles memes.

ciao...
BruNews, MVP VC++

rebixav · Answer

D&#8217;après ce que je comprend, "RDTSC" est une fonction trés pécise pour calculé le temps d'une fonction !
mais là c'est une boucle de plusieurs millons qui fait 1,33 secondes au lieu de 0.13 Secondes, je l'ai encore refait hier  je veut dire que là pas besoin de d'avoir un super chronomètre pour ce rendre compte qu'il y a quelque chose (mais je ne sais pas quoi ?)

Resultat de la vitesse des : Registre, instruction, calcul, et mémoire ! ! !

2 réponses

Votre réponse

Discussions similaires