Extended (80 bit) double floating-point-in-x87, nicht SSE2 - wir verpassen Sie es nicht?

Las ich heute über Forscher entdecken, dass NVidia Phys-X-Bibliotheken verwenden, x87-FP vs. SSE2. Natürlich wird dies suboptimal für die parallele Datensätze, wo Geschwindigkeit Trumpf Präzision. Allerdings, der Autor des Artikels geht auf Zitat:

Intel begonnen, entmutigt die Verwendung von x87-mit der Einführung der P4 Ende 2000. AMD veralteten x87-seit dem K8 von 2003 als x86-64 definiert ist, mit SSE2-support; ÜBER die C7 unterstützt SSE2 seit 2005. In 64-bit-Versionen von Windows, x87 ist veraltet user-Modus, und gänzlich verboten im kernel-Modus. So ziemlich jeder in der Branche hat empfohlen SSE über x87-seit 2005 und es gibt keine Gründe für die Verwendung von x87, es sei denn, die software ist zum ausführen auf einem embedded-Pentium oder 486.

Ich wunderte mich über dieses. Ich weiß, dass x87 nutzt 80-bit-extended-doubles, die intern zur Berechnung der Werte, und SSE2 nicht. Ist das nicht eine Sache für jedermann? Es scheint für mich überraschend. Ich weiß, wenn ich Berechnungen für Punkte, Linien und Polygone in einer Ebene, können die Werte überraschend falsch, wenn dabei die Subtraktionen, und Bereiche können zusammenbrechen und Zeilen-alias einem anderen aufgrund mangelnder Präzision. Mit 80-bit-Werte im Vergleich zu 64-bit-Werte helfen könnte, würde ich mir überlegen.

Ist das falsch? Wenn nicht, was können wir verwenden, um führen Sie erweiterte Doppel-FP-Operationen, wenn x87 ausgelaufen?

Nicht wirklich eine Antwort auf deine Frage, aber ich persönlich bin der Hoffnung, für die 128-bit-IEEE-754 binären format zu mainstream geworden.
im ernst, genau das, was dauert da so lange? AVX kann ein standard vor, der steigt aus...
Dieser ist eine gute Antwort auf das, was war der Grund zu entmutigen x87. Und ja, SSE-Berechnungen sind weniger präzise, es ist deutlich zu erkennen auf modernen JIT-Compiler (im Vergleich zu herkömmlichen x87-Basis-Compiler).

InformationsquelleAutor codekaizen | 2010-07-08

24

Das größte problem mit x87-ist im Grunde, dass alle register Operationen werden durchgeführt in 80 bits, während die meisten der Zeit, die Menschen nur 64-bit-floats (also double-precision floats). Was passiert, ist, laden Sie eine 64-bit-float in die x87-stack, und es wird umgewandelt zu 80 bits. Sie haben einige Operationen in 80 bits, dann speichern Sie es zurück in den Speicher, die Umwandlung in 64 bit. Erhalten Sie ein anderes Ergebnis, als wenn Sie alles getan hatte, was den Betrieb mit nur 64 bits, und mit einem optimierenden compiler kann sehr unberechenbar sein, wie viele conversions könnte der Wert gehen durch, so ist es schwer, stellen Sie sicher, dass Sie immer die "richtige" Antwort, wenn dabei die regression-tests.

Das andere problem, das nur Angelegenheiten aus der Sicht von jemandem schreiben, der Versammlung (oder indirekt schreiben der Montage, in dem Fall von jemandem schreiben einen code-generator für ein compiler), ist, dass die x87-verwendet ein register, stack, in der Erwägung, dass SSE verwendet individuell zugänglichen Registern. Mit x87-Sie haben eine Reihe von zusätzlichen Anweisungen, um den stack zu manipulieren, und ich denke mir, Intel und AMD würden lieber Ihre Prozessoren schnell laufen mit SSE-code, als der Versuch zu machen, diese extra-stack-manipulation x87-Instruktionen schnell laufen.

BTW, wenn Sie Probleme mit der Ungenauigkeit, werden Sie wollen, um einen Blick auf den Artikel "Was jeder Programmierer wissen sollte, über floating-point Arithmetik", und dann vielleicht mit einer beliebiger Genauigkeit Mathematik-Bibliothek (z.B. GMP) statt.
- Die Optimierung der Compiler sind schon schlimm genug, aber versuchen, eine JIT, der die Fähigkeit hat zu kleine inline-Methoden (und daher variieren die Anzahl der in-memory-temps). Manchmal nenne ich diese Methode und bekommen eine Antwort, manchmal rufe ich die gleiche Methode mit den gleichen Argumenten und kommen zu einem anderen Ergebnis, je nachdem, ob der JITter-inlined den Anruf oder nicht! Das war ein Spaß regression auf die Spur.
- Ja, ich sehe, dass nicht kompliziert mit Compiler machen diese Art von Entscheidungen treffen-ganz besonders, wenn der JIT-Compiler tun. Als der Präzision, mit der ich zurzeit Skalierung der Anzahl [0..1] und entfernen Sie die gemeinsamen bits zu verringern, die Rauschen durch bits einfach Abbrechen und nur gedacht, dass 80 bits würde mir mehr Raum. Während die wahre, offenbar, die Nebenwirkungen sind ein zu hoher Preis. Ich hoffe, dass ich testen Sie es auf QP-hardware... wenn die erscheint.
- Weiß, Wenn Sie java verwenden, und Sie MÜSSEN genau die gleichen Ergebnisse jedes mal, wenn Sie die Gleitkomma-Mathematik, untersuchen Sie die Verwendung der strictfp Schlüsselwort. Dies zwingt die Mathematik zu IEEE 754 und nicht, was die native Plattform bietet (x87 auf 32b intel zum Beispiel). en.wikipedia.org/wiki/Strictfp
- Ich bin tatsächlich mit .NET. Soweit ich weiß, gibt es keine Entsprechung gibt. 🙁
- Es ist erwähnenswert, dass die 80-bit-Genauigkeit war nie gedacht für die Lagerung. Es wurde absichtlich entworfen, um zu dienen, als eine höhere Präzision zwischendarstellung, die würde zurück konvertiert werden, um float oder double, wenn die Ergebnisse gespeichert werden.
- Würde etwas verhindern, dass eine 8x87 compiler zu halten und alle Zwischenergebnisse als 80-bit-Werte, ob Sie passen in Registern oder nicht, und angeben, dass Sie das tun wird? Würden die Ergebnisse aus solchen compiler nicht vollständig reproduzierbar mit jedem anderen compiler, der hat ebenfalls?
- Wenn die x87-compiler entspricht dem CLI-spec dann muss es abschneiden höhere Genauigkeit Werte, wenn es eine explizite Konvertierung Unterricht. Auch wenn wir reden nicht über die CLI, muss man definieren "Zwischenergebnis." Wenn eine Funktion gibt ein double zurück, der Rückgabewert ist vermutlich nicht intermediate. Aber was ist, wenn die Funktion inlined? Verschiedene Compiler wird vermutlich treffen unterschiedliche Entscheidungen über inlining. Wenn der return-Wert einer inline-Funktion muss nicht abgeschnitten werden, dann verschiedene Compiler kann zu unterschiedlichen Ergebnissen führen.
- Einige Maschinen/Compiler 80-bit-Mathematik intern, aber würde willkürlich konvertieren-Werte in 64-bit - double jeder Zeit, die Sie nicht passen in Registern, also, wenn someDouble=f1()*f2()+f3()*f4() ausgewertet wurde in Links-zu-rechts-Sequenz, es könnte die Runde f1()*f2() zu einem double aber nicht rund, f3()*f4 - () [, da keine weitere Funktionsaufrufe erforderlich wäre, zwischen der Zeit, es wurde berechnet und die Zeit someDouble gespeichert wurde]. Diese Art von Verhalten ist eklig und böse. Aber wenn die Regeln für, wenn Dinge wurden auf-oder abgerundet wurden, unabhängig von dem, was getan oder nicht getan fit in Registern, ich würde nicht sehen, ein problem.
- Persönlich, was ich gerne sehen würde wäre eine Sprache mit unterschiedlichen Typen für z.B. ieee float, fast float, und short real, wo das Produkt von zwei IEEE-floats würde immer werden gerundet, um float während fast float würde gerundet werden oder nicht so bequem. Ein short real wäre ein 32-bit-floating-point-Wert, aber würde umgewandelt werden, um die maximale Genauigkeit Typ bei der Durchführung math es, wenn eine solche Umwandlung könnte zur Verbesserung der Genauigkeit des Ergebnisses [z.B. Umstellung erforderlich sein würde, wenn computing f1=f2+f3+f4;, aber nicht f1=f2+f3;].
- Da floating-Variablen verwendet werden, in einer Reihe von verschiedenen Möglichkeiten, mit unterschiedlichen Typen für verschiedene Nutzungsmuster erlauben würde, die Sprache Designer, nützliche Warnungen in Fällen, in denen ein Programmierer, der will strenge IEEE-single-precision-Semantik versehentlich multipliziert, indem 1.01 statt 1.01 f, während es für einen Programmierer, der will so genau wie möglich multiplizieren eine single-precision-float von 1.01 zu tun, ohne hässliche Typumwandlungen.
- Beachten Sie, dass die x87-FPU hat tatsächlich eine Kontrolle Wort, das können Sie reduzieren die interne Präzision von 64 bit oder sogar 32 bit zu bekommen bitweise identische Ergebnisse, aber niemand scheint zu verwenden.
- laut Bruce Dawson, MSVC verwendet, um zu reduzieren, um 64-bit (53 bit Mantisse) in der CRT-startup. randomascii.wordpress.com/2012/03/21/... Und DirectX offenbar verwendet, um ihn zu reduzieren, um float Präzision für Ihren gesamten Prozess!
InformationsquelleAutor tsuyoshi
5

Zur korrekten Verwendung der extended-precision math, ist es notwendig, dass eine Sprache unterstützt einen Typ, der verwendet werden kann zum speichern des Ergebnisses der intermediate-Berechnungen, und kann ersetzt werden, für die Ausdrücke, die nachgeben, diese Ergebnisse. Also, gegeben:
```
void print_dist_squared(double x1, double y1, double x2, double y2)
{
  printf("%12.6f", (x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
}
```
sollte es einige geben, die verwendet werden könnten, zu erfassen und zu ersetzen, die gemeinsame Teilausdrücke x2-x1 und y2-y1, so dass der code wie folgt umgeschrieben werden:
```
void print_dist_squared(double x1, double y1, double x2, double y2)
{
  some_type dx = x2-x1;
  some_type dy = y2-y1;
  printf("%12.6f", dx*dx + dy*dy);
}
```
ohne änderung der Semantik des Programms. Leider ANSI-C nicht angeben, jede Art, die verwendet werden könnte, für some_type auf Plattformen, die extended-precision-Berechnungen, und es wurde weit mehr üblich, die Schuld von Intel, um die Existenz der extended-precision-Typen als Schuld ANSI verkrachte unterstützen.

In der Tat, das extended-precision-Arten haben nur so viel Wert auf den Plattformen ohne floating-point-Einheiten, wie Sie tun, auf x87-Prozessoren, da auf solchen Prozessoren eine Berechnung wie x+y+z würde die folgenden Schritte aus:
1. Entpacken Sie die Mantisse, exponent, und eventuell Zeichen von x in ein separates Register (exponent und Vorzeichen können oft "Doppel-Koje")
2. Entpacken y ebenfalls.
3. Rechts-shift der Mantisse des Wertes mit der unteren exponent, falls vorhanden, und fügen Sie hinzu oder subtrahieren Sie die Werte.
4. Falls x und y verschiedene Zeichen, von Links-shift der Mantisse, bis das bit ganz Links 1 ist, und passen Sie die Exponenten entsprechend.
5. Pack der exponent und Mantisse zurück in double-format.
6. Entpacken Sie das temporäre Ergebnis.
7. Z entpacken.
8. Rechts-shift der Mantisse des Wertes mit der unteren exponent, falls vorhanden, und fügen Sie hinzu oder subtrahieren Sie die Werte.
9. Im Fall der früheren Ergebnis-und z haben verschiedene Zeichen, von Links-shift der Mantisse, bis das bit ganz Links 1 ist, und passen Sie die Exponenten entsprechend.
10. Pack der exponent und Mantisse zurück in double-format.
Verwendung eines extended-precision-Typ wird erlauben, die Schritte 4, 5 und 6 eliminiert werden. Seit ein 53-bit-Mantisse zu groß ist, um in weniger als vier 16-bit-Register oder zwei 32-bit-Register, das durchführen einer addition mit einem 64-bit-Mantisse ist nicht langsamer als ein 53-bit-Mantisse, also die Verwendung von extended-precision math bietet eine schnellere Berechnung ohne Nachteil in einer Sprache, die unterstützt eine richtige Art zu halten Sie temporäre Ergebnisse. Es gibt keinen Grund, die Schuld von Intel für die Bereitstellung eine FPU, die erfüllen könnten, Gleitkommaoperationen in der Mode-das war auch die effizienteste Methode, die auf non-FPU-chips.
- Richtig, aber ich denke, dass wir kann - Fehler von Intel für die Bereitstellung nicht ein Weg zu standards-compliant korrekt gerundeten Grundrechenarten (auf 64-bit Double) überhaupt. Ja, Sie können ändern Sie die FPU Genauigkeit 53 bit anstelle von 64 bit ist, aber das ist klobig, langsam, Risiken, die sich mit code-Bibliothek, die erwartet, dass die 64-bit-Präzision, und nicht selbst das problem zu lösen: während es entfällt die doppelte Rundung in die normale Domäne, ändert es nichts an der Exponenten-Bereich, so bleibt immer noch die Möglichkeit der doppelten Rundung am Unterlauf. SSE(2) ist eine große Verbesserung in dieser Hinsicht.
- Zwar gibt es spezialisierte Anwendungen, die bit-konsequente floating-point-Verhalten bei Operationen mit kürzeren Typen für die meisten Anwendungen ist es besser, die richtige Unterstützung für erweiterte Präzision. Ich sehe SSE(2) und x87-dienen unterschiedlichen Zwecken, und hätte gern gesehen haben, Sprachen Sie beide eifrig-die Förderung und strikte floating-point-Typen; weitere Ausdrücke mit strengen Typen sollten IMHO nur sein Cabrio zu den größeren Typen nach "sichtbar" nötigt Sie, auf Ihre eigene Art, so, wenn f1 und f2 waren streng float-Typen d1=f1*f2...
- ...müssten so geschrieben werden, als d1=(float)(f1*f2); [nicht d1=(double)(f1*f2);!]. Ich würde vermuten, dass in Fällen, in denen jemand schreibt d1=f1*f2; gibt es eine sehr hohe Wahrscheinlichkeit, dass (1) würde der code entweder nicht beabsichtigt gewesen zu sagen d1=(double)f1*f2;, (2) ein Programmierer sieht der code denkt, es bedeutet, dass, oder (3) ein Programmierer sieht der code denkt, es war gemeint, dass. Dass der code so geschrieben werden, als d1=(float)(f1*f2); in Fällen, in denen dieses Verhalten ist beabsichtigt, zu beseitigen diese Gefahren.
- aber nicht long double eine erweiterte Präzision geben?
- Es ist, und ich schlage vor, dass viele Leute Abneigung es ist eine Folge von Sprachen, die' schlechte Behandlung von ihm. Die design-Absicht von C war, dass unsuffixed-Literale werden mit der höchsten Präzision-Typ und Variable Funktion Argumente fördern sollte, um die höchste Präzision zu geben, so dass code wie "printf("%9.4 f/%9.4 f", x, y*Y_SCALE);` wouldn ' T sorgen zu machen über die Art der Y_SCALE, und selbst wenn der gleiche Wert Y_SCALE war manchmal verwendet, in float und double Berechnungen. Mit einem long double Art, die ist nicht austauschbar in printf macht die Sache umständlich, wie...
- ...mit einer Erklärung wie long double d=0.1; set d zu 0.10000000000000000555 eher als 0.10000000000000000000813151629364.
InformationsquelleAutor supercat
2

Die andere Antwort scheint nahe zu legen, dass mit 80-bit-Genauigkeit ist eine schlechte Idee, ist es aber nicht. Es führt eine manchmal entscheidende Rolle in halten Ungenauigkeit in der Bucht, siehe z.B. die Schriften von W. Kahan.

Verwenden Sie immer die 80-bit-Mittelstufe-Arithmetik, wenn Sie können Weg mit es Geschwindigkeit her. Wenn das bedeutet, dass Sie verwenden müssen, x87-Mathematik, sowie, dazu. Die Unterstützung für Sie ist allgegenwärtig und solange die Leute immer das richtige zu tun, bleibt er allgegenwärtig.
- Obwohl, etwas ironisch, die Zwischenschicht 64-bit-Präzision (nicht 80-bit-Genauigkeit) aus der Nutzung des 80-bit-x87-Register kann dazu führen, weniger genaue Ergebnisse für einfache arithmetische Operationen auf regulären 53 bit verdoppelt. Vorausgesetzt, die üblichen rund-um-Beziehungen-zu-sogar der Rundung-Modus, der den Betrieb 1e16 + 2.9999 auf IEEE-754 binary64 Werte gibt ein korrekt gerundetes Ergebnis von 10000000000000002.0 auf einer Maschine mit SSE2-Unterstützung, aber eine falsch-abgerundete Ergebnis der 10000000000000004.0 bei der Verwendung mit x87-FPU Genauigkeit nicht verändert gegenüber dem Standardwert von 64-bit-Präzision Dank Doppel-Rundung.
- Es gibt ein paar Fälle, in denen mit doppelter Genauigkeit zu berechnen Sie x+y ergeben würde, ein Ergebnis mit einem Rundungsfehler von 1/2ulp, während die Verwendung von extended-Genauigkeit und Konvertierung zu verdoppeln, würde die Ausbeute eines round-off error of2049/4096ulp. Auf der anderen Seite, es gibt viel mehr Fälle, wo die Verwendung von extended-precision-compute-x+y+z, erzielen Sie ein präzises Ergebnis, während bei Verwendung von "double" erzielen Sie ein Ergebnis, das weit weniger zutreffend ist, oder in einigen Fällen Schlicht Falsch.
InformationsquelleAutor Anonymous
0

Double Kommazahl ist 11 bits weniger als f80 (etwa 2,5 Knabbereien/Ziffern), viele Apps (meist Spiele), es würde nicht Schaden. Aber Sie müssen alle die Genauigkeit verfügbar für sagen -, Raum-Programm oder medizinische app.

Es ist ein bisschen irreführend, wenn einige sagen, dass der f80 (und entmutigen Sie es), das auf stack. FPU-Register und Operationen ähnlich stack-Betrieb, vielleicht ist das, was die Menschen verwirrt. Es tatsächlich Speicher basiert (load/store), nicht stapelbar, pro-se, im Vergleich zu, zum Beispiel, Aufrufkonvention wie cdecl stdcall was tun eigentlich die übergabe von Parametern via stack. und nichts falsch mit, dass.

Der große Vorteil von SSE ist eigentlich serialisieren Betrieb, 2, 4, 8 Werte auf einmal, mit vielen varian-Operationen. Ja, Sie können direkt transfer zu registrieren, aber Sie werden übertragen von Werten in den Speicher eh am Ende.

Der große Nachteil der f80 ist, seine seltsame 10 byte lang, es stören die Ausrichtung. man müsste so ausrichten, dass Sie 16 für einen schnelleren Zugriff. aber nicht wirklich praktikabel für array.

Haben Sie immer noch zu verwenden fpu für trigonometrische und andere trancedental mathematische Operationen. Für asm, es gibt viele f80 tricks, die wirklich Spaß und ist nützlich.

Für Spiele und regelmäßige einfache app, die (fast alle), können Sie nur verdoppeln, ohne dabei jemand gestorben ist. Aber für ein paar ernste, mathematische oder wissenschaftliche Anwendung, die Sie einfach nicht Graben f80.
- serialize operation. Du meinst "parallel-Betrieb". Oder SIMD-Betrieb.
- You still have to use fpu for trigonometric and other trancedental math operations. Wenn du meinst x87 FSIN, FYL2X (log2), etc. dann Nein, das ist falsch. Mathematik-Bibliotheken implementieren diese Funktionen in software mit SSE-math.
- Noch bevor x87 überholt war, gute mathematische Bibliotheken nicht verwenden, FSIN, weil der innere Wert von Pi verwendet für range reduction ist nicht genau genug; nur 66 bits. Intel ist nicht in der Lage, dies zu ändern, für die Rückwärtskompatibilität mit vorhandenen Gründen, aber FSIN hat große Fehler der Nähe +/- pi/2
- Ja. sorry, ich meinte parallel. Emulation ist immer viel, viel langsamer. in der Tat haben wir vor dem numerischen Prozessor gab. Siehe Kahan Hinweise auf IEEE-754 hinausgehend, en.wikipedia.org/wiki/Floating_point#IEEE_754_design_rationale: "Das Extended-format ist so konzipiert, verwendet werden, mit nur geringem Verlust der Geschwindigkeit,.." Aber aus pragmatischen Gründen (schnellere Rechner, größere Kapazität in alles), ich denke, niemand stört mit verwendet langsamen und aufgeblähten code nicht mehr.
- Über PI, könnten Sie finden Sie unter jpl.nasa.gov/edu/news/2016/3/16/... Multiprecission ist sicher schön, aber es ist für Spaß und Bewegung nur.
- Die Emulation fsin in der software ist nicht viel langsamer. Die interne Implementierung ist micro-codiert mit 71-100 uops (Intel Haswell), mit einer Gesamt-Wartezeit von 47-106 Zyklen, und (in diesem Fall) macht nichts, was nicht getan werden kann mit einfachen x86-Anweisungen, die jede Dekodierung nur eine einzige uop. Und re: Pi Präzision, der Artikel, den Sie verlinkt nicht sagen nichts über die katastrophale Absage oder floating-point-Probleme. Hast du auch gelesen, Bruce Dawson ' s Artikel, den ich verlinkte früher? Haben Sie schon von der katastrophalen Absage?
- BTW, herzlich willkommen auf Stack Overflow. Sie sollten Bearbeiten Ihre Korrektur ("parallel") in der Antwort.
InformationsquelleAutor user6801759

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.