PHP 8.0: JIT

PHP was historically an interpreted language, that all of the code was interpreted by a virtual machine (Zend VM). This was changed with the introduction of Opcache and Opcodes, which were generated from the PHP code, and can be cached in memory. PHP 7.0 added the concept of AST (Abstract Syntax Tree), that further separated the parser from the compiler.

Just-In-Time?compilation is a hybrid model of interpreter and AOT (Ahead-of-Time) compilation, that some or all of the code is compiled, often at run-time, without requiring the developer to manually compile it.

PHP's JIT internally uses?DynASM?from LuaJIT, and as implemented as part of the Opcache.

DynASM

DynASM, from LuaJIT project, was much faster for PHP's JIT. Its support for target CPU instruction sets is limited compared to LLVM, but it provides support for x86 and x86-64 instruction sets; the most common ones for a server-side programming language such as PHP.

PHP 8.0's JIT implementation uses?DynASM?for its code generation. PHP's JIT is bound by the limitations of DynASM for target processor architectures.

How PHP JIT Works

PHP JIT is implemented as a part of Opcache. This keeps JIT separated from the PHP engine.

The three components of JIT is to store, inspect, and seamlessly invoke the code with the virtual machine or directly using the machine code stored in the buffer.

Buffer

The JIT bugger is storage where the compiled CPU machine is stored. By default buffer can be store 256M data. But you change it from the opcache.jit_buffer_size INI settings .

Triggers

Triggers in Opcache are responsible in invoking the compiled machine code when it encounters a code structure. These triggers can be a function call entry, a loop, etc.

Tracer

JIT tracer functionality inspects the code before, after, or during its execution, and determines which code is "hot", as in which structures can be compiled with JIT.

Tracer can compile the code as it is being run, when a certain code structure reaches the threshold, that is also configurable.

Tracing JIT and Function JIT

PHP 8.0 adds two?modes?of JIT operation. This is further customizable, but the most prominent types of JIT functionality are aliased?function?and?tracing.

Function JIT?mode is a rather simple one in comparison. It JIT compiles a whole function, without tracing for frequently used code structures such as loops inside a function.

Tracing JIT, that is selected by default in PHP 8.0, tries to identify the frequently used?parts?of code, and selectively compiles those structures for the best balance of compilation time and memory usage.

PHP's JIT implementation allows to fine tune?when?JIT should be used (when the script is loaded, after the first run, or during the execution),?what?(the whole function, or individual code structures), and?how?the optimizations be made (use of AVX instructions, use of CPU registers, etc.)

JIT-friendly code

If you want to get the best output from JIT optimization then you should write strictly typed code. As shown in the figure above.

Some of the improvements in PHP 7, in fact, come from these optimizations that it can eliminate dead code and improve reference counting. This means more strictly typed code gives more opportunities for PHP to optimize code at Opcache level, and also at JIT level.

Basic JIT Configuration

By default, JIT is enabled, but you turned off by change the configuration file.

By default JIT configuration is:

opcache.enable=1
opcache.enable_cli=1
opcache.jit_buffer_size=256M        

The?opcache.jit?directive allows to fine tune the JIT functionality.

opcache.jit=tracing        

opcode.jit?is a somewhat complicated configuration value. It accepts?disable,?on,?off,?trace,?function, and a 4-digit value (not a bit-mask) of 4 different flags in the order.

• disable: Completely disables JIT feature at start-up time, and cannot be enabled run-time.
• off: Disabled, but it's possible to enable JIT at run-time.
• on: Enables?tracing?mode.
• tracing: An alias to the?granular configuration?1254.
• function: An alias to the?granular configuration?1205.

PHP JIT accepts?tracing?or?function?as an easy configuration that represents a combination of configuration.

In addition to the?tracing?and?function?aliases, the?opcache.jit?directive accepts a?4-digit?configuration value as well. it can further configure the JIT behavior.

The 4-digit configuration value is in the form of?CRTO, where each position allows a single digit value for the flag designated by the letter.

JIT Flags

The?opcache.jit?directive accepts a 4-digit value to control the JIT behavior, in the form of?CRTO, and accepts following values for?C,?R,?T, and?O?positions.

CPU-specific Optimization Flags

• 0: Disable CPU-specific optimization.
• 1: Enable use of AVX, if the CPU supports it.

Register Allocation

• 0: Don't perform register allocation.
• 1: Perform block-local register allocation.
• 2: Perform global register allocation.

Trigger

• 0: Compile all functions on script load.
• 1: Compile all functions on first execution.
• 2: Profile first request and compile the hottest functions afterwards.
• 3: Profile on the fly and compile hot functions.
• 4: Currently unused.
• 5: Use tracing JIT. Profile on the fly and compile traces for hot code segments.

Optimization Level

• 0: No JIT.
• 1: Minimal JIT (call standard VM handlers).
• 2: Inline VM handlers.
• 3: Use type inference.
• 4: Use call graph.
• 5: Optimize whole script.

PHP Script Benchmark

Closing Thoughts

JIT implementation in PHP has significantly improved its performance and utilization of hardware capabilities. Years of development have resulted in substantial enhancements, particularly for computationally intensive workloads. However, there is still room for further improvement in PHP's JIT, and its performance is expected to continue getting better in the future.

References

1. https://php.watch/versions/8.0/JIT
2. https://php.watch/articles/jit-in-depth