One minute to understand whether PHP is interpreted or compiled?

• The running efficiency is much slower than compiled programs. The interpreter does a lot of code optimization and runtime security checks; these extra steps take up more resources and further slow down the application.

OK, through the above study, I believe everyone has a general understanding of interpreted languages ​​and compiled languages, and PHP language is an interpreted language, and the interpreter that interprets PHP language is the Zend engine .

Moreover, based on the comparison of the advantages and disadvantages of the two, it can be found that compiled languages ​​are more suitable for low-level operations, while interpreted languages ​​are more used in Web development.

Let’s take a deeper look at the execution process of PHP:

The compilation and execution of PHP are separated, that is: the compilation is completed first, and then executed. Many people will say: The same is true for c, indeed. However, this separation of PHP can provide us with a lot of convenience, but of course it also has many disadvantages.

Let’s talk about the whole process first:

①php will call the compilation function zend_compile_file() to compile. The specific implementation of this function actually includes two main processes: lexical analysis (Lex implementation) and syntax analysis (Yacc implementation). After executing this function: the compilation of the php script is complete. The input of this function is: php script file, and the output is op_array. To put it simply: the compilation process is to parse the script into instructions that the php virtual machine can process, and op_array is just an array made of these instructions ( This is very similar to the assembly code generated by compilation of some compiled languages, which are also commands one by one).

②: Then the php virtual machine will call the zend_execute() function to execute. The input of this function is the op_array generated in the compilation stage above, where it will parse each command and process it. Since there are about 150 op commands in total, it needs to process these 150 commands. A very interesting question arises here: How does it handle these 150 commands? First of all, each command has a corresponding processor for processing. Therefore: the virtual machine will be distributed to the corresponding processor for processing based on the type of each command in op_array.

There are two small questions here: 1: What is the processor here? 2: How is it distributed?

To answer these two questions, we need to explain it from the distribution mechanism: There are three mechanisms for the PHP virtual machine to distribute commands: CALL, SWITCH, and GOTO. PHP uses the CALL method by default, and That is, all opcode processors are defined as functions and then called by the virtual machine. This method is the traditional method and is generally considered the most stable method. The SWITCH method and the GOTO method distribute opcodes through switch and goto. to the corresponding processing logic (segment) for execution.

Now let’s answer the two questions above:

1: The processor actually processes the logic of the op command. It can exist in the form of a function or a logical segment, depending on how the command is distributed.

2: There are three distribution methods: call, switch and goto. Which one is more efficient? In fact, you can already have a preliminary understanding from the above explanation. Both switch and goto have corresponding logical segments in the zend_execute() function, which can be executed directly. The call executes the function call in the zend_execute() function. It's obvious: function calling efficiency is the lowest, and you have to push it on the stack after calling it once! So in terms of efficiency: call is the lowest. For switch and goto: For example, if you want to execute the processing of the third command: switch must first judge whether it is the first two, while goto does not need to judge at all and jumps directly to the logical code segment of the third command for execution. This is better than Switch reduces the loss of sequential judgment from top to bottom, so: goto efficiency is higher than switch. So in general, these three distribution methods: goto > switch > call

Let’s talk about the weakness of PHP’s separation of compilation and execution:

In fact, it can’t It is considered a weakness. Although the zend engine (php's virtual machine) strictly separates compilation and execution, for the user: it is as if there is no separation, because every time I execute a PHP script request, I have to execute: compile->execute these two stages. No stage is missing. So we can compare this with a compiled language like c: Run the same request 100 times

① For c, since it only needs to be compiled once in the early stage, it will not be compiled again after it is compiled. , it only needs to be executed, so the loss is:

1 compile and execute 100 times

② For php, it needs to be compiled and executed every time, so the loss is:

Compile 100 times and execute 100 times

Obviously: From a quantitative point of view, interpreted languages ​​consume much more than compiled languages. To put it bluntly: the separation of compilation and execution of PHP is not a real separation. And c is the real separation.

PHP has been aware of this problem for a long time, so it thought of a way to solve this problem: this solution is eAccelerator. The main idea is as follows:

After the script is run for the first time, the compiled script is saved in a certain way (op_array is stored in it). Within the cache validity time specified by us, when the script is run for the second time At this time, there is no need to perform repetitive compilation work, but directly call and execute the compiled file saved previously, which greatly improves program performance.

Finally, let’s talk about the advantages of separating PHP compilation and execution;

This advantage is actually for programmers, not for users. Because of the separation of these two stages, we can do some things we want to do here.

For example, if you want to encrypt and decrypt files, you want to encrypt some php script source code files so that users cannot see the source code. At the same time, this encrypted source code file can be parsed and processed by the PHP virtual machine. Of course: to achieve this, you must first think about the encryption and decryption algorithm and ensure that this is a reversible process.

Now that you have encrypted the php source code file, you need to define the suffix of this encrypted file, assuming it is: *.buaa. The question is: How do we enable the PHP virtual machine to process files with this suffix? This requires the separation of compilation and execution mentioned above.

Recall: the input of the compilation phase is the php source file, and the output is op_array. OK, let’s make a fuss at this stage. The main idea is: first in the compilation function zend_compile_file(): look at the suffix of the input file: if it is normal .php, then follow the normal logic; if it is *.buaa, then decrypt it first and then follow the normal logic. . .

Conclusion:

• PHP is an interpreted language. The PHP code is interpreted into opcode and then handed over to the Zend engine for execution.

• Use APC to cache opcode, reducing the time for PHP to interpret it as opcode.

Recommended learning: php video tutorial