fenv_access pragma

Désactive (on) ou active (off) des optimisations susceptibles de modifier les tests d’indicateur d’environnement à virgule flottante et les modifications du mode.

Syntaxe

#pragma fenv_access ( { on | off } )

Notes

Par défaut, fenv_access est off. Le compilateur part du principe que votre code n’accède pas ou ne manipule pas l’environnement à virgule flottante. Si l’accès à l’environnement n’est pas nécessaire, le compilateur peut faire plus pour optimiser votre code à virgule flottante.

Activez fenv_access si votre code teste des indicateurs d’état à virgule flottante, des exceptions ou définit des indicateurs de mode de contrôle. Le compilateur désactive les optimisations à virgule flottante, afin que votre code puisse accéder à l’environnement à virgule flottante de manière cohérente.

L’option /fp:strict de ligne de commande active fenv_accessautomatiquement . Pour plus d’informations sur ce comportement et d’autres comportements à virgule flottante, consultez /fp (Spécifier le comportement à virgule flottante).

Il existe des restrictions sur les façons dont vous pouvez utiliser la fenv_accesspragma combinaison avec d’autres paramètres à virgule flottante :

• Vous ne pouvez pas activer fenv_access , sauf si la sémantique précise est activée. La sémantique précise peut être activée par le float_controlpragmaou à l’aide des options du /fp:precise compilateur./fp:strict Le compilateur a la valeur par défaut /fp:precise si aucune autre option de ligne de commande à virgule flottante n’est spécifiée.

• Vous ne pouvez pas utiliser float_control pour désactiver la sémantique précise quand fenv_access(on) elle est définie.

Les types d’optimisations soumis sont fenv_access les suivants :

• Élimination globale de sous-expressions communes

• Déplacement de code

• Pliage constant

Voici d’autres directives à virgule pragma flottante :

• float_control

• fp_contract

Exemples

Cet exemple montre comment définir fenv_access on le registre de contrôle à virgule flottante pour la précision 24 bits :

// pragma_directive_fenv_access_x86.cpp
// compile with: /O2 /arch:IA32
// processor: x86
#include <stdio.h>
#include <float.h>
#include <errno.h>
#pragma fenv_access (on)

int main() {
   double z, b = 0.1, t = 0.1;
   unsigned int currentControl;
   errno_t err;

   err = _controlfp_s(&currentControl, _PC_24, _MCW_PC);
   if (err != 0) {
      printf_s("The function _controlfp_s failed!\n");
      return -1;
   }
   z = b * t;
   printf_s ("out=%.15e\n",z);
}

out=9.999999776482582e-03

Si vous commentez #pragma fenv_access (on) à partir de l’exemple précédent, la sortie est différente. C’est parce que le compilateur effectue une évaluation au moment de la compilation, qui n’utilise pas le mode de contrôle.

// pragma_directive_fenv_access_2.cpp
// compile with: /O2 /arch:IA32
#include <stdio.h>
#include <float.h>

int main() {
   double z, b = 0.1, t = 0.1;
   unsigned int currentControl;
   errno_t err;

   err = _controlfp_s(&currentControl, _PC_24, _MCW_PC);
   if (err != 0) {
      printf_s("The function _controlfp_s failed!\n");
      return -1;
   }
   z = b * t;
   printf_s ("out=%.15e\n",z);
}

out=1.000000000000000e-02

Voir aussi

Pragma directives et mots __pragma _Pragma clés