question sur GCC

boujour,
j'ai une question un peu toute bete mais ca me gratte quand meme.
je lisais un code asm et j'ai remarque que chaque fois qu'il y avait une multiplication par une puissance de 2 le gus faisais un decallage a gauche.
donc je me suis poser la question de savoir si le compilo GCC quand il doit faire une mutipliation avec une puissance de 2 fait juste un decallage car visiblement plus rapide ou bien une vrai multiplication?
en d'autre terme est-il plus rapide en C d'ecrire

3<<2 pour faire 3x4 ou bien 3*4 est strictement equivalent?

merci

C'est le genre de chose que les compilateurs font tres bien. Et quand ils ne le font pas, c'est qu'il y a une difference (p.e. avec le decalage a droite de nombres signes, l'arrondi est different de celui des divisions pour les nombres negatifs).

reponse interressante mais qui m'avance pas beaucoup.
surtout a la question si dans mon code en C j'ecrivais
3<<2 ca fait une difference ou pas avec 3*4?

Citation:

---

Envoyé par lilington

reponse interressante mais qui m'avance pas beaucoup.

---

tu veux qu'on dise quoi ? C'est le compilo qui décide de décaler ou pas.

Citation:

---

Envoyé par lilington

surtout a la question si dans mon code en C j'ecrivais
3<<2 ca fait une difference ou pas avec 3*4?

---

On va dire non, à moins de tomber sur un compilo tout pourri. :aie:
Ex avec VC 2008 :

Code:

---

1 2 3 4

int i =3; i = i<<2; int j = 3; j= j*4;

---

désassemblé, donne :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

int i =3; 0041138E mov dword ptr [i],3 i = i<<2; 00411395 mov eax,dword ptr [i] 00411398 shl eax,2 0041139B mov dword ptr [i],eax int j = 3; 0041139E mov dword ptr [j],3 j= j*4; 004113A5 mov eax,dword ptr [j] 004113A8 shl eax,2 004113AB mov dword ptr [j],eax

---

donc c'est le même code asm.

J'essaye le code mala92 avec avec MinGW :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

0x004016EC push %ebp 0x004016ED mov %esp,%ebp 0x004016EF and $0xfffffff0,%esp 0x004016F2 sub $0x10,%esp 0x004016F5 call 0x401b10 <__main> 0x004016FA movl $0x3,0x8(%esp) 0x00401702 shll $0x2,0x8(%esp) 0x00401707 movl $0x3,0xc(%esp) 0x0040170F shll $0x2,0xc(%esp) 0x00401714 mov $0x0,%eax 0x00401719 leave 0x0040171A ret

---

Je discutais de la chose avec un collègue qui me disait : ton compilateur sait si un décalage est plus intéressant ou si ton processeur cible dispose d'ALU qui font le calcul aussi (voire plus) rapidement.

Bon ben du coup je me dis aussi que j'ai poster pour rien car effectivement un objdump me donnait la reponse pour GCC

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

000000000040049c<main>: 40049c: 55 push rbp 40049d: 48 89 e5 mov rbp,rsp 4004a0: 89 7d ec mov DWORD PTR [rbp-0x14],edi 4004a3: 48 89 75 e0 mov QWORD PTR [rbp-0x20],rsi 4004a7: c7 45 fc 03 00 00 00 mov DWORD PTR [rbp-0x4],0x3 4004ae: c1 65 fc 02 shl DWORD PTR [rbp-0x4],0x2 4004b2: c7 45 f8 03 00 00 00 mov DWORD PTR [rbp-0x8],0x3 4004b9: c1 65 f8 02 shl DWORD PTR [rbp-0x8],0x2 4004bd: c7 45 f4 03 00 00 00 mov DWORD PTR [rbp-0xc],0x3 4004c4: 8b 55 f4 mov edx,DWORD PTR [rbp-0xc] 4004c7: 89 d0 mov eax,edx 4004c9: 01 c0 add eax,eax 4004cb: 01 d0 add eax,edx 4004cd: 89 45 f4 mov DWORD PTR [rbp-0xc],eax 4004d0: b8 00 00 00 00 mov eax,0x0 4004d5: 5d pop rbp 4004d6: c3 ret 4004d7: 66 0f 1f 84 00 00 00 nop WORD PTR [rax+rax*1+0x0] 4004de: 00 00

---

pour le code:

Code:

---

1 2 3 4 5 6

int i=3; i=i<<2; int j=3; j=j*4 int k=3; k=k*3;

---

bizarre de voir comment il multiplie par trois. tiens je vais multiplier par mille pour voir.
c'est amusant ce truc.

Citation:

---

Envoyé par lilington

reponse interressante mais qui m'avance pas beaucoup.
surtout a la question si dans mon code en C j'ecrivais 3<<2 ca fait une difference ou pas avec 3*4?

---

On peut dire aujourd'hui que ça ne fait plus de différence, parce qu'effectivement les compilateurs sont matures et sont devenus très doués en matière d'optimisation. Il y a plusieurs discussions ici sur le sujet lorsque l'on pensait qu'un compilateur pouvait certes produire du code très raffiné mais qui ne pourrait jamais l'être autant qu'un code assembleur écrit à la main. C'est en général en essayant de le démontrer qu'on s'aperçoit que c'est très difficile et qu'on mesure l'ampleur du chemin parcouru. Et c'est un « assembliste » convaincu qui te parle. :-)

Par contre, ça n'a pas toujours été le cas et ça peut ne pas l'être avec d'autres compilateurs. C'est donc toujours une bonne idée d'utiliser les différents opérateurs pour exprimer ce que tu veux faire. Si tu souhaites réellement décaler des bits ou si tu veux faire une multiplication. Cette approche sémantique a de l'importance si en fonction des types : si tu modifies tes int en float, « * 2 » fonctionnera toujours mais pas « << 1 ». C'est intéressant dans les deux sens : si c'est vraiment un décalage de bits que tu souhaites faire, il est appréciable que le compilateur provoque une erreur si tu lui passes un type inadapté.

Citation:

---

GCC quand il doit faire une mutipliation avec une puissance de 2 fait juste un decallage car visiblement plus rapide ou bien une vrai multiplication?

---

Ça dépend des cas : il choisira ce qui est le plus efficace et il est de fait que sur un entier, c'est le décalage à gauche qui le sera à tous les coups.

Il reste toutefois un cas où l'utilité du décalage est indéniable, et c'est celui-ci :

Code:

---

1 2 3 4 5 6 7 8 9

#include <stdio.h>   int main (void) { int i;   for (i=0;i<31;i++) printf ("2 puissance %d = %d\n",i,1 << i); return 0; }

---

Pour faire la même chose sans passer par un accumulateur (une variable qui garderait l'état précédent à chaque tour et que l'on n'aurait qu'à multiplier par deux), il faudrait recourir à pow(), ce qui est inacceptable.

magnifique exemple. merci