Czy mogę wskazać optymalizatorowi, podając zakres liczby całkowitej?

Używam inttypu do przechowywania wartości. Zgodnie z semantyką programu, wartość zawsze zmienia się w bardzo małym zakresie (0 - 36) i int(nie a char) jest używana tylko ze względu na wydajność procesora.

Wygląda na to, że na tak małym zakresie liczb całkowitych można przeprowadzić wiele specjalnych optymalizacji arytmetycznych. Wiele wywołań funkcji na tych liczbach całkowitych może zostać zoptymalizowanych do postaci małego zestawu operacji „magicznych”, a niektóre funkcje mogą być nawet zoptymalizowane pod kątem przeszukiwania tabel.

Czy można więc powiedzieć kompilatorowi, że intjest to zawsze w tak małym zakresie i czy kompilator może wykonać te optymalizacje?

Tak to mozliwe. Na przykład, gccmożesz użyć, __builtin_unreachableaby powiedzieć kompilatorowi o niemożliwych warunkach, na przykład:

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

Powyższy warunek możemy zawinąć w makro:

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

I używaj go w ten sposób:

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

Jak widać ,gcc przeprowadza optymalizacje na podstawie tych informacji:

#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;
    }
}

Produkuje:

func(int):
    mov     eax, 17
    ret

Jest to jednak jedna wada jeśli Twój kod kiedykolwiek złamie takie założenia, otrzymujesz niezdefiniowane zachowanie .

Nie powiadamia Cię, kiedy to się stanie, nawet w kompilacjach do debugowania. Aby łatwiej debugować / testować / wychwytywać błędy z założeniami, możesz użyć hybrydowego makra zakładaj / potwierdzaj (kredyty dla @David Z), jak to:

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

W debug buduje (z NDEBUG nie określono), to działa jak zwykły assert, drukowania i komunikat o błędzieabort programu „ing i uwalniania buduje to sprawia, że korzystanie z założenia, produkujących zoptymalizowany kod.

Należy jednak pamiętać, że nie zastępuje zwykłego assert- condpozostaje w kompilacjach wydań, więc nie powinieneś robić czegoś takiego assume(VeryExpensiveComputation()).

Jest to standardowe wsparcie. Powinieneś zrobić to include stdint.h( cstdint), a następnie użyć type uint_fast8_t.

To mówi kompilatorowi, że używasz tylko liczb z przedziału od 0 do 255, ale można użyć większego typu, jeśli daje to szybszy kod. Podobnie kompilator może założyć, że zmienna nigdy nie będzie miała wartości powyżej 255, a następnie odpowiednio przeprowadzi optymalizacje.

Obecna odpowiedź jest dobra w przypadku, gdy wiesz na pewno jaki jest zakres, ale jeśli nadal chcesz poprawnego zachowania, gdy wartość jest poza oczekiwanym zakresem, to nie zadziała.

W tym przypadku odkryłem, że ta technika może działać:

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

Pomysł polega na kompromisie między kodem a danymi: przenosisz 1 bit danych (czy x == c) do logiki sterowania .
Wskazuje to optymalizatorowi, który xw rzeczywistości jest znaną stałą c, zachęcając go do wbudowania i optymalizacji pierwszego wywołania funkcjifoo oddzielnie od reszty, prawdopodobnie dość mocno.

Upewnij się, że kod został faktycznie uwzględniony w pojedynczej procedurze foo - nie duplikuj kodu.

Przykład:

Aby ta technika zadziałała, musisz mieć trochę szczęścia - są przypadki, w których kompilator decyduje się nie oceniać rzeczy statycznie i są one w pewnym sensie arbitralne. Ale kiedy to działa, działa dobrze:

#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);
}

Wystarczy użyć -O3i zauważ wstępnie oceniano stałe 0x20i 0x30ena wyjściu asemblera .

Chcę tylko powiedzieć, że jeśli potrzebujesz rozwiązania, które jest bardziej standardowe w C ++, możesz użyć [[noreturn]]atrybutu, aby napisać własne unreachable.

Dlatego ponownie wykorzystam doskonały przykład Denissa, aby zademonstrować:

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;
    }
}

Co, jak widać , daje prawie identyczny kod:

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

Wadą jest oczywiście to, że otrzymujesz ostrzeżenie, że [[noreturn]]funkcja rzeczywiście zwraca.