Pourquoi différer (! =, <>) Est plus rapide que égal (=, ==)?

Eh bien, cela pourrait être ou ça ne pouvait pas être, c'est la question suivante :-) La chose est que cela dépend de la langue de programmation que vous utilisez. Étant donné que toutes vos déclarations finiront par finir par des instructions à la CPU, celle qui utilise le moins d'instructions pour atteindre le résultat sera la plus rapide.

Par exemple, si vous dites que les bits x sont égaux aux bits y, vous pouvez utiliser l'instruction qui utilise un xor utilisant les deux bits comme une entrée, si le résultat est autre que 0, il n'est pas le même. Alors, comment sauriez-vous que le résultat est autre que 0? En utilisant l'instruction qui retourne true si vous dites que l'entrée A est supérieure à 0.

C'est déjà 2 instructions que vous utilisez pour le faire, mais comme la plupart des CPU ont une instruction qui se compare en un seul cycle, il s'agit d'un mauvais exemple.

Le point que je fais est toujours le même, vous ne pouvez pas faire ces déclarations généralement sans fournir le langage de programmation et l'architecture de la CPU.

Cela pourrait avoir quelque chose à voir avec la prédiction des succursales sur la CPU. La prédiction des succursales statiques prédirait qu'une succursale ne serait tout simplement pas prise et récupérerait la prochaine instruction. Cependant, presque personne ne l'utilise plus. Autre que cela, je dirais que c'est taureau parce que les comparaisons doivent être identiques.

Juste deviner, mais vous souhaitez conserver la logique, vous ne pouvez pas simplement remplacer xxx

avec xxx

pour conserver la logique , le code d'origine doit avoir été quelque chose comme xxx

ou xxx

et qui peut vraiment être un peu plus lentement que le test sur l'inégalité.

Cela pourrait également résulter d'une interprétation erronée d'une expérience.

La plupart des compilateurs / optimiseurs supposent qu'une succursale est prise par défaut. Si vous inverser l'opérateur et l'ordre IF-alors-alors, et la succursale qui est maintenant prise est la clause de l'autre, cela pourrait provoquer un effet de vitesse supplémentaire dans le calcul hautement en calcul (*)

(*) Évidemment, vous devez faire beaucoup d'opérations pour cela. Mais cela peut être important pour les boucles les plus strictes par ex. codecs ou analyse d'image / vision de la machine où vous avez 50 Mo / s de données au chalut. .... Et puis je ne sois même que sur ce niveau pour le code vraiment réutilisable. Pour le code d'entreprise ordinaire, cela ne vaut pas la peine.

Je pense qu'il y a une certaine confusion dans votre question précédente sur ce que l'algorithme était que vous essayiez de mettre en œuvre, et donc dans ce que le" spef-up "prétendait faire.

Voici un démontage de Delphi 2007. Optimisation sur. (Remarque, Optimisation a changé le code un peu, mais pas de manière pertinente. P>

Unit70.pas.31: for I := 0 to 100 do
004552B5 33C0             xor eax,eax
Unit70.pas.33: if i = j then
004552B7 3B02             cmp eax,[edx]
004552B9 7506             jnz $004552c1
Unit70.pas.34: k := k+1;
004552BB FF05D0DC4500     inc dword ptr [$0045dcd0]
Unit70.pas.35: if i <> j then
004552C1 3B02             cmp eax,[edx]
004552C3 7406             jz $004552cb
Unit70.pas.36: l := l + 1;
004552C5 FF05D4DC4500     inc dword ptr [$0045dcd4]
Unit70.pas.37: end;
004552CB 40               inc eax
Unit70.pas.31: for I := 0 to 100 do
004552CC 83F865           cmp eax,$65
004552CF 75E6             jnz $004552b7
Unit70.pas.38: end;
004552D1 C3               ret