Unterschied in der floating-point-Arithmetik zwischen x86 und x64

Stolperte ich über einen Unterschied in der Art floating-point-Arithmetik getan werden zwischen MS VS 2010 baut für x86 und x64 (sowohl ausgeführt auf die gleiche 64-bit-Maschine).

Dies ist ein reduziertes Codebeispiel:

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;

Den booleschen bLarger1, ist immer falsch (d 65.0 in beiden builds).
Variable bLarger2 false für x64, aber wahr für x86!

Ich bin mir wohl bewusst floating-point-Arithmetik und Rundung-Effekte statt. Ich weiß auch, dass 32-bit manchmal verwendet verschiedene Anweisungen für Gleitkomma-Operationen als 64-bit-builds. Aber in diesem Fall bin ich es fehlten einige Informationen.

Warum gibt es eine Diskrepanz zwischen bLarger1 und bLarger2 auf den ersten Platz? Warum ist es nur auf der 32-bit-build?

Unterschied in der floating-point-Arithmetik zwischen x86 und x64

  • meine Vermutung ist, dass die x86-version ist die Verwendung der FPU-Register für, die und die x64 ist die Verwendung der SSE-Register für die. Aber Sie wahrscheinlich benötigen, zu betrachten, IL-code und auch in den Maschinen-code.
  • Sicherlich x86 ist mit x87-Einheit, und die x64 ist die Verwendung der SSE-Einheit. Aber es nicht wirklich erklären, den Unterschied. Sie sollten beide die gleiche Antwort erhalten. @Oliver kann Ihnen zeigen, wie Sie kompilieren den code, weil meiner ziemlich Versuch einer repro gescheitert. Beide bools sind false für x86 und x64 für mich.
  • OK, jetzt habe ich ein repro!
  • Es geht um die Art und Weise ein*c behandelt wird, in den Ausdruck für bLarger2. Ich denke, es wird eine float-mult in einem und ein Doppel-mult in die andere, oder so ähnlich
  • Die Frage ist, warum ist dies überraschend, wohl wissend, dass floating-point nicht genau. Je nach compiler, compiler-Optionen, etc. Ergebnisse können abweichen.
  • Auch der Unterschied zwischen den zwei Vergleich-Operationen auf der gleichen Plattform, die gleich Aussehen, war besonders verwirrend für mich
  • Während die floating point Arithmetik nicht exakt repräsentieren alle realen Werte, es ist wiederholbar und gut definiert. Es ist nicht unvernünftig, zu hoffen, dass für Kohärenz zwischen den verschiedenen Compilern.

InformationsquelleAutor Oliver Zendel | 2014-03-28
  1. 17

    Das Problem Scharniere auf diesen Ausdruck:

    bool bLarger2 = (a*c)<b;

    Ich schaute auf den code, der generiert unter VS2008, nicht mit VS2010 zur hand. Für 64-bit-code ist:

    000000013FD51100 movss xmm1,dword ptr [a] 
000000013FD51106 mulss xmm1,dword ptr [c] 
000000013FD5110C movss xmm0,dword ptr [b] 
000000013FD51112 comiss xmm0,xmm1

    Für 32-bit-code ist:

    00FC14DC fld dword ptr [a] 
00FC14DF fmul dword ptr [c] 
00FC14E2 fld dword ptr [b] 
00FC14E5 fcompp

    Also unter 32 bit die Berechnung erfolgt in der x87-Einheit, und die unter 64 bit ausgeführt wird, indem die x 64 Gerät.

    - Und der Unterschied hier ist, dass die x87-Operationen werden alle durchgeführt, die höher ist als einfacher Genauigkeit. Standardmäßig werden die Berechnungen durchgeführt, die die doppelte Genauigkeit. Auf der anderen Seite der SSE-unit-Operationen sind Reine single-precision-Berechnungen.

    Können Sie überzeugen, die 32-bit-Einheit, um alle Berechnungen durchzuführen, single precision Genauigkeit wie diese:

    _controlfp(_PC_24, _MCW_PC);

    Wenn Sie hinzufügen, dass Ihre 32-bit-Programm werden Sie feststellen, dass die booleans sind beide auf false gesetzt.

    Gibt es einen fundamentalen Unterschied in der Art und Weise, dass die x87 and SSE floating point-Einheiten arbeiten. Die x87-Einheit verwendet die gleichen Anweisungen für die single-und double-precision-Arten. Das laden der Daten in Registern in die x87-FPU-stack und die Register sind immer 10 byte Intel erweitert. Sie können Einfluss auf die Genauigkeit mit der floating-point-control-Wort. Aber die Anweisungen, die der compiler schreibt, sind nichts von diesem Staat.

    Auf der anderen Seite, die die SSE-Einheit verwendet verschiedene Anweisungen für Operationen, die auf single-und double-precision. Das bedeutet, dass der compiler emittieren kann code, ist die volle Kontrolle über die Genauigkeit der Berechnung.

    So, die x87-Einheit ist der "bad guy" hier. Sie kann vielleicht versuchen Sie zu überzeugen, einen compiler zu emittieren SSE-Instruktionen auch für 32-bit-targets. Und sicherlich, wenn ich kompiliert deinen code unter VS2013 ich festgestellt, dass die beiden 32-und 64-bit-targets emittiert SSE-Anweisungen.

    • Interessant, so nehme ich den Unterschied zwischen der Art bLarger1 und bLarger2 berechnet werden, ist die Präzision des ALU. Für bLarger2 das Ergebnis mit der höheren Genauigkeit ist gehalten, die in der ALU zum Vergleich, während bLarger1 wird zunächst laden Sie die single-precision-Werte auf und vergleichen diese.
    • Richtig
    • Hm, weder das ändern "Aktivieren der Erweiterten Befehlssatz" oder "Floating-Point-Modell" führte zu einem anderen Verhalten (VS2010 x86); _controlfp funktioniert der trick, aber ich bin immer noch neugierig, wenn es gibt eine compiler-Einstellung selbst, dass die Ergebnisse in die selbe Verhalten
    • Es gibt keine compiler-Einstellung, ändert sich die control-word. Das ist eine runtime-Eigenschaft hat und so verwaltet werden, zur Laufzeit. Und es ist insgesamt Minenfeld FWIW mit Modulen, Links, rechts und Mitte Schrauben mit dem control word". Kompilieren mit /arch:SSE2 und vermeiden Sie alle, die x87-Schmerzen. Aber Ihr Programm läuft nur auf Rechnern mit SSE2-Einheiten.
    • Das ist eine Einschränkung mit der ich Leben kann (in diesem Fall). Danke!
    • Eigentlich bin ich gar nicht sicher, dass /arch:SSE2, wird Sie zwangsläufig, um es getan. Wie auch immer, ich denke, wir tun zumindest verstehen, die Ursache für das Verhalten.
    • Ich probierte es aus und in Kombination mit "Schnell" Floating-Point-Modell (/fp:fast) der Probe Verhalten ist konsistent (beide Boolesche Werte false sind auf beiden Plattformen)
    • Ausgezeichnet. Ihr Programm wird ein wenig schneller mit SSE2-Unterstützung.
    • Beachten Sie, dass die Lösung Referenzen _controlfp(_MCW_PC, _PC_24); aber der Microsoft-Dokumentation und Intellisense in VS2017 zeigt an, dass die Maske die zweite - parameter. docs.microsoft.com/en-us/cpp/c-runtime-library/reference/... Was bedeutet, dass diese Zeile sollte lauten: _controlfp(_PC_24, MCW_PC) Hier sind die docs für 2008, die behaupten das gleiche. msdn.microsoft.com/en-us/library/e9b52ceh(v=vs. 90).aspx
    • Sind Sie richtig. Ich habe geändert, die Antwort entsprechend. Danke.

    InformationsquelleAutor David Heffernan
  2. -2

    Floating-points-Operationen sind immer ungenau und der Vergleich der beiden schwebt dieser in der Nähe (oder gleich) fast nie wieder die richtige Leistung.

    Gleitkommazahlen gespeichert und verarbeitet, die sich anders als auf 32bit und 64bit Maschinen (wie auch vorgeschlagen, durch Kommentare). Wenn ich mich richtig erinnere, in VC 32-bit floats gespeichert werden, auf den Stapel und FPU (Floating-Point Unit) verarbeitet, in der Erwägung, dass schwimmt auf einer 64bit-Maschine gespeichert werden können, in speziellen Registern (SSE) und berechnet mithilfe von anderen Einheiten in der CPU.

    Habe ich keine eindeutige Quelle zu meiner Antwort, aber bitte schauen Sie auf auf dieser Seite oder diese.

    • Es gibt keinen Unterschied in der Lagerung. Diese sind IEEE754 schwimmt. Ein standard-format.
    • Sie gespeichert sind, die gleiche Weise, aber mit verschiedenen Standorten ist, was ich versuche zu sagen.
    • Aber floats sind nicht unbedingt auf dem stack gespeichert werden. Die x87-Einheit hat Ihre eigenen register stack von 8 extended-precision-floating-point-Register ST(0) ST(7). Sie sind spezielle Register für sicher. Und die SSE-Einheit hat Ihre eigenen, spezialisierten Registern.
    InformationsquelleAutor Janman
Schreibe einen Kommentar