Was ist die Schleifeninversionstechnik?

Ich habe ein Dokument durchgearbeitet, in dem es um Just-in-Time-Compiler- Optimierungstechniken (JIT) für Java geht. Eine davon war "Loop Inversion". Und das Dokument sagt:

Sie ersetzen eine reguläre whileSchleife durch eine do-whileSchleife. Und die do-whileSchleife wird innerhalb einer ifKlausel gesetzt. Dieser Ersatz führt zu zwei Sprüngen weniger.

Wie funktioniert die Schleifeninversion und wie optimiert sie unseren Codepfad?

NB: Es wäre großartig, wenn jemand anhand eines Beispiels für Java-Code erklären könnte, wie JIT ihn für nativen Code optimiert und warum er in modernen Prozessoren optimal ist.

while (condition) { 
  ... 
}

Arbeitsablauf:

1. Zustand prüfen;
2. Wenn false, springen Sie zur Außenseite der Schleife.
3. Führen Sie eine Iteration aus.
4. nach oben springen.

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

Arbeitsablauf:

1. Zustand prüfen;
2. Wenn false, springen Sie über die Schleife hinaus.
3. Führen Sie eine Iteration aus.
4. Zustand prüfen;
5. Wenn dies zutrifft, fahren Sie mit Schritt 3 fort.

Wenn Sie diese beiden vergleichen, können Sie leicht erkennen, dass letztere möglicherweise überhaupt keine Sprünge ausführen, vorausgesetzt, es gibt genau einen Schritt durch die Schleife, und im Allgemeinen ist die Anzahl der Sprünge um eins geringer als die Anzahl der Iterationen. Ersterer muss zurückspringen, um die Bedingung zu überprüfen, und nur dann aus der Schleife springen, wenn die Bedingung falsch ist.

Sprünge auf modernen Pipeline-CPU-Architekturen können sehr teuer sein: Da die CPU die Ausführung der Überprüfungen vor dem Sprung beendet, befinden sich die Anweisungen über diesen Sprung hinaus bereits in der Mitte der Pipeline. Diese gesamte Verarbeitung muss verworfen werden, wenn die Verzweigungsvorhersage fehlschlägt. Die weitere Ausführung wird verzögert, während die Pipeline erneut gestartet wird.

Erläuterung der erwähnten Verzweigungsvorhersage : Für jede Art von bedingtem Sprung verfügt die CPU über zwei Anweisungen, die jeweils eine Wette auf das Ergebnis enthalten. Zum Beispiel würden Sie am Ende einer Schleife eine Anweisung mit der Aufschrift " Sprung, wenn nicht Null, Wetten auf Nicht Null " einfügen, da der Sprung bei allen Iterationen mit Ausnahme der letzten ausgeführt werden muss. Auf diese Weise beginnt die CPU, ihre Pipeline mit den Anweisungen zu pumpen, die dem Sprungziel folgen, anstatt denen, die der Sprunganweisung selbst folgen.

Wichtige Notiz

Bitte nehmen Sie dies nicht als Beispiel für die Optimierung auf Quellcode-Ebene. Das wäre völlig falsch, da der JIT-Compiler, wie bereits aus Ihrer Frage hervorgeht, die Umwandlung von der ersten in die zweite Form routinemäßig und völlig eigenständig durchführt.

Dies kann eine Schleife optimieren, die immer mindestens einmal ausgeführt wird.

Eine reguläre whileSchleife springt dann immer mindestens einmal zum Anfang und am Ende einmal zum Ende. Ein Beispiel für eine einfache Schleife, die einmal ausgeführt wird:

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

Eine do-whileSchleife hingegen überspringt den ersten und letzten Sprung. Hier ist eine äquivalente Schleife wie oben, die ohne Sprünge ausgeführt wird:

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

Lassen Sie uns durch sie gehen:

Die whileVersion:

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

1. Zuerst testen wir nund springen zu, done();wenn die Bedingung nicht erfüllt ist.
2. Dann verwenden und erhöhen wir n.
3. Jetzt kehren wir zum Zustand zurück.
4. Spülen, wiederholen.
5. Wenn die Bedingung nicht mehr erfüllt ist, springen wir zu done().

Die do-whileVersion:

(Denken Sie daran, dass wir dies im Quellcode nicht tun [was zu Wartungsproblemen führen würde], der Compiler / JIT erledigt dies für uns.)

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

1. Zuerst testen wir nund springen zu, done();wenn die Bedingung nicht erfüllt ist.
2. Dann verwenden und erhöhen wir n.
3. Jetzt testen wir den Zustand und springen zurück, wenn er wahr ist.
4. Spülen, wiederholen.
5. Wenn die Bedingung nicht mehr erfüllt ist, fließen wir (nicht springen) zu done().

So zum Beispiel, wenn nbeginnt zu sein 9, wir überhaupt nicht in der Sprung - do-whileVersion, während in der whileVersion müssen wir an den Anfang zurückspringen, tun Sie den Test, und dann bis zum Ende springen zurück , wenn wir es sehen , ist nicht wahr .

Die Schleifeninversion ist eine Technik zur Leistungsoptimierung, die die Leistung verbessert, da der Prozessor mit weniger Anweisungen das gleiche Ergebnis erzielen kann. Dies sollte vor allem die Leistung unter Randbedingungen verbessern.

Dieser Link bietet ein weiteres Beispiel für die Schleifeninversion. In wenigen Architekturen, in denen Dekrementieren und Vergleichen als ein einziger Befehlssatz implementiert ist, ist es sinnvoll, eine for-Schleife mit Dekrementierungs- und Vergleichsoperation in eine Weile umzuwandeln.

Wikipedia hat ein sehr gutes Beispiel und ich erkläre es hier noch einmal.

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

wird vom Compiler in konvertiert

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

Wie übersetzt sich dies in Leistung? Wenn der Wert von i 99 ist, muss der Prozessor kein GOTO ausführen (was im ersten Fall erforderlich ist). Dies verbessert die Leistung.