Qual è la tecnica di inversione del ciclo?

Stavo esaminando un documento che parla delle tecniche di ottimizzazione del compilatore just-in-time (JIT) per Java. Uno di questi era "inversione di ciclo". E il documento dice:

Sostituisci un whileciclo regolare con un do-whileciclo. E il do-whileciclo è impostato all'interno di una ifclausola. Questa sostituzione porta a due salti in meno.

Come funziona l'inversione del ciclo e come ottimizza il nostro percorso di codice?

NB: Sarebbe fantastico se qualcuno potesse spiegare con un esempio di codice Java e come JIT lo ottimizza in codice nativo e perché è ottimale nei processori moderni.

while (condition) { 
  ... 
}

Flusso di lavoro:

1. controllare le condizioni;
2. se falso, salta fuori dal ciclo;
3. eseguire un'iterazione;
4. salta in cima.

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

Flusso di lavoro:

1. controllare le condizioni;
2. se falso, salta oltre il ciclo;
3. eseguire un'iterazione;
4. controllare le condizioni;
5. se è vero, vai al passaggio 3.

Confrontando questi due si può facilmente vedere che quest'ultimo potrebbe non fare alcun salto, a condizione che ci sia esattamente un passaggio attraverso il ciclo, e generalmente il numero di salti sarà uno in meno rispetto al numero di iterazioni. Il primo dovrà tornare indietro per controllare la condizione, solo per saltare fuori dal ciclo quando la condizione è falsa.

I salti sulle moderne architetture di CPU in pipeline possono essere piuttosto costosi: poiché la CPU sta terminando l'esecuzione dei controlli prima del salto, le istruzioni oltre quel salto sono già nel mezzo della pipeline. Tutta questa elaborazione deve essere scartata se la previsione del ramo fallisce. L'ulteriore esecuzione viene ritardata mentre la pipeline viene riattivata.

Spiegazione della previsione del ramo citato : per ogni tipo di salto condizionale la CPU ha due istruzioni, ciascuna inclusa una scommessa sul risultato. Ad esempio, potresti mettere un'istruzione che dice " salta se non zero, scommettendo su non zero " alla fine di un ciclo perché il salto dovrà essere fatto su tutte le iterazioni tranne l'ultima. In questo modo la CPU inizia a pompare la sua pipeline con le istruzioni che seguono l'obiettivo di salto invece di quelle che seguono l'istruzione di salto stessa.

Nota importante

Si prega di non prenderlo come esempio di come ottimizzare a livello di codice sorgente. Ciò sarebbe del tutto fuorviante poiché, come già chiaro dalla tua domanda, la trasformazione dalla prima forma alla seconda è qualcosa che il compilatore JIT fa come una questione di routine, completamente da solo.

Questo può ottimizzare un ciclo che viene sempre eseguito almeno una volta.

Un whileciclo regolare salterà quindi sempre all'inizio almeno una volta e salterà alla fine una volta alla fine. Un esempio di un semplice ciclo in esecuzione una volta:

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

Un do-whileloop invece salterà il primo e l'ultimo salto. Ecco un ciclo equivalente a quello sopra, che verrà eseguito senza salti:

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

Vediamoli:

La whileversione:

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

1. Per prima cosa testiamo ne passiamo a done();se la condizione non è vera.
2. Quindi usiamo e incrementiamo n.
3. Ora torniamo alla condizione.
4. Risciacquare, ripetere.
5. Quando la condizione non è più vera, passiamo a done().

La do-whileversione:

(Ricorda, in realtà non lo facciamo nel codice sorgente [che introdurrebbe problemi di manutenzione], il compilatore / JIT lo fa per noi.)

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

1. Per prima cosa testiamo ne passiamo a done();se la condizione non è vera.
2. Quindi usiamo e incrementiamo n.
3. Ora testiamo la condizione e torniamo indietro se è vera.
4. Risciacquare, ripetere.
5. Quando la condizione non è più vera, fluiamo (non saltiamo) verso done().

Quindi, ad esempio, se ninizia 9, non saltiamo mai nella do-whileversione, mentre nella whileversione dobbiamo tornare all'inizio, fare il test e poi tornare alla fine quando vediamo che non è vero .

L'inversione di loop è una tecnica di ottimizzazione delle prestazioni che migliora le prestazioni poiché il processore può ottenere lo stesso risultato con meno istruzioni. Ciò dovrebbe principalmente migliorare le prestazioni in condizioni al contorno.

Questo collegamento fornisce un altro esempio di inversione del ciclo. In poche architetture in cui il decremento e il confronto sono implementati come un singolo set di istruzioni, ha senso convertire un ciclo for in un while con l'operazione di decremento e confronto.

Wikipedia ha un ottimo esempio e lo sto spiegando di nuovo qui.

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

verrà convertito dal compilatore in

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

Come si traduce in prestazioni? Quando il valore di i è 99, il processore non ha bisogno di eseguire un GOTO (che è richiesto nel primo caso). Ciò migliora le prestazioni.