PHP 8.0 feature focus: Just-in-Time compilation

Understanding Programming Languages

Computers do not comprehend programming languages in the way humans do. Instead, they interpret very low-level instructions that are virtually impossible for humans to write manually. In this article, we will explore the various methods used to translate human-readable programming languages, such as PHP or Rust, into machine-understandable instructions.

Compilation: AOT (Ahead-of-Time)

One of the most fundamental and efficient methods of translation is Ahead-of-Time (AOT) compilation. This approach involves directly converting human-friendly source code into CPU instructions and storing them in a stand-alone executable binary file. Languages like C, C++, and Rust commonly employ this technique to achieve optimal performance.

Interpretation: Scripting Languages

Interpreted languages, often referred to as scripting languages, take a less efficient but more straightforward approach to translation. These languages employ an interpreter program that translates each line of source code into machine code as it is executed. PHP 3, for instance, used this method, resulting in significantly slower performance compared to modern PHP.

Virtual Machines: Striking a Balance

Another approach is the use of virtual machines, which operate similarly to interpreters but first convert the source code into a simpler language. This simplified language is a very low-level scripting language that can be interpreted much faster. This approach strikes a balance between complexity, development ease, and performance. Some languages, like Java, C#, and Go, perform this simplified language conversion ahead of time, while others, such as PHP, Python, or JavaScript, do it on-the-fly. Java calls its simplified version “bytecode,” while PHP uses the term “opcodes.”

Just in Time (JIT) Compilation

A recent trend in compilation is the introduction of Just in Time (JIT) compilers. A JIT compiler begins with the simplified intermediary language and converts it on-the-fly into machine code, which is stored in memory and executed. JIT compilers can be complex because they need to selectively determine which parts of the code should be compiled to machine code for optimal performance. The process of converting the simplified code to native machine code may sometimes take longer than running the simplified code itself. Consequently, JIT compilers often analyze the code as it runs to identify the most beneficial optimizations. Java was one of the first languages to incorporate JIT compilation, and PHP joined the list with PHP 8.0.

PHP’s JIT Compilation

The introduction of PHP’s JIT compiler has been a long-awaited development, with years of development effort preceding its release. The JIT is built as an extension to the opcode cache, allowing it to be enabled or disabled during PHP’s build or at runtime via php.ini configuration.

Configuring the JIT

The JIT extension is initially disabled and can be enabled in php.ini by setting opcache.jit_buffer_size to a non-zero value. This value determines the amount of memory space the JIT can use to store optimized machine code. It’s essential to strike a balance, as excessive memory allocation for the JIT could result in wasted resources. Another critical setting is opcache.jit, which controls four levels of JIT aggressiveness, represented as 4-digit numbers. However, fine-tuning the JIT configuration requires experimentation, as there is no one-size-fits-all approach.

Performance Implications

Whether the JIT compiler will improve performance depends on various factors. For web applications, the impact may be moderate, as PHP typically operates in a shared-nothing configuration, with each request exiting after processing. This leaves minimal time for the JIT to analyze and optimize code. Additionally, many web applications involve I/O operations, which the JIT cannot accelerate significantly. Nevertheless, in use cases beyond web development, such as persistent daemons, parsers, and CPU-intensive processes like machine learning, the JIT holds great potential for performance enhancements.

Expanding PHP’s Role

The JIT’s potential extends beyond traditional web applications. Persistent daemons, parsers, machine learning, and other long-running CPU-intensive processes stand to benefit significantly from the JIT’s capabilities. Applications like React PHP or AmPHP may also experience notable improvements. Furthermore, PHP’s adoption in machine learning libraries, such as Rubix ML or PHP-ML, could become more viable due to the potential speed boost provided by the JIT. PHP has evolved from being the fastest major web scripting language to a high-performance general data processing language, opening up new possibilities for developers worldwide.

Acknowledgments

The development of PHP’s JIT compiler has been a multi-year effort, and credit goes to Dmitry Stogov and Zeev Suraski for their dedication to making this RFC a reality.

Conclusion

In conclusion, PHP’s introduction of a Just in Time (JIT) compiler marks a significant advancement in the language’s capabilities. While its impact on web applications may be moderate, it holds the potential to revolutionize CPU-intensive processes, making PHP a viable choice for a wide range of high-performance applications. As PHP continues to evolve, developers can look forward to enhanced efficiency and versatility in their projects. Stay tuned for more exciting features and advancements in PHP 8.0 and beyond.