OPcache e compilação JIT
Acelere o PHP com cache de bytecode e JIT.
OPcache e compilação JIT é uma aula grátis de PHP Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de PHP Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de PHP Academy inclui 4 aulas no total.
Armazenamento da Compilação
O OPcache armazena códigos de operação compilados na memória compartilhada, para que o PHP ignore a análise léxica, a análise sintática e a compilação em cada requisição. Além disso, o JIT (desde o PHP 8.0) compila códigos de operação frequentemente executados em código de máquina nativo. Juntos, eles formam a base do desempenho do PHP.
Esta lição aborda a configuração do OPcache, o pré-carregamento e o ajuste do JIT.
O que o OPcache Faz
O op_array compilado de cada arquivo é armazenado em um segmento de memória compartilhada usado por todos os processos FPM. Uma requisição que encontra o conteúdo no cache reutiliza os códigos de operação diretamente. O OPcache também executa um otimizador (propagação de constantes, eliminação de código morto e fusão de códigos de operação) na primeira vez que compila um arquivo.
; Core OPcache config (php.ini)
opcache.enable = 1
opcache.memory_consumption = 256 ; MB of shared memory
opcache.interned_strings_buffer = 16 ; MB for interned strings
opcache.max_accelerated_files = 20000 ; cap on cached scriptsValidação de Marcas de Tempo
validate_timestamps determina se o OPcache verifica novamente as marcas de modificação dos arquivos. No desenvolvimento, mantenha-o ativado com um revalidate_freq curto; em produção, defina-o como 0 para que o PHP nunca consulte os arquivos, e faça a implantação limpando o cache (ou reconstruindo a imagem).
; Production: never re-stat files
opcache.validate_timestamps = 0
; Development: check every 2 seconds
; opcache.validate_timestamps = 1
; opcache.revalidate_freq = 2Inspecionando o Cache
opcache_get_status() informa a taxa de acertos, o uso de memória e os scripts armazenados em cache; opcache_get_configuration() mostra as configurações. Uma taxa de acertos baixa ou reinicializações frequentes significa pouca memória ou arquivos demais.
<?php
if (function_exists('opcache_get_status')) {
$s = opcache_get_status(false);
if ($s) {
printf("hits: %d\n", $s['opcache_statistics']['hits']);
printf("misses: %d\n", $s['opcache_statistics']['misses']);
printf("hit %%: %.2f\n", $s['opcache_statistics']['opcache_hit_rate']);
printf("used: %.1f MB\n", $s['memory_usage']['used_memory'] / 1048576);
} else {
echo "OPcache enabled but no status (likely CLI)\n";
}
} else {
echo "OPcache not available\n";
}
?>Pré-carregamento
O pré-carregamento (PHP 7.4+) compila um conjunto de classes e funções uma vez na inicialização do servidor e as mantém permanentemente na memória, disponíveis para todas as requisições sem carregamento automático ou vinculação por requisição. Aponte opcache.preload para um script que use require para carregar os arquivos e aquecer o cache.
; php.ini
opcache.preload = /app/preload.php
opcache.preload_user = www-dataEscrevendo um Script de Pré-carregamento
O script de pré-carregamento é executado no processo mestre. Use opcache_compile_file() para carregar classes sem executá-las ou simplesmente use require. As estruturas de aplicação geram uma lista de pré-carregamento; veja abaixo o formato de uma.
<?php
// preload.php — runs once at startup
$dir = '/app/src';
$rii = new RecursiveIteratorIterator(
new RecursiveDirectoryIterator($dir)
);
foreach ($rii as $file) {
if ($file->getExtension() === 'php') {
// Compiles + links the class into shared memory
opcache_compile_file($file->getPathname());
}
}
?>Introdução ao JIT
Mesmo com os códigos de operação armazenados em cache, a VM ainda os interpreta. O JIT compila sequências de códigos de operação frequentemente executadas em instruções nativas da CPU, eliminando a sobrecarga do despacho da VM. O ganho é grande para código numérico limitado pela CPU e modesto para aplicações web típicas limitadas pela entrada e saída (que passam tempo no banco de dados e na rede, não na CPU).
Configurando o JIT
O JIT funciona dentro do OPcache, portanto o OPcache precisa estar ativado. opcache.jit_buffer_size aloca espaço para o código de máquina gerado (0 desativa o JIT). opcache.jit é um modo de quatro dígitos que controla o disparo e a estratégia de otimização.
; Enable JIT (requires opcache.enable=1)
opcache.jit_buffer_size = 128M
opcache.jit = tracing ; alias for 1254, the common default
; The 4 digits CRTO mean:
; C - CPU optimization flags
; R - register allocation
; T - trigger (when to JIT)
; O - optimization levelJIT de Rastreamento em Comparação com JIT de Função
Há duas estratégias: o JIT de função (modo 1205) compila funções inteiras na primeira chamada; o JIT de rastreamento (1254, o alias padrão tracing) cria um perfil da execução e compila laços e caminhos frequentemente executados, geralmente obtendo resultados melhores porque se especializa nos tipos observados. O rastreamento é a opção padrão recomendada.
; Tracing JIT (recommended) — compiles hot traces
opcache.jit = tracing
; Function JIT — compiles entire functions when first called
; opcache.jit = function
; Disable JIT but keep opcode cache
; opcache.jit_buffer_size = 0Medindo o Impacto do JIT
O JIT se destaca em laços numéricos intensivos. Este teste de desempenho autossuficiente (um laço interno semelhante ao de Mandelbrot) é o tipo de carga limitada pela CPU em que o JIT pode reduzir substancialmente o tempo de execução; execute-o com e sem jit_buffer_size para comparar.
<?php
function mandelEscape(float $cr, float $ci, int $max): int {
$zr = 0.0; $zi = 0.0; $n = 0;
while ($n < $max && ($zr * $zr + $zi * $zi) <= 4.0) {
$t = $zr * $zr - $zi * $zi + $cr;
$zi = 2.0 * $zr * $zi + $ci;
$zr = $t;
$n++;
}
return $n;
}
$start = hrtime(true);
$sum = 0;
for ($y = 0; $y < 200; $y++) {
for ($x = 0; $x < 200; $x++) {
$sum += mandelEscape($x / 100 - 2, $y / 100 - 1, 256);
}
}
printf("sum=%d time=%.2f ms\n", $sum, (hrtime(true) - $start) / 1e6);
?>Quando NOT Esperar Ganhos
Em uma requisição típica que consulta um banco de dados, renderiza um modelo e retorna JSON, a CPU faz pouca aritmética bruta — o JIT pode gerar ganhos de poucos pontos percentuais ou nenhum. Priorize primeiro o OPcache, o pré-carregamento e um bom uso do banco de dados e da memória cache. Reserve o ajuste do JIT para processamento de imagens, matemática, analisadores e outros códigos intensivos em cálculos.
Verificação Rápida
O que o pré-carregamento oferece que o armazenamento comum em cache do OPcache não oferece?
Resumo
O OPcache armazena op_arrays compilados na memória compartilhada e executa um otimizador; defina validate_timestamps=0 em produção e dimensione corretamente memory_consumption/max_accelerated_files. O pré-carregamento mantém as classes escolhidas residentes na inicialização. O JIT (dentro do OPcache, precisa de jit_buffer_size) compila código frequentemente executado em instruções nativas — grandes ganhos para matemática limitada pela CPU e poucos para aplicações web limitadas pela entrada e saída. Use opcache_get_status() para verificar.
Perguntas Frequentes
A aula “OPcache e compilação JIT” é grátis?
Sim — o texto completo de “OPcache e compilação JIT” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de PHP Academy, atualize para CoddyKit PRO. O curso de PHP Academy inclui 4 aulas no total.
O que vou aprender em “OPcache e compilação JIT”?
Acelere o PHP com cache de bytecode e JIT. Você pratica PHP Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar PHP Academy?
Nenhuma experiência prévia é necessária. PHP Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “OPcache e compilação JIT”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de PHP Academy?
Sim. Cada aula de PHP Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Como funciona o Zend Engine
- Gerenciamento de memória e coleta de lixo
- OPcache e compilação JIT
- Escrevendo uma extensão PHP básica em C