Що таке техніка інверсії петлі?

Я переглядав документ, який розповідає про методи оптимізації компілятора (JIT) для Java. Одним з них була "інверсія петлі". І в документі сказано:

Ви замінюєте звичайний whileцикл на do-whileцикл. І do-whileцикл встановлюється в ifреченні. Ця заміна призводить до двох менших стрибків.

Як працює інверсія циклу і як вона оптимізує наш шлях до коду?

Примітка: Було б чудово, якщо хтось може пояснити на прикладі коду Java і як JIT оптимізує його до власного коду і чому це оптимально в сучасних процесорах.

while (condition) { 
  ... 
}

Робочий процес:

1. перевірити стан;
2. якщо false, перейти до зовнішньої частини циклу;
3. запустити одну ітерацію;
4. стрибнути наверх.

if (condition) do {
  ...
} while (condition);

Робочий процес:

1. перевірити стан;
2. якщо хибне, перейти до петель;
3. запустити одну ітерацію;
4. перевірити стан;
5. якщо це так, перейдіть до кроку 3.

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

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

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

Важлива примітка

Будь ласка , НЕ приймайте це як приклад того , як оптимізувати на рівні вихідного коду. Це було б цілком помилковим, оскільки, як вже зрозуміло з Вашого запитання, перетворення з першої форми у другу - це те, що компілятор JIT робить, як правило, повністю самостійно.

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

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

int i = 0;
while (i++ < 1) {
    //do something
}  

do-whileПетля з іншого боку буде пропускати перший і останній стрибок. Ось еквівалентний цикл наведеному вище, який буде працювати без стрибків:

int i = 0;
if (i++ < 1) {
    do {
        //do something
    } while (i++ < 1); 
}

Пройдемося по них:

whileверсія:

void foo(int n) {
    while (n < 10) {
       use(n);
       ++n;
    }
    done();
}

1. Спочатку ми перевіряємо nі переходимо до того, done();якщо умова не відповідає дійсності.
2. Потім ми використовуємо і збільшуємо n.
3. Тепер ми переходимо до стану.
4. Промити, повторити.
5. Коли умова вже не відповідає дійсності, ми переходимо до done().

do-whileверсія:

(Пам’ятайте, насправді ми не робимо цього у вихідному коді [що може спричинити проблеми технічного обслуговування], компілятор / JIT робить це за нас.)

void foo(int n) {
    if (n < 10) {
        do {
            use(n);
            ++n;
        }
        while (n < 10);
    }
    done();
}

1. Спочатку ми перевіряємо nі переходимо до того, done();якщо умова не відповідає дійсності.
2. Потім ми використовуємо і збільшуємо n.
3. Тепер ми перевіряємо стан і відскакуємо назад, якщо це правда.
4. Промити, повторити.
5. Коли умова вже не відповідає дійсності, ми переходимо до (не стрибаємо) до done().

Так, наприклад, якщо все nпочинається 9, ми ніколи взагалі не переходимо у do-whileверсію, тоді як у whileверсії ми маємо перейти назад на початок, зробити тест, а потім перейти назад до кінця, коли побачимо, що це неправда .

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

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

У Вікіпедії є дуже хороший приклад, і я ще раз пояснюю це тут.

 int i, a[100];
  i = 0;
  while (i < 100) {
    a[i] = 0;
    i++;
  }

буде перетворено компілятором в

  int i, a[100];
  i = 0;
  if (i < 100) {
    do {
      a[i] = 0;
      i++;
    } while (i < 100);
  }

Як це перекладається на продуктивність? Коли значення i дорівнює 99, процесору не потрібно виконувати GOTO (що потрібно в першому випадку). Це покращує продуктивність.