Salut,

En lisant le manuel d'AMD sur l'architecture amd64 je tombe sur une
partie qui concerne les "mov", et il y est donné cet exemple :

cmp ecx, 5
jnz continue
mov eax, ebx
continue:
...

Il est dit qu'une optimisation serait d'utiliser les mov conditonnels qui sont spécialement implémentés et ça donne ça :

cmp ecx, 5
cmovz eax, ebx

L'argument qui est invoqué c'est que le cmov serait pas affecté par une erreur du processeur lors des prédictions de branchement ( "Replacing conditional jumps with conditional moves also has the advantage that it can avoid branch-
prediction penalties that may be caused by conditional jumps." )

La question est donc : pourquoi avec le premier code on risque de tomber dans un raté lors de la prédiction et pas avec le second

« La question est donc : pourquoi avec le premier code on risque de tomber dans un raté lors de la prédiction et pas avec le second »

Ne pas essayer de comprendre comment fonctionne un processeur CISC dont t’as aucune information sur la manière dont c’est synthétisé est généralement une bonne philosophie de vie

En vrai t’as aucune idée des algos de prédictions ou des optimisations processeurs qu’ils utilisent. Tu ne peux faire que des suppositions S’ils disent « pour un cmov c’est comme ça », toute l’information que tu as c’est : « notre prédicteur de branchement marche “mieux” dans le cas 2 que 1 ». Ils mettent cette information pour que les gars qui font des compilos puissent optimiser ça, mais ils vont pas te dire toutes les spécifications de leurs procos pour des raisons de secret industriel
C’est moche, mais c’est comme ça …

Et dans la recherche en archi la mode en ce moment c’est les processeurs ARM

Un branchement change le float d’exécution du programme, la prochaine exécution n'est pas forcement celle qui vient juste après en mémoire.

Si le branchement est conditionnelle, on peut faire de la prédiction: Si on estime que le branchement va se faire, on exécute les instructions a l'avance mais si le branchement ne se fait pas, il faut annuler lesdites instructions (Pas mal de cycles seront perdus.)

Avec cmoz, que la condition soit satisfaite ou pas, la prochaine instruction sera toujours la suivante. Il n'y a pas de branchement donc pas de prédiction a faire.

Dark bah ils font bien le manuel très détaillé sur l'archi donc ils peuvent bien lâcher ça.

elite ça me va, mais dans l'implémentation de cmov y a pas une prédiction ?

kernel Non, c’est une composante critique et c’est encore un sujet de recherche chaud, donc ils gardent le secret. Le manuel est destiné aux usagers, pas aux développeurs (enfin tu m’as compris ).

Je vois ça dark.

elite je crois que je viens de tiquer ton explication, avec cmov le pipeline peut passer à la suite des instructions sans problème avec qu'avec le jmp faut revenir en cas de fail.

Dans cmov, tu n'as pas besoin de prediction de branchement, l'instruction est juste active ou desactive conditionellement. du fait il n'y a pas de jump du tout qui est effectue. Je ne connais pas l'archi interne des proc AMD (j'ai jamais regarde en fait.) Mais intuitivement, tu peux pipeliner le mov de facon naturel et en fonction de la condition effectuer le writeback ou pas.

Imagine que tu implemente cmov toi meme au dessus d'un pipeline RISC standard. Tu peux generer deux instructions d'abors un compare et un move. La seule difference est que tu retiens le resultat du move pendant un cycle poour controller si le write back est effectue ou non.

Donc en effet, il n'y a pas de branchement du tout dans cette instruction. Mais c'est certainement decoupe en deux instructions de microcode. En plus ca prends une instruction de moins que l'autre. Et une des instructions gagne est un jmp conditionel, ce qui reviens a dire que tu gagne une entree dans la table de prediction de branchement.

merci pour les précisions les gars

"la prochaine exécution n'est pas forcement celle qui vient juste après en mémoire."

correction: je voulais dire la prochaine instruction.

pour l'implementation des mov conditionel: ils se font si l'etat du flag cible est 1 ou 0.
sachant qu'avec le complément à deux, la valeur -1 met tous les bits sur 1, on peut faire

x := (x AND DEC(flag)) OR (new_value AND NEG(flag))

ainsi pas besoin de prédiction, de correction et compagnie (mais c'est pas forcement plus efficace).

par example, CMOVe (if equal) se fait si ZF = 1

si ZF = 1
x := (x AND DEC(1)) OR (new_value AND NEG(1))
x := (x AND 0) OR (new_value AND -1)
x := 0 OR new_value
X := new_value

si ZF = 0
x := (x AND DEC(0)) OR (new_value AND NEG(0))
x := (x AND -1) OR (new_value AND 0)
x := x OR 0
x := x

merci elite c'est une implémentation bien pensée