Skip to content


Subversion checkout URL

You can clone with
Download ZIP
C PHP Other
branch: patch-1

This branch is 1 commit ahead, 128 commits behind zendtech:master

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.


Zend OPcache

Zend OPcache provides faster PHP execution through opcode caching and
optimization. It works by storing precompiled script bytecode in shared memory, 
which eliminates reading code from disk and compiling it on subsequent requests.
It also optimizes a few bytecode patterns for faster code execution.


This version of Zend OPcache is compatible with PHP 5.2.*, 5.3.*, 5.4.*
and the PHP-5.5 development branch.  PHP 5.2 support may be removed in the future.

Quick Install

- Compile

 ./configure \

- Install

 make install # copies into the PHP extension directory

- Edit php.ini


NOTE: If you want to use Zend OPcache together with Xdebug or Zend Debugger,
ensure that the respective debugging extension is loaded after OPcache. 
You can verify this with "php -v" or phpinfo(), where the debugging extension must
appear after OPcache.

- Restart PHP

Speed Tuning

We recommend the following configuration settings for best performance:


You also may add the following, but it may break some applications and
frameworks. Please read the description of these directives. Add them at your
own risk.


In some cases, you may have to enable or disable some features for better
compatibility, at the cost of some performance.

Configuration Directives

opcache.enable (default "1")
	OPcache On/Off switch. When set to Off, code is not optimized and cached.

opcache.enable_cli (default "0")
	Activate OPcache for the CLI version of PHP. It's used mostly for testing
	and debugging.

opcache.memory_consumption (default "64")
	The amount (in Mbytes) of shared memory OPcache uses for storing
	precompiled PHP code.

opcache.interned_strings_buffer (default "4")
	The amount of memory for interned strings in Mbytes.

opcache.max_accelerated_files (default "2000")
	The maximum number of keys (scripts) in the OPcache hash table.
	The number is actually the first one in the following set of prime
	numbers that is bigger than the one supplied: { 223, 463, 983, 1979, 3907,
	7963, 16229, 32531, 65407, 130987, 262237, 524521, 1048793 }. Only numbers
	between 200 and 1000000 are allowed.

opcache.max_wasted_percentage (default "5")
	The maximum percentage of "wasted" memory until a restart is scheduled.

opcache.use_cwd (default "1")
	When this setting is enabled, OPcache appends the current working
	directory to the script key, thus eliminating possible collisions between
	files with the same basename. Disabling the directive improves performance,
	but may break existing applications.

opcache.validate_timestamps (default "1")
	When disabled, you must reset OPcache manually or restart the webserver for
	changes to the filesystem to take effect.
	The frequency of the check is controlled by the directive

opcache.revalidate_freq (default "2")
	How often (in seconds) OPcache checks file timestamps for changes to the
	cached files. 
	"1" means: validate once per second, but only once per request.
	"0" means: always validate.

opcache.file_update_protection (default "2")
	Prevents caching files that are less than this number of seconds old.
	It protects from caching incompletely uploaded files. In case all file
	updates on your site are atomic, you may increase performance by setting it
	to "0".

opcache.revalidate_path (default "0")
	Enables or disables the "file search in include_path" optimization.
	If the file search is disabled and a cached file is found that uses
	the same include_path, the file is not searched again. Thus, if a file
	with the same name appears somewhere else in include_path, it
	won't be found. Enable this directive if this optimization breaks your 
	application. The default for this directive is disabled.

opcache.save_comments (default "1")
	If disabled, all PHPDoc comments are dropped from the code to reduce the
	size of the optimized code. Disabling "Doc Comments" may break some
	existing applications and frameworks which rely on annotation-style
	docblocks, for example Doctrine, ZF2 and PHPUnit.

opcache.load_comments (default "1")
	If disabled, PHPDoc comments are not loaded from shared memory, so
	"Doc Comments" may be always stored (save_comments=1), but not loaded 
	by applications that don't need them.

opcache.fast_shutdown (default "0")
	If enabled, a fast shutdown sequence is used for the accelerated code
	The fast shutdown sequence doesn't free each allocated block, but lets
	the Zend Engine Memory Manager do the work.

opcache.enable_file_override (default "0")
	Enable the file existence override (file_exists() etc.) performance 

opcache.optimization_level (default "0xffffffff")
	A bitmask, where each bit enables or disables the appropriate OPcache

opcache.inherited_hack (default "1")
	Enable this hack as a workaround for "can't redeclare class" errors.
	The OPcache stores the places where DECLARE_CLASS opcodes use
	inheritance (These are the only opcodes that can be executed by PHP,
	but which may not be executed because the parent class is missing due to
	optimization). When the file is loaded, OPcache tries to bind the
	inherited classes by using the current environment. The problem with this
	scenario is that, while the DECLARE_CLASS opcode may not be needed for the
	current script, if the script requires that the opcode at least be defined,
	it may not run. The default for this directive is disabled, which means
	that optimization is active. In php-5.3 and above this hack is not needed
	anymore and this setting has no effect.

opcache.dups_fix (default "0")
	Enable this hack as a workaround for "Cannot redeclare class" errors.

	The location of the OPcache blacklist file (wildcards allowed).
	Each OPcache blacklist file is a text file that holds the names of files
	that should not be accelerated. The file format is to add each filename
	to a new line. The filename may be a full path or just a file prefix
	(i.e., /var/www/x  blacklists all the files and directories in /var/www
	that start with 'x'). Line starting with a ; are ignored (comments).
	Files are usually triggered by one of the following three reasons:
	1) Directories that contain auto generated code, like Smarty or ZFW cache.
	2) Code that does not work well when accelerated, due to some delayed
	   compile time evaluation.
	3) Code that triggers an OPcache bug.

opcache.max_file_size (default "0")
	When this directive is enabled, files larger than the setting value
	are not  cached.

opcache.consistency_checks (default "0")
	Check the cache checksum each N requests.
	The default value of "0" means that the cache is never checked.
	Because calculating the checksum impairs performance, this directive should
	be enabled only as part of a debugging process.

opcache.force_restart_timeout (default "180")
	How long to wait (in seconds) for a scheduled restart to begin if the cache
	is not being accessed.
	The OPcache uses this directive to identify a situation where there may
	be a problem with a process. After this time period has passed, the
	OPcache assumes that something has happened and starts killing the
	processes that still hold the locks that are preventing a restart.
	If the log level is 3 or above, a "killed locker" error is recorded
	in the Apache logs when this happens.

	OPcache error_log file name. Empty string means "stderr".

opcache.log_verbosity_level (default "1")
	All OPcache errors go to the Web server log.
	By default, only fatal errors (level 0) or errors (level 1) are logged.
	You can also enable warnings (level 2), info messages (level 3) or
	debug messages (level 4).

	Preferred Shared Memory back-end. Leave empty and let the system decide.

opcache.protect_memory (default "0")
	Protect the shared memory from unexpected writing during script execution.
	Used for internal debugging only.

opcache.restrict_api (default "")
	Allows calling OPcache API functions only from PHP scripts from a path that
	starts from the specified string. The default "" means no restriction.

	Mapping base address of shared memory segments (Windows only). All PHP
	processes have to map shared memory into the same address space. This
	directive allows to manually fix "Unable to reattach to base address"
Something went wrong with that request. Please try again.