Discussion :

[lilington]

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

[Jean-Marc.Bourguet]

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).

[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?

[mala92]

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.

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.
Ex avec VC 2008 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

désassemblé, donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Bktero]

J'essaye le code mala92 avec avec MinGW :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[lilington]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Obsidian]

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é.

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[lilington]

magnifique exemple. merci