What is PHP8’s JIT?

JIT is a compiler strategy that expresses code into an intermediate state, converts it into architecture-dependent machine code at runtime, and executes it on the fly. In PHP8, Zend VM does not Certain opcodes need to be interpreted and these instructions will be executed directly as CPU level instructions.

JIT for PHP 8

PHP 8 Just In Time (JIT) Compiler The impact is unquestionable. But so far, I've found that very little is known about what JIT is supposed to do.

Recommended video tutorial: "PHP Programming from Beginner to Mastery"

After many studies and giving up, I decided to check the PHP source code myself. Combining some of my knowledge of the C language and all the bits and pieces of information I've gathered so far, I've come up with this article, which I hope will help you understand PHP's JIT better.

To put it simply: When the JIT works as expected, your code is not executed through the Zend VM, but directly as a set of CPU-level instructions.

That's the whole idea.

But to understand it better we need to consider how php works internally. Not very complicated, but needs some introduction.

How is PHP code executed?

As we all know, PHP is an interpreted language, but what does this sentence itself mean?

Every time PHP code (command line script or WEB application) is executed, it must go through the PHP interpreter. The most commonly used are the PHP-FPM and CLI interpreters.

The interpreter's job is simple: receive PHP code, interpret it, and return the result.

General interpreted languages ​​follow this process. Some languages ​​may eliminate a few steps, but the general idea is the same. In PHP, the process is as follows:

Reads the PHP code and interprets it as a set of keywords called Tokens. This process lets the interpreter know what code has been written in each program. This step is called Lexing or Tokenizing.

After getting the Tokens collection, the PHP interpreter will try to parse them. An abstract syntax tree (AST) is generated through a process called Parsing. Here AST is a set of nodes representing what operations to perform. For example, "echo 1 1" actually means "print the result of 1 1" or more specifically "print an operation, this operation is 1 1".

With AST, operations and priorities can be understood more easily. Converting an abstract syntax tree into an operation that can be executed by the CPU requires a transition expression (IR), which in PHP we call Opcodes. The process of converting ASTs into Opcodes is called compilation.

With Opcodes, here comes the fun part: executing code! PHP has an engine called Zend VM that is able to receive a sequence of Opcodes and execute them. After all Opcodes are executed, Zend VM terminates the program.

This is a process diagram including the Opcache extension:

What is the effect of JIT compilation?

After listening to Zeev's PHP and JIT broadcast on PHP Internals News, I figured out what JIT actually does.

If the Opcache extension can get Opcodes faster and transfer them directly to the Zend VM, the JIT allows them to run without using the Zend VM at all.

Zend VM is a program written in C that acts as a layer between Opcodes and the CPU. JIT generates compiled code directly at runtime, so PHP can

skip the Zend VM and be executed directly by the CPU. In theory, performance will be better.

This sounds strange because a specific implementation needs to be written for each type of structure before it can be compiled into machine code. But in fact this is reasonable.

PHP's JIT uses a library called DynaASM (Dynamic Assembler), which maps a set of CPU instructions in a specific format into assembly code for many different CPU types. Therefore, the compiler only needs to use DynASM to convert Opcodes into machine code for a specific structure.

However, there is a problem that has troubled me for a long time.

If preloading can parse PHP code into Opcodes before execution, and DynASM can compile Opcodes into machine code (Just In Time compilation), why don't we use pre-run compilation (Ahead of Time compilation) immediately What about compiling PHP immediately?

One of the reasons I found out by listening to Zeev's broadcast is that PHP is a weakly typed language, which means that PHP usually doesn't know the type of a variable until the Zend VM tries to execute an opcode.

You can check the Zend_value union type to learn that many pointers point to variables of different types. Whenever Zend VM tries to get a value from a Zend_value, it uses a macro like ZSTR_VAL to get a pointer to a string in the union type.

For example, this Zend VM handler handles "less than or equal to" (

It is not feasible to perform type inference logic using machine code, and may become slower.

Evaluating first and then compiling is also not a good option because compiling to machine code is a CPU-intensive task. So compiling everything at runtime is also not good.

Recommended tutorials: "PHP" "PHP7"

The above is the detailed content of What is PHP8’s JIT?. For more information, please follow other related articles on the PHP Chinese website!