PHP 5.4.36 Released

Configuration à l'exécution

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

Bien que la configuration par défaut d'APC soit suffisante pour la plupart des installations, les utilisateurs avancés devraient affiner certains paramètres.

Il y a deux décisions importantes que vous devez prendre lorsque vous configurez APC. Tout d'abord, quelle quantité de mémoire partagée va être allouée à APC, et ensuite, si vous voulez qu'APC vérifie à chaque requête si un fichier a été modifié. Les deux directives de configuration correspondantes sont apc.shm_size et apc.stat. Lisez avec attention la section suivante sur ces deux directives de configuration.

Une fois que vous avez un serveur qui fonctionne, vous devriez copier le script apc.php fourni avec l'extension vers un endroit accessible par le serveur web, puis l'appeler depuis votre navigateur. Il vous fournira de nombreux détails sur votre cache. Si GD est actif sur votre configuration PHP, il y aura aussi des graphiques intéressants. La première chose à vérifier, bien évidemment, est que APC stocke effectivement des fichiers en cache. Si cela fonctionne, le nombre Cache full count sur la gauche indiquera le nombre de fois où le cache a atteint sa capacité maximale, et où APC a dû effacer de force des entrées qui n'avaient pas été accédées dans les dernières apc.ttl secondes. Dans le cas d'un cache bien configuré, ce nombre est minimisé. Si le cache est constamment rempli, et donc vidé de force, les opérations résultantes auront un impact dévastateur sur les performances. La manière la plus simple de minimiser ce nombre est d'allouer plus de mémoire pour APC. Ceci dit, la directive apc.filters peut être utilisée pour mettre en cache moins de scripts.

Lorsque APC est compilé avec le support mmap (Memory Mapping), il n'utilisera qu'un seul segment mémoire, alors que APC compilé avec le support SHM (SysV Shared Memory) utilisera plusieurs segments mémoires. MMAP n'a pas de limite maximale comme SHM dans /proc/sys/kernel/shmmax. En général MMAP est recommandé car il accèdera à la mémoire de manière plus rapide lorsque le serveur web est redémarré et il réduit aussi les impacts des allocations mémoire au démarrage.

Options de configuration APC
Nom Défaut Modifiable Historique
apc.enabled "1" PHP_INI_SYSTEM PHP_INI_SYSTEM avec APC 2. PHP_INI_ALL avec APC <= 3.0.12
apc.shm_segments "1" PHP_INI_SYSTEM  
apc.shm_size "32M" PHP_INI_SYSTEM  
apc.shm_strings_buffer "4M" PHP_INI_SYSTEM Disponible depuis APC 3.1.4.
apc.optimization "0" PHP_INI_ALL PHP_INI_SYSTEM avec APC 2. Supprimé depuis APC 3.0.13.
apc.num_files_hint "1000" PHP_INI_SYSTEM  
apc.user_entries_hint "4096" PHP_INI_SYSTEM Disponible depuis APC 3.0.0.
apc.ttl "0" PHP_INI_SYSTEM Disponible depuis APC 3.0.0.
apc.user_ttl "0" PHP_INI_SYSTEM Disponible depuis APC 3.0.0.
apc.gc_ttl "3600" PHP_INI_SYSTEM  
apc.cache_by_default "1" PHP_INI_ALL PHP_INI_SYSTEM avec APC <= 3.0.12. Disponible depuis APC 3.0.0.
apc.filters NULL PHP_INI_SYSTEM  
apc.mmap_file_mask NULL PHP_INI_SYSTEM  
apc.slam_defense "1" PHP_INI_SYSTEM Disponible depuis APC 3.0.0. Avant la version 3.1.4 d'APC, la valeur par défaut était "0" (désactivé).
apc.file_update_protection "2" PHP_INI_SYSTEM Disponible depuis APC 3.0.6.
apc.enable_cli "0" PHP_INI_SYSTEM Disponible depuis APC 3.0.7.
apc.max_file_size "1M" PHP_INI_SYSTEM Disponible depuis APC 3.0.7.
apc.use_request_time "1" PHP_INI_ALL Disponible depuis APC 3.1.3.
apc.stat "1" PHP_INI_SYSTEM Disponible depuis APC 3.0.10.
apc.write_lock "1" PHP_INI_SYSTEM Disponible depuis APC 3.0.11.
apc.report_autofilter "0" PHP_INI_SYSTEM Disponible depuis APC 3.0.11.
apc.serializer "default" PHP_INI_SYSTEM Disponible depuis APC 3.1.0.
apc.include_once_override "0" PHP_INI_SYSTEM Disponible depuis APC 3.0.12.
apc.rfc1867 "0" PHP_INI_SYSTEM Disponible depuis APC 3.0.13.
apc.rfc1867_prefix "upload_" PHP_INI_SYSTEM  
apc.rfc1867_name "APC_UPLOAD_PROGRESS" PHP_INI_SYSTEM  
apc.rfc1867_freq "0" PHP_INI_SYSTEM  
apc.rfc1867_ttl "3600" PHP_INI_SYSTEM Disponible depuis APC 3.1.1.
apc.localcache "0" PHP_INI_SYSTEM Disponible en APC 3.0.14 - 3.1.11.
apc.localcache.size "512" PHP_INI_SYSTEM Disponible en APC 3.0.14 - 3.1.11.
apc.coredump_unmap "0" PHP_INI_SYSTEM Disponible depuis APC 3.0.16.
apc.stat_ctime "0" PHP_INI_SYSTEM Disponible depuis APC 3.0.13.
apc.preload_path NULL PHP_INI_SYSTEM Disponible depuis APC 3.1.1.
apc.file_md5 "0" PHP_INI_SYSTEM Disponible depuis APC 3.1.1.
apc.canonicalize "1" PHP_INI_SYSTEM Disponible depuis APC 3.1.1.
apc.lazy_functions 0 PHP_INI_SYSTEM Disponible depuis APC 3.1.3.
apc.lazy_classes 0 PHP_INI_SYSTEM Disponible depuis APC 3.1.3.
Pour plus de détails sur les modes PHP_INI_*, reportez-vous à Où une directive de configuration peut être modifiée.

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

apc.enabled booléen

apc.enabled peut être défini à 0 pour désactiver APC. Ceci est principalement utile lorsque APC est compilé statiquement dans PHP, et qu'il n'y a donc aucun autre moyen de le désactiver (lorsque compilé en tant que DSO, la ligne extension dans le php.ini peut juste être commentée).

apc.shm_segments entier

Le nombre de segments mémoire à allouer pour le cache compilé. Si APC arrive à court de mémoire partagée, mais que vous avez déjà défini apc.shm_size à une valeur aussi élevée que votre système le permet, vous pouvez tenter de relever cette valeur.

apc.shm_size entier

La taille de chaque segment de mémoire partagée en MB. Par défaut, quelques systèmes (incluant la plupart des BSD) ont une limite de taille d'un segment mémoire partagé très basse.

apc.shm_strings_buffer string

La taille de la mémoire à utiliser comme tampon partagé pour les chaînes utilisées en interne par APC. La taille devra être suffixé par un M pour Méga-octets, un G pour Giga-octets. L'activation de cette option va réduire la quantité de mémoire utilisée par le worker PHP-FPM, sachant que les chaînes seront stockées qu'une seule fois plutôt que pour chaque worker.

apc.optimization entier

Le degré d'optimisation. Zéro désactive l'optimiseur, et de hautes valeurs utilisent des optimisations agressives. Attendez-vous à des améliorations très modestes de vitesse. Ceci est expérimental.

apc.num_files_hint entier

Un "conseil" au sujet du nombre de fichiers sources distincts qui seront inclus ou demandés sur votre serveur web. Définissez le à zéro ou omettez-le si vous n'êtes pas sûr ; ce paramètre est principalement utile pour les sites qui ont des milliers de fichiers sources.

apc.user_entries_hint entier

Tout comme apc.num_files_hint, un "conseil" à propos du nombre de variables de cache utilisateur distinctes à stocker. Définissez le à 0 ou ne le définissez pas si vous n'êtes pas sûr.

apc.ttl entier

Le nombre de secondes pendant lesquelles une entrée de cache est autorisée à stagner dans un slot dans le cas où ce slot d'entrée de cache est nécessaire pour une autre entrée. Laisser ce paramètre à zéro signifie que le cache d'APC pourrait potentiellement se remplir de vieilles entrées alors que de nouvelles entrées ne seraient pas mises en cache. Dans le cas d'un cache arrivant totalement à court de mémoire disponible, celui-ci sera totalement vidé si ttl est égal à 0. Dans le cas contraire, si le ttl est supérieur à 0, APC essayera de supprimer des entrées ayant expirées.

apc.user_ttl entier

Le nombre de secondes pendant lesquelles une entrée du cache utilisateur est autorisée à résider dans un slot dans le cas où ce slot d'entrée de cache est demandé par une autre entrée. Laisser cette option à zéro signifie que votre cache peut potentiellement se remplir d'entrées obsolètes alors que de nouvelles entrées ne seront pas mises en cache. Dans le cas où le cache est totalement à court d'espace, il sera totalement vidé si ttl vaut 0. Sinon, si le ttl est supérieur à 0, APC tentera de supprimer les entrées qui ont dépassées leur date d'expiration.

apc.gc_ttl entier

Le nombre de secondes pendant lesquelles une entrée de cache peut rester dans la liste de ramasse-miettes. Cette directive fournit une sécurité dans le cas où un processus serveur meurt pendant qu'il exécute un fichier source mis en cache ; si ce fichier source est modifié, la mémoire allouée pour l'ancienne version ne sera pas récupérée tant que la durée spécifiée par ce TTL ne sera pas écoulée. Positionnez cette directive à zéro pour désactiver cette fonctionnalité.

apc.cache_by_default booléen

Actif par défaut, mais peut être désactivé et utilisé en conjonction avec un apc.filters positif pour que les fichiers soient mis en cache uniquement s'ils correspondent à un filtre positif.

apc.filters chaîne de caractères

Une liste d'expressions rationnelles POSIX étendues séparées par des virgules. Si un masque correspond à un nom de fichier source, alors celui-ci ne sera pas mis en cache. Notez que le nom du fichier utilisé pour la comparaison est celui passé aux instructions include ou require, et non un chemin absolu. Si le premier caractère de l'expression est un +, alors l'expression sera additive dans le sens que chaque fichier correspondant à l'expression sera mis en cache, et si le premier caractère est un - alors tout ce qui correspond ne sera pas mis en cache. Le cas du - est celui par défaut, il peut donc être omis.

apc.mmap_file_mask chaîne de caractères

Si compilé avec le support MMAP en utilisant --enable-mmap, ce sera le masque de fichier de style mktemp à passer au module MMAP pour déterminer si votre région de mémoire MMAP va être mise dans un fichier ou en mémoire partagée. Pour de la mise en cache vers un fichier MMAP, définissez ce paramètre comme /tmp/apc.XXXXXX (exactement 6 X). Pour utiliser shm_open/mmap de style POSIX, placez un .shm quelque part dans votre masque, comme /apc.shm.XXXXXX. Vous pouvez également définir ce paramètre à /dev/zero pour utiliser l'interface/dev/zero de votre kernel vers de la mémoire anonyme MMAP. Le laisser indéfini forcera un MMAP anonyme.

apc.slam_defense entier

Sur les serveurs très surchargés, lorsque vous démarrez le serveur ou modifiez des fichiers, vous pouvez créer une course d'un grand nombre de processus essayant tous de mettre en cache le même fichier au même moment. Cette option définit le pourcentage de processus qui éviteront de tenter de mettre en cache un fichier non mis en cache. Ou pensez à elle comme à la probabilité qu'a un processus d'éviter la mise en cache. Par exemple, définir apc.slam_defense à 75 signifie qu'il y aura 75 % de chances qu'un processus donné ne mette pas en cache un fichier qui ne s'y trouvera pas déjà. Positionnez cette directive à 0 pour désactiver cette fonctionnalité.

Cette directive a été rendue obsolète par apc.write_lock.

apc.file_update_protection entier

Lorsque qu'un fichier est modifié sur un serveur web, il faudrait vraiment que ce soit fait d'une façon atomique. Typiquement, cela peut se faire en écrivant vers un fichier temporaire, et en renommant (mv) celui-ci vers son emplacement permanent lorsqu'il est prêt. La plupart des éditeurs de texte, cp, tar et d'autres programmes de ce genre ne font pas cela. Cela signifie qu'il y a une chance pour qu'un fichier soit accédé (et donc, mis en cache) alors qu'il est encore en cours d'écriture. Le paramètre apc.file_update_protection fait intervenir un délai avant la mise en cache des nouveaux fichiers. Par défaut, il vaut 2 secondes, ce qui signifie que si le timestamp de modification (mtime) d'un fichier montre qu'il est agé de moins de 2 secondes au moment où il est accédé, ce fichier ne sera pas mis en cache. La malheureuse personne qui a accédé à ce fichier à moitié écrit verra toujours quelque chose d'étrange, mais au moins, ceci ne persistera pas en cache. Si tous les fichiers du serveurs sont modifiés de manière atomique, à l'aide d'une méthode comme rsync qui fait cela correctement, cette protection peut être désactivée en définissant cette directive à 0. Si le système est noyé sous les entrées/sorties et que des procédures de mise à jour durent plus de 2 secondes, cette valeur devrait être augmentée, pour activer la protection sur ces opérations d'écritures plus lentes.

apc.enable_cli entier

Principalement pour tester et déboguer. Définir ceci active APC pour la version CLI de PHP. Dans des circonstances normales, il n'est pas idéal de créer, peupler, et détruire le cache APC à chaque requête CLI, mais pour divers scénarios de test, il est utile de pouvoir activer facilement APC pour la version CLI de PHP.

apc.max_file_size entier

Permet d'éviter la mise en cache de fichiers dont la taille est supérieure à cette valeur. Par défaut, 1Mo.

apc.stat entier

Faites très attention si vous modifiez cette valeur. Elle vaut par défaut on, ce qui force APC à vérifier (stat) le script à chaque requête pour déterminer s'il a été modifié ou non. S'il a été modifié, il sera compilé à nouveau et la nouvelle version sera mise en cache. En désactivant cette option, aucune vérification n'aura lieu. Cela signifie généralement que si vous voulez forcer APC à détecter des modifications, vous devrez redémarrer le serveur web, ou vider manuellement le cache. Notez que les configurations FastCGI de serveurs peuvent ne pas vider le cache au redémarrage. Sur un serveur de production où vous modifiez rarement le code, le fait de désactiver cette option permet de réaliser un gain de performances significatif.

Cette option est également prise en compte pour les fichiers inclus/requis, mais notez que si vous utilisez des chemins relatifs (n'importe quel chemin qui ne commence pas par un / sous Unix), APC doit vérifier de manière à identifier le fichier de manière unique. Si vous utilisez des chemins absolus pour vos inclusions, APC peut éviter ces vérifications et utiliser ce chemin absolu en tant qu'identifiant unique du fichier.

apc.write_lock booléen

Sur les serveurs très chargés, lorsque vous démarrez le serveur ou lorsque beaucoup de fichiers ont été modifiés au même moment, APC peut essayer de compiler et de mettre en cache le même fichier plusieurs fois. Write_lock garantit qu'un seul processus tentera la compilation et la mise en cache d'un script non caché. Les autres processus essayant d'utiliser le script fonctionneront sans utiliser le cache d'opcode, au lieu d'être bloqués dans l'attente de l'initialisation de celui-ci.

apc.report_autofilter booléen

Loggue tous les scripts qui ont été automatiquement exclus de la mise en cache à cause de problèmes de liaison.

apc.serializer string

Utilisé pour configurer APC pour utiliser un linéariseur tierce.

apc.include_once_override booléen

Optimise les appels aux fonctions include_once et require_once et évite les appels système coûteux qui auraient autrement été effectués.

Avertissement

Cette fonctionnalité est EXPERIMENTALE. Son comportement, son nom, ainsi que sa documentation peuvent être modifiés sans avertissement dans une version future d'APC. Cette fonctionnalité doit être utilisée à votre propre risque.

apc.rfc1867 booléen

Le gestionnaire de progression de téléchargement de fichier RFC1867 n'est disponible que si vous avez compilé APC avec PHP 5.2.0 ou supérieur. Lorsque le support est actif, les fichiers téléchargés qui incluent un champ appelé APC_UPLOAD_PROGRESS avant le champ "file" d'un formulaire de téléchargement feront qu'APC créera automatiquement une entrée de cache utilisateur nommée upload_keykey est la valeur de l'entrée de formulaire APC_UPLOAD_PROGRESS.

Notez que le champ caché spécifié par APC_UPLOAD_PROGRESS doit être placé avant le champ de type file, sinon le suivi de l'upload ne fonctionnera pas correctement.

Notez que la surveillance du téléchargement de fichier n'est pas compatible avec les threads pour le moment. Ainsi, les nouveaux téléchargements survenant tandis qu'un précédent est toujours en cours désactiveront la surveillance précédente.

Notez que rate n'est disponible que lorsque tous les transferts sont terminés.

Exemple #1 Exemple avec apc.rfc1867

<?php
print_r
(apc_fetch("upload_$_POST[APC_UPLOAD_PROGRESS]"));
?>

L'exemple ci-dessus va afficher quelque chose de similaire à :

Array
(
    [total] => 1142543
    [current] => 1142543
    [rate] => 1828068.8
    [filename] => test
    [name] => file
    [temp_filename] => /tmp/php8F
    [cancel_upload] => 0
    [done] => 1
)

apc.rfc1867_prefix chaîne de caractères

Préfixe de la clé à utiliser pour l'entrée de cache utilisateur générée par la fonctionnalité de progression de téléchargement RFC1867.

apc.rfc1867_name chaîne de caractères

Spécifie le nom du champ masqué du formulaire qui active le suivi de la progression du téléchargement et spécifie le suffixe de la clé du cache utilisateur.

apc.rfc1867_freq chaîne de caractères

La fréquence à laquelle des mises à jour doivent être effectuées pour l'entrée du cache utilisateur pour la progression du téléchargement. Ceci peut prendre la forme d'un pourcentage de la taille totale du fichier ou une taille en octets, optionnellement suffixée par "k", "m", ou "g" pour kilo-octets, méga-octets ou giga-octets (insensible à la casse). Si vous définissez cette option à 0, la mise à jour interviendra aussi souvent que possible, ce qui peut rendre le téléchargement plus lent.

apc.rfc1867_ttl integer

TTL pour les entrées rfc1867.

apc.localcache booléen

Ceci active un cache sans verrou, propre au processus courant, qui réduit les blocages de verrous lorsque le cache est en cours d'écriture.

apc.localcache.size entier

La taille du cache propre au processus, qui devrait être définie à une valeur suffisamment élevée, soit approximativement la moitié de la valeur de apc.num_files_hint.

apc.coredump_unmap booléen

Active la gestion APC des signaux, comme SIGSEGV, qui écrit les fichiers internes lorsqu'il est émis. Lorsque ces signaux sont reçus, APC tentera de détacher les segments de la mémoire partagée afin de les exclure du fichier interne. Cette configuration devrait rendre plus stable le système lorsque des signaux fatals sont reçus et qu'un gros segment APC de mémoire partagée est configuré.

Avertissement

Cette fonctionnalité est potentiellement dangereuse. Le détachement d'un segment de mémoire partagée dans un gestionnaire de signaux fatals peut produire à un comportement indéterminé si une erreur fatale survient.

Note:

Bien que certains noyaux puissent fournir une fonctionnalité permettant d'ignorer divers types de mémoire partagée lors de la génération du fichier interne, ces implémentations peuvent également ignorer d'importants segments de mémoire partagée tel que le scoreboard d'Apache.

apc.stat_ctime entier

Une vérification avec ctime permet d'éviter les problèmes causés par des programmes comme svn ou rsync en s'assurant que les inodes n'ont pas été modifiés depuis le dernier appel à stat. APC, normalement, n'utilise que mtime pour cela.

apc.canonicalize bool

Si activé, les chemins relatifs sont canonisés en mode no-stat. Si défini, alors les fichiers inclus via les gestionnaires de flux ne pourront pas être mis en cache, puisque que la fonction realpath() ne supporte pas les gestionnaires de flux.

apc.preload_path string

Optionnellement, définit un chemin vers le dossier depuis lequel APC va charger les données de cache au démarrage.

apc.use_request_time bool

Utilise le temps de début de requête SAPI pour le TTL.

apc.file_md5 bool

Enregistre un hashage md5 pour les fichiers.

apc.lazy_functions integer

Active le chargement à la demande pour les fonctions.

apc.lazy_classes integer

Active le chargement à la demande pour les classes.

add a note add a note

User Contributed Notes 11 notes

up
2
danbettles at yahoo dot co dot uk
6 years ago
To automatically cache only PHP class files named "<class name>.class.php", add the following lines to php.ini.

apc.cache_by_default = "Off"
apc.filters = "+\.class\.php$"

Notes:
- The regexp is case /sensitive/, so if, say, your project contains filenames with mixed case, you'll need something like "+\.(class|CLASS)\.(php|PHP)$".  I've tried delimiting patterns and using the "i" modifier, but that doesn't seem to work.
- Setting cache_by_default to "On" and applying the positive filter will /not/ work.

If you have more complicated requirements and, like me, you're not familiar with POSIX Extended Regular Expressions (ERE) inparticular, you may find the following link useful.  http://www.regular-expressions.info/refflavors.html
up
1
lamperz at gmail dot com
6 years ago
I'm trying to get upload progress with apc_fetch.
I founded apc_fetch always return false till the upload completed.After fews hours debug, I finally notice that my APC_UPLOAD_PROGRESS was set after the file form.

SO, You should write your form like this
<input type="hidden" id="file_id" name="APC_UPLOAD_PROGRESS" value="blablabla"/>
<input type="file" id="select_file" name="file" value="upload" onchange="parent.test();"/>

the hidden field with name="APC_UPLOAD_PROGRESS" SHOULD be ALWAYS BEFORE input type="file"
up
0
klaus at hax dot at
1 year ago
Note: If you want to run a script on Windows with apc.enabled=1 as a scheduled task whilst another instance of php is running (like on a webserver) apparently you have to disable apc for this scheduled task, otherwise it will not run and you will have something in your error log like: PHP Fatal error: PHP Startup: apc_shm_create: shmget(0, 33554432, 658) failed: No such file or directory.

So simply execute your scheduled task with:

c:\php\php.exe -d apc.enabled=0 and all will be fine.
up
0
bas_vijfiwinkel
2 years ago
I took some time to look at the preload_path option.

At the moment of writing the preload_path option is broken because of a bug in the APC source code
which will not allow you to properly preload the cache.

The way to fix it :
Inside 'main_apc.c' in the method called 'static int apc_load_data(const char *data_file TSRMLS_DC)', the length of the key of the value that needs to be stored is determined with the following line :
key_len = strlen(key);
If I am correct this is only the length of the string itself without the null-terminator
However, "_apc_store" seems to want the length of the key string including the terminator.
If I change the line above to :
key_len = strlen(key)+1;
then the preload function works as expected.
You can also notice that 1 character is missing when looking at the user cache entries apc.php. But if you try to use that as a key then APC will not return the contents so that didn't work as a workaround.

If one is able to compile the apc library from source, then one can of course easily fix this option by changing the source code.

Files in the specified path should have the extension '.data'.
The filename itself will become the key for the data that is in that specific file.
The data in the file is a serialized string representing what you want to assign to the specific key. For example s:2:"123" will generate the string "123".
One can only specify 1 value for each key and it should be null-terminated.

It is not possible to preload PHP scripts.
Only values that one retrieved with apc_fetch can be preloaded.
up
0
amir w of colnect dot com TIPS
4 years ago
Want to avoid segmentation with apc.shm_segments?If your linux server limits the shared memory block size and you're forced to use apc.shm_segments instead, change the setting by using (here is 512M but change it as you like):
# sysctl -w kernel.shmmax=536870912

(but if you want the change to be permanent after a restart you would have to add the following line in /etc/sysctl.conf

kernel.shmmax=536870912)

and updating apc.ini

apc.shm_segments="1"
apc.shm_size="512"


apc.stat is an extremely important setting for a production server, especially if many files are accessed on every request, which is quite normal on complicated web applications.

Always aspire to use:
apc.stat="0"
so that APC does not try to check that each and every file exists on every request you make. It also means you can update files on your server without crashing incoming requests on that time fragment. Whenever you wish to force APC to re-read all the files, simply clear the cache or restart your server.
up
0
Will
5 years ago
For anyone wondering why shm_segments is being ignored on their setup, it could be because of the following:

If you've configured APC to use memory mapped files (with the --enable-mmap option), the shm_segments setting is ignored unless you specify a file mask via the mmap_file_mask setting.

This is because APC won't attempt to create multiple anonymous files to map into memory without a mask (since it has no way of naming them sensibly). To set up multiple segments you have to give a file mask so they can be named separately.

apc.mmap_file_mask=/tmp/apc.XXXXXX

Make sure to use exactly 6 "X"s (this is the part that is changed by APC). You can place these files anywhere, they don't have to go in /tmp.

With that said, I'm not sure what the performance impact of having multiple MMAP segments would be. I'm guessing it would probably be negative so you probably don't want to do this.
up
0
neorush at gmail dot com
5 years ago
apc_fetch always returned false.  Turns out that "apc.rfc1867" was set to "0".  I added this line to my php.ini:
apc.rfc1867 = 1
but it could have certainly been changed with ini_set().  That took me way to long to figure out.
up
0
bishop
5 years ago
The apc.rfc1867 example code above is a little fast and loose for those running in environments where APC RFC1867 may or may not be available.  This is a little more expressive:

<?php

// if we have PHP and APC
$havePHP = (1 === version_compare(PHP_VERSION, '5.2.0') ? true : false);
$haveAPC = (extension_loaded('apc') && 1 === version_compare(phpversion('apc'), '3.0.13') ? true : false);
if (
$havePHP && $haveAPC) {
   
// if APC and upload tracking is enabled
   
if (ini_get('apc.enabled') && ini_get('apc.rfc1867')) {
       
// get the stats
       
$key = ini_get('apc.rfc1867_prefix') . $_REQUEST['apcid'];
       
$stats = apc_fetch($key);
    }
}

?>
up
-1
fusionstream [a](t) gmail.com
4 years ago
If you are getting 0kb out of 0kb for your upload progress with large files, make sure that upload_max_filesize and post_max_size are larger than the file you are uploading. As far as I can tell, apc.max_file_size does not affect it.
up
-1
d_inkubus at yahoo dot com
4 years ago
apc.include_once_override=1 can cause more problems than it solves.  If you're running into weird errors regarding relative paths, make sure this setting is off.  PHP 5.3 already implements most of the speed ups in these calls anyway.
up
-2
amir w of colnect dot com TIPS
4 years ago
apc.stat is an extremely important setting for a production server, especially if many files are accessed on every request, which is quite normal on complicated web applications.

Always aspire to use:
apc.stat="0"
so that APC does not try to check that each and every file exists on every request you make. It also means you can update files on your server without crashing incoming requests on that time fragment. Whenever you wish to force APC to re-read all the files, simply clear the cache or restart your server.
To Top