Можно ли намекнуть оптимизатору, указав диапазон целого числа?

Я использую intтип для хранения значения. В соответствии с семантикой программы значение всегда изменяется в очень небольшом диапазоне (0 - 36), и int(не a char) используется только из-за эффективности процессора.

Кажется, что многие специальные арифметические оптимизации могут быть выполнены для такого небольшого диапазона целых чисел. Многие вызовы функций для этих целых чисел могут быть оптимизированы в небольшой набор «магических» операций, а некоторые функции могут быть даже оптимизированы для поиска в таблице.

Итак, можно ли сказать компилятору, что intон всегда находится в этом небольшом диапазоне, и возможно ли, чтобы компилятор выполнял эти оптимизации?

Да, это возможно. Например, gccвы можете __builtin_unreachableсообщить компилятору о невозможных условиях, например:

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

Мы можем обернуть условие выше в макрос:

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

И используйте это так:

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

Как видите , gccвыполняет оптимизацию на основе этой информации:

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

Производит:

func(int):
    mov     eax, 17
    ret

Однако есть один недостаток: если ваш код нарушает такие предположения, вы получаете неопределенное поведение .

Он не уведомляет вас, когда это происходит, даже в отладочных сборках. Для более легкой отладки / тестирования / выявления ошибок с допущениями вы можете использовать гибридный макрос предположения / утверждения (кредиты @David Z), например, такой:

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

В отладочных сборках (с NDEBUG не определенным) он работает как обычное assertпечатное сообщение об ошибке и abortпрограмма, а в сборочных выпусках он использует допущение, создающее оптимизированный код.

Обратите внимание, однако, что он не заменяет обычный assert- condостается в сборках релиза, поэтому вы не должны делать что-то подобное assume(VeryExpensiveComputation()).

Существует стандартная поддержка для этого. Что вы должны сделать, это включить stdint.h( cstdint), а затем использовать тип uint_fast8_t.

Это говорит компилятору, что вы используете только числа от 0 до 255, но что он может использовать больший тип, если это дает более быстрый код. Точно так же компилятор может предположить, что переменная никогда не будет иметь значения выше 255, и затем выполнить соответствующие оптимизации.

Текущий ответ подходит для случая, когда вы точно знаете , что это за диапазон, но если вам все еще нужно правильное поведение, когда значение выходит за пределы ожидаемого диапазона, тогда оно не будет работать.

Для этого случая я обнаружил, что эта техника может работать:

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

Идея заключается в обмене данными кода: вы перемещаете 1 бит данных (независимо от того x == c) ли в управляющую логику .
Это намекает оптимизатору, который xна самом деле является известной константой c, побуждая его встроить и оптимизировать первый вызов fooотдельно от остальных, возможно, довольно сильно.

Удостоверьтесь, что на самом деле код разделен на одну подпрограмму foo- не дублируйте код.

Пример:

Чтобы эта техника работала, вам нужно немного повезти - в некоторых случаях компилятор решает не оценивать вещи статически, и они являются произвольными. Но когда это работает, это работает хорошо:

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

Просто используйте -O3и обратите внимание на предварительно оцененные константы0x20 и 0x30eв выходе на ассемблере .

Я просто хочу сказать, что если вы хотите решение, которое является более стандартным C ++, вы можете использовать этот [[noreturn]]атрибут для написания своего собственного unreachable.

Поэтому я переназначу отличный пример Дениса, чтобы продемонстрировать:

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

Что, как вы можете видеть , приводит к почти идентичному коду:

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

Недостатком является, конечно, то, что вы получаете предупреждение о том, что [[noreturn]]функция действительно возвращает.