Posso suggerire l'ottimizzatore fornendo l'intervallo di un numero intero?

Sto usando un inttipo per memorizzare un valore. Dalla semantica del programma, il valore varia sempre in un intervallo molto piccolo (0 - 36) e int(non a char) viene utilizzato solo a causa dell'efficienza della CPU.

Sembra che molte ottimizzazioni aritmetiche speciali possano essere eseguite su un così piccolo intervallo di numeri interi. Molte chiamate di funzione su tali numeri interi potrebbero essere ottimizzate in un piccolo insieme di operazioni "magiche" e alcune funzioni potrebbero persino essere ottimizzate nelle ricerche di tabella.

Quindi, è possibile dire al compilatore che questo intè sempre in quel piccolo intervallo, ed è possibile per il compilatore fare queste ottimizzazioni?

Sì, è possibile. Ad esempio, gccpuoi usare __builtin_unreachableper dire al compilatore di condizioni impossibili, in questo modo:

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

Possiamo racchiudere la condizione sopra in una macro:

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

E usalo così:

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

Come puoi vedere , gccesegue ottimizzazioni basate su queste informazioni:

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

produce:

func(int):
    mov     eax, 17
    ret

Un aspetto negativo, tuttavia, è che se il tuo codice rompe tali assunzioni, ottieni un comportamento indefinito .

Non ti avvisa quando ciò accade, anche nelle build di debug. Per eseguire il debug / test / catturare più facilmente i bug con ipotesi, è possibile utilizzare una macro ibrida assume / assert (crediti a @David Z), come questa:

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

Nelle build di debug (con NDEBUG non definito), funziona come un normale assertmessaggio di errore di stampa e abortprogramma, e nelle build di rilascio fa uso di un presupposto, producendo codice ottimizzato.

Nota, tuttavia, che non sostituisce i normali assert: condrimane nelle build di rilascio, quindi non dovresti fare qualcosa del genere assume(VeryExpensiveComputation()).

C'è un supporto standard per questo. Quello che dovresti fare è includere stdint.h( cstdint) e quindi usare il tipo uint_fast8_t.

Questo dice al compilatore che stai usando solo numeri tra 0 - 255, ma che è libero di usare un tipo più grande se questo dà un codice più veloce. Allo stesso modo, il compilatore può presumere che la variabile non avrà mai un valore superiore a 255 e quindi eseguire le ottimizzazioni di conseguenza.

La risposta attuale è utile nel caso in cui si sappia con certezza quale sia l'intervallo, ma se si desidera comunque un comportamento corretto quando il valore è al di fuori dell'intervallo previsto, non funzionerà.

In tal caso, ho scoperto che questa tecnica può funzionare:

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

L'idea è un compromesso dati-codice: stai spostando 1 bit di dati (se x == c) nella logica di controllo .
Ciò suggerisce all'ottimizzatore che xè in realtà una costante nota c, incoraggiandolo a incorporare e ottimizzare la prima invocazione fooseparatamente dal resto, possibilmente piuttosto pesantemente.

Assicurati di fattorizzare effettivamente il codice in una singola subroutine foo, tuttavia, non duplicare il codice.

Esempio:

Affinché questa tecnica funzioni, devi essere un po 'fortunato: ci sono casi in cui il compilatore decide di non valutare staticamente le cose e sono in qualche modo arbitrari. Ma quando funziona, funziona bene:

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

Basta usare -O3e notare le costanti pre-valutati 0x20e 0x30ein uscita assembler .

Sto solo dicendo che se vuoi una soluzione che sia C ++ più standard, puoi usare l' [[noreturn]]attributo per scrivere la tua unreachable.

Quindi riproverò l' eccellente esempio di deniss per dimostrare:

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

Che come puoi vedere , risulta in un codice quasi identico:

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

Il rovescio della medaglia è ovviamente che si riceve un avviso che una [[noreturn]]funzione, in effetti, ritorna.