Warum kann der Compiler die Gleitkommaaddition mit 0 nicht optimieren? [duplicate]

Ich habe vier Identitätsfunktionen, die im Wesentlichen nichts tun. Nur Multiplikation mit 1 könnte von clang zu einem einzigen optimiert werden ret Aussage.

float id0(float x) {
    return x + 1 - 1;
}

float id1(float x) {
    return x + 0;
}

float id2(float x) {
    return x * 2 / 2;
}

float id3(float x) {
    return x * 1;
}

Und die folgende Compilerausgabe ist: (clang 10, at -O3)

.LCPI0_0:
        .long   1065353216              # float 1
.LCPI0_1:
        .long   3212836864              # float -1
id0(float):                                # @id0(float)
        addss   xmm0, dword ptr [rip + .LCPI0_0]
        addss   xmm0, dword ptr [rip + .LCPI0_1]
        ret
id1(float):                                # @id1(float)
        xorps   xmm1, xmm1
        addss   xmm0, xmm1
        ret
.LCPI2_0:
        .long   1056964608              # float 0.5
id2(float):                                # @id2(float)
        addss   xmm0, xmm0
        mulss   xmm0, dword ptr [rip + .LCPI2_0]
        ret
id3(float):                                # @id3(float)
        ret

Ich kann verstehen, warum id0 und id2 kann nicht optimiert werden. Sie erhöhen den Wert, der sich dann in positive Unendlichkeit verwandeln könnte und die zweite Operation würde ihn nicht zurückverwandeln.

Aber warum nicht id1 optimiert werden? Eine Addition mit Unendlich würde Unendlich ergeben, eine Addition mit einer beliebigen regulären Zahl würde diese Zahl ergeben und eine Addition mit NaN ergäbe NaN. Warum ist es also keine “echte” Identitätsoperation wie * 1.

Beispiel mit Compiler Explorer

IEEE 754-Gleitkommazahlen haben zwei Nullwerte, einen negativen und einen positiven. Zusammengenommen ergibt sich das positive Ergebnis.

So id1(-0.f) ist 0.fnicht -0.f.
Beachten Sie, dass id1(-0.f) == -0.f Weil 0.f == -0.f.

Demo

Beachten Sie auch, dass das Kompilieren mit -ffast-math in GCC führt die Optimierung durch und ändert das Ergebnis.

“Ich habe vier Identitätsfunktionen, die im Wesentlichen nichts tun.”

Das ist nicht wahr.

Für Fließkommazahlen x + 1 - 1 ist nicht gleich x + 0es ist gleich (x + 1) - 1. Also wenn man zB einen sehr kleinen hat x dann verlieren Sie diesen sehr kleinen Teil in der x + 1 Schritt, und der Compiler kann nicht wissen, ob das Ihre Absicht war oder nicht.

Und im Fall von x * 2 / 2das x * 2 aufgrund der Gleitkommapräzision möglicherweise auch nicht genau, so dass Sie hier einen ähnlichen Fall haben, der Compiler weiß nicht, ob Sie aus irgendeinem Grund den Wert von ändern möchten x auf diese Weise.

Diese wären also gleich:

float id0(float x) {
    return x + (1. - 1.);
}

float id1(float x) {
    return x + 0;
}

Und diese wären gleich:

float id2(float x) {
    return x * (2. / 2.);
}

float id3(float x) {
    return x * 1;
}

Das gewünschte Verhalten könnte sicherlich auch anders definiert werden. Aber wie bereits von Nelfeal erwähnt, muss diese Optimierung explizit mit aktiviert werden -ffast-math

Aktivieren Sie den schnellen mathematischen Modus. Diese Option lässt den Compiler aggressive, potenziell verlustbehaftete Annahmen über Gleitkomma-Mathematik treffen. Diese beinhalten:

• Fließkomma-Mathematik gehorcht regulären algebraischen Regeln für reelle Zahlen (z. B. + und * sind assoziativ, x/y == x * (1/y) und (a + b) * c == a * c + b * c) ,
• Operanden für Gleitkommaoperationen sind nicht gleich NaN und Inf und
• +0 und -0 sind austauschbar.

fast-math ist für clang und gcc eine Sammlung von Flags (hier das von clang aufgelistete):

• -fno-Ehre-Unendlichkeiten
• -fno-honor-nans
• -fno-math-fehlernr
• -endliche-math
• -fassoziativ-math
• -reziproke-math
• -fno-vorzeichenbehaftete Nullen
• -fno-trapping-math
• -ffp-Vertrag=schnell

Lies das float-number-gui.de Webseite, mehr dazu IEEE754der C11-Standard n1570dem C++11-Standard n3337.

float id1(float x) {
    return x + 0;
}

Wenn x passiert, um eine Signalisierung zu sein NaNdein id1 vielleicht sogar nicht zurückkehren (und wahrscheinlich sollte nicht Rückkehr).

Wenn x ist also ein ruhiges NaN id1(x) != x seit NaN != NaN (wenigstens NaN == NaN sollte falsch sein).

Im etwas Fälle, die Sie teuer wollen Arithmetik mit beliebiger Genauigkeit. Dann erwägen Sie die Verwendung GMPlib.

PS. Fließkommazahlen können Ihnen nach Ihrer Wahl Albträume oder einen Doktortitel bescheren. Sie manchmal Leute töten oder zumindest große finanzielle Katastrophen anrichten (z. B. ein Verlust von mehreren hundert Millionen US$ oder €).