Mejoras de Rendimiento en PHP 8.x

; Habilitar JIT en php.ini
; Requiere OPcache habilitado

opcache.enable=1
opcache.jit_buffer_size=100M
opcache.jit=1255

; Modos JIT disponibles:
; 0 = deshabilitado
; 1205 = modo tracing (recomendado para web)
; 1255 = modo tracing agresivo
; 1235 = modo function

<?php

declare(strict_types=1);

// Operaciones matematicas intensivas: GRAN mejora con JIT
function calcularFibonacci(int $n): int
{
    if ($n <= 1) {
        return $n;
    }
    return calcularFibonacci($n - 1) + calcularFibonacci($n - 2);
}

// Procesamiento de imagenes, criptografia, ML: GRAN mejora

// Aplicaciones web tipicas: mejora MODERADA
// La mayoria del tiempo se va en I/O (base de datos, red)

// Verificar si JIT esta habilitado
if (function_exists('opcache_get_status')) {
    $status = opcache_get_status();
    if (isset($status['jit']['enabled'])) {
        echo 'JIT habilitado: ' . ($status['jit']['enabled'] ? 'Si' : 'No');
    }
}

; Configuracion recomendada para produccion
opcache.enable=1
opcache.memory_consumption=256
opcache.interned_strings_buffer=16
opcache.max_accelerated_files=10000

; En produccion: no revalidar archivos
opcache.validate_timestamps=0

; En desarrollo: revalidar cada 2 segundos
; opcache.validate_timestamps=1
; opcache.revalidate_freq=2

<?php

declare(strict_types=1);

// Verificar estado de OPcache
$status = opcache_get_status();

echo 'Memoria usada: ' . $status['memory_usage']['used_memory'];
echo 'Scripts cacheados: ' . $status['opcache_statistics']['num_cached_scripts'];
echo 'Hit rate: ' . $status['opcache_statistics']['opcache_hit_rate'] . '%';

// Limpiar cache (necesario despues de deploy)
opcache_reset();

; En php.ini
opcache.preload=/var/www/app/preload.php
opcache.preload_user=www-data

<?php

// preload.php - Se ejecuta una vez al iniciar PHP-FPM

// Precargar clases frecuentes
$archivos = [
    __DIR__ . '/src/Core/App.php',
    __DIR__ . '/src/Core/Router.php',
    __DIR__ . '/src/Core/Request.php',
    __DIR__ . '/src/Core/Response.php',
];

foreach ($archivos as $archivo) {
    if (file_exists($archivo)) {
        opcache_compile_file($archivo);
    }
}

// O usar el autoloader de Composer
require __DIR__ . '/vendor/autoload.php';

// Precargar clases especificas
$clases = [
    App\Core\App::class,
    App\Core\Router::class,
];

foreach ($clases as $clase) {
    if (class_exists($clase)) {
        // La clase ya esta cargada
    }
}

<?php

declare(strict_types=1);

// 1. Match es mas rapido que switch
// PHP optimiza match a tabla de saltos

$estado = match ($codigo) {
    200 => 'OK',
    404 => 'Not Found',
    500 => 'Server Error',
    default => 'Unknown',
};

// 2. Named arguments: sin penalizacion
// El compilador optimiza a llamadas posicionales

function crearUsuario(string $nombre, string $email, bool $activo = true): array
{
    return compact('nombre', 'email', 'activo');
}

// Esto se optimiza internamente
$user = crearUsuario(nombre: 'Ana', email: 'ana@example.com');

// 3. Nullsafe operator: optimizado
// Evita multiples comprobaciones

$ciudad = $usuario?->direccion?->ciudad;

// 4. Constructor promotion: mismo rendimiento
// Solo azucar sintactico, sin overhead

class Producto
{
    public function __construct(
        public readonly string $nombre,
        public readonly float $precio,
    ) {}
}

<?php

declare(strict_types=1);

// Con tipos: PHP sabe exactamente que esperar
function calcular(int $a, int $b): int
{
    return $a + $b;
}

// Sin tipos: PHP debe inferir y posiblemente convertir
function calcularSinTipos($a, $b)
{
    return $a + $b; // ¿Son numeros? ¿Strings? PHP debe verificar
}

// Union types (PHP 8.0): eficientes
function procesar(int|float $valor): float
{
    return $valor * 1.5;
}

// Intersection types (PHP 8.1): validacion en compilacion
interface Serializable {}
interface Jsonable {}

function exportar(Serializable&Jsonable $objeto): string
{
    // PHP verifica tipos en compilacion, no en runtime
    return '';
}

<?php

declare(strict_types=1);

// Spread operator: optimizado para arrays grandes
$base = [1, 2, 3];
$extendido = [...$base, 4, 5, 6];

// array_is_list: O(1) en muchos casos
// PHP trackea internamente si un array es lista
$lista = [1, 2, 3];
$esLista = array_is_list($lista); // Muy rapido

// Unpacking con claves string (PHP 8.1)
$defaults = ['color' => 'azul', 'size' => 'M'];
$custom = ['color' => 'rojo'];
$merged = [...$defaults, ...$custom]; // ['color' => 'rojo', 'size' => 'M']

<?php

declare(strict_types=1);

// 1. Usa readonly para inmutabilidad
// PHP puede optimizar mejor datos que no cambian
readonly class Config
{
    public function __construct(
        public string $appName,
        public string $environment,
    ) {}
}

// 2. Prefiere funciones nativas sobre regex simple
$texto = 'Hola mundo';

// Lento
if (preg_match('/mundo/', $texto)) {}

// Rapido
if (str_contains($texto, 'mundo')) {}

// 3. Evita crear objetos innecesarios en bucles
// Malo
foreach ($items as $item) {
    $formatter = new Formatter(); // Objeto nuevo cada iteracion
    echo $formatter->format($item);
}

// Mejor
$formatter = new Formatter();
foreach ($items as $item) {
    echo $formatter->format($item);
}

// 4. Usa generators para grandes conjuntos de datos
function leerArchivo(string $path): Generator
{
    $handle = fopen($path, 'r');
    while (($linea = fgets($handle)) !== false) {
        yield trim($linea);
    }
    fclose($handle);
}

// Procesa linea por linea, sin cargar todo en memoria
foreach (leerArchivo('datos.txt') as $linea) {
    procesar($linea);
}

<?php

declare(strict_types=1);

// Medir tiempo de ejecucion
$inicio = hrtime(true);

// ... codigo a medir ...

$fin = hrtime(true);
$nanosegundos = $fin - $inicio;
$milisegundos = $nanosegundos / 1e6;

echo "Tiempo: {$milisegundos}ms";

// Medir memoria
$memoriaInicial = memory_get_usage();

// ... codigo a medir ...

$memoriaFinal = memory_get_usage();
$diferencia = $memoriaFinal - $memoriaInicial;

echo "Memoria usada: " . ($diferencia / 1024) . " KB";

// Pico de memoria
echo "Pico: " . (memory_get_peak_usage() / 1024 / 1024) . " MB";

// Reiniciar pico (PHP 8.2)
memory_reset_peak_usage();

// Funcion simple de benchmark
function benchmark(callable $fn, int $iteraciones = 1000): float
{
    $inicio = hrtime(true);

    for ($i = 0; $i < $iteraciones; $i++) {
        $fn();
    }

    $fin = hrtime(true);
    return ($fin - $inicio) / 1e6 / $iteraciones;
}

$tiempoPromedio = benchmark(fn () => str_contains('texto', 'ext'));
echo "Promedio: {$tiempoPromedio}ms";