Posso sugerir o otimizador, fornecendo o intervalo de um número inteiro?

Estou usando um inttipo para armazenar um valor. Pela semântica do programa, o valor sempre varia em um intervalo muito pequeno (0 - 36) e int(não a char) é usado apenas devido à eficiência da CPU.

Parece que muitas otimizações aritméticas especiais podem ser executadas em um intervalo tão pequeno de números inteiros. Muitas chamadas de função nesses números inteiros podem ser otimizadas em um pequeno conjunto de operações "mágicas", e algumas funções podem até ser otimizadas em consultas de tabela.

Portanto, é possível dizer ao compilador que isso intestá sempre nesse pequeno intervalo e é possível que o compilador faça essas otimizações?

Sim, é possível. Por exemplo, gccvocê pode usar __builtin_unreachablepara informar o compilador sobre condições impossíveis, como:

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

Podemos quebrar a condição acima em uma macro:

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

E use-o assim:

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

Como você pode ver , gccrealiza otimizações com base nessas informações:

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

Produz:

func(int):
    mov     eax, 17
    ret

Uma desvantagem, no entanto, é que, se seu código quebrar essas suposições, você terá um comportamento indefinido .

Ele não o notifica quando isso acontece, mesmo nas versões de depuração. Para depurar / testar / capturar bugs com suposições mais facilmente, você pode usar uma macro híbrida de assumir / afirmar (créditos para @David Z), como esta:

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

Nas compilações de depuração (com NDEBUG não definidas), ele funciona como uma assertmensagem de erro comum e abortprograma de impressão, e nas compilações de versão utiliza uma suposição, produzindo código otimizado.

Observe, no entanto, que ele não substitui os permanentes regulares assert- condnas versões de lançamento, portanto você não deve fazer algo assim assume(VeryExpensiveComputation()).

Existe suporte padrão para isso. O que você deve fazer é incluir stdint.h( cstdint) e, em seguida, usar o tipo uint_fast8_t.

Isso informa ao compilador que você está usando apenas números entre 0 e 255, mas que é livre usar um tipo maior se isso fornecer um código mais rápido. Da mesma forma, o compilador pode assumir que a variável nunca terá um valor acima de 255 e, em seguida, fará otimizações de acordo.

A resposta atual é boa para o caso quando você sabe ao certo qual é o intervalo, mas se ainda deseja um comportamento correto quando o valor está fora do intervalo esperado, ele não funcionará.

Nesse caso, achei que essa técnica pode funcionar:

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

A idéia é uma troca de dados de código: você está movendo 1 bit de dados (se x == c) para a lógica de controle .
Isso sugere que o otimizador xé de fato uma constante conhecida c, incentivando-o a alinhar e otimizar a primeira chamada de fooseparadamente do resto, possivelmente muito.

fooEntretanto, certifique-se de fatorar o código em uma única sub-rotina - não duplique o código.

Exemplo:

Para que essa técnica funcione, você precisa ter um pouco de sorte - há casos em que o compilador decide não avaliar as coisas estaticamente, e elas são arbitrárias. Mas quando funciona, funciona bem:

#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 usar -O3e observar as constantes pré-avaliadas 0x20e 0x30ena saída do assembler .

Estou apenas dizendo que, se você quiser uma solução mais C ++ padrão, poderá usar o [[noreturn]]atributo para escrever sua própria unreachable.

Então, refiz o excelente exemplo de deniss para demonstrar:

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

O que, como você pode ver , resulta em código quase idêntico:

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

A desvantagem é, obviamente, que você recebe um aviso de que uma [[noreturn]]função realmente retorna.