In-depth understanding of PHP opcode caching principles

What is a opcode cache?

When the interpreter finishes parsing the script code, it generates intermediate code that can be run directly, also known as the opcode (Operate code,opcode). The goal of the Opcode cache is to avoid duplication of compilation and reduce CPU and memory overhead. If the performance bottleneck for dynamic content is not CPU and memory, but I/O operations, such as disk I/O overhead from database queries, the performance gains of the opcode cache are very limited. But since the opcode cache can bring down CPU and memory overhead, this is always a good thing.

Modern opcode buffers (optimizer+,apc2.0+, others) are stored using shared memory and can be executed directly from the file without the "deserialization" code before execution. This leads to significant performance acceleration, which typically reduces the overall server's memory consumption and has few drawbacks.

Why use the opcode cache?

This has to be said from the life cycle of the PHP code, which takes five steps when requesting a PHP script, as shown in:

The Zend engine must read files from the file system, scan its dictionaries and expressions, parse files, create computer code to execute (called opcode), and finally execute opcode. Each time the PHP script will execute the above steps, if the PHP source code does not change, then opcode will not change, obviously there is no need to re-generate opcode every time, combined with the ubiquitous caching mechanism in the web, we can cache opcode, It is not faster to access the cached opcode directly later, and the flowchart after enabling opcode caching is as follows:

are there those php opcode cache plugins?

Optimizer+ (optimizer+ in mid-March 2013 opcache,php 5.5 episode Opcache, the others will not disappear? ), Eaccelerator, XCache, APC ...

PHP opcode principle

OpCode is a PHP script-compiled intermediate language, like Java's bytecode, or. NET MSL, for example, you write down the following PHP code:

1. <?php
2. echo "Hello World";
3. $a = 1 + 1;
4. echo $a;
5. ?>

PHP executes this code in the following 4 steps (to be exact, it should be PHP's language engine Zend)

1. Scanning (lexing), converting the PHP code to a language fragment (Tokens)
2. parsing, converting tokens into simple and meaningful expressions
3. compilation, compile the expression into Opocdes
4. Execution, execute opcodes sequentially, one at a time, thus realizing the function of PHP script

Aside: Now some caches such as APC, can make PHP cache opcodes, so that every time there is a request, there is no need to repeat the previous 3 steps, so that can greatly improve the speed of PHP execution.

Then what is lexing? The students who have learned the principles of compiling should have some knowledge of the lexical analysis steps in the compiling principle, Lex is a basis table for lexical analysis. ZEND/ZEND_LANGUAGE_SCANNER.C will perform lexical analysis based on the PHP code entered by the ZEND/ZEND_LANGUAGE_SCANNER.L (lex file) to get a "word", PHP4.2 began to provide a function called Token_get_all, this function can be said a section of PHP code scanning into tokens;

If we use this function to process the PHP code we mentioned at the beginning, we will get the following result:

2. Array
4. (
6. [0] = = Array
8. (
10. [0] = 367
12. [1] = = Array
14. (
16. [0] = 316
18. [1] = echo
20. )
22. [2] = = Array
24. (
26. [0] = 370
28. [1] = =
30. )
32. [3] = = Array
34. (
36. [0] = 315
38. [1] = "Hello World"
40. )
42. [4] = =;
44. [5] = = Array
46. (
48. [0] = 370
50. [1] = =
52. )
54. [6] = =
56. [7] = = Array
58. (
60. [0] = 370
62. [1] = =
64. )
66. [8] = = Array
68. (
70. [0] = 305
72. [1] = 1
74. )
76. [9] = = Array
78. (
80. [0] = 370
82. [1] = =
84. )
86. [Ten] = +
88. [one] = = Array
90. (
92. [0] = 370
94. [1] = =
96. )
98. [+] = Array
100. (
102. [0] = 305
104. [1] = 1
106. )
108. [+] =;
110. [+] = Array
112. (
114. [0] = 370
116. [1] = =
118. )
120. [+] = Array
122. (
124. [0] = 316
126. [1] = echo
128. )
130. [+] = Array
132. (
134. [0] = 370
136. [1] = =
138. )
140. [+] =;
142. )

Analysis of the return result we can find that the source of strings, characters, spaces, will be returned as is. Each character in the source code appears in the appropriate order. And, other such as tags, operators, statements, will be converted to a two-part Array:token ID (that is, in the Zend internal change Token of the corresponding code, such as, t_echo,t_string), and the source of the original content.

Next, is the parsing stage, parsing first discards more spaces in the tokens array, and then converts the remaining tokens to a simple expression of one

1. echo a constant string
2. Add numbers together
3. Store the result of the prior expression to a variable
4. echo a variable

Then change the compilation stage, it will tokens compiled into a op_array, each op_arrayd contains the following 5 parts:

1. The identification of the opcode number, indicating the type of operation for each op_array, such as Add, echo
2. Results Store opcode results
3. Operand 1 to opcode operand
4. Number of Operations 2
5. Extended value 1 shaping to differentiate the overloaded operator

For example, our PHP code will be parsing into:

1. * zend_echo ' Hello world '
2. * Zend_add ~0 1 1
3. * Zend_assign!0 ~0
4. * Zend_echo!0

You might ask, where is our $ A?

This introduces the operands, each of which consists of the following two parts:

1. Op_type: For Is_const, Is_tmp_var, Is_var, is_unused, or IS_CV b)
2. U, a consortium, holds the value (const) or Lvalue (Var) of this operand in different types, depending on the op_type.

And for Var, every Var is different.

Is_tmp_var, as the name implies, this is a temporary variable, save some Op_array results, so that the next op_array to use, this operand of u holds a pointer to the variable table of a handle (integer), this operand is generally used to start, such as ~0, A temporary variable that represents the unknown number No. 0 of the variable table

Is_var This is our general sense of the variable, they start with a $ expression

IS_CV says ZE2.1/ PHP5.1 later compiler uses a cache mechanism, this variable holds the address of the variable referenced by it, when a variable is referenced for the first time, it will be CV up, the reference to this variable will not need to find the active symbol table again, CV variable to! The beginning indicates.

So it seems that our $ A is optimized to 0.

Reference: http://www.laruence.com/2008/06/18/221.html

In-depth understanding of PHP opcode caching principles