Na czym polega technika inwersji pętli?

Może to zoptymalizować pętlę, która jest zawsze wykonywana co najmniej raz.

Zwykła pętla while będzie wtedy zawsze skakać z powrotem do początku przynajmniej raz i skakać do końca raz na końcu. Przykład prostej pętli uruchamianej raz:

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

A do-while pętla z drugiej strony pominie pierwszy i ostatni skok. Poniżej znajduje się pętla równoważna do powyższej, która będzie działać bez skoków:

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

Przejdźmy przez nie:

Wersja while:

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

1. najpierw testujemy n i przeskakujemy do done();, jeśli warunek nie jest prawdziwy.
2. następnie używamy i zwiększamy n.
Teraz wracamy do stanu.
3. przepłukać, powtórzyć.
4. gdy warunek nie jest już prawdziwy, przeskakujemy do done().

Wersja do-while:

(pamiętaj, że nie robimy tego w kodzie źródłowym [co wprowadziłoby konserwację problemy], kompilator/JIT robi to za nas.)

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

1. najpierw testujemy n i przeskakujemy do done();, jeśli warunek nie jest prawdziwy.
2. następnie używamy i zwiększamy n.
3. teraz testujemy warunek i skaczemy z powrotem, jeśli to prawda.
4. przepłukać, powtórzyć.
5. gdy warunek nie jest już prawdziwy, płyniemy (nie przeskakujemy) do done().

Więc na przykład, jeśli n zaczyna się 9, nigdy nie przeskakujemy w wersji do-while, natomiast w wersji while wersja musimy wrócić do początku, zrobić test, a następnie przejść z powrotem do końca, gdy widzimy, że to nieprawda.

Inwersja pętli jest techniką optymalizacji wydajności, która poprawia wydajność, ponieważ procesor może osiągnąć ten sam wynik przy mniejszej liczbie instrukcji. Powinno to przede wszystkim poprawić wydajność w warunkach brzegowych.

Ten link stanowi kolejny przykład inwersji pętli. W kilku architekturach, w których decrement i compare są zaimplementowane jako pojedynczy zestaw instrukcji, warto przekonwertować pętlę for NA A while z decrement i compare operacja.

Wikipedia ma bardzo dobry przykład i wyjaśniam go tutaj ponownie.

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

Zostanie przekonwertowany przez kompilator na

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

Jak to przekłada się na wydajność? Gdy wartość i wynosi 99, procesor nie musi wykonywać GOTO (co jest wymagane w pierwszym przypadku). Poprawia to wydajność.