Чи можу я натякнути на оптимізатор, давши діапазон цілого числа?

Я використовую intтип для зберігання значення. За семантикою програми значення завжди змінюється в дуже малому діапазоні (0 - 36), а int(не а 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програма 'ing, а в версії версій використовує припущення, створюючи оптимізований код.

Однак зауважте, що він не є заміною для регулярних 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]]функція дійсно повертається.