Discussion :

[ft1103]

Bonjour,

Est-il vrai, avec les processeurs actuels, qu'effectuer un décalage binaire à la place d'une multiplication est plus optimal ?
ex : unsigned int size = 4
char tab[size >> 1] ou char tab[size * 2]

Merci d'avance pour vos réponses.

[Bktero]

Salut,

Tu voulais plutôt dire

Code :

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

char tab[size << 1]

, non ?

On dit souvent que les décalages sont plus rapides que les multiplications, et a fortiori que les divisions.

L'article Wikipédia est quand un peu nuancé sur les processeurs modernes surpuissants :

A bitwise operation operates on one or more bit patterns or binary numerals at the level of their individual bits. It is a fast, primitive action directly supported by the processor, and is used to manipulate values for comparisons and calculations. On simple low-cost processors, typically, bitwise operations are substantially faster than division, several times faster than multiplication, and sometimes significantly faster than addition. While modern processors usually perform addition and multiplication just as fast as bitwise operations due to their longer instruction pipelines and other architectural design choices, bitwise operations do commonly use less power/performance because of the reduced use of resources.

Au-delà de cette réponse générale qu'on pourrait résumer en "c'est globalement plus rapide", la question est "est ce que c'est intéressant d'écrire cela ?".
Cette discussion de Stackoverflow regroupe de bons arguments sur le sujet.

1. Le premier est que tu peux tester en regardant le code assembleur généré et voir s'il y a une différence en faveur de l'écriture avec <<. Mais voir point 2.
   
2. Le second et sans doute le plus important est que le compilateur optimise bien mieux que toi. Il est capable de remplacer un *2 par un <<1 si cela est meilleur pour l'architecture cible. Tu as donc souvent intérêt à laisser la forme correspondant à ce que tu souhaites, le compilateur se chargera de faire les optimisations. De plus, ton code sera beaucoup plus lisible !
   
3. Le dernier argument est qu'il y a certainement énormément de choses à optimiser dans 99% des applications avant de s'intéresser à un tel détail. Tu ne t'y intéresseras probablement que si tu fais du calcul intensif avec un délai très bref et à la condition préalable que ton algorithme et son implémentation soient quasi-parfaite.

Personnellement, je n'ai jamais eu à utiliser cette écriture

[AhyGoon]

C'est plus rapide pour le processeur de faire un décallage qu'une multiplication ou division.
Simplement car cela represent moins de manipulation.

Par contre cela ne marche que pour des * ou / par une puissance de 2.


Maintenant, les compilateurs actuels (ou même assez ancien en fait ^^) savent faire l'optimisation d'eux même.

J'ai pu le tester sur un SOFTUNE V3 (Fujitsu cible MB90F497G)
écrire

Code :

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

1
2
3
int i = 1;
i = i * 2;

ou bien

Code :

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

1
2
3
int i = 1;
i <<=  1;

Cela produit un code de même taille. (j'avais fait cela à 1 endroit et vérifié que la taille globale du binaire restait la même.)


Du coup, comme on ne gagne rien à remplacer * et / par << ou >>, il vaut mieux écrire clairement que l'on fait une division ou une multiplication afin de rendre le code plus clair au lecteur. Ca évite aussi des bug si tu fais un décalage sur un float ^^.

[ft1103]

Merci pour vos réponses qui m'ont bien éclairé.

[ClaudeBg]

Salut
-----

C'est plus rapide pour le processeur de faire un décallage qu'une multiplication ou division.

Ça dépend du processseur.
Certains feront une multiplication en 1 cycle alors que les décalages nécessiteront de travailler sur plusieurs octets, ou nécessiteront un positionnement du carry avant l'opération.

Par contre, pour d'autres, une multiplication nécessitera plus de transferts de registres qu'un décalage.

Il faut voir au cas par cas, on ne peut pas généraliser.

Par contre cela ne marche que pour des * ou / par une puissance de 2.

À partir du moment où on multiplie par une constante, il y a très souvent moyen de se servir des décalages plutôt que de la multiplication, surtout si le processeur est dépourvu d'instructions gérant les multiplications de la taille souhaitée (on est sur un forum "embarqué").

Par exemple, a * 10 =

((a << 2) + a) <<1

Ce sera beaucoup plus rapide à exécuter sur un processeur ne disposant pas d'une instruction de multiplication de taille suffisante (taille de a?), mais moins rapide si ce processeur en dispose.

Ceci étant que, comme il a été dit, la plupart des compilateurs performants savent parfaitement tirer parti de ces astuces, elles ne sont vraiment pratiques que pour celui qui programme en langage d'assemblage.

A+
Claude