0Pricing
PHP Academy · Leçon

OPcache et compilation JIT

Accélérez PHP grâce à la mise en cache du bytecode et au JIT.

OPcache et compilation JIT est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.

Mise en cache de la compilation

OPcache stocke les codes opérationnels compilés dans la mémoire partagée afin que PHP évite l'analyse lexicale, l'analyse syntaxique et la compilation à chaque requête. Par-dessus, le JIT (depuis PHP 8.0) compile les codes opérationnels très sollicités en code machine natif. Ensemble, ils constituent le socle des performances de PHP.

Cette leçon explique la configuration d'OPcache, le préchargement et le réglage du JIT.

Ce que fait OPcache

Le op_array compilé de chaque fichier est mis en cache dans un segment de mémoire partagée utilisé par tous les processus FPM. Une requête qui trouve l'élément dans le cache réutilise directement les codes opérationnels. OPcache exécute également un optimiseur (évaluation des constantes, élimination du code mort, fusion de codes opérationnels) lors de la première compilation d'un fichier.

; 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 scripts

Validation des dates de modification

validate_timestamps détermine si OPcache vérifie de nouveau les dates de modification des fichiers. En développement, laissez cette option activée avec une courte valeur de revalidate_freq ; en production, définissez-la à 0 afin que PHP ne consulte jamais les dates des fichiers, puis déployez en vidant le cache (ou en reconstruisant l'image).

; Production: never re-stat files
opcache.validate_timestamps = 0

; Development: check every 2 seconds
; opcache.validate_timestamps = 1
; opcache.revalidate_freq = 2

Inspecter le cache

opcache_get_status() indique le taux de réussite, l'utilisation de la mémoire et les scripts mis en cache ; opcache_get_configuration() affiche les paramètres. Un faible taux de réussite ou des redémarrages fréquents indiquent un manque de mémoire ou un trop grand nombre de fichiers.

<?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échargement

Le préchargement (PHP 7.4 et versions ultérieures) compile un ensemble de classes et de fonctions une seule fois au démarrage du serveur et les conserve en permanence en mémoire, à la disposition de chaque requête sans chargement automatique ni liaison par requête. Indiquez dans opcache.preload un script qui charge les fichiers nécessaires pour les préchauffer.

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

Écrire un script de préchargement

Le script de préchargement s'exécute dans le processus maître. Utilisez opcache_compile_file() pour charger des classes sans les exécuter, ou utilisez simplement require. Les cadres applicatifs génèrent une liste de préchargement ; en voici la structure.

<?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());
    }
}
?>

Place au JIT

Même lorsque les codes opérationnels sont mis en cache, la VM les interprète toujours. Le JIT compile les séquences de codes opérationnels très sollicitées en instructions natives du CPU, supprimant le coût de distribution de la VM. Le gain est important pour le code numérique limité par le processeur, mais modeste pour les applications web classiques limitées par les entrées-sorties (qui passent leur temps dans la base de données ou le réseau, et non dans le processeur).

Configurer le JIT

Le JIT fonctionne au sein d'OPcache, qui doit donc être activé. opcache.jit_buffer_size alloue l'espace destiné au code machine généré (0 désactive le JIT). opcache.jit est un mode à quatre chiffres qui contrôle le déclenchement et la stratégie d'optimisation.

; 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 level

JIT par traçage ou JIT de fonctions

Deux stratégies existent : le JIT de fonctions (mode 1205) compile les fonctions entières lors du premier appel ; le JIT par traçage (1254, l'alias tracing par défaut) profile l'exécution et compile les boucles et chemins très sollicités, ce qui donne souvent de meilleurs résultats parce qu'il se spécialise en fonction des types observés. Le traçage est la valeur par défaut recommandée.

; 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 = 0

Mesurer l'effet du JIT

Le JIT excelle dans les boucles numériques intensives. Ce test de performance autonome (une boucle interne de type Mandelbrot) représente le genre de charge limitée par le processeur pour laquelle le JIT peut réduire considérablement le temps d'exécution ; exécutez-le avec et sans jit_buffer_size pour comparer.

<?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);
?>

Quand NOT s'attendre à des gains

Pour une requête classique qui interroge une base de données, effectue le rendu d'un modèle et renvoie du JSON, le processeur réalise peu de calculs arithmétiques bruts : le JIT peut apporter quelques pourcents de gain, voire aucun. Donnez d'abord la priorité à OPcache, au préchargement et à une bonne utilisation de la base de données et du cache. Réservez le réglage du JIT au traitement d'images, aux calculs mathématiques, aux analyseurs et aux autres codes très gourmands en calcul.

Vérification rapide

Qu'est-ce que le préchargement vous apporte que la mise en cache ordinaire d'OPcache ne vous apporte pas ?

Récapitulatif

OPcache met en cache les tableaux de codes opérationnels compilés dans la mémoire partagée et exécute un optimiseur ; définissez validate_timestamps=0 en production et dimensionnez correctement memory_consumption/max_accelerated_files. Le préchargement conserve les classes choisies en mémoire dès le démarrage. Le JIT (intégré à OPcache, il nécessite jit_buffer_size) compile le code très sollicité en instructions natives : les gains sont importants pour les calculs limités par le processeur, mais faibles pour les applications web limitées par les entrées-sorties. Utilisez opcache_get_status() pour vérifier la configuration.

Questions Fréquemment Posées

La leçon « OPcache et compilation JIT » est-elle gratuite ?

Oui — le texte complet de « OPcache et compilation JIT » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « OPcache et compilation JIT » ?

Accélérez PHP grâce à la mise en cache du bytecode et au JIT. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PHP Academy ?

Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « OPcache et compilation JIT » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?

Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Fonctionnement du moteur Zend
  2. Gestion de la mémoire et récupération des déchets
  3. OPcache et compilation JIT
  4. Écrire une extension PHP de base en C
← Retour à PHP Academy