Чому компілятор не може (або ні) оптимізувати передбачуваний цикл додавання до множення?

Це питання, яке прийшло в голову під час читання блискучої відповіді Mysticial на запитання: чому швидше обробити відсортований масив, ніж несортований масив ?

Контекст для задіяних типів:

const unsigned arraySize = 32768;
int data[arraySize];
long long sum = 0;

У своїй відповіді він пояснює, що Intel Compiler (ICC) оптимізує це:

for (int i = 0; i < 100000; ++i)
    for (int c = 0; c < arraySize; ++c)
        if (data[c] >= 128)
            sum += data[c];

... у щось еквівалентне цьому:

for (int c = 0; c < arraySize; ++c)
    if (data[c] >= 128)
        for (int i = 0; i < 100000; ++i)
            sum += data[c];

Оптимізатор визнає, що вони еквівалентні, і тому обмінюється петлями , переміщуючи гілку за межами внутрішньої петлі. Дуже розумний!

Але чому це не робиться?

for (int c = 0; c < arraySize; ++c)
    if (data[c] >= 128)
        sum += 100000 * data[c];

Сподіваємось, містичне (або хто-небудь інший) може дати не менш яскраву відповідь. Я ніколи не дізнавався про оптимізації, про які говорилося в тому іншому питанні раніше, тому я дуже вдячний за це.

Компілятор загалом не може трансформуватися

for (int c = 0; c < arraySize; ++c)
    if (data[c] >= 128)
        for (int i = 0; i < 100000; ++i)
            sum += data[c];

в

for (int c = 0; c < arraySize; ++c)
    if (data[c] >= 128)
        sum += 100000 * data[c];

тому що останнє може призвести до переповнення підписаних цілих чисел, де їх немає. Навіть із гарантованою поведінкою обертання для переповнення підписаних цілих чисел комплементу, це змінить результат (якщо data[c]30000, продукт став би -1294967296для типових 32-бітних ints з обертанням, тоді як 100000 разів додавши 30000 до sum, якщо це не переливається, збільшується sumна 3000000000). Зауважте, що однакові справедливі для непідписаних величин, з різними числами, переповнення 100000 * data[c], як правило, вводить модуль зменшення, 2^32який не повинен відображатися в кінцевому результаті.

Це могло б перетворити його на

for (int c = 0; c < arraySize; ++c)
    if (data[c] >= 128)
        sum += 100000LL * data[c];  // resp. 100000ull

однак, якщо, як завжди, long longдостатньо більше, ніж int.

Чому це не робиться, я не можу сказати, я думаю, це те, що Містікал сказав , "мабуть, він не виконує цикл, що руйнується циклом, після петлі-обміну".

Зауважте, що сам цикл-обмін не є дійсним (для підписаних цілих чисел), оскільки

for (int c = 0; c < arraySize; ++c)
    if (condition(data[c]))
        for (int i = 0; i < 100000; ++i)
            sum += data[c];

може призвести до переповнення куди

for (int i = 0; i < 100000; ++i)
    for (int c = 0; c < arraySize; ++c)
        if (condition(data[c]))
            sum += data[c];

не буде. Тут кошерніше, оскільки умова гарантує, що всі data[c]додані мають однаковий знак, тож якщо один переповнює, обидва роблять.

Я би не надто впевнений, що компілятор врахував це, хоча (@Mysticial, чи можете ви спробувати з умовою, як-то data[c] & 0x80чи так, що може відповідати позитивним та негативним значенням?). У мене були компілятори, які роблять недійсні оптимізації (наприклад, пару років тому, я мав ICC (11.0, iirc) використовувати конверсію з підписанням 32-біт-інт-в-подвійний у тому, 1.0/nде nбув unsigned int. Був приблизно вдвічі швидший, ніж gcc але неправильно, багато значень було більше 2^31, ой.).

Ця відповідь не стосується конкретного випадку, але він стосується назви питання і може бути цікавим майбутнім читачам:

Через кінцеву точність повторне додавання з плаваючою комою не рівносильно множенню . Поміркуйте:

float const step = 1e-15;
float const init = 1;
long int const count = 1000000000;

float result1 = init;
for( int i = 0; i < count; ++i ) result1 += step;

float result2 = init;
result2 += step * count;

cout << (result1 - result2);

Демо

Компілятор містить різні пропуски, що робить оптимізацію. Зазвичай в кожному проході робиться або оптимізація операторів, або циклічна оптимізація. В даний час не існує моделі, яка б оптимізувала тіло циклу на основі заголовків циклу. Це важко виявити і менш поширене.

Оптимізацією, яку було зроблено, було циклічне інваріантне рух коду. Це можна зробити за допомогою набору прийомів.

Ну, я б здогадався, що деякі компілятори можуть зробити таку оптимізацію, припускаючи, що мова йде про арифметику Integer.

У той же час деякі компілятори можуть відмовитися це робити, оскільки заміна повторюваного додавання на множення може змінити поведінку переповнення коду. Для цілих цілей без підпису це не повинно змінювати значення, оскільки їх поведінка переповнення повністю визначена мовою. Але для підписаних, можливо, це (мабуть, не на платформі доповнення 2). Це правда, що підписане переповнення насправді призводить до невизначеної поведінки в С, це означає, що слід цілком нормально ігнорувати цю семантику переповнення взагалі, але не всі компілятори досить сміливі для цього. Він часто викликає багато критики з боку натовпу "С - це просто мова монтажу вищого рівня". (Пам'ятаєте, що сталося, коли GCC запровадив оптимізацію, засновану на суворій семантиці?)

Історично GCC показав себе як компілятор, який вимагає зробити такі різкі кроки, але інші компілятори, можливо, вважають за краще дотримуватися сприйнятої "призначеної для користувача" поведінки, навіть якщо вона не визначена мовою.

Це зараз - принаймні, кланг робить :

long long add_100k_signed(int *data, int arraySize)
{
    long long sum = 0;

    for (int c = 0; c < arraySize; ++c)
        if (data[c] >= 128)
            for (int i = 0; i < 100000; ++i)
                sum += data[c];
    return sum;
}

компілює з -O1 до

add_100k_signed:                        # @add_100k_signed
        test    esi, esi
        jle     .LBB0_1
        mov     r9d, esi
        xor     r8d, r8d
        xor     esi, esi
        xor     eax, eax
.LBB0_4:                                # =>This Inner Loop Header: Depth=1
        movsxd  rdx, dword ptr [rdi + 4*rsi]
        imul    rcx, rdx, 100000
        cmp     rdx, 127
        cmovle  rcx, r8
        add     rax, rcx
        add     rsi, 1
        cmp     r9, rsi
        jne     .LBB0_4
        ret
.LBB0_1:
        xor     eax, eax
        ret

Переповнення цілого числа не має нічого спільного з цим; якщо є переповнення цілочисельних чисел, що спричиняє невизначене поведінку, це може статися в будь-якому випадку Ось такий самий вид функції, який використовується intзамістьlong :

int add_100k_signed(int *data, int arraySize)
{
    int sum = 0;

    for (int c = 0; c < arraySize; ++c)
        if (data[c] >= 128)
            for (int i = 0; i < 100000; ++i)
                sum += data[c];
    return sum;
}

компілює з -O1 до

add_100k_signed:                        # @add_100k_signed
        test    esi, esi
        jle     .LBB0_1
        mov     r9d, esi
        xor     r8d, r8d
        xor     esi, esi
        xor     eax, eax
.LBB0_4:                                # =>This Inner Loop Header: Depth=1
        mov     edx, dword ptr [rdi + 4*rsi]
        imul    ecx, edx, 100000
        cmp     edx, 127
        cmovle  ecx, r8d
        add     eax, ecx
        add     rsi, 1
        cmp     r9, rsi
        jne     .LBB0_4
        ret
.LBB0_1:
        xor     eax, eax
        ret

Існує концептуальна перешкода на шляху такого оптимізації. Автори-компілятори витрачають багато сил на зменшення сили - наприклад, замінюючи множення на додавання та зрушення. Вони звикають думати, що розмножуватися - це погано. Тож випадок, коли треба йти іншим шляхом, є дивовижним та контрсуєтним. Тож ніхто не думає це здійснити.

Люди, які розробляють та підтримують компілятори, мають обмежену кількість часу та енергії, щоб витратити їх на роботу, тому вони, як правило, хочуть зосередитись на тому, що їх найбільше хвилює користувачів: перетворення добре написаного коду на швидкий код. Вони не хочуть витрачати свій час на пошук способів перетворити нерозумний код у швидкий код - саме для цього використовується огляд коду. У мові високого рівня може бути "нерозумний" код, який виражає важливу ідею, тому варто витратити час розробникам на це швидко - наприклад, скорочення вирубки лісів та злиття потоків дозволяють програмам Haskell, структурованим на певних видах лінь створені структури даних для компіляції в тісні петлі, які не виділяють пам'ять. Але такий стимул просто не поширюється на перетворення певного додавання в множення. Якщо ви хочете, щоб це було швидко,