Por que um loop Java de 4 bilhões de iterações leva apenas 2 ms?

Estou executando o seguinte código Java em um laptop com Intel Core i7 de 2,7 GHz. Eu pretendia deixá-lo medir quanto tempo leva para terminar um loop com 2 ^ 32 iterações, que esperava ser cerca de 1,48 segundos (4 / 2,7 = 1,48).

Mas, na verdade, leva apenas 2 milissegundos, em vez de 1,48 s. Estou me perguntando se isso é resultado de alguma otimização JVM subjacente?

public static void main(String[] args)
{
    long start = System.nanoTime();

    for (int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE; i++){
    }
    long finish = System.nanoTime();
    long d = (finish - start) / 1000000;

    System.out.println("Used " + d);
}

Existem duas possibilidades acontecendo aqui:

1. O compilador percebeu que o loop é redundante e não fez nada para otimizá-lo.

2. O JIT (compilador just-in-time) percebeu que o loop é redundante e não fazia nada, então o otimizou.

Os compiladores modernos são muito inteligentes; eles podem ver quando o código é inútil. Tente colocar um loop vazio em GodBolt e olhar para a saída, em seguida, ative as -O2otimizações, você verá que a saída é algo na linha de

main():
    xor eax, eax
    ret

Gostaria de esclarecer algo, em Java a maioria das otimizações são feitas pelo JIT. Em algumas outras linguagens (como C / C ++), a maioria das otimizações é feita pelo primeiro compilador.

Parece que foi otimizado pelo compilador JIT. Quando eu o desligo ( -Djava.compiler=NONE), o código fica muito mais lento:

$ javac MyClass.java
$ java MyClass
Used 4
$ java -Djava.compiler=NONE MyClass
Used 40409

Eu coloquei o código do OP dentro de class MyClass.

Vou apenas declarar o óbvio - que se trata de uma otimização JVM que acontece, o loop simplesmente será removido. Aqui está um pequeno teste que mostra a grande diferença JITquando ativado / ativado apenas para C1 Compilere desativado em tudo.

Isenção de responsabilidade: não escreva testes como este - isso é apenas para provar que a "remoção" do loop real acontece no C2 Compiler:

@Benchmark
@Fork(1)
public void full() {
    long result = 0;
    for (int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE; i++) {
        ++result;
    }
}

@Benchmark
@Fork(1)
public void minusOne() {
    long result = 0;
    for (int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE - 1; i++) {
        ++result;
    }
}

@Benchmark
@Fork(value = 1, jvmArgsAppend = { "-XX:TieredStopAtLevel=1" })
public void withoutC2() {
    long result = 0;
    for (int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE - 1; i++) {
        ++result;
    }
}

@Benchmark
@Fork(value = 1, jvmArgsAppend = { "-Xint" })
public void withoutAll() {
    long result = 0;
    for (int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE - 1; i++) {
        ++result;
    }
}

Os resultados mostram que dependendo de qual parte do JITestá habilitado, o método fica mais rápido (muito mais rápido que parece que está fazendo "nada" - remoção de loop, o que parece estar acontecendo no C2 Compiler- que é o nível máximo):

 Benchmark                Mode  Cnt      Score   Error  Units
 Loop.full        avgt    2     ≈ 10⁻⁷          ms/op
 Loop.minusOne    avgt    2     ≈ 10⁻⁶          ms/op
 Loop.withoutAll  avgt    2  51782.751          ms/op
 Loop.withoutC2   avgt    2   1699.137          ms/op 

Conforme já apontado, o compilador JIT (just-in-time) pode otimizar um loop vazio para remover iterações desnecessárias. Mas como?

Na verdade, existem dois compiladores JIT: C1 e C2 . Primeiro, o código é compilado com o C1. C1 coleta as estatísticas e ajuda a JVM a descobrir que, em 100% dos casos, nosso loop vazio não muda nada e é inútil. Nesta situação C2 entra em cena. Quando o código é chamado com muita frequência, ele pode ser otimizado e compilado com o C2 usando as estatísticas coletadas.

Como exemplo, testarei o próximo snippet de código (meu JDK está configurado para slowdebug build 9-internal ):

public class Demo {
    private static void run() {
        for (int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE; i++) {
        }
        System.out.println("Done!");
    }
}

Com as seguintes opções de linha de comando:

-XX:+UnlockDiagnosticVMOptions -XX:CompileCommand=print,*Demo.run

E existem diferentes versões do meu método de execução , compilado com o C1 e C2 apropriadamente. Para mim, a variante final (C2) é mais ou menos assim:

...

; B1: # B3 B2 <- BLOCK HEAD IS JUNK  Freq: 1
0x00000000125461b0: mov   dword ptr [rsp+0ffffffffffff7000h], eax
0x00000000125461b7: push  rbp
0x00000000125461b8: sub   rsp, 40h
0x00000000125461bc: mov   ebp, dword ptr [rdx]
0x00000000125461be: mov   rcx, rdx
0x00000000125461c1: mov   r10, 57fbc220h
0x00000000125461cb: call  indirect r10    ; *iload_1

0x00000000125461ce: cmp   ebp, 7fffffffh  ; 7fffffff => 2147483647
0x00000000125461d4: jnl   125461dbh       ; jump if not less

; B2: # B3 <- B1  Freq: 0.999999
0x00000000125461d6: mov   ebp, 7fffffffh  ; *if_icmpge

; B3: # N44 <- B1 B2  Freq: 1       
0x00000000125461db: mov   edx, 0ffffff5dh
0x0000000012837d60: nop
0x0000000012837d61: nop
0x0000000012837d62: nop
0x0000000012837d63: call  0ae86fa0h

...

É um pouco confuso, mas se você olhar de perto, você notará que não há um loop de longa duração aqui. Existem 3 blocos: B1, B2 e B3 e as etapas de execução podem serB1 -> B2 -> B3 ou B1 -> B3. Onde Freq: 1- frequência estimada normalizada de execução de um bloco.

Você está medindo o tempo que leva para detectar que o loop não faz nada, compila o código em um thread de segundo plano e elimina o código.

for (int t = 0; t < 5; t++) {
    long start = System.nanoTime();
    for (int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE; i++) {
    }
    long time = System.nanoTime() - start;

    String s = String.format("%d: Took %.6f ms", t, time / 1e6);
    Thread.sleep(50);
    System.out.println(s);
    Thread.sleep(50);
}

Se você executar isso com, -XX:+PrintCompilationpoderá ver que o código foi compilado em segundo plano para o compilador de nível 3 ou C1 e depois de alguns loops para o nível 4 de C4.

    129   34 %     3       A::main @ 15 (93 bytes)
    130   35       3       A::main (93 bytes)
    130   36 %     4       A::main @ 15 (93 bytes)
    131   34 %     3       A::main @ -2 (93 bytes)   made not entrant
    131   36 %     4       A::main @ -2 (93 bytes)   made not entrant
0: Took 2.510408 ms
    268   75 %     3       A::main @ 15 (93 bytes)
    271   76 %     4       A::main @ 15 (93 bytes)
    274   75 %     3       A::main @ -2 (93 bytes)   made not entrant
1: Took 5.629456 ms
2: Took 0.000000 ms
3: Took 0.000364 ms
4: Took 0.000365 ms

Se você alterar o loop para usar um, longele não ficará tão otimizado.

    for (long i = Integer.MIN_VALUE; i < Integer.MAX_VALUE; i++) {
    }

em vez disso você consegue

0: Took 1579.267321 ms
1: Took 1674.148662 ms
2: Took 1885.692166 ms
3: Took 1709.870567 ms
4: Took 1754.005112 ms

Você considera o tempo de início e término em nanossegundos e divide por 10 ^ 6 para calcular a latência

long d = (finish - start) / 1000000

deve ser 10^9porque 1segundo = 10^9nanossegundo.