Kann ich den Optimierer durch Angabe des Bereichs einer Ganzzahl andeuten?

Ich verwende einen intTyp, um einen Wert zu speichern. Aufgrund der Semantik des Programms variiert der Wert immer in einem sehr kleinen Bereich (0 - 36) und wird int(nicht a char) nur wegen der CPU-Effizienz verwendet.

Es scheint, dass viele spezielle arithmetische Optimierungen für einen so kleinen Bereich von ganzen Zahlen durchgeführt werden können. Viele Funktionsaufrufe für diese Ganzzahlen können in kleinen "magischen" Operationen optimiert werden, und einige Funktionen können sogar in Tabellensuchen optimiert werden.

Kann man dem Compiler also mitteilen, dass dies intimmer in diesem kleinen Bereich liegt, und kann der Compiler diese Optimierungen vornehmen?

Ja, es ist möglich. Zum Beispiel können gccSie damit __builtin_unreachableden Compiler über unmögliche Bedingungen informieren, wie zum Beispiel:

if (value < 0 || value > 36) __builtin_unreachable();

Wir können die obige Bedingung in ein Makro einschließen:

#define assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)

Und benutze es so:

assume(x >= 0 && x <= 10);

Wie Sie sehen können , werden gccOptimierungen basierend auf diesen Informationen durchgeführt:

#define assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)

int func(int x){
    assume(x >=0 && x <= 10);

    if (x > 11){
        return 2;
    }
    else{
        return 17;
    }
}

Produziert:

func(int):
    mov     eax, 17
    ret

Ein Nachteil ist jedoch, dass Sie undefiniertes Verhalten erhalten , wenn Ihr Code jemals solche Annahmen verletzt .

Es benachrichtigt Sie nicht, wenn dies geschieht, selbst bei Debug-Builds. Um Fehler mit Annahmen einfacher zu debuggen / testen / abzufangen, können Sie ein hybrides Annahme- / Assert-Makro (Credits für @David Z) wie das folgende verwenden:

#if defined(NDEBUG)
#define assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)
#else
#include <cassert>
#define assume(cond) assert(cond)
#endif

In Debug-Builds (mit NDEBUG nicht definiert) funktioniert es wie ein gewöhnliches assertDruckfehler- und abortProgrammierprogramm, und in Release-Builds wird eine Annahme verwendet, die optimierten Code erzeugt.

Beachten Sie jedoch, dass es kein Ersatz für reguläres ist assert- condverbleibt in Release-Builds, daher sollten Sie so etwas nicht tun assume(VeryExpensiveComputation()).

Hierfür gibt es Standardunterstützung. Was Sie tun sollten, ist, include stdint.h( cstdint) einzuschließen und dann den Typ zu verwenden uint_fast8_t.

Dies teilt dem Compiler mit, dass Sie nur Zahlen zwischen 0 und 255 verwenden, dass es jedoch kostenlos ist, einen größeren Typ zu verwenden, wenn dies schnelleren Code ergibt. Ebenso kann der Compiler davon ausgehen, dass die Variable niemals einen Wert über 255 haben wird, und dann entsprechende Optimierungen vornehmen.

Die aktuelle Antwort ist gut für den Fall, dass Sie sicher wissen, um welchen Bereich es sich handelt. Wenn Sie jedoch weiterhin ein korrektes Verhalten wünschen, wenn der Wert außerhalb des erwarteten Bereichs liegt, funktioniert dies nicht.

In diesem Fall habe ich festgestellt, dass diese Technik funktionieren kann:

if (x == c)  // assume c is a constant
{
    foo(x);
}
else
{
    foo(x);
}

Die Idee ist , ein Code-Daten Kompromiss: Sie verschieben 1 Bit von Daten (ob x == c) in der Steuerlogik .
Dies deutet auf den Optimierer hin, der xtatsächlich eine bekannte Konstante ist c, und ermutigt ihn, den ersten Aufruf von foogetrennt vom Rest zu integrieren und zu optimieren , möglicherweise ziemlich stark.

Stellen Sie jedoch sicher, dass der Code tatsächlich in einer einzigen Unterroutine berücksichtigt wird foo- duplizieren Sie den Code nicht.

Beispiel:

Damit diese Technik funktioniert, müssen Sie ein wenig Glück haben - es gibt Fälle, in denen der Compiler beschließt, die Dinge nicht statisch zu bewerten, und sie sind willkürlich. Aber wenn es funktioniert, funktioniert es gut:

#include <math.h>
#include <stdio.h>

unsigned foo(unsigned x)
{
    return x * (x + 1);
}

unsigned bar(unsigned x) { return foo(x + 1) + foo(2 * x); }

int main()
{
    unsigned x;
    scanf("%u", &x);
    unsigned r;
    if (x == 1)
    {
        r = bar(bar(x));
    }
    else if (x == 0)
    {
        r = bar(bar(x));
    }
    else
    {
        r = bar(x + 1);
    }
    printf("%#x\n", r);
}

Verwenden Sie einfach -O3und beachten Sie die vorge ausgewertet Konstanten 0x20und 0x30ein Assembler ausgegeben .

Ich möchte nur sagen, dass Sie, wenn Sie eine Lösung mit mehr Standard-C ++ wünschen, das [[noreturn]]Attribut verwenden können, um Ihre eigene zu schreiben unreachable.

Also werde ich das hervorragende Beispiel von Deniss erneut verwenden , um zu demonstrieren:

namespace detail {
    [[noreturn]] void unreachable(){}
}

#define assume(cond) do { if (!(cond)) detail::unreachable(); } while (0)

int func(int x){
    assume(x >=0 && x <= 10);

    if (x > 11){
        return 2;
    }
    else{
        return 17;
    }
}

Was, wie Sie sehen können , zu nahezu identischem Code führt:

detail::unreachable():
        rep ret
func(int):
        movl    $17, %eax
        ret

Der Nachteil ist natürlich, dass Sie eine Warnung erhalten, dass eine [[noreturn]]Funktion tatsächlich zurückkehrt.