Qual é a técnica de inversão de loop?

Eu estava lendo um documento que fala sobre técnicas de otimização do compilador just-in-time (JIT) para Java. Um deles era "inversão de loop". E o documento diz:

Você substitui um whileloop regular por um do-whileloop. E o do-whileloop é definido dentro de uma ifcláusula. Essa substituição leva a dois saltos a menos.

Como funciona a inversão de loop e como ela otimiza nosso caminho de código?

NB: Seria ótimo se alguém pudesse explicar com um exemplo de código Java e como o JIT o otimiza para código nativo e por que é ideal em processadores modernos.

while (condition) { 
  ... 
}

Fluxo de trabalho:

1. verificar condição;
2. se falso, pula para fora do loop;
3. execute uma iteração;
4. pule para cima.

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

Fluxo de trabalho:

1. verificar condição;
2. se falso, pula para além do loop;
3. execute uma iteração;
4. verificar condição;
5. se verdadeiro, pule para a etapa 3.

Comparando esses dois, você pode facilmente ver que o último pode não fazer nenhum salto, desde que haja exatamente uma etapa no loop e, geralmente, o número de saltos será um a menos que o número de iterações. O primeiro terá que voltar para verificar a condição, apenas para sair do loop quando a condição for falsa.

Os saltos nas arquiteturas modernas de CPU com pipeline podem ser bastante caros: como a CPU está terminando a execução das verificações antes do salto, as instruções além desse salto já estão no meio do pipeline. Todo esse processamento deve ser descartado se a previsão do branch falhar. A execução posterior é atrasada enquanto o pipeline está sendo reprimido.

Explicando a previsão de desvio mencionada : para cada tipo de salto condicional, a CPU possui duas instruções, cada uma incluindo uma aposta no resultado. Por exemplo, você colocaria uma instrução dizendo " pule se não for zero, apostando no não zero " no final de um loop, porque o salto terá que ser feito em todas as iterações, exceto na última. Dessa forma, a CPU começa a bombear seu pipeline com as instruções que seguem o destino de salto, em vez daquelas que seguem a própria instrução de salto.

Nota importante

Por favor, não tome isso como um exemplo de como otimizar ao nível do código-fonte. Isso seria totalmente equivocado, pois, como já ficou claro em sua pergunta, a transformação da primeira forma para a segunda é algo que o compilador JIT faz rotineiramente, completamente por conta própria.

Isso pode otimizar um loop que sempre é executado pelo menos uma vez.

Um whileloop regular sempre voltará ao início pelo menos uma vez e saltará para o final uma vez no final. Um exemplo de um loop simples executado uma vez:

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

Um do-whileloop, por outro lado, pulará o primeiro e o último salto. Aqui está um loop equivalente ao acima, que será executado sem saltos:

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

Vamos examiná-los:

A whileversão:

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

1. Primeiro, testamos ne verificamos done();se a condição não é verdadeira.
2. Então usamos e incrementamos n.
3. Agora voltamos à condição.
4. Enxágüe, repita.
5. Quando a condição não for mais verdadeira, passamos para done().

A do-whileversão:

(Lembre-se de que não fazemos isso no código-fonte [isso introduziria problemas de manutenção], o compilador / JIT faz isso por nós.)

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

1. Primeiro, testamos ne verificamos done();se a condição não é verdadeira.
2. Então usamos e incrementamos n.
3. Agora testamos a condição e voltamos para ver se é verdade.
4. Enxágüe, repita.
5. Quando a condição não é mais verdadeira, fluímos (não saltamos) para done().

Então, por exemplo, se ncomeça sendo 9, nunca pulamos na do-whileversão, enquanto na whileversão temos que voltar ao início, fazer o teste e depois voltar ao final quando vemos que não é verdade .

A inversão de loop é uma técnica de otimização de desempenho que melhora o desempenho, pois o processador pode obter o mesmo resultado com menos instruções. Isso deve melhorar principalmente o desempenho em condições de limite.

Este link fornece outro exemplo de inversão de loop. Em algumas arquiteturas em que decremento e comparação são implementados como um único conjunto de instruções, faz sentido converter um loop for em um while com decremento e operação de comparação.

A Wikipedia tem um exemplo muito bom e estou explicando-o aqui novamente.

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

será convertido pelo compilador para

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

Como isso se traduz em desempenho? Quando o valor de i é 99, o processador não precisa realizar um GOTO (que é necessário no primeiro caso). Isso melhora o desempenho.