Pourquoi l'arithmétique à virgule flottante dans les architectures x86 et x64 produit-elle des résultats différents ?

Comprendre l'écart dans l'arithmétique à virgule flottante entre x86 et x64

Dans le domaine de la programmation informatique, la distinction dans la façon dont l'arithmétique à virgule flottante est gérés entre les architectures x86 et x64 peuvent conduire à des résultats inattendus. Cette requête explore un tel écart, impliquant spécifiquement la comparaison de deux valeurs à virgule flottante dans les versions de Microsoft Visual Studio 2010.

Le problème

Exécution de l'extrait de code suivant en x86 et les versions x64 sur la même machine 64 bits révèlent une différence :

float a = 50.0f;
float b = 65.0f;
float c = 1.3f;
float d = a * c;
bool bLarger1 = d < b;
bool bLarger2 = (a * c) < b;

Le booléen bLarger1 reste faux dans les deux versions, tandis que bLarger2 est faux en x64 mais vrai en x86. Cette incohérence soulève des questions sur les mécanismes sous-jacents de l'arithmétique à virgule flottante dans ces architectures.

La cause

Le nœud du problème réside dans l'évaluation de l'expression :

bool bLarger2 = (a * c) < b;

L'examen du code assembleur généré pour x86 et x64 révèle une différence clé. En x64, le calcul est effectué à l’aide d’instructions pures simple précision. En revanche, x86 utilise l'unité à virgule flottante x87, qui fonctionne avec une précision plus élevée (double précision par défaut).

L'explication

Cette distinction découle de les différences fondamentales entre le FPU x87 et l'unité x64 SSE. L'unité x87 utilise les mêmes instructions pour les calculs en simple et double précision, ce qui entraîne un niveau d'imprécision dans les opérations en simple précision. D'autre part, l'unité SSE utilise des instructions distinctes pour chaque précision, garantissant des calculs précis en simple précision.

La solution

Pour résoudre cet écart dans le 32- bit (x86), il est possible de forcer l'unité x87 à effectuer des calculs en simple précision en utilisant l'indicateur de contrôle suivant :

_controlfp(_PC_24, _MCW_PC);

Cela entraînera la définition des deux variables booléennes (bLarger1 et bLarger2). à false dans les versions x86 et x64.

Conclusion

L'écart dans l'arithmétique à virgule flottante entre x86 et x64 provient des différences dans leurs unités à virgule flottante sous-jacentes. En comprenant ces distinctions et en prenant les mesures appropriées, telles que forcer les calculs en simple précision dans x86, les programmeurs peuvent garantir des résultats précis et cohérents sur différentes architectures.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!