Question C / C ++: est-il plus rapide d'attribuer un 0 à une variable longue non signée ou de xor la variable avec elle-même? [fermé]


Je me rends compte que la différence peut être négligeable, mais qui est plus efficace en essayant de supprimer un long non signé?

unsigned long x;

...

x=0;

--OR--

x^=x;

Taylor


9
2018-04-04 16:40


origine


Réponses:


Si vous deviez implémenter un compilateur, que feriez-vous? En effet, vous choisiriez l'implémentation la plus rapide pour les deux. Comme les deux sont égaux, cette implémentation la plus rapide est la même pour les deux.

En d'autres termes, tout compilateur publié après 5000 B.C. générera le même code d'assemblage pour les deux x = 0 et x ^= x si vous activez les optimisations. Cela signifie qu'ils sont également rapides.

Cela ne va pas seulement pour l'affectation / xorring, mais aussi pour multiplication, entre autres algorithmes. Exprimez votre intention et laissez le compilateur l'optimiser. Le compilateur est meilleur en optimisations que vous, croyez-moi.

En d'autres termes, écrivez du code lisible et utilisez x = 0;.


Oh, au fait, xorring bit par bit un entier non initialisé par lui-même est un comportement indéfini et un bon compilateur devrait optimiser la totalité.


30
2018-04-04 16:42



Tout d'abord, si une valeur n'a pas été affectée à la variable, il est techniquement "comportement indéfini" de faire autre chose que de lui attribuer une valeur.

Deuxièmement, avec XOR, il est peu probable qu’elle soit plus rapide sur un processeur produit au cours des 15 à 20 dernières années, car elle nécessite une lecture supplémentaire. Cela a peut-être été plus rapide (en raison du SHORT PLUS CODE) il y a très longtemps, mais en réalité, je crois même que c'est faux.

Edit: Je tiens à souligner que cela peut encore être plus rapide / plus compact pour XOR un registre pour le rendre nul dans les processeurs modernes. Mais si nous supposons que nous ne pouvons pas savoir si x est dans un registre ou non, alors nous ne devrions pas non plus compliquer la tâche du compilateur pour déterminer ce que nous faisons réellement.


11
2018-04-04 16:43



Pourquoi spéculer sur ce que fait le compilateur? Essayons à la place!

Voici un code de test:

void fzero()
{
   unsigned long x;

   x = 0;
}

void fxor()
{
   unsigned long x;

   x ^= x;
}


int main()
{
   fzero();
   fxor();
}

Et maintenant, regardons le code machine résultant:

; 10   :    unsigned long x;
; 11   : 
; 12   :    x ^= x;
; 13   : }

00000   c2 00 00     ret     0

; 3    :    unsigned long x;
; 4    : 
; 5    :    x = 0;
; 6    : }

00000   c2 00 00     ret     0

PUBLIC  main
; Function compile flags: /Ogtpy
;   COMDAT main
_TEXT   SEGMENT
main    PROC                        ; COMDAT

; 18   :    fzero();
; 19   :    fxor();
; 20   : }

  00000 33 c0        xor     eax, eax
  00002 c3       ret     0
main    ENDP

Oh regarde! Ils étaient tout aussi rapides, prenant tous les deux exactement 0 ns.


2