Discussion :

[corentin59]

Bonjour

Ce bout de code

Code :

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

1
2
int a;
a = a * 2;

et celui-ci

Code :

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

1
2
int a;
a = a << 1;

font la même chose : multiplier a par 2. Par contre, quel est le code le plus rapide à l'exécution et comment le vérifier ?

[nicolas.sitbon]

Moi je commencerais déjà par désassembler tout ça pour voir comment le compilateur l'a optimisé. Ensuite, si tu n'arrives toujours pas à voir, il reste la méthode itérative : tu lances 1 000 000 000 de multiplications avec les 2 méthodes et tu compares les temps d'exécutions sachant que de toutes façons ça peux varier en fonction de ton compilateur, de ton architecture, ...

[ram-0000]

Mon avis : ne te prend pas la tête.

Ecrit un code simple à comprendre et en accord avec ton contexte de développement.

Si dans ton contexte, l'instruction "*" a plus de sens que "<<" utilise la multiplication, si tu manipules des bits, utilise l'instruction "<<".

Après c'est le boulot de l'optimiseur de changer/remplacer certaines instructions par d'autres parce qu'il sait que celle la va plus vite et fait le même boulot que l'autre.

[dapounet]

Bonjour

Ce bout de code

Code :

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

1
2
int a;
a = a * 2;

et celui-ci

Code :

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

1
2
int a;
a = a << 1;

font la même chose : multiplier a par 2. Par contre, quel est le code le plus rapide à l'exécution et comment le vérifier ?

C'est la même chose, à part peut-être si tu utilises un compilateur complètement dépassé. La plupart des compilateurs sont capables de simplifier aussi n'importe quelle multiplication ou division par constante.

[Thierry Chappuis]

Le code suivant:

Code C :

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
int f1(int n)
{
    int res = 2 * n;
    return res;
}
 
int f2(int n)
{
    int res = n << 1;
    return res;
}
 
int main(void)
{
    f1(100);
    f2(100);
    return 0;
}

donne (après compilation avec gcc -S -O2 -c):

Code Asm :

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

1
2
3
4
5
6
7
_f1:
	pushl	%ebp
	movl	%esp, %ebp
	movl	8(%ebp), %eax
	popl	%ebp
	addl	%eax, %eax
	ret

et

Code Asm :

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

1
2
3
4
5
6
7
_f2:
	pushl	%ebp
	movl	%esp, %ebp
	movl	8(%ebp), %eax
	popl	%ebp
	addl	%eax, %eax
	ret

On voit que le code généré est strictement identique dans les deux cas. Et même avec un niveau d'optimisation -O0, gcc génère un code identique pour f1() et f2():

Code asm :

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

1
2
3
4
5
6
7
8
9
	pushl	%ebp
	movl	%esp, %ebp
	subl	$16, %esp
	movl	8(%ebp), %eax
	addl	%eax, %eax
	movl	%eax, -4(%ebp)
	movl	-4(%ebp), %eax
	leave
	ret

Donc, inutile de se tourmenter avec ce genre de micro-optimisations qui ne t'apportera pas grand chose. L'essentiel est d'écrire du code lisible et de se concentrer sur l'optimisation au niveau du choix et de la conception de l'algo.

Thierry

[corentin59]

OK, merci pour vos réponses.

[ram-0000]

Code Asm :

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

1
2
3
4
5
6
_f1:	pushl	%ebp
	movl	%esp, %ebp
	movl	8(%ebp), %eax
	popl	%ebp
	addl	%eax, %eax
	ret

Et même si mes souvenirs en assembleurs ne sont pas trop rouillés, l'optimiseur a remplacé dans les 2 cas la multiplication et le décalage par une addition

Code Asm :

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

1
2
 
addl	%eax, %eax

Cela revient à ajouter dans eax, le contenu de eax donc à multiplier par 2 le registre eax. L'optimiseur pense donc que dans ce cas, une addition est encore plus rapide.

[NairodDorian]

Par contre, quel est le code le plus rapide à l'exécution [...]

ça dépend sur quel processeur tu veux faire tourner ce code.
Si tu as un processeur Intel Pentium III l'instruction shl sera plus rapide que mul et add par contre si tu tournes sur un processeur Intel récent Pentium 4 et après l'instruction add est plus rapide que mul et shl.

Une petite remarque aussi sur la fonction codé par Thierry :
sa fonction :

Code :

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

1
2
3
4
5
int f1(int n)
{
    int res = 2 * n;
    return res;
}

Devrait être écrite comme ceci :

Code :

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

1
2
3
4
unsigned int __fastcall f1(unsigned n)
{
return n << 1;
}

Voilà...

[Thierry Chappuis]

Une petite remarque aussi sur la fonction codé par Thierry :
sa fonction :

Code :

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

1
2
3
4
5
int f1(int n)
{
    int res = 2 * n;
    return res;
}

Devrait être écrite comme ceci :

Code :

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

1
2
3
4
unsigned int __fastcall f1(unsigned n)
{
return n << 1;
}

Voilà...

Pourquoi?

Je fais confiance aux qualités d'optimiseur de mon compilo.

Thierry

[Emmanuel Delahaye]

Ce bout de code

Code :

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

1
2
int a;
a = a * 2;

et celui-ci

Code :

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

1
2
int a;
a = a << 1;

font la même chose : multiplier a par 2. Par contre, quel est le code le plus rapide à l'exécution et comment le vérifier ?

N'oublie pas que le code source n'est une déclaration d'intention à l'encontre du compilateur, qui lui, écrit le code machine qui va bien. Il est fort probable que les 2 codes sources donnent le même code machine avec un compilateur moderne... Tu ne verras donc pas la différence.

Si tu veux la voir, il faut coder en assembleur.