Que fait réellement le ffast-math de gcc?

Je comprends que le --ffast-mathdrapeau de gcc peut considérablement augmenter la vitesse des opérations flottantes et va en dehors des normes IEEE, mais je n'arrive pas à trouver des informations sur ce qui se passe réellement quand il est activé. Quelqu'un peut-il expliquer certains détails et peut-être donner un exemple clair de la façon dont quelque chose changerait si le drapeau était activé ou désactivé?

J'ai essayé de fouiller dans SO pour des questions similaires, mais je n'ai rien trouvé expliquant le fonctionnement de ffast-math.

Comme vous l'avez mentionné, il permet des optimisations qui ne préservent pas la stricte conformité IEEE.

Un exemple est celui-ci:

x = x*x*x*x*x*x*x*x;

à

x *= x;
x *= x;
x *= x;

L'arithmétique à virgule flottante n'étant pas associative, l'ordre et la factorisation des opérations affecteront les résultats en raison de l'arrondi. Par conséquent, cette optimisation n'est pas effectuée sous un comportement FP strict.

Je n'ai pas vraiment vérifié pour voir si GCC fait réellement cette optimisation particulière. Mais l'idée est la même.

-ffast-math fait bien plus que casser la stricte conformité IEEE.

Tout d'abord, bien sûr, il ne respecte pas la stricte conformité IEEE, permettant par exemple de réorganiser les instructions en quelque chose qui est mathématiquement le même (idéalement) mais pas exactement le même en virgule flottante.

Deuxièmement, il désactive le réglage errnoaprès les fonctions mathématiques à instruction unique, ce qui signifie éviter d'écrire dans une variable locale de thread (cela peut faire une différence de 100% pour ces fonctions sur certaines architectures).

Troisièmement, il suppose que toutes les mathématiques sont finies , ce qui signifie qu'aucune vérification de NaN (ou zéro) n'est effectuée là où elles auraient des effets néfastes. On suppose simplement que cela n'arrivera pas.

Quatrièmement, il permet des approximations réciproques pour la division et la racine carrée réciproque.

De plus, il désactive le zéro signé (le code suppose que le zéro signé n'existe pas, même si la cible le prend en charge) et l'arrondi mathématique, ce qui permet entre autres un repliement constant au moment de la compilation.

Enfin, il génère du code qui suppose qu'aucune interruption matérielle ne peut se produire en raison de la signalisation / du piégeage mathématique (c'est-à-dire que si celles-ci ne peuvent pas être désactivées sur l'architecture cible et se produisent par conséquent , elles ne seront pas traitées).