Come si ottimizza la performance di PHP (OPcache, JIT)?

Question

Accepted Answer

L'ottimizzazione della performance di PHP abbraccia **OPcache** (memorizzazione nella cache del codice compilato — il guadagno più significativo), il compilatore **JIT** (PHP 8), codice efficiente, caching dei dati e ottimizzazione del database. PHP 8.x moderno è drammaticamente più veloce delle versioni precedenti, e la corretta configurazione è importante.

## OPcache — l'ottimizzazione essenziale

```text
Without OPcache: PHP RE-COMPILES every .php file to bytecode on EVERY request (slow!).
With OPcache: compiled bytecode is CACHED in memory → subsequent requests skip
  compilation entirely → often 2-3x faster. ALWAYS enable it in production.
```

```ini
; php.ini — enable and tune OPcache
opcache.enable=1
opcache.memory_consumption=256
opcache.max_accelerated_files=20000
opcache.validate_timestamps=0    ; production: don't check files for changes (fastest)
```

**OPcache** memorizza nella cache il bytecode compilato dei tuoi file PHP in memoria, così PHP non ricompila a ogni richiesta — tipicamente un speedup di 2-3x, ed è l'ottimizzazione di produzione più importante (spesso basta semplicemente abilitarla).

## JIT (Just-In-Time compilation, PHP 8)

```ini
opcache.jit_buffer_size=128M
opcache.jit=tracing
```

```text
The JIT compiles hot code to native machine code at runtime.
✓ Big gains for CPU-INTENSIVE work (math, image processing, computation)
✗ Little benefit for typical I/O-bound web apps (DB/network are the bottleneck, not CPU)
→ Helps specific workloads; not a magic speedup for regular web requests.
```

JIT aiuta i carichi di lavoro CPU-bound ma offre poco per le app web tipiche I/O-bound (dove il database/network domina) — quindi imposta aspettative realistiche.

## Ottimizzazioni a livello di applicazione

```text
✓ The DATABASE is usually the real bottleneck — fix N+1 queries, add indexes, paginate
✓ Cache expensive results (Redis/Memcached); cache rendered output where possible
✓ Optimize Composer autoloading for production: composer dump-autoload -o
✓ Use efficient algorithms/data structures; avoid heavy work in loops
✓ Offload slow tasks to queues (don't block the request)
✓ Use a recent PHP version — each 8.x release brings real performance gains
```

## Misura prima

```text
Use profilers (Xdebug, Blackfire, Tideways) to find the ACTUAL bottleneck.
For most web apps it's the database or external calls, NOT PHP code itself.
```

## Perché è importante

L'ottimizzazione della performance di PHP è una conoscenza preziosa a livello senior, e comprendere i lever principali — soprattutto la disciplina di misurare prima — è importante per costruire applicazioni veloci e scalabili.

L'ottimizzazione più impattante è **OPcache**: poiché PHP altrimenti ricompilarebbe ogni file a ogni richiesta, abilitare OPcache (che memorizza nella cache il bytecode compilato in memoria) tipicamente consegna uno speedup di 2-3x ed è una configurazione di produzione essenziale e non negoziabile spesso trascurata.

Comprendere il compilatore **JIT** (PHP 8) è importante per impostare aspettative realistiche — aiuta i carichi di lavoro CPU-intensivi ma offre poco per le app web tipiche I/O-bound, quindi non è uno speedup universale.

Oltre alla sintonizzazione a livello di PHP, riconoscere che il **database è solitamente il vero collo di bottiglia** (così correggere le query N+1, aggiungere indici e la paginazione consegnano i guadagni più significativi nel mondo reale), insieme al caching dei dati (Redis), all'autoloading ottimizzato e allo scarico del lavoro lento su code, copre il toolkit pratico di ottimizzazione.

La disciplina sovraordinata — **profilare per trovare il vero collo di bottiglia** (solitamente il database o le chiamate esterne, non il codice PHP) piuttosto che indovinare — è ciò che rende l'ottimizzazione efficace.

Anche interessante da sapere: PHP 8.x moderno è drammaticamente più veloce delle versioni precedenti, quindi semplicemente stare al passo aiuta.

Comprendere OPcache (il guadagno essenziale), il ruolo realistico di JIT, l'ottimizzazione focalizzata sul database e la sintonizzazione guidata dalla misurazione è conoscenza importante per mantenere le applicazioni PHP veloci sotto carico reale — una preoccupazione frequente e praticamente significativa per i sistemi di produzione.