Home > Article > Backend Development > An article explaining the principle and use of PHP opcache in detail
This article brings you relevant knowledge about PHP opcache. It mainly talks about how to understand the OPCache function and how to use it. Interested friends can take a look at it together. I hope Helpful to everyone.
In PHP projects, especially in scenarios with high concurrency and large traffic, how to improve the response time of PHP is a very important task.
Opcache is an indispensable component for optimizing PHP performance, especially in projects that apply the PHP framework.
1. Overview
Before understanding the OPCache function, we must first understand the working mechanism of PHP-FPM Nginx and the mechanism of PHP script interpretation and execution.
1.1 The working mechanism of PHP-FPM Nginx
The request goes from the web browser to Nginx, and then to PHP processing. There are a total of five steps:
First Step: Start the service
#Start PHP-FPM. PHP-FPM supports two communication modes: TCP socket and Unix socket;
PHP-FPM will start two types of processes: Master process and Worker process. The former is responsible for monitoring ports and allocation Tasks and management Worker processes; the latter is PHP's cgi program, which is responsible for interpreting, compiling and executing PHP scripts.
Start Nginx. First, the ngx_http_fastcgi_module module will be loaded to initialize the FastCGI execution environment and implement the FastCGI protocol request proxy
Note here: the fastcgi worker process (cgi process) is managed by PHP-FPM. Not Nginx. Nginx is just a proxy
Second step: Request => Nginx
Nginx receives the request and configures it based on location , choose a suitable handler
Here is the handler for proxy PHP
##The third step: Nginx => PHP-FPM
Step 4: PHP-FPM Master => Worker
After understanding the overall processing flow of PHP Nginx, let’s take a look at the specific execution flow of PHP scripts. First, let’s look at an example:
<p><?php <br> if (!empty($_POST)) {<br> echo "Response Body POST: ", json_encode($_POST), "\n";<br> }<br> if (!empty($_GET)) { <br> echo "Response Body GET: ", json_encode($_GET), "\n";<br> }<br></p>Let’s analyze the execution process:
1.php initializes the execution link, starts the Zend engine, and loads the registered extension module2. After initialization, read the script file, Zend The engine performs lexical analysis (lex) and syntax analysis (bison) on the script file to generate a syntax tree
3.Zend engine compiles the syntax tree and generates opcode,
4.Zend engine executes opcode and returns the execution result
In PHP cli mode, each time a PHP script is executed, the four steps will be executed in sequence;
In fact, the syntax tree and opcode generated by steps 2) and 3), the same PHP script will have the same result every time it is run. In PHP -In FPM mode, each request must be processed again, which is a huge waste of system resources. So is there any way to optimize it?
Of course, such as:
OPCache is officially produced by Zend and is open The free opcode cache extension also has code optimization functions, eliminating the overhead of loading and parsing PHP scripts each time. The OPcache extension has been bundled in PHP 5.5.0 and subsequent versions. Cache two types of content:
The main mechanism of OPCache caching is to put compiled operation codes into shared memory and provide access to other processes. This involves the memory sharing mechanism. In addition, all memory resource operations have locking issues. We will explain them one by one.
3.1 Shared memoryUNIX/Linux systems provide many ways to share memory between processes:
1.System-V shm API: System V shared memory
sysv shm is persistent unless explicitly stated by a process deleted, otherwise it will always exist in the memory until the system is shut down;
2.mmap API:
The memory mapped by mmap is not persistent. If the process is shut down, the mapping It will become invalid immediately, unless it has been mapped to a file in advance
The memory mapping mechanism mmap is a POSIX standard system call, and there are two types: anonymous mapping and file mapping
One of the advantages of mmap is that it maps files to the address space of the process
avoids the copying process of data from the user buffer to the kernel page cache buffer;
Of course, another advantage is that frequent read/write system calls are not required
3.POSIX API:
System V’s shared memory is Outdated, POSIX shared memory provides an API that is simpler to use and more rationally designed.
4.Unix socket API
OPCache uses the first three shared memory mechanisms, depending on the configuration or default mmap Memory sharing mode. According to the scenario of PHP bytecode caching, OPCache's memory management design is very simple, with fast reading and writing, no memory release, and expired data is set to Wasted.
When the Wasted memory is greater than the set value, the OPCache mechanism is automatically restarted, the cache is cleared and regenerated.
3.2 Mutex lock
Any operation of memory resources involves the lock mechanism.
Shared memory: Only one process is allowed to perform write operations in a unit time, and multiple processes are allowed to perform read operations; while writing operations are performed, read operations are not blocked, so that there is rarely a lock-up situation.
This leads to another problem: new code, large traffic scenarios, processes queue up to perform cache opcode operations; repeated writing leads to waste of resources.
4. OPCache cache interpretation
OPCache is the official Opcode cache solution. After PHP5.5 version, it has been packaged into PHP source code and released together.
It caches the bytecode and data generated by PHP compilation into shared memory. At each request, the compiled opcode is directly read from the cache and executed.
Improve the running efficiency of PHP by saving the script compilation process. If you are using the APC extension to do the same job, it is now highly recommended to use OPCache instead, especially in PHP7.
4.1 OPCode
Cache Opcache will cache OPCode and the following content:
Functions involved in PHP scripts
Class defined in PHP script
PHP script file path
PHP script OPArray
PHP script’s own structure/content
4.2 Interned String
Caching First we need to understand, what is Interned String?
In PHP5.4, the Interned String mechanism was introduced to optimize PHP's storage and processing of strings. Especially when dealing with large blocks of strings, such as PHP doces, Interned String can optimize memory. The contents of the Interned String cache include: variable names, class names, method names, strings, comments, etc.
In PHP-FPM mode, Interned String cache characters are limited to within the Worker process. If cached in OPCache, the Interned String cached string can be used between Worker processes to save memory.
We need to pay attention to one thing. In PHP development, there are usually large comments, which will also be cached in OPCache. You can turn off the caching of comments through the configuration of php.ini.
However, in frameworks such as Zend Framework, comments will be referenced, so whether to turn off the cache of comments needs to be treated differently.
5. OPCache update strategy
is a cache, which has expiration and update strategies. The update strategy of OPCache is very simple. The expired data is set to Wasted. When the set value is reached, the cache is cleared and the cache is rebuilt.
Note here: In high-traffic scenarios, rebuilding the cache is a very resource-consuming task. OPCache does not prevent other processes from reading when creating the cache. This results in a large number of processes repeatedly creating new caches. Therefore, do not set the OPCache expiration time
Every time new code is released, the cache will be repeatedly created. How to avoid it?
Don’t release code during peak periods, this is a rule that must be followed under any circumstances
Code warm-up, such as using script batch debugging PHP accesses the URL, or uses the API exposed by OPCache such as opcache_compile_file() for compilation and caching
6. OPCache configuration
6.1 Memory configuration
opcache.preferred_memory_model="mmap" OPcache's preferred memory module. If left blank, OPcache will select the applicable module. Normally, automatic selection will suffice. Optional values include: mmap, shm, posix and win32.
opcache.memory_consumption=64 OPcache shared memory size in megabytes, default 64M
opcache.interned_strings_buffer=4 Use Memory size to store temporary strings, in megabytes, default 4M
opcache.max_wasted_percentage=5 The upper limit of wasted memory, in percentage. If this limit is reached, OPcache will generate a restart event. Default 5
6.2 Number and size of files allowed to be cached
opcache.max_accelerated_files=2000 The upper limit of the number of script files that can be stored in the OPcache hash table. The real value is the first prime number found in the prime number set {223, 463, 983, 1979, 3907, 7963, 16229, 32531, 65407, 130987} that is greater than or equal to the set value. The minimum value range of the setting value is 200, the maximum value is 100000 before PHP 5.5.6, and 1000000 after PHP 5.5.6. Default value 2000
opcache.max_file_size=0 The upper limit of cached file size in bytes. Set to 0 to cache all files. Default value 0
6.3 Comment related cache
opcache.load_commentsboolean If disabled, these will not be loaded even if the file contains comments Annotation content. This option can be used together with opcache.save_comments to load comment content on demand.
opcache.fast_shutdown boolean If enabled, fast stop resume events will be used. The so-called quick stop resumption event refers to the memory management module that relies on the Zend engine to release the memory of all requested variables at once, rather than releasing each allocated memory block in sequence.
6.4 Second-level cache configuration
opcache.file_cache Configure the second-level cache directory and enable the second-level cache. Enabling second-level cache can improve performance when the SHM memory is full, the server is restarted, or the SHM is reset. The default value is the empty string "", which disables file-based caching.
opcache.file_cache_onlyboolean Enables or disables opcode caching in shared memory.
opcache.file_cache_consistency_checksboolean Whether to verify the checksum of the file when loading the script from the file cache.
opcache.file_cache_fallbackboolean On Windows platforms, when a process cannot attach to shared memory, file-based caching is used, that is: opcache.file_cache_only=1. File caching needs to be enabled explicitly.
Recommended learning: "PHP Video Tutorial"
The above is the detailed content of An article explaining the principle and use of PHP opcache in detail. For more information, please follow other related articles on the PHP Chinese website!