Configuration à l'exécution

Le comportement de ces fonctions est affecté par la configuration dans le fichier php.ini.

Voici un éclaircissement sur l'utilisation des directives de configuration.

opcache.enable bool

Active le cache d'opcode. Lorsqu'il est désactivé, le code n'est ni optimisé, ni mis en cache. Le paramétrage de opcache.enable ne peut être activé pendant l'exécution via la fonction ini_set(), il ne peut être que désactivé. Tenter de l'activer dans un script va générer une alerte.

opcache.enable_cli bool

Active le cache d'opcode pour la version CLI de PHP.

opcache.memory_consumption int

La taille de la mémoire partagée utilisée par OPcache, en mégaoctets. La valeur minimale permissible est "8", qui est forcé si une valeur plus petite est définie.

opcache.interned_strings_buffer int

La quantité de mémoire utilisée pour stocker des chaînes internes, en mégaoctets. La valeur maximale est de 32767 sur les architectures 64 bits, et de 4095 sur les architectures 32 bits.

Note: Avant PHP 8.4.0, la valeur maximale était de 4095 mégaoctets sur toutes les architectures.

opcache.max_accelerated_files int

Le nombre maximal de clés (et donc, de scripts) dans la table de hachage d'OPcache. La valeur actuellement utilisée sera le premier nombre du jeu des nombres premiers { 223, 463, 983, 1979, 3907, 7963, 16229, 32531, 65407, 130987, 262237, 524521, 1048793 } qui est plus grand ou égal que la valeur configurée. La valeur minimale est 200. La valeur maximale est 100000 dans PHP < 5.5.6, et 1000000 dans les versions ultérieures. Les valeurs hors de cet intervalle sont fixées à l'intervalle autorisé.

opcache.max_wasted_percentage int

Le pourcentage maximum de mémoire gaspillée autorisée avant qu'un redémarrage ne soit programmé, s'il n'y a pas assez de mémoire disponible. La valeur maximale permissible est "50", qui est forcé si une valeur plus grande est définie.

opcache.use_cwd bool

Si activé, OPcache ajoute le dossier de travail courant à la clé du script, éliminant ainsi les collisions possibles entre les fichiers dont le nom de base est identique. Le fait de désactiver cette fonctionnalité améliore les performances, mais peut casser les applications existantes.

opcache.validate_timestamps bool

Si activé, OPcache va vérifier les mises à jour des scripts toutes les opcache.revalidate_freq secondes. Lorsque cette directive est désactivée, il faut réinitialiser OPcache manuellement via la fonction opcache_reset(), la fonction opcache_invalidate() ou en redémarrant le serveur Web pour que les modifications du système de fichiers prennent effet.

Note: OPcache peut toujours valider l'horodatage d'un fichier lors de la compilation si les options opcache.file_update_protection ou opcache.max_file_size sont définies sur des valeurs non nulles.

opcache.revalidate_freq int

La fréquence de vérification du timestamp du script afin de détecter les possibles mises à jour, en secondes. La valeur 0 fera qu'OPcache vérifiera les mises à jour à chaque requête. Cette directive de configuration est ignorée si opcache.validate_timestamps est désactivé.

opcache.revalidate_path bool

Si désactivé, les fichiers en cache existant utilisant le même include_path seront réutilisés. Aussi, si un fichier avec le même nom est quelque part ailleurs dans le include_path, il ne sera pas trouvé.

opcache.save_comments bool

Si désactivé, tous les commentaires de documentation seront supprimés du cache opcode afin de réduire la taille du code optimisé. La désactivation de cette directive peut casser des applications et des frameworks qui s'appuient sur l'analyse des commentaires pour les annotations, comme Doctrine, Zend Framework 2 et PHPUnit.

opcache.fast_shutdown bool

Si activé, une séquence d'arrêt rapide sera utilisée, qui ne libère pas chaque bloc alloué, mais s'appuie sur le gestionnaire de mémoire Zend Engine pour désallouer le jeu entier des variables de requêtes, en masse. Cette directive a été supprimée dans PHP 7.2.0. Une variante de la séquence d'arrêt rapide a été intégrée dans PHP et sera automatiquement utilisée si possible.

opcache.enable_file_override bool

Lorsqu'activé, le cache opcode sera vérifié pour savoir si un fichier a déjà été mis en cache lorsque les fonctions file_exists(), is_file() et is_readable() sont appelées. Ceci peut accroître les performances des applications qui vérifient l'existence et la lisibilité des scripts PHP, mais risque de retourner des données périmées si opcache.validate_timestamps est désactivé.

opcache.optimization_level int

Un masque de bits qui contrôle quelles passes d'optimisation sont exécutées. La valeur par défaut est 0x7FFEBFFF, qui active toutes les optimisations sûres. Désactiver des optimisations ou activer des optimisations non sûres est surtout utile pour déboguer/développer l'optimiseur. Chaque bit dans le masque de bits active une passe d'optimisation spécifique :

Masque de bits des passes d'optimisation

Bit	Nom de la passe	Description	Défaut
0	PASS_1	Optimisations peephole simples	Activé
1	PASS_2	Inutilisé (a été fusionné dans PASS_1)	Activé
2	PASS_3	Optimisation de saut simple	Activé
3	PASS_4	Optimisation des appels	Activé
4	PASS_5	Optimisation basée sur le graphe de flux de contrôle	Activé
5	PASS_6	Optimisation basée sur l'analyse de flux de données	Activé
6	PASS_7	Indique si le graphe d'appels doit être utilisé pour les optimisations SSA	Activé
7	PASS_8	Propagation conditionnelle de constantes creuses	Activé
8	PASS_9	Optimisation des variables temporaires	Activé
9	PASS_10	Suppression des opcodes NOP	Activé
10	PASS_11	Compactage des littéraux	Activé
11	PASS_12	Pré-calcul de la taille de la pile d'appels	Activé
12	PASS_13	Suppression des variables inutilisées	Activé
13	PASS_14	Élimination du code mort	Activé
14	PASS_15	Collecte et substitution des déclarations de constantes (non sûr)	Désactivé
15	PASS_16	Inlining de fonctions triviales (partie de l'optimisation des appels)	Activé
16	(Drapeau)	Ignorer la possibilité de surcharge d'opérateur (non sûr)	Désactivé

Note: Optimisations sûres vs non sûres
Les optimisations sûres (activées par défaut) préservent le comportement exact du code PHP tout en améliorant les performances. Elles incluent l'élimination du code mort, le repliement de constantes et l'optimisation des sauts. Les optimisations non sûres (désactivées par défaut) peuvent altérer le comportement dans des cas particuliers :

• Bit 14 : Collecte des constantes. Les constantes sont substituées à la compilation, ignorant l'ordre de déclaration à l'exécution :
  <?php
echo getA(); // Affiche : "hello" au lieu de lancer une Error
const A = "hello";
function getA() { return A; }
• Bit 16 : Ignorer la surcharge d'opérateur. Non sûr lors de l'utilisation de classes avec do_operation (par exemple GMP, BCMath) dans des opérations arithmétiques. Avec des déclarations de type, l'optimiseur peut appliquer les mêmes optimisations en toute sécurité.

opcache.inherited_hack bool

Cette directive de configuration est ignorée.

opcache.dups_fix bool

Ce hack ne doit être activé que comme solution de contournement des erreurs "Cannot redeclare class".

opcache.blacklist_filename string

L'endroit de stockage du fichier gérant la liste noire OPcache. Un fichier de liste noire est un fichier texte contenant des noms de fichiers qui ne doivent pas être accélérés ; un par ligne. Les jokers sont autorisés, et les préfixes peuvent également être fournis. Les lignes commençant par un point-virgule sont vues comme des commentaires et seront donc ignorées. Un fichier de liste noire simple ressemble à ceci :

; Correspond à un fichier spécifique.
/var/www/broken.php
; Un préfixe qui correspond à tous les fichiers qui commencent par x.
/var/www/x
; Une correspondance avec un joker.
/var/www/*-broken.php

opcache.max_file_size int

La taille maximale du fichier pouvant être mis en cache, en octets. Si vaut 0, tous les fichiers pourront être mis en cache.

opcache.consistency_checks int

Si la valeur est différente de zéro, OPcache va vérifier la somme de contrôle du cache toutes les N requêtes, où N est la valeur de cette directive de configuration. Ceci ne doit être activé que lors du débogage, sachant qu'il impacte fortement les performances.

Note: Désactivé à partir de PHP 8.1.18 et 8.2.5. Supprimé à partir de PHP 8.3.0.

opcache.force_restart_timeout int

La durée à attendre pour le début d'un redémarrage programmé, si le cache n'est pas activé, en secondes. Si ce délai d'attente est atteint, alors OPcache imagine que quelque chose se passe mal, et va tuer les processus gérant les verrous sur le cache pour permettre un redémarrage. Si opcache.log_verbosity_level vaut 2 ou plus, un avertissement sera enregistré dans le journal d'événements des erreurs lorsque ce comportement survient. Cette directive n'est pas supportée sur Windows.

opcache.error_log string

Le log d'erreurs pour les erreurs OPcache. Une chaîne vide sera vue comme stderr, et les erreurs seront envoyées vers la sortie d'erreurs standard (qui sera le log des erreurs du serveur Web dans la plupart des cas).

opcache.log_verbosity_level int

Le niveau de verbosité des logs. Par défaut, seules les erreurs fatales (niveau 0) et les erreurs (niveau 1) seront enregistrées. Les autres niveaux disponibles sont les alertes (niveau 2), les messages d'information (niveau 3), et les messages de débogage (niveau 4).

opcache.record_warnings bool

Si cette option est activée, OPcache enregistrera les avertissements de compilation et les rejouera lors du prochain include, même s'il est servi depuis le cache.

opcache.preferred_memory_model string

Le modèle de mémoire préféré pour OPcache, à utiliser. Si laissé vide, OPcache va choisir le modèle le plus approprié, ce qui est la meilleure façon de faire dans la plupart des cas. Les valeurs possibles sont mmap, shm, posix et win32.

opcache.protect_memory bool

Protège la mémoire partagée des écritures inattendues pendant l'exécution des scripts. Ceci est utile uniquement pour du débogage interne.

opcache.mmap_base string

La base utilisée pour les segments de mémoire partagée sous Windows. Tous les processus PHP doivent lier la mémoire partagée dans le même espace d'adresse. L'utilisation de cette directive permet de corriger les erreurs "Unable to reattach to base address".

opcache.restrict_api string

Autorise l'appel aux fonctions de l'API d'OPcache uniquement depuis des scripts PHP dont le chemin commence par une chaîne spécifique. La valeur par défaut, "", signifie "aucune restriction".

opcache.file_update_protection string

Empêche la mise en cache des fichiers datant moins que ce nombre de secondes. Ceci protège de la mise en cache des fichiers incomplètement mis à jour. Si toutes les mises à jour de fichiers sont atomiques, les performances peuvent être augmentées en le définissant à 0. Cela permettra de mettre en cache les fichiers immédiatement.

opcache.huge_code_pages bool

Active ou désactive la copie de code PHP (segment de texte) dans des HUGE PAGES. Ceci devrait améliorer les performances, mais nécessite une configuration appropriée du système d'exploitation. Disponible sur Linux à partir de PHP 7.0.0, et sur FreeBSD à partir de PHP 7.4.0.

opcache.lockfile_path string

Chemin absolu utilisé pour enregistrer les lockfiles partagés (pour *nix uniquement)

opcache.opt_debug_level string

Produit un vidage opcode pour déboguer les différentes étapes d'optimisation. 0x10000 affichera les opcodes tels que le compilateur les produit avant qu'aucune optimisation ne se produise alors que 0x20000 affichera les codes optimisés.

opcache.file_cache string

Active et définit le répertoire de cache de second niveau. Ceci devrait améliorer les performances quand la mémoire SHM est pleine, au redémarrage du serveur ou réinitialisation de SHM. La valeur par défaut "" désactive la mise en cache basée sur les fichiers.

opcache.file_cache_only bool

Active ou désactive la mise en cache de l'opcode dans la mémoire partagée.

Note: Avant PHP 8.1.0, désactiver cette directive avec un fichier de cache déjà rempli nécessite le vidage manuel du cache.

opcache.file_cache_consistency_checks bool

Active ou désactive la validation de la somme de contrôle lorsque le script est chargé à partir du cache de fichiers.

opcache.file_cache_fallback bool

Implique opcache.file_cache_only=1 pour un certain processus qui a échoué à se rattacher à la mémoire partagée (pour Windows uniquement). Le cache de fichiers activé explicitement est requis.

Attention

Désactiver cette option de configuration peut empêcher les processus de démarrer, et est donc découragé.

opcache.validate_permission bool

Valide les permissions des fichiers mises en cache par rapport à l'utilisateur actuel.

opcache.validate_root bool

Empêche la collision de noms dans les environnements `chroot`és. Ceci devrait être activé dans tous les environnements `chroot`és pour empêcher l'accès aux fichiers en-dehors du chroot.

opcache.preload string

Spécifie un script PHP qui sera compilé et exécuté lors du démarrage du serveur, et qui peut précharger d'autres fichiers, soit grâce à include ou en utilisant la fonction opcache_compile_file(). Toutes les entités (par exemple fonctions et classes) définies dans ces fichiers seront disponibles aux requêtes prêtes à l'emploi, jusqu'à ce que le serveur soit éteint.

Note: Le préchargement n'est pas supporté sur Windows.

opcache.preload_user string

Permet au préchargement d'être exécuté en tant qu'utilisateur système spécifié. Ceci est utile pour les serveurs qui démarrent en tant que root avant de passer à un utilisateur système non privilégié. Le préchargement en tant que root n'est pas autorisé par défaut pour des raisons de sécurité, sauf si cette directive est explicitement définie sur root. À partir de PHP 8.3.0, cette directive n'a plus besoin d'être définie afin d'autoriser le préchargement lors de l'exécution en tant que root avec CLI SAPI ou phpdbg SAPI.

opcache.cache_id string

Sur Windows, tous les processus exécutant le même PHP SAPI sous le même compte utilisateur ayant le même ID de cache partagent une instance unique d'OPcache. La valeur de l'ID de cache peut être choisie librement.

Astuce

Pour IIS, des pools d'applications différentes peuvent avoir leur propre instance OPcache en utilisant la variable d'environnement APP_POOL_ID comme opcache.cache_id.

opcache.jit string|int

Pour un usage typique, cette option accepte une des quatre valeurs de chaîne suivantes :

• disable: Désactivé complètement, ne peut pas être activé lors du runtime.
• off: Désactivé, mais peut être activé lors du runtime.
• tracing/on: Utilise le tracing JIT. Activé par défaut et recommandé pour la plupart des utilisateurs.
• function: Utilise le function JIT.

Pour un usage avancé, cette option accepte un entier à 4 chiffres CRTO, où les chiffres signifient :

C (Drapeaux d'optimisation spécifiques au CPU)

• 0: Désactive les optimisations spécifiques au CPU.
• 1: Active l'usage d'AVX, si le CPU le supporte.

R (allocation de registre)

• 0: N'accomplit aucune allocation de registres
• 1: Accomplit des allocations de registres au niveau d'un bloc.
• 2: Accomplit des allocations de registres globales.

T (trigger/déclencheur)

• 0: Compile toutes les fonctions lors du chargement du script.
• 1: Compile les fonctions lors de leur première exécution.
• 2: Profile les fonctions lors de la première requête et compile les fonctions les plus chaudes juste après.
• 3: Profile à la volée et compile les fonctions chaudes.
• 4: Actuellement inutilisé.
• 5: Utilise le tracing JIT. Profile à la volée et compile les traces pour les segments de code chaud.

O (niveau d'optimisation)

• 0: Pas de JIT.
• 1: JIT minimal (appelle les handlers standard de la VM).
• 2: Inline les handlers de la VM.
• 3: Utilise l'inférence de type.
• 4: Utilise un graphe d'appel.
• 5: Optimise le script entier.

Le mode "tracing" correspond à CRTO = 1254, le mode "function" correspond à CRTO = 1205.

opcache.jit_buffer_size int

La quantité de mémoire partagée réservée pour du code compilé JIT. Une valeur de zéro désactive le JIT. Lorsqu'un entier est utilisé, sa valeur est mesurée en octets. Vous pouvez également utiliser la notation sténographique comme décrit dans cette entrée de la FAQ..

opcache.jit_debug int

Un masque de bits spécifiant quelle sortie de débogage de JIT activer Pour les valeurs possibles, consulter » zend_jit.h (voir les définitions de macro commençant par ZEND_JIT_DEBUG).

opcache.jit_bisect_limit int

Option de débogage qui désactive la compilation JIT après la compilation d'un certain nombre de fonctions. Ceci peut être utile pour bissecter la source d'une mauvaise compilation JIT. Remarque : cette option ne fonctionne que lorsque le déclencheur JIT est défini à 0 (compilation au chargement du script) ou 1 (compilation à la première exécution), par exemple, opcache.jit=1215. Voir plus dans l'option opcache.jit.

opcache.jit_prof_threshold float

Lors de l'utilisation du mode de déclencheur "profile les fonctions lors de la première requête", cette limite détermine si une fonction est considérée chaude. Le nombre d'appels à la fonction divisé par le nombre d'appels à toutes les fonctions doit être supérieur à cette limite. Par exemple, une limite de 0.005 signifie qu'une fonction qui correspond à plus de 0.5% de tous les appels sera compilée JIT.

opcache.jit_max_root_traces int

Nombre maximal de traces racines (root traces). La trace racine est un flux d'exécution prenant d'abord un chemin à travers le code, qui est une unité de la compilation JIT. JIT ne compilera pas de nouveau code s'il atteint cette limite.

opcache.jit_max_side_traces int

Nombre maximal de traces adjacentes (side traces) qu'une trace racine peut avoir. La trace adjacente est un autre flux d'exécution qui ne suit pas le chemin de la trace racine compilée. Les traces adjacentes appartenant à la même trace racine ne seront pas compilées si elles atteignent cette limite.

opcache.jit_max_exit_counters int

Nombre maximal de compteurs de sortie de trace adjacente. Ceci limite le nombre total de traces adjacentes qu'il peut y avoir, à travers toutes les traces racines.

opcache.jit_hot_loop int

Après combien d'itérations une boucle est considérée chaude. L'intervalle de valeurs valides est [0,255] ; pour tout paramètre hors de cette plage, par exemple -1 ou 256, la valeur par défaut sera utilisée à la place. Spécialement, une valeur nulle désactivera le JIT pour tracer et compiler toutes les boucles.

Note: Il est recommandé de définir ce paramètre comme un nombre premier, afin d'éviter qu'il ne soit un multiple du nombre d'itérations des boucles.

opcache.jit_hot_func int

Après combien d'appels une fonction est considérée chaude. La plage de valeurs valides est [0,255] ; pour tout paramètre hors de cette plage, par exemple -1 ou 256, la valeur par défaut sera utilisée à la place. Spécialement, une valeur nulle désactivera le JIT pour tracer et compiler toutes les fonctions.

opcache.jit_hot_return int

Après combien de retours un retour est considéré chaud. La plage de valeurs valides est [0,255] ; pour tout paramètre hors de cette plage, par exemple -1 ou 256, la valeur par défaut sera utilisée à la place. Spécialement, une valeur nulle désactivera le JIT pour tracer et compiler tous les retours.

opcache.jit_hot_side_exit int

Après combien de sorties une sortie adjacente est considérée chaude. La plage de valeurs valides est [0,255] ; pour tout paramètre hors de cette plage, par exemple -1 ou 256, la valeur par défaut sera utilisée à la place. Spécialement, une valeur nulle désactivera le JIT pour tracer et compiler toutes les sorties latérales.

opcache.jit_blacklist_root_trace int

Nombre maximal de tentatives de compilation d'une trace racine avant que celle-ci ne soit exclue.

opcache.jit_blacklist_side_trace int

Nombre maximal de tentatives de compilation d'une trace adjacente avant que celle-ci ne soit exclue.

opcache.jit_max_loop_unrolls int

Nombre maximal de tentatives pour dérouler une boucle dans une trace adjacente, tentant d'atteindre la trace racine et de fermer la boucle extérieure.

opcache.jit_max_recursive_calls int

Nombre maximal d'appels récursifs déroulés dans une boucle.

opcache.jit_max_recursive_returns int

Nombre maximal de retours récursifs déroulés dans une boucle.

opcache.jit_max_polymorphic_calls int

Nombre maximal de tentatives pour inliner un appel polymorphe (dynamique ou méthode). Les appels au-dessus de cette limite sont traités comme mégamorphes et ne sont pas inlinés.