Коли, якщо взагалі, розгортання циклу все ще корисно?

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

// Search for elements to swap.
while(myArray[++index1] < pivot) {}
while(pivot < myArray[--index2]) {}

Я спробував розгорнути щось на зразок:

while(true) {
    if(myArray[++index1] < pivot) break;
    if(myArray[++index1] < pivot) break;
    // More unrolling
}


while(true) {
    if(pivot < myArray[--index2]) break;
    if(pivot < myArray[--index2]) break;
    // More unrolling
}

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

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

Простий приклад:

for (int i=0; i<n; i++)
{
  sum += data[i];
}

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

З іншого боку, цей код:

for (int i=0; i<n; i+=4)
{
  sum1 += data[i+0];
  sum2 += data[i+1];
  sum3 += data[i+2];
  sum4 += data[i+3];
}
sum = sum1 + sum2 + sum3 + sum4;

може працювати швидше. Якщо ви отримаєте помилку кеш-пам’яті або іншу стійку в одному розрахунку, все ще існують три інші ланцюжки залежностей, які не залежать від стійки. Порушений процесор може виконувати їх.

Це не зробить жодної різниці, тому що ви виконуєте однакову кількість порівнянь. Ось кращий приклад. Замість:

for (int i=0; i<200; i++) {
  doStuff();
}

написати:

for (int i=0; i<50; i++) {
  doStuff();
  doStuff();
  doStuff();
  doStuff();
}

Навіть тоді це майже напевно не матиме значення, але зараз ви робите 50 порівнянь замість 200 (уявіть, порівняння є більш складним).

Ручне розгортання циклу загалом є, в основному, артефактом історії. Це ще один із зростаючого списку речей, які хороший компілятор зробить для вас, коли це важливо. Наприклад, більшість людей не турбуються писати x <<= 1або x += xзамість цього x *= 2. Ви просто пишете, x *= 2і компілятор оптимізує його для вас, якнайкраще.

В основному стає все менше потреби вгадувати свій компілятор.

Незалежно від прогнозування гілок на сучасному обладнанні, більшість компіляторів все одно роблять розгортання циклу для вас.

Варто було б з’ясувати, скільки оптимізацій для вас робить ваш компілятор.

Мені здалося, що виступ Фелікса фон Лайтнера дуже просвітницький на цю тему. Рекомендую прочитати. Короткий зміст: Сучасні компілятори ДУЖЕ розумні, тому оптимізація рук майже ніколи не є ефективною.

Наскільки я розумію, сучасні компілятори вже розгортають цикли там, де це доречно - наприклад, gcc, якщо передано прапори оптимізації, в інструкції сказано, що це буде:

Розгорніть цикли, кількість ітерацій яких можна визначити під час компіляції або при вході в цикл.

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

Розгортання шлейфу, будь то розгортання вручну чи розгортання компілятора, часто може призвести до контрпродуктивності, особливо з новішими процесорами x86 (Core 2, Core i7). Підсумок: порівняйте код із розгортанням циклу та без нього на тих процесорах, на яких ви плануєте розгорнути цей код.

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

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

Ось приклад того, як отримати максимальну продуктивність.

Розгортання петлі може бути корисним у конкретних випадках. Єдиний виграш - це не пропуск деяких тестів!

Наприклад, це може дозволити скалярну заміну, ефективну вставку попереднього завантаження програмного забезпечення ... Ви були б здивовані, наскільки це може бути корисним (ви можете легко отримати 10% прискорення на більшості циклів навіть з -O3) шляхом агресивного розгортання.

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

Розгортання петлі цілком залежить від розміру вашої проблеми. Це цілком залежить від того, чи може ваш алгоритм зменшити розмір на менші групи робіт. Те, що ви зробили вище, не схоже на це. Я не впевнений, що моделювання Монте-Карло можна навіть розгорнути.

Хорошим сценарієм розгортання циклу було б обертання зображення. Оскільки ви могли обертати окремі групи робіт. Щоб це працювало, вам довелося б зменшити кількість ітерацій.

Розгортання циклу все ще корисно, якщо в циклі та в циклі є багато локальних змінних. Щоб повторно використовувати ці регістри більше, а не зберігати один для індексу циклу.

У вашому прикладі ви використовуєте невелику кількість локальних змінних, не перевитрачуючи регістри.

Порівняння (до кінця циклу) також є головним недоліком, якщо порівняння важке (тобто не testінструкція), особливо якщо це залежить від зовнішньої функції.

Розгортання циклу допомагає підвищити обізнаність процесора щодо прогнозування гілок, але це відбувається в будь-якому випадку.