Döngü ters çevirme tekniği nedir?

Java için tam zamanında derleyici (JIT) optimizasyon tekniklerinden bahseden bir belgeye bakıyordum. Bunlardan biri "döngü ters çevirme" idi. Ve belge diyor ki:

Normal whilebir do-whiledöngüyü bir döngü ile değiştirirsiniz . Ve do-whiledöngü bir ifcümle içinde ayarlanır . Bu değiştirme, iki daha az sıçramaya yol açar.

Döngü ters çevirme nasıl çalışır ve kod yolumuzu nasıl optimize eder?

Not: Biri bir Java kodu örneğiyle ve JIT'in bunu yerel koda nasıl optimize ettiğini ve modern işlemcilerde neden en uygun olduğunu açıklayabilirse harika olur.

while (condition) { 
  ... 
}

İş akışı:

1. durumu kontrol edin;
2. yanlış ise döngünün dışına atlayın;
3. bir yineleme çalıştırın;
4. üste atla.

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

İş akışı:

1. durumu kontrol edin;
2. yanlışsa, döngünün ötesine atlayın;
3. bir yineleme çalıştırın;
4. durumu kontrol edin;
5. doğruysa 3. adıma atlayın.

Bu ikisini karşılaştırdığınızda, döngüde tam olarak bir adım olması koşuluyla ikincisinin hiç atlama yapmayabileceğini kolayca görebilirsiniz ve genellikle atlama sayısı yineleme sayısından bir az olacaktır. İlki, koşulu kontrol etmek için geri atlamak zorunda kalacak, yalnızca koşul yanlış olduğunda döngüden atlamak zorunda kalacak.

Modern ardışık düzen CPU mimarilerinde sıçramalar oldukça pahalı olabilir: CPU, atlamadan önce kontrollerin yürütülmesini bitirirken, bu atlamanın ötesindeki talimatlar zaten ardışık düzenin ortasındadır. Şube tahmini başarısız olursa, tüm bu işlemler atılmalıdır. Boru hattı cezalandırılırken daha fazla yürütme ertelenir.

Bahsedilen dal tahminini açıklamak : her tür koşullu sıçrama için CPU'nun her biri sonuca ilişkin bir bahis içeren iki talimatı vardır . Örneğin, bir döngünün sonuna " sıfır değilse zıpla, sıfır değil üzerine bahis yap " diyen bir talimat koyarsınız , çünkü atlama sonuncusu hariç tüm yinelemelerde yapılmalıdır. Bu şekilde CPU, atlama komutunun kendisini izleyenler yerine atlama hedefini izleyen talimatlarla işlem hattını pompalamaya başlar.

Önemli Not

Lütfen değil kaynak kodu düzeyinde nasıl optimize bir örnek olarak alın. Bu tamamen yanlış olacaktır çünkü, sorunuzdan da anlaşılacağı üzere, ilk formdan ikinciye dönüşüm, JIT derleyicisinin tamamen kendi başına rutin olarak yaptığı bir şeydir.

Bu, her zaman en az bir kez yürütülen bir döngüyü optimize edebilir.

Düzenli bir whiledöngü daha sonra her zaman en az bir kez başlangıca geri atlayacak ve sonunda bir kez sona atlayacaktır. Bir kez çalışan basit bir döngü örneği:

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

do-whileÖte yandan bir döngü, ilk ve son atlamayı atlayacaktır. Atlamasız olarak çalışan yukarıdakine eşdeğer bir döngü:

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

Onların üzerinden geçelim:

whileversiyon:

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

1. Önce koşul doğru değilse test nedip atlarız done();.
2. Sonra kullanırız ve arttırırız n.
3. Şimdi duruma geri dönüyoruz.
4. Durulayın, tekrarlayın.
5. Koşul artık doğru olmadığında, atlıyoruz done().

do-whileversiyon:

(Unutmayın, bunu aslında kaynak kodunda yapmıyoruz [bu bakım sorunlarını ortaya çıkarır], derleyici / JIT bunu bizim için yapar.)

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

1. Önce koşul doğru değilse test nedip atlarız done();.
2. Sonra kullanırız ve arttırırız n.
3. Şimdi durumu test ediyoruz ve doğruysa geri dönüyoruz.
4. Durulayın, tekrarlayın.
5. Koşul artık doğru olmadığında, akarız (atlamayız) done().

Örneğin, var nolmaya başlarsak 9, do-whilesürümde asla atlamayız , oysa whilesürümde başa dönmemiz, testi yapmamız ve sonra doğru olmadığını gördüğümüzde sona geri dönmemiz gerekir. .

Döngü ters çevirme, işlemci aynı sonucu daha az komutla elde edebileceğinden performansı artıran bir performans optimizasyon tekniğidir. Bu, çoğunlukla sınır koşullarında performansı iyileştirmelidir.

Bu bağlantı , döngü tersine çevirme için başka bir örnek sağlar. Azaltma ve karşılaştırmanın tek bir komut seti olarak uygulandığı birkaç mimaride, bir for döngüsünü azaltma ve karşılaştırma işlemi ile bir süreye dönüştürmek mantıklıdır.

Wikipedia'nın çok güzel bir örneği var ve bunu burada tekrar açıklıyorum.

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

derleyici tarafından dönüştürülecek

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

Bu nasıl performansa dönüşür? İ'nin değeri 99 olduğunda, işlemcinin bir GOTO gerçekleştirmesine gerek yoktur (bu ilk durumda gereklidir). Bu, performansı artırır.