PHP 8.5: OPcache, JIT y profiling, todo medido

OPcache frenó la CLI pero aceleró 35× las peticiones al servidor; el JIT dio 4.5× en cálculo y 8 % con strings. Y una concatenación 900× más lenta.

Serie: curso de PHP 6/6 (avanzado). Esta clase es para quien ya tiene código PHP que funciona y ahora quiere saber en qué se va el tiempo y la memoria: el freelancer cuyo cliente se queja de que "el panel tarda", el desarrollador de una startup al que le toca optimizar el job nocturno que importa un CSV gigante, o quien se prepara para una entrevista técnica y quiere hablar de OPcache con datos y no con mitos. Al terminar vas a poder activar OPcache y el JIT donde ayudan (y saber dónde no), medir con hrtime sin instalar un profiler, leer los opcodes que PHP ejecuta de verdad y detectar el puñado de patrones en bucles que cuestan 100× más de lo que deberían.

Si una página o un proceso batch en PHP está "lento" y la primera sugerencia que escuchas es "activa el JIT", esta clase es para ti. En nuestras mediciones el JIT dio 4.5× en aritmética pura y un 8 % en trabajo web típico, mientras que reescribir una sola línea que armaba un string dio casi 900×. Cada número de abajo se midió en la máquina descrita a continuación; cuando una medición nos engañó (un benchmark que corrió sin OPcache porque el archivo era demasiado nuevo), la dejamos.

Entorno: PHP 8.5.6 CLI (NTS) con Zend OPcache, Mac con Apple Silicon (M1 Pro), macOS, memory_limit=128M. No hay xdebug, SPX, xhprof ni Blackfire instalados, y esta clase no instala nada: todos los tiempos usan hrtime(). Las medianas se dan con el número de ejecuciones. Las rutas en la salida se acortaron a ~/demo/.

Profiling sin extensiones: hrtime y comprobar qué estás midiendo

hrtime(true) devuelve un contador monotónico de nanosegundos como entero. A diferencia de microtime(true), nunca salta cuando se ajusta el reloj del sistema y no tiene redondeo de float. Este helper ejecutó todos los benchmarks dentro del proceso en esta clase:

<?php
// one warm-up call, then the median of 5 rounds
function bench(string $name, callable $fn, int $rounds = 5): void {
    $fn();                                            // warm-up round, discarded
    $t = [];
    for ($r = 0; $r < $rounds; $r++) { $s = hrtime(true); $res = $fn(); $t[] = (hrtime(true) - $s) / 1e6; }
    sort($t);
    printf("%-34s %8.2f ms   (%s)\n", $name, $t[intdiv($rounds, 2)], is_scalar($res) ? $res : count($res));
}

También imprime el resultado: si dos variantes devuelven valores distintos, estás comparando trabajos distintos. Un profiler de verdad (el profiler de xdebug, SPX, Blackfire) te muestra qué función es lenta sin que tengas que adivinar. Aquí no hay ninguno instalado, así que el método es: mide una petición completa y luego acota con hrtime alrededor de los sospechosos, como en una búsqueda binaria.

PHP también trae una forma de ver lo que realmente ejecuta. opcache.opt_debug_level vuelca los opcodes antes (0x10000) y después (0x20000) del optimizador:

function f(array $a): int {
    $n = 0;
    for ($i = 0; $i < count($a); $i++) $n += strlen("hello") * 2;
    return $n;
}
$ php -d opcache.enable_cli=1 -d opcache.opt_debug_level=0x20000 ops.php
f:
     ; (after optimizer)
0004 CV1($n) = ADD CV1($n) int(10)
0005 PRE_INC CV2($i)
0006 T4 = COUNT CV0($a)
0007 T3 = IS_SMALLER CV2($i) T4
0008 JMPNZ T3 0004

strlen("hello") * 2 ya se había convertido en la constante int(10) en el volcado anterior al optimizador: el compilador la pliega (constant folding). Un benchmark de "qué tan rápido es strlen" escrito así mide una suma. Y count() no es una llamada a función, sino un único opcode COUNT, lo que importa en la sección siguiente.

OPcache en la CLI vs en un servidor

OPcache guarda los opcodes compilados en memoria compartida para que la siguiente petición se salte el parseo y la compilación. En la CLI está apagado por defecto (opcache.enable_cli => Off), y es a propósito. Generamos un archivo de 437 KB con 2000 clases pequeñas y medimos 20 procesos php nuevos (después de una ejecución descartada) por configuración:

empty script                 median   56.1 ms
opcache.enable_cli=0         median   64.7 ms   last line: M1999-05998 loaded 2000 classes in 7.78 ms
opcache.enable_cli=1         median   75.7 ms   last line: M1999-05998 loaded 2000 classes in 17.49 ms
enable_cli=1 + file_cache    median   58.3 ms   last line: M1999-05998 loaded 2000 classes in 1.74 ms

Las otras dos series de 20 ejecuciones dieron 63.9/75.3/58.2 y 64.3/74.5/58.2 ms. Con enable_cli=1 la CLI se volvió más lenta: cada proceso ejecuta el optimizador, llena una caché y termina, así que nunca se reutiliza nada. opcache.file_cache=<dir> con opcache.file_cache_only=1 escribe el código compilado en disco, y los procesos siguientes cargaron las 2000 clases en 1.74 ms en lugar de 7.78 ms. Fíjate en el piso de 56 ms: arrancar este build de PHP, con 67 extensiones cargadas, cuesta más que todo nuestro script.

Un servidor es el caso opuesto. El servidor integrado es un único proceso de larga vida, y opcache.enable se aplica a él. 300 peticiones secuenciales con ext/curl, descartando la primera:

Servidor integrado Mediana p95 Tiempo de carga dentro del script
opcache.enable=0 6.79 ms (6.95 en una 2.ª ejecución) 7.43 ms 6.31 ms
opcache.enable=1 0.18 ms (0.20) 0.26 ms 0.01 ms

opcache_get_status() después: hits=1198 misses=3 cached_scripts=3. Unas 35× por petición, casi todo tiempo de compilación. PHP-FPM y el mod_php de Apache se comportan como la segunda fila, y por eso OPcache simplemente debe estar encendido en producción.

El JIT: un benchmark limitado por CPU

Desde PHP 8.0, OPcache incluye un compilador JIT que convierte los opcodes más usados en código máquina. En 8.5 está apagado por defecto (opcache.jit => disable, opcache.jit_buffer_size => 64M). La prueba es un Mandelbrot de 600×600 con un máximo de 200 iteraciones por píxel: aritmética de punto flotante pura en bucles de PHP.

<?php
// mandel.php — CPU-bound: 600x600 Mandelbrot, 200 iterations max. Prints a checksum.
declare(strict_types=1);
function mandel(int $w, int $h, int $maxIter): int {
    $inside = 0;
    for ($y = 0; $y < $h; $y++) {
        $ci = 2.0 * $y / $h - 1.0;
        for ($x = 0; $x < $w; $x++) {
            $cr = 3.0 * $x / $w - 2.0;
            $zr = 0.0; $zi = 0.0; $i = 0;
            while ($i < $maxIter && $zr * $zr + $zi * $zi < 4.0) {
                $t = $zr * $zr - $zi * $zi + $cr;
                $zi = 2.0 * $zr * $zi + $ci;
                $zr = $t;
                $i++;
            }
            if ($i === $maxIter) $inside++;
        }
    }
    return $inside;
}
$t = hrtime(true);
$r = mandel(600, 600, 200);
printf("mandel %d  %.1f ms\n", $r, (hrtime(true) - $t) / 1e6);

Cinco procesos nuevos por configuración, cronómetro dentro del script; todas las ejecuciones imprimieron el mismo checksum 91677:

Flags Mediana Mín–máx
opcache.enable_cli=0 524.7 ms 524.4–525.5
enable_cli=1, jit=disable 334.4 ms 333.6–338.7
jit=tracing, jit_buffer_size=0 333.2 ms 332.8–333.8
jit=tracing, buffer 64M 75.0 ms 74.6–76.4
jit=function, buffer 64M 74.1 ms 73.9–74.9
Gráfico de barras. Sin OPcache el Mandelbrot tardó 524,7 milisegundos. Con OPcache pero sin JIT tardó 334,4 milisegundos, porque el optimizador igual se ejecuta. Con el JIT tracing tardó 75,0 milisegundos y con el JIT function 74,1 milisegundos, unas 4,5 veces más rápido que OPcache solo. Con opcache.jit=tracing pero un buffer de JIT de 0 tardó 333,2 milisegundos, lo mismo que sin JIT.
Un Mandelbrot de 600×600 (máximo 200 iteraciones) en PHP 8.5.6 CLI, mediana de 5 procesos nuevos, Mac con Apple Silicon (M1 Pro). Menos es mejor.

Tres hallazgos. OPcache solo ya hizo el bucle 1.6× más rápido, porque su optimizador infiere tipos y usa opcodes especializados. El JIT sumó otras 4.5×. Y jit=tracing con un buffer de cero no hizo nada, en silencio. opcache_get_status(false)['jit'] te dice la verdad:

-d opcache.jit=tracing                              → opcache_get_status: false
-d opcache.enable_cli=1 -d opcache.jit=tracing      → jit enabled=true on=true kind=5 buffer=67108848
... -d opcache.jit_buffer_size=0                    → jit enabled=false on=false kind=5 buffer=0
-d opcache.enable_cli=1 -d opcache.jit=bogus
PHP Warning:  Invalid "opcache.jit" setting. Should be "disable", "on", "off", "tracing", "function" or 4-digit number in Unknown on line 0

Sin enable_cli=1, la configuración del JIT no tiene ningún efecto en la CLI, y solo un typo produce un warning. El JIT tracing y el function empataron con esta única función caliente; tracing suele ganar cuando las rutas calientes atraviesan varias funciones.

El JIT con trabajo de strings y arrays

La mayor parte del tiempo de PHP se va en armar arrays, llamar a json_encode, ordenar y usar funciones de strings, y todo eso corre como código C dentro de PHP, con o sin JIT:

<?php
// strwork.php — "web-ish" work: build rows, json_encode, explode, str_replace, sort.
declare(strict_types=1);
mt_srand(42);
$t = hrtime(true);
$total = 0;
for ($round = 0; $round < 40; $round++) {
    $rows = [];
    for ($i = 0; $i < 5000; $i++) {
        $rows[] = ['id' => $i, 'name' => 'user_' . mt_rand(1, 99999), 'tags' => 'a,b,c,' . ($i % 7)];
    }
    $json = json_encode($rows);
    $back = json_decode($json, true);
    usort($back, fn($a, $b) => strcmp($a['name'], $b['name']));
    foreach ($back as $r) {
        $total += count(explode(',', $r['tags'])) + strlen(str_replace('user_', 'u:', $r['name']));
    }
}
printf("strwork %d  %.1f ms\n", $total, (hrtime(true) - $t) / 1e6);
Flags Mediana de 5 Mín–máx
sin OPcache 261.5 ms 254.1–267.6
OPcache, JIT apagado 261.2 ms 260.2–267.5
JIT tracing 240.2 ms 234.9–245.0
JIT function 244.7 ms 241.0–258.0

Cerca de un 8 %, y los rangos mín–máx casi se tocan. Una página típica que consulta una base de datos y renderiza una plantilla va a ver menos, porque esperar E/S no se acelera en absoluto. Vale la pena activar el JIT para procesamiento de imágenes, cálculo matemático o parsers escritos en PHP; para una app CRUD, OPcache es la ganancia y el JIT es ruido.

Memoria: arrays vs generadores con 1 millón de elementos

memory_get_peak_usage() después de sumar un millón de enteros, cada modo en un proceso nuevo, medido respecto del uso antes del bucle:

function numbers(int $n): Generator { for ($i = 0; $i < $n; $i++) yield $i; }
// 'array': $a = range(0, $n - 1); foreach ($a as $v) $sum += $v;
// 'gen':   foreach (numbers($n) as $v) $sum += $v;
1,000,000 de elementos Aumento del pico Tiempo
array de ints con range() 16.0 MB 7 ms
generador (yield) 0.0 MB 22 ms
claves string ["k$i" => $i] 76.0 MB 66 ms
strings ["row-$i", …] 54.2 MB 45 ms
filas [['id' => $i, 'v' => …], …] Fatal con 128M; 374.6 MB con 1G 185 ms

Un array empaquetado de enteros cuesta 16 bytes por elemento; un generador guarda un solo valor a la vez pero aquí fue 3× más lento, porque cada yield reanuda una función. Las claves string agregan una tabla hash y un string por clave. El caso de una fila por array es lo que construye una consulta de "traer todas las filas", y con el límite por defecto murió:

PHP Fatal error:  Allowed memory size of 134217728 bytes exhausted (tried to allocate 20480 bytes) in ~/demo/mem.php on line 13

Los generadores son la herramienta para procesar entradas grandes como flujo (un CSV, un cursor sobre PDOStatement::fetch()), donde convierten "sin memoria" en "memoria constante". Para arrays pequeños que ya entran en memoria, un array es más rápido.

Patrones lentos comunes, medidos

slow.php ejecutó cada patrón con el helper bench(), mediana de 5 después de un calentamiento, primero sin OPcache (el valor por defecto de la CLI) y luego con OPcache y el JIT tracing:

Patrón Sin OPcache OPcache + JIT
for con count($data) en la condición, 1M 7.55 ms 1.13 ms
count() sacado a una variable 6.54 ms 1.02 ms
foreach 5.24 ms 1.89 ms
$s .= $piece, 200k piezas 8.96 ms 8.33 ms
$s = $s . $piece, 200k piezas 7961 ms 7619 ms
$s = $piece . $s, 20k piezas 66.70 ms 95.60 ms
implode() de un array, 200k 9.85 ms 9.96 ms
in_array 10k agujas en 10k strings 232.51 ms 224.93 ms
array_flip una vez + isset 10k veces 0.37 ms 0.26 ms
in_array, una sola búsqueda 0.04 ms 0.04 ms
array_flip + isset, una sola búsqueda 0.08 ms 0.09 ms
$all = array_merge($all, $chunk), 2k × 50 227.13 ms 224.18 ms
array_push($all, ...$chunk) 1.06 ms 1.10 ms
juntar los chunks, un solo array_merge(...$parts) 0.46 ms 0.46 ms

count() en la condición del bucle es el consejo de rendimiento más repetido y el menos importante aquí: 1 ms en un millón de iteraciones, porque count() es un opcode O(1) (el volcado de arriba). Sácalo a una variable por legibilidad si quieres. Con el JIT, foreach fue el más lento de los tres, un recordatorio de que el folclore de PHP 5 no sobrevive a una medición.

La concatenación de strings es donde está la trampa de verdad.

Error típico: $s = $s . $x en un bucle

El error: escribir la forma larga de agregar al final, a menudo cuando la línea también hace otra cosa, como $html = $html . render($row);.

Lo que pasa en realidad: cada iteración crea un string nuevo y copia todo lo construido hasta ese momento. 200,000 piezas tardaron 7961 ms en lugar de 8.96 ms, casi 900×, y crece con el cuadrado del tamaño:

n= 25000  s=s.x     91.6 ms   s.=x  1.00 ms
n= 50000  s=s.x    296.6 ms   s.=x  2.06 ms
n=100000  s=s.x   1141.0 ms   s.=x  4.10 ms

Duplicar n lo hizo 3.2–3.8× más lento; .= creció de forma lineal, porque PHP puede extender el string en su lugar cuando tiene la única referencia. Anteponer ($s = $piece . $s) también es cuadrático. El JIT no ayudó (7619 ms).

La solución: .=, o juntar las piezas en un array y llamar a implode() una vez. Ambas tardaron unos 9 ms.

Gráfico de barras. Agregar con .= tardó 8,96 milisegundos e implode de un array 9,85 milisegundos, pero escribir s igual a s punto pieza tardó 7961 milisegundos, casi 900 veces más lento, porque cada paso copia el string completo.
Armar el mismo string de 2,3 MB con 200.000 piezas, mediana de 5 rondas tras un calentamiento, PHP 8.5.6 CLI sin OPcache. El JIT no cambió la fila lenta (7619 ms).

in_array vs isset sobre un array invertido. in_array recorre el array, así que 10,000 búsquedas en 10,000 elementos son 100 millones de comparaciones en el peor caso: 232 ms. Invertirlo una vez convierte los valores en claves de una tabla hash, y cada isset es una sola búsqueda hash: 0.37 ms, 628× más rápido. Pero para una única búsqueda, invertir cuesta más de lo que ahorra (0.08 contra 0.04 ms). Invierte cuando vas a buscar muchas veces en el mismo array.

array_merge en un bucle copia el array creciente cada vez, con la misma forma cuadrática: 227 ms contra 0.46 ms si juntas los chunks y fusionas una sola vez.

Microbenchmarks que engañan (uno nos engañó a nosotros)

Para mostrar el calentamiento del JIT escribimos un archivo pequeño que llama seis veces a mandel(150, 150, 200), lo creamos y lo ejecutamos de inmediato con opcache.jit=tracing:

call 1: 33.38 ms
call 2: 32.96 ms
...
call 6: 33.82 ms

Idéntico a tener el JIT apagado. El buffer del JIT había crecido apenas 1 KB. La causa era opcache.file_update_protection => 2: OPcache se niega a cachear un archivo modificado en los últimos 2 segundos (para no cachear un archivo escrito a medias), y sin caché no hay JIT. Dos segundos después, el mismo comando:

call 1: 5.16 ms
call 2: 4.72 ms
call 6: 4.70 ms

Un script de benchmark generado y ejecutado al instante, o editado y vuelto a ejecutar dentro de los 2 segundos, mide PHP sin OPcache. Otras trampas de esta clase:

  • Los valores por defecto de la CLI no son producción. Sin OPcache el bucle con count() tardó 7.55 ms; con OPcache, 1.13 ms. Mide con la misma configuración de OPcache que tu servidor.
  • Constant folding. strlen("hello") dentro de un bucle se compila a 10. Alimenta los benchmarks con valores que el compilador no pueda conocer.
  • Demasiado pequeño para importar. 0.04 contra 0.08 ms para una búsqueda es real pero irrelevante; el caso de 232 contra 0.37 ms es el que importa.
  • El arranque del proceso domina. El script vacío tardó 56 ms; una optimización de 5 ms en una herramienta de CLI es invisible al lado de eso.
  • Ruido. strwork varió entre 254 y 268 ms en ejecuciones idénticas; las diferencias de menos de un 5 % necesitan muchas más ejecuciones.

Tabla de decisión

Diagrama de decisión. Empieza midiendo con hrtime. Si la parte lenta repite una búsqueda, una copia o una fusión dentro de un bucle, corrige el algoritmo, lo que dio entre 500 y 900 veces en nuestras pruebas. Si el servidor vuelve a leer muchos archivos PHP por petición, activa OPcache, que bajó una petición de 6,8 a 0,2 milisegundos. Si el trabajo es aritmética pura en bucles de PHP, prueba el JIT, que dio 4,5 veces. Si no, el tiempo está en funciones escritas en C o en E/S, y el JIT ganó apenas un 8 por ciento.
Qué perilla probar primero, según las mediciones de esta clase. Corrige el algoritmo antes de tocar php.ini.
Situación Haz esto Evidencia
Cualquier servidor web (FPM, mod_php, LiteSpeed) opcache.enable=1 6.79 → 0.18 ms por petición
Scripts de CLI de una sola ejecución, cron deja enable_cli=0, o agrega opcache.file_cache 64.7 vs 75.7 vs 58.3 ms
Aritmética pura en bucles de PHP opcache.jit=tracing (buffer > 0) 334 → 75 ms
JSON, strings, arrays, base de datos sáltate el JIT, corrige los algoritmos 261 → 240 ms
Armar strings .= o implode 8.96 ms vs 7961 ms
Muchas pruebas de pertenencia array_flip una vez, luego isset 232 → 0.37 ms
Entradas grandes generadores 0 MB vs un error fatal
¿Está encendido el JIT? revisa opcache_get_status()['jit']['on'] el buffer 0 lo desactivó en silencio

Límites honestos y notas de versión

  • Medido solo en PHP 8.5.6, en una única máquina con Apple Silicon. Las ganancias del JIT en servidores Linux x86-64 van a ser distintas. No ejecutamos versiones anteriores. Según los changelogs de PHP: el JIT se agregó en 8.0; en 8.4 los valores por defecto cambiaron a opcache.jit=disable con jit_buffer_size=64M (antes era jit=tracing con un buffer de 0, que también significaba apagado).
  • No usamos ninguna extensión de profiling. xdebug, SPX, xhprof y Blackfire mostrarían el costo por función; hrtime solo puede medir lo que envuelves. En un hosting compartido muchas veces tampoco puedes instalarlas, y por eso vale la pena conocer este método.
  • La prueba de servidor usó el servidor integrado de PHP, de un solo hilo, con peticiones secuenciales, no carga concurrente. Muestra el costo de compilación que elimina OPcache, no el throughput.
  • memory_get_peak_usage() solo cuenta el allocator propio de PHP. La memoria que toman las bibliotecas (argon2 en la clase 5, bibliotecas de imágenes, el motor de SQLite) no aparece ahí.

Ejercicio

1. Esta función devuelve los IDs de los usuarios activos. Con 30,000 usuarios y 10,000 direcciones activas tardó 1213 ms en nuestra prueba. Sin cambiar su salida, hazla rápida, y explica cómo demostrarías que el resultado es el mismo.

function activeIds(array $users, array $activeEmails): array {
    $out = [];
    foreach ($users as $u) {
        if (in_array($u['email'], $activeEmails, true)) $out = array_merge($out, [$u['id']]);
    }
    return $out;
}

Respuestas

Hay dos patrones cuadráticos: in_array dentro del bucle, y array_merge, que copia $out en cada coincidencia.

function activeIds(array $users, array $activeEmails): array {
    $active = array_flip($activeEmails);      // once: values become keys
    $out = [];
    foreach ($users as $u) {
        if (isset($active[$u['email']])) $out[] = $u['id'];
    }
    return $out;
}

Una diferencia que hay que revisar: in_array(..., true) compara de forma estricta, mientras que las claves de array convierten strings numéricos como "123" en enteros. Con direcciones de email eso no puede pasar. Para demostrar la igualdad, ejecuta ambas versiones sobre la misma entrada con semilla fija (mt_srand(42)) y compara con ===. Nuestra ejecución: slow 1212.8 ms, fast 2.49 ms, 4625 ids, identical: true, unas 490× más rápido.

Esta es la última clase de PHP. La clase 5 cubrió el lado de seguridad del mismo código.

Lo que sigue

Preguntas frecuentes

¿Activar OPcache en la CLI de PHP hace más rápidos los scripts?

No para scripts que se ejecutan una sola vez. Con opcache.enable_cli=1, nuestro script que carga 2000 clases tardó 74.5–75.7 ms por ejecución en lugar de 63.9–64.7 ms (tres series de 20 ejecuciones), porque la caché se construye y se tira en cada proceso. Agregar opcache.file_cache lo bajó a 58.2 ms. En el servidor integrado, que es un único proceso de larga vida, OPcache bajó una petición de 6.79 ms a 0.18 ms.

¿Cuánto más rápido es PHP 8.5 con el JIT?

Depende del trabajo. Un Mandelbrot limitado por CPU pasó de 334.4 ms (OPcache, JIT apagado) a 75.0 ms con opcache.jit=tracing, unas 4.5×. Una carga de json_encode, usort, explode y str_replace pasó de 261.2 ms a 240.2 ms, cerca de un 8 %, porque el tiempo se gasta dentro de funciones escritas en C.

¿$s = $s . $x es más lento que $s .= $x en PHP?

Sí, muchísimo dentro de un bucle. Armar un string de 2.3 MB a partir de 200,000 piezas tardó 8.96 ms con .= y 7961 ms con $s = $s . $x en PHP 8.5, porque la segunda forma copia el string completo cada vez. El JIT no lo arregló.

  • #php
  • #php-8.5
  • #rendimiento
  • #opcache
  • #jit
  • #profiling
  • #generadores
  • #memoria
  • #avanzado

t.laboratory

A technical blog that records real problems from the apps, servers and services we build and run — and the code that fixed them.

Acerca de · Apps

↑