FPU et puissance d'un nombre

Question

Bonjour, 

Voila, j'ai 'cod&#233;' 2 fonctions permettant de calculer un nombre n a une puissance exp (la fonction est bourrin, cad pas de decoupages de la fonction selon que le nombre soit pair ou impair..), une en ASM avec les instructions du CPU, et une autre avec les instructions de la FPU (celle dont j'ai vraiment besoin, pour certaines raisons..).
Et j'ai donc d&#233;cid&#233; de comparer la vitesse des 2fonctions, et la reponse est sans appel : Cpu plus rapide que Fpu (Avec mes fonctions a moi !).
Donc j'aimerais savoir comment 'optimiser' la fonction FPU ci dessous :


__declspec(
naked) 
int 
__stdcall PuissFPU(
int n, 
int exp)


{



__asm {


mov eax, [esp + 8] 
//eax == exp


fild [esp + 4] 
//empile n, ST(1) == n 


fild [esp + 4] 
//empile n, ST(0) == n, Contiendra le resultat


sub eax, 1


Deb:


fmul ST, ST(1)


sub eax, 1


test eax, eax


jne Deb


sub esp, 4


fist dword ptr[esp]


mov eax, [esp]


add esp, 4


ret 8 


}


}


__declspec(
naked) 
int 
__stdcall Puiss(
int n, 
int exp)


{



__asm {


mov ecx, [esp + 4]


mov edx, [esp + 8]


mov eax, ecx


sub edx, 1


Deb:


imul eax, ecx


sub edx, 1


test edx, edx


jne Deb


ret 8


}


}

Voila, merci d'avance a tous ;)
Amicalement, Alex 

+2(p - n)

BruNews · Answer

Dans tous les cas il est normal que par FPU soit plus lent qu'avec les 3 registres g&#233;n&#233;raux.
Tu peux gagner un peu en passant les params en registres.
Inutile de d&#233;placer ESP en sortie, c'est trop couteux, surtout si tu indexes sur lui l'instruction suivante.

__declspec(naked) int __fastcall PuissFPU(int n, DWORD exp){ // ECX n, EDX exp
  __asm {
    mov     [esp-4], ecx  ; n
    dec     edx
    jle     short puissExit
    fild    dword ptr[esp-4]
    fld     st(0)
  boucle:
    fmul    st(0), st(1)
    dec     edx
    jne     short boucle
    fistp   dword ptr[esp-4]
    fstp    st(0)
puissExit:
    mov     eax, [esp-4]
    ret     0
  }
}

Je n'ai pas mesur&#233;, je te laisse faire, pas le temps.
Si exp <= 1, je retourne n, c'est pas tr&#232;s orthodoxe, tu adapteras selon besoin.

ciao...
BruNews, MVP VC++

cs_AlexMAN · Answer

En fait, je ne veux pas passer toucher aux registres generaux, c'est ca la raison qui m'a pouss&#233; a utiliser le FPU...Parce que dans ma fonction appellante, je dois conserver la valeur presente dans ces registres, donc pas de __fastcall...Donc ca me rassure, merci ;)
Puis ce que je te tiens, je veux decomposer un nombre en tous ses chiffres et partie de ses chiffres de taille egale :

1634 => Soit 1, 6, 3, 4 soit 16, 34
100  => 1, 0, 0

J'utilise pour cela le reste de la division entiere par 10^x mais bien sur, c'est une division et c'est lent, donc je me demandais s'il n'existait pas une maniere de coder ca en deplacant des bits ou un truc plus rapide.

Merci Brunews
A bientot

+2(p - n)

BruNews · Answer

mais non, une division par une constante, 10 ici, se fait par multiplication, va voir bnultoa dans mes sources.

ciao...
BruNews, MVP VC++

BruNews · Answer

Je viens de t'envoyer ReciDiv.zip qui te donnera le code asm suivant le diviseur indiqu&#233;.

ciao...
BruNews, MVP VC++

FPU et puissance d'un nombre

4 réponses

Votre réponse

Discussions similaires