que fait -ffast-math?

Il existe une réponse canonique à cette question dans le wiki de GCC , qui est vraisemblablement maintenue, cest de loin la source dinformation la plus fiable pour ce type de question. Cette question, par contre, peut éventuellement devenir obsolète. Tout cela est expliqué plus en détail dans le wiki, avec des exemples. Ce qui suit est essentiellement une citation de celui-ci pour illustrer comment il répond à cette question exacte, avec des commentaires mineurs:

• -fno-signaling-nans

• -fno-trapping-math

  La norme IEEE recommande que les implémentations permettent aux gestionnaires dinterruptions de gérer exc eptions comme la division par zéro et le débordement. Cet indicateur suppose quaucun piège visible dutilisation ne se produira.

• -funsafe-math-optimizations – Ces optimisations cassent les lois de larithmétique à virgule flottante et peuvent les remplacer par les lois de larithmétique ordinaire à précision infinie:

  En raison derreurs darrondi lassociatif la loi de lalgèbre nest pas nécessairement valable pour les nombres à virgule flottante et donc les expressions comme (x + y) + z ne sont pas nécessairement égales à x + (y + z).

• -ffinite-math-only – Quantités spéciales telles que inf ou nan sont supposés ne jamais apparaître, ce qui économise le temps passé à les rechercher et à les gérer de manière appropriée. Par exemple, $ x – x $ devrait-il toujours être égal à 0,0 $?

• -fno-errno-math

  désactive le réglage de la variable errno comme requis par C89 / C99 lors de lappel des routines de la bibliothèque mathématique. Pour Fortran, il sagit de la valeur par défaut.

• -fcx-limited-range

  fait que létape de réduction de portée est omise lors de lexécution dune division complexe. Cela utilise $ a / b = ((ar * br + ai * bi) / t) + i ((ai * br – ar * bi) / t) $ avec $ t = br * br + bi * bi $ et pourrait ne fonctionne pas bien sur des plages arbitraires dentrées.

• -fno-rounding-math

• -fno-signed-zeros
  

  En raison derreurs darrondi, la loi associative de lalgèbre nest pas nécessaire pour les nombres à virgule flottante et donc les expressions comme (x + y) + z ne sont pas nécessairement égaux à x + (y + z).

À proprement parler, les implications des deux derniers ne sont pas toujours aussi intuitives quon pourrait le penser. Par exemple (voir wiki), quen est-il de $ – (a – a) = a – a $, est-ce $ + 0.0 $ ou $ -0.0 $? Je crois quil existe une bonne quantité de littérature sur les implications exactes, en particulier par Bill Kahan .

• Non mentionné directement (je vous ne le voyez pas?), mais avec -ffast-math, certaines fonctions spéciales courantes telles que la réciproque $ 1 / x $ et la racine carrée $ \ sqrt {x} $ sont remplacées par less des versions précises qui sont plus rapides, mais qui ont toujours des niveaux derreur « tolérables » (par rapport à lerreur 0ulp requise par la norme) – ici, par exemple, est la précision généralement fournie par la libm de la glibc. En effet, cest la cause la plus courante daccélération de -ffast-math, dans un code qui fait beaucoup darithmétique avec des divisions et des racines carrées, presque au point que je ( personnellement ) pense que les autres sous-options (-ffinite-math-only et similaires en particulier – la signalisation NaN s sont assez utiles pour le débogage) causent un peu aussi beaucoup de tracas en termes de coût / avantage.

Jai vu que le temps pris pour un simple $ O (n ^ 2) $ algorithme étant réduit à celui dun algorithme $ O (n) $ en utilisant loption.

Je pense que cest improbable et il est possible que vous ayez fait une erreur dans votre analyse.Les optimisations à virgule flottante non sécurisées peuvent rendre les expressions individuelles un peu moins chères à évaluer en raison dun plus grand choix doptimisations. Mais laccélération doit toujours être au plus un facteur constant. Est-il possible que vous ayez comparé un algorithme $ O (n ^ 2) $ avec un $ O (n) $ pour un $ n $ insuffisamment grand?

Un algorithme $ n ^ 2 $ peut être réduit à quelque chose qui se comporte $ O (n) $ si, par exemple, si $ n $ est connu du compilateur, et est un multiple de la taille du vecteur pour les instructions vectorielles (le cas échéant) prises en charge par le processeur. Si le compilateur peut voir tout cela, il peut dérouler une boucle interne et utiliser des instructions vectorielles pour faire le travail. Cela peut réduire les opérations globales effectuées à une poignée et améliorer considérablement les performances.

Ma lecture est que fast-math nactive pas une telle optimisation, mais cela pourrait si elles sont implicitement activées par unsafe-math-optimizations en raison de restrictions dassociativité qui y sont désactivées.