Apa teknik loop inversi?

Saya sedang membaca dokumen yang berbicara tentang teknik pengoptimalan just-in-time compiler (JIT) untuk Java. Salah satunya adalah "loop inversion". Dan dokumen itu mengatakan:

Anda mengganti whileloop biasa dengan do-whileloop. Dan do-whileloop diatur dalam ifklausa. Penggantian ini menyebabkan dua lompatan lebih sedikit.

Bagaimana cara kerja loop inversi dan bagaimana cara mengoptimalkan jalur kode kita?

NB: Akan sangat bagus jika seseorang dapat menjelaskan dengan contoh kode Java dan bagaimana JIT mengoptimalkannya ke kode asli dan mengapa itu optimal dalam prosesor modern.

while (condition) { 
  ... 
}

Alur Kerja:

1. periksa kondisi;
2. jika salah, lompat ke luar loop;
3. menjalankan satu iterasi;
4. lompat ke atas.

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

Alur Kerja:

1. periksa kondisi;
2. jika salah, lompat ke luar loop;
3. menjalankan satu iterasi;
4. periksa kondisi;
5. jika benar, lompat ke langkah 3.

Membandingkan keduanya, Anda dapat dengan mudah melihat bahwa yang terakhir mungkin tidak melakukan lompatan sama sekali, asalkan ada tepat satu langkah melalui loop, dan umumnya jumlah lompatan akan menjadi satu kurang dari jumlah iterasi. Mantan harus melompat kembali untuk memeriksa kondisinya, hanya untuk melompat keluar dari lingkaran ketika kondisinya salah.

Lompatan pada arsitektur CPU pipelined modern bisa jadi sangat mahal: karena CPU sedang menyelesaikan eksekusi pemeriksaan sebelum lompatan, instruksi di luar lompatan itu sudah ada di tengah pipeline. Semua pemrosesan ini harus dibuang jika prediksi cabang gagal. Eksekusi lebih lanjut ditunda saat pipa sedang ditegur.

Menjelaskan prediksi cabang yang disebutkan : untuk setiap jenis lompatan bersyarat, CPU memiliki dua instruksi, masing-masing termasuk taruhan pada hasilnya. Misalnya, Anda akan meletakkan instruksi yang mengatakan " lompat jika bukan nol, bertaruh bukan nol " di akhir putaran karena lompatan harus dilakukan pada semua iterasi kecuali yang terakhir. Dengan cara itu CPU mulai memompa pipeline-nya dengan instruksi yang mengikuti target lompat, bukan yang mengikuti instruksi lompat itu sendiri.

Catatan penting

Jangan tidak mengambil ini sebagai contoh bagaimana mengoptimalkan pada tingkat kode sumber. Itu akan salah kaprah karena, seperti yang sudah jelas dari pertanyaan Anda, transformasi dari bentuk pertama ke bentuk kedua adalah sesuatu yang dilakukan oleh compiler JIT sebagai masalah rutin, sepenuhnya sendiri.

Ini dapat mengoptimalkan loop yang selalu dijalankan setidaknya sekali.

Putaran biasa whilekemudian akan selalu melompat kembali ke awal setidaknya sekali dan melompat ke akhir sekali di akhir. Contoh loop sederhana yang berjalan satu kali:

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

Sebuah do-whileloop di sisi lain akan melewatkan lompatan pertama dan terakhir. Berikut adalah loop yang setara dengan loop di atas, yang akan berjalan tanpa lompatan:

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

Mari kita telusuri mereka:

The whileVersi:

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

1. Pertama kita uji ndan lompat ke done();jika kondisinya tidak benar.
2. Kemudian kami menggunakan dan meningkatkan n.
3. Sekarang kita kembali ke kondisi tersebut.
4. Bilas, ulangi.
5. Ketika kondisinya tidak lagi benar, kami melompat ke done().

The do-whileVersi:

(Ingat, kita sebenarnya tidak melakukan ini di kode sumber [yang akan menyebabkan masalah pemeliharaan], kompilator / JIT melakukannya untuk kita.)

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

1. Pertama kita uji ndan lompat ke done();jika kondisinya tidak benar.
2. Kemudian kami menggunakan dan meningkatkan n.
3. Sekarang kami menguji kondisinya dan melompat kembali jika itu benar.
4. Bilas, ulangi.
5. Ketika kondisinya tidak lagi benar, kita mengalir (bukan melompat) ke done().

Jadi misalnya, jika nmulai menjadi 9, kita tidak pernah melompat sama sekali dalam do-whileversi, sedangkan dalam whileversi kita harus melompat kembali ke awal, melakukan pengujian, dan kemudian melompat kembali ke akhir ketika kita melihat itu tidak benar .

Loop inversi adalah teknik pengoptimalan kinerja yang meningkatkan kinerja karena prosesor dapat mencapai hasil yang sama dengan instruksi yang lebih sedikit. Ini sebagian besar akan meningkatkan kinerja dalam kondisi batas.

Tautan ini memberikan contoh lain untuk inversi loop. Dalam beberapa arsitektur di mana penurunan dan perbandingan diimplementasikan sebagai satu set instruksi, masuk akal untuk mengubah perulangan for menjadi sementara dengan operasi pengurangan dan perbandingan.

Wikipedia memiliki contoh yang sangat bagus dan saya menjelaskannya lagi di sini.

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

akan diubah oleh kompilator menjadi

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

Bagaimana ini diterjemahkan menjadi kinerja? Ketika nilai i adalah 99, prosesor tidak perlu melakukan GOTO (yang diperlukan dalam kasus pertama). Ini meningkatkan kinerja.