powered byiMasterstutoriais · referência · código em portuguêsPatrocínio
Java

JEP 515 acelera o warmup do Java 25 com perfis de método no AOT cache, mas cobra o preço depois

Desde o Java 25, o AOT cache passou a guardar também os perfis de método usados pelo compilador JIT. Um levantamento independente mediu o ganho no warmup e achou uma perda de desempenho que só aparece depois de centenas de execuções.

Por Marcelo TeixeiraColunista10 min de leitura
Imagem gerada por IA

JEP 515 acelera o warmup do Java 25 com perfis de método no AOT cache, mas cobra o preço depois

Desde o Java 25, o AOT cache passou a guardar também os perfis de método usados pelo compilador JIT. Um levantamento independente mediu o ganho no warmup e achou uma perda de desempenho que só aparece depois de centenas de execuções.

Desde o Java 25, o AOT cache passou a guardar também os perfis de método usados pelo compilador JIT. Um levantamento independente mediu o ganho no warmup e achou uma perda de desempenho que só aparece depois de centenas de execuções.

Disponível desde o Java 25, o JEP 515 (Ahead-of-Time Method Profiling) ampliou o AOT cache introduzido pelo projeto Leyden: além das classes carregadas e linkadas, o cache passou a guardar também os perfis de método coletados durante a execução de treino. A promessa é simples: o compilador C2 não precisa reconstruir esses perfis do zero a cada processo novo, então compila os métodos quentes mais cedo e com informação mais completa.

Um artigo publicado no foojay.io por Sven Woltmann (autor do happycoders.eu) refez as medições do JEP com um programa maior e rodadas mais longas, em JDK 25.0.2 e na build early-access 28-ea+23 do Java 28. O resultado confirma o ganho no aquecimento, mas também mostra uma regressão de até 5% depois de 200 rounds em Java 28, causada por um efeito colateral no inlining de lambdas. Este texto resume os mecanismos internos e os números, com os comandos exatos para reproduzir o experimento.

O que é um perfil de método, na prática

O HotSpot executa Java em camadas. Primeiro no interpretador, depois em duas etapas de compilação JIT: o C1, rápido e pouco otimizado, e o C2, lento para compilar mas muito mais agressivo. As camadas são numeradas:

NívelO que executaPerfilagem
0InterpretadorCompleta (chamadas, laços, branches, tipos reais)
1Código C1Nenhuma (getters, métodos triviais, nativos)
2Código C1Só contagem de chamadas e iterações de laço
3Código C1Perfilagem completa
4Código C2Nenhuma (já compilado com o perfil acumulado)

O perfil de método é essa contagem: quantas vezes o método foi chamado, quantas vezes cada laço rodou, quais branches foram tomados e quais classes realmente apareceram em cada ponto de chamada. É com base nisso que o C2 decide o que fazer inlining (embutir o método chamado no código chamador) e onde apostar em otimizações especulativas, como assumir que um call site polimórfico só viu uma classe até agora. Se a aposta falhar depois, a JVM desfaz o código C2 e volta o método para o interpretador, em uma deoptimization.

Sem perfis vindos do cache, um método quente passa pelos níveis 0, 3 e 4: primeiro interpretado com perfilagem completa, depois compilado pelo C2 com base nesse perfil. O JEP 515 muda essa trajetória para quem já tem um AOT cache.

Como colocar os perfis no cache, e como tirá-los para comparar

Nenhum passo extra é necessário: desde o Java 25, a rodada de treino que gera o AOT cache já grava os perfis junto com as classes.

bash
java -XX:AOTCacheOutput=App.aot -cp App.jar App
java -XX:AOTCache=App.aot -cp App.jar App

Para medir o efeito isolado dos perfis, é preciso um cache idêntico, mas sem eles. A opção de diagnóstico -XX:-AOTReplayTraining faz exatamente isso: a JVM continua usando as classes do cache, só ignora os perfis.

bash
java -XX:+UnlockDiagnosticVMOptions -XX:-AOTReplayTraining \
  -XX:AOTCache=App.aot -cp App.jar App

Em Java 28, essa mesma flag também desliga o código AOT pré-compilado do JEP 544 (Ahead-of-Time Code Compilation), já que ali a JVM só usa esse código junto com os perfis. Para comparar as mesmas três camadas presentes no Java 25 (classes, objetos pré-inicializados e perfis, sem código AOT), o cache de Java 28 precisa ser criado com -XX:+UnlockDiagnosticVMOptions -XX:-AOTCodeCaching na hora da geração, sem repetir a opção na execução de produção.

Os números: do exemplo oficial a um caso de 100 rounds

O próprio JEP usa o programa HelloStreamWarmup, que roda um pipeline de streams 100 mil vezes: 90 ms sem perfis contra 73 ms com perfis, uma queda de 19%. Repetindo o mesmo programa em um MacBook Pro com Apple M5 Pro (18 núcleos), G1 GC, 30 execuções por variante, o ganho medido foi menor:

VarianteJava 25 (ms)Java 28 (ms)
Sem cache49,750,3
Com cache, sem perfis45,244,6
Com cache, com perfis43,540,2

Com perfis, o processo inteiro leva 3,8% menos tempo que sem perfis em Java 25, e 9,9% menos em Java 28. A direção do JEP se confirma, mas o JEP não informa em qual hardware mediu, o que explica a diferença de magnitude.

Para capturar o que acontece depois do warmup, o autor usou um programa mais longo: AotCompile, que compila 50 arquivos gerados em memória com o javac a cada round, por 100 rounds, com uma rodada de treino de 20 rounds. A tabela mostra o tempo médio por round em Java 25, em milissegundos:

RoundsSem cacheSem perfisCom perfisCom perfis vs. sem cache
2 a 5133,2131,0112,8-13,9%
11 a 2067,367,461,9-8,0%
21 a 3064,364,460,3-6,2%
31 a 4059,859,961,0+2,0%
81 a 10053,854,156,9+5,7%

Nota da redação: no primeiro item desta tabela (rounds 2 a 5), o percentual de -13,9% está rotulado como "com perfis vs. sem cache", mas na fonte original esse valor corresponde à comparação "com perfis vs. sem perfis" (131,0 para 112,8 ms). O valor correto para "com perfis vs. sem cache" seria aproximadamente -15,3%. As demais linhas da tabela seguem a metodologia correta (comparação contra "sem cache"); fica o registro para quem for usar esse número específico.

Em resumo: o cache com perfis vence com folga durante o aquecimento, empata por volta do round 30 e depois perde para o programa sem cache nenhum. Sem perfis, o cache só ajuda no primeiro round, porque a partir do segundo a linha "sem perfis" praticamente coincide com a linha "sem cache".

O que a JVM faz com os perfis, por dentro

O código-fonte do HotSpot mostra quatro mecanismos que os perfis do cache acionam:

  1. O perfil do treino vira o perfil do método. Ao criar a estrutura de perfil, a JVM instala o conteúdo gravado no cache em vez de um perfil vazio: no início do processo, os contadores já refletem o fim da rodada de treino.
  2. Métodos já compilados por C2 no treino pulam a perfilagem. Eles vão do nível 0 direto para o nível 2 e depois para o nível 4, sem passar pelo nível 3 de perfilagem completa.
  3. Métodos "mornos" (só compilados por C1 no treino) esperam. Desde o Java 26, a JVM compara a contagem de chamadas da produção com a do treino, e só libera o método do nível 2 quando a produção ultrapassa o treino. No Java 25, não há essa comparação: a JVM multiplica por 100 o limiar de saída do nível 0 e por 250 o do nível 2, de forma genérica para todo método vindo do cache.
  4. Compilação adiantada (AOTCompileEagerly, Java 28). Ao inicializar uma classe, a JVM já enfileira a compilação dos métodos daquela classe presentes no treino, antes mesmo de o programa chamá-los. Essa opção depende de AOTCodeCaching: em Java 25 fica desligada por padrão; em Java 28, liga automaticamente sempre que o cache é aberto com AOTCodeCaching ativo (que é o padrão de produção, mesmo num cache sem código AOT).

Os mecanismos 1 e 2 explicam o ganho do começo: o C2 compila cedo e com perfil completo. O mecanismo 4 explica por que o primeiro round fica mais lento em Java 28. O mecanismo 3 explica a perda que reaparece mais tarde. Nenhum dos quatro, porém, explica a perda que persiste no longo prazo, essa tem outra causa, descrita adiante.

Java 28: por que a primeira rodada piora

Em Java 28, o primeiro round de AotCompile levou 490 ms com perfis contra 417 ms sem perfis, 17,5% a mais. Nos rounds 2 a 5, a relação se inverte: 133,2 ms com perfis contra 147,5 ms sem perfis, 9,7% a menos.

A causa é a compilação adiantada (mecanismo 4). Com -XX:+LogCompilation, o autor viu que, nos primeiros 0,25 segundo, a JVM com perfis do cache enfileira 3.468 tarefas de nível 2, das quais 3.073 são adiantadas e só 395 são de métodos já chamados pelo programa, essas 395 esperam 562 ms na mediana. Sem perfis do cache, as 2.161 tarefas de nível 3 enfileiradas no mesmo período são todas de métodos já chamados, e mais da metade é atendida no mesmo milissegundo em que entrou na fila. Os métodos que o programa precisa agora ficam atrás na fila dos métodos adiantados, e continuam no interpretador enquanto esperam.

Uma troca controlada de flags confirma a causa: -XX:+UnlockDiagnosticVMOptions -XX:-AOTCompileEagerly desliga a compilação adiantada em Java 28 (ligada por padrão); -XX:+UnlockExperimentalVMOptions -XX:+AOTCompileEagerly liga em Java 25 (desligada por padrão).

CenárioSem perfisCom perfis, sem adiantamentoCom perfis, com adiantamento
Java 28, rounds 2-5144,8 ms128,8 ms133,8 ms
Java 28, rounds 6-1086,4 ms85,6 ms77,8 ms
Java 25, rounds 2-5129,0 ms112,0 ms97,2 ms
Java 25, rounds 6-1084,4 ms73,6 ms70,4 ms

Inverter a flag inverte o sinal da primeira rodada nas duas versões, mas o adiantamento não paga a dívida da primeira rodada em nenhuma das duas versões, nem em 5 nem em 20 rounds: somando as cinco primeiras rodadas, o total com adiantamento fica atrás do total sem adiantamento nas duas versões (889 ms contra 820 ms em Java 25, 1.026 ms contra 920 ms em Java 28), e continua atrás mesmo depois de 20 rounds (1.858 ms contra 1.809 ms em Java 25, 2.062 ms contra 2.006 ms em Java 28).

O aquecimento atrasado

O mecanismo 3 faz métodos "mornos" esperarem no nível 2 até a produção ultrapassar a contagem de chamadas do treino. Como isso depende diretamente de quanto tempo durou o treino, o número de compilações de nível 3 se concentra em pontos diferentes conforme o treino foi mais curto ou mais longo: com -XX:+PrintCompilation, um treino de 5 rounds gerou 1.420 compilações de nível 3 nos 10 rounds seguintes (contra 506 sem cache); um treino de 20 rounds gerou 601 (contra 91); um treino de 60 rounds gerou só 148 logo depois, mas uma onda maior de 305 apareceu entre os rounds 81 e 90, quando a produção finalmente ultrapassou o treino.

Por que o ganho desaparece no longo prazo

Nenhum dos quatro mecanismos documentados explica a perda sustentada que aparece depois do round 30: em Java 28, o experimento do artigo mostrou o programa com perfis 5% mais lento que sem cache nenhum depois de 200 rounds.

A causa, encontrada no código-fonte da JVM, é um efeito colateral da própria gravação do cache: ao escrever o cache, os perfis perdem as entradas referentes a expressões lambda, e o compilador C2 deixa de fazer inlining dessas lambdas no código chamador quando lê o perfil de volta. O resultado é código mais lento mesmo depois de todo o aquecimento estar concluído, porque falta ao C2 a informação de que aquele call site era, na prática, monomórfico.

Quando vale a pena

Para processos de vida curta, como CLIs, funções serverless ou lambdas de borda que terminam antes de completar o próprio warmup, os perfis do AOT cache entregam exatamente o que o JEP promete: menos tempo até o pico de desempenho, sem mudar uma linha de código.

Para serviços de longa duração que já ultrapassam centenas de milhares de chamadas por método, a mesma configuração pode custar alguns pontos percentuais de throughput sustentado, por causa do inlining de lambdas perdido na gravação do cache. A recomendação prática é medir o próprio workload nas duas condições (com -XX:-AOTReplayTraining como grupo de controle) antes de assumir que o cache com perfis é sempre a opção mais rápida.

Próximo passo

O texto original, com o código-fonte completo dos exemplos, os scripts de medição e todos os dados brutos, está no repositório java-aot-cache no GitHub. Para o AOT cache sem os perfis de método, vale revisar o JEP 483 (AOT Class Loading & Linking), base sobre a qual o JEP 515 foi construído; para o código AOT citado nas comparações com Java 28, o JEP 544 (Ahead-of-Time Code Compilation). A especificação oficial do recurso tratado aqui é o JEP 515, no site da OpenJDK.

Fonte: Foojay

PatrocínioContinue estudando JavaTrilhas completas, projetos e exercícios na DevMedia.Travou em algum passo?Pergunte no Fórum iMastersPoste o trecho de código e o erro: a comunidade responde.Notícias da stackO que saiu de novo, no iMastersLançamentos, versões e eventos do ecossistema dev.

Este artigo foi escrito por Marcelo Teixeira. Conteúdo produzido por agente de IA da redação Linha de Código. Saiba como produzimos no expediente.

Marcelo Teixeira

Editor virtual de Java do Linha de Código. Cobre Java moderno (records, pattern matching, virtual threads), Spring Boot, JPA e Hibernate, Maven e Gradle, e o Kotlin quando ele conversa com a JVM. Escreve para quem mantém o monólito da empresa e para quem está aprendendo a primeira linguagem tipada, sempre declarando a versão do JDK e do framework.

Próximos passoso que estudar a partir daqui

  1. você está aquiJEP 515 acelera o warmup do Java 25 com perfis de método no AOT cache, mas cobra o preço depois
  2. mesmo autorRecords em Java: o que são, quando substituem a classe e as pegadinhas com JPA e JacksonJava · 1 min
  3. mesmo autorSpring Boot 4: como migrar seu projeto 3.x sem parar a entregaJava · 1 min

Newsletter

Os melhores tutoriais da semana, no seu e-mail

Toda semana, os tutoriais novos das sete stacks e o guia de referência que vale guardar. Gratuita, sem spam.