Voila, j'ai 'codé' 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écidé 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)
Dans tous les cas il est normal que par FPU soit plus lent qu'avec les 3 registres généraux.
Tu peux gagner un peu en passant les params en registres.
Inutile de dé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é, je te laisse faire, pas le temps.
Si exp <= 1, je retourne n, c'est pas très orthodoxe, tu adapteras selon besoin.
En fait, je ne veux pas passer toucher aux registres generaux, c'est ca la raison qui m'a poussé 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.
