Luiz Schons – Performance

JIT (Just in Time) — PHP

Tue, 28 May 2024 00:00:00 -0300

If you haven't upgraded to PHP 8.0 or later yet, it's time to do it. PHP 8.0 was released on November 26, 2020 and brought the JIT (Just In Time) compiler, which is what we are going to talk about today.

Opcode

When you run a PHP script, PHP compiles it into an intermediate code called opcode (PHP Opcode). The opcode is then executed by the Zend virtual machine.

Here is an example of PHP code and its opcode:

PHP:

$a = M_PI;
$b = 10 + sin($a);
echo "Result: ", $b;

Opcode:

Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename: /in/ceTlX
function name: (null)
number of ops: 9
compiled vars: !0 = $a, !1 = $b
line #* E I O op fetch ext return operands
-------------------------------------------------------------------------------------
 2 0 E > ASSIGN !0, 3.14159
 3 1 INIT_FCALL 'sin'
 2 SEND_VAR !0
 3 DO_ICALL $3
 4 ADD ~4 10, $3
 5 ASSIGN !1, ~4
 4 6 ECHO 'Result%3A+'
 7 ECHO !1
 5 8 > RETURN 1

Basically, opcode is a sequence of instructions that the Zend virtual machine executes.

JIT

So where does the JIT come in? The JIT is a compiler that compiles opcode into native machine code. In other words, it turns opcode into machine code that the CPU can execute directly.

This way, we no longer use the Zend virtual machine to execute the opcode, but the native machine code generated by the JIT.

Enabling the JIT

The JIT is not enabled by default. To enable it, you need a few extra steps.

First, you need to install the opcache extension:

sudo apt-get install php8.0-opcache

Then, you need to enable the JIT in the PHP configuration file (php.ini):

[opcache]
opcache.enable=1
opcache.jit_buffer_size=100M
opcache.jit=tracing
opcache.jit=1205
opcache.enable_cli=1

Here we are enabling the JIT and setting the JIT buffer size to 100 MB. The JIT can run in two modes: tracing and function. The tracing mode is the default and is faster, while the function mode is more precise.

To better understand the difference between the tracing and function modes, I recommend reading the official documentation.

Finally, we enable the JIT for the command line (opcache.enable_cli=1).

Benchmark

If you run PHP on the web, the JIT may not make much difference. But if you run PHP scripts on the command line, the JIT can bring a big performance gain.

So let's run a benchmark to compare PHP 8.0 performance with and without the JIT.

In the php-jit-doc repository you will find a PHP script that calculates a lot of things to keep the processor busy.

We won't go into the details of how this script is written or its patterns, since the focus is the JIT.

Let's run the script without the JIT:

./start.sh

The result was:

Execution time: 6.2343468666077 seconds
Encrypted: 46d37684d6032ef0167c00d29f3358d5a180438d3e8604e4c11728699d78fdb0a32284bfa8234ed59f69e7febd0d23bebab983211565582a98da8cb5c8800e42

Now let's enable the JIT and run the script again:

./start-jit.sh

The result was:

Execution time: 3.292811870575 seconds
Encrypted: 46d37684d6032ef0167c00d29f3358d5a180438d3e8604e4c11728699d78fdb0a32284bfa8234ed59f69e7febd0d23bebab983211565582a98da8cb5c8800e42

With the JIT enabled, the PHP script ran 3 seconds faster. That is a very significant performance gain.

But remember, the JIT is not a silver bullet. It may not make much difference for PHP scripts that run on the web. For PHP scripts that run on the command line, however, the JIT can bring a big performance gain.

Conclusion

This was a brief overview of the JIT in PHP 8.0. If you want to learn more about it, I recommend reading the official documentation.

I only brought basic, teaching examples so you can understand what the JIT is and how to enable it. I think it was important to cover this first so we can talk about more complex and advanced topics.

If you liked this content, leave a comment and share it with your friends. See you next time!

Parallel and Asynchronous Programming with PHP

Thu, 25 Apr 2024 00:00:00 -0300

Photo by Ben Griffiths on Unsplash

Introduction

PHP is a general-purpose programming language widely used for web development. However, PHP can also be used for desktop applications, automation scripts and more. In this article, we will explore using PHP for parallel and asynchronous programming.

Parallel Programming

Parallel programming is a programming paradigm that splits a problem into smaller parts that can run at the same time. In PHP, parallel programming can be done with the parallel extension or the pthreads extension, which let you create threads in PHP.

But do you know what a thread is?

A thread is a basic unit of processing that can run independently. In a parallel program, several threads can run at the same time, which can result in a significant performance boost.

When you buy a multi-core processor, you are buying the ability to run several threads at the same time. However, to take full advantage of that, the software has to be built to use those resources efficiently.

Parallel Programming Example in PHP

<?php
use function parallel\run;

class DataProcessor
{
 public function process(array $data): array {
 $formattedData = $this->formatData($data);
 $excel_file = $this->generateExcel($formattedData);
 $this->sendEmail($excel_file, Auth::user()->email);
 }
}

$data = range(1, 1000);
$processor = new DataProcessor();

$parallelResult1 = run(function () use ($processor, $data) {
 return $processor->process($data);
});

$parallelResult2 = $processor->process($data);

In the example above, we use the parallel extension to run the process method of the DataProcessor class in parallel. This means the method runs in a separate thread, which can result in better performance.

This is not a silver bullet, and it is not always the best solution for every problem. In some cases, however, parallel programming can be an efficient way to improve an application's performance.

The example above is quite simplified, but it shows how parallel programming can be used in PHP. For more information about the parallel extension, see the official documentation.

Here is an image illustrating parallel programming:

Illustration of parallel programming, taken from the internet.

Note that parallel programming is different from asynchronous programming. In parallel programming, several threads run at the same time, while in asynchronous programming several tasks can run concurrently, but not necessarily at the same time.

Asynchronous Programming

Asynchronous programming is a programming paradigm that runs tasks concurrently, without waiting for one task to finish before starting another. In PHP, asynchronous programming can be done with the swoole extension, which lets you create asynchronous web servers in PHP.

But do you know what an asynchronous web server is?

An asynchronous web server is a server that can handle several requests at the same time without creating a new thread for each one. This makes the server more efficient and able to handle a large number of requests concurrently.

You may see the term “self-contained server” in some places, but the idea is the same: a server that can handle several requests at the same time without creating a new thread for each one.

Asynchronous Programming Example in PHP

use Swoole\Http\Server;
$server = new Server("0.0.0.0", 9501);

$server->on("start", function (Server $server) {
 echo "Server started at http://{$server->host}:{$server->port}\n";
});

$server->on("request", function ($request, $response) {
 $data = $request->rawContent();
 $response->end("Received data: $data");
});

$server->start();

In the example above, we use the swoole extension to create an asynchronous web server in PHP. The server listens on port 9501 and answers every request with a message containing the data it received.

This example is quite simplified, but it shows how asynchronous programming can be used in PHP. For more information about the swoole extension, see the official documentation.

Here is an image illustrating asynchronous programming:

Illustration of asynchronous programming, taken from the internet.

Request Lifecycle in PHP-FPM

When a request is made to a PHP web server such as PHP-FPM, the server goes through several steps to process it and return a response to the client. The lifecycle of a request in PHP-FPM can be split into these steps:

Receiving the Request: The web server (Apache, Nginx, etc.) receives the client's request and forwards it to PHP-FPM.
Process Pool: PHP-FPM keeps a pool of preloaded PHP processes to handle requests. When a request arrives, PHP-FPM picks an available process to handle it.
Autoload: PHP-FPM loads the files needed to process the request, including the classes and functions used in the PHP script. Classes and functions are loaded automatically by PHP, following the autoload rules defined in composer.json.
Parsing and Compilation: PHP parses the PHP script and compiles the code into a form the PHP interpreter can execute.
Script Execution: PHP executes the script, processing its instructions and generating the request's output.
Building the Response: PHP-FPM builds the response, including the HTTP headers and the response body.
Sending the Response: PHP-FPM sends the response to the web server, which forwards it back to the client.
Ending the Process: After sending the response, the PHP process finishes and returns to the pool of processes available for new requests.

The lifecycle of a request in PHP-FPM can vary depending on the web server and PHP-FPM configuration. However, these steps are common to most PHP web servers.

Request Lifecycle in Swoole

When a request is made to an asynchronous PHP web server such as Swoole, the server goes through several steps to process it and return a response to the client. The lifecycle of a request in Swoole can be split into these steps:

The lifecycle starts when the Swoole server boots and sets up the PHP script that will handle requests. The Swoole server listens on a specific port and waits for requests to arrive.

At this point, the server already has autoload configured, the required classes and functions are already loaded, and the PHP script is ready to handle requests.

Receiving the Request: When a request reaches the Swoole server, the server receives it and passes it to the PHP script configured to handle it.
Processing the Request: The PHP script processes the request, running the instructions needed to generate the response.
Parsing and Compilation: PHP parses the PHP script and compiles the code into a form the PHP interpreter can execute.
Script Execution: PHP executes the script, processing its instructions and generating the request's output.
Building the Response: The PHP script builds the response, including the HTTP headers and the response body.
Sending the Response: The Swoole server sends the response to the client, ending the request's lifecycle.

At that point, the Swoole server is ready for new requests, keeping a pool of PHP processes available to handle them asynchronously.

The difference between the request lifecycle in PHP-FPM and in Swoole lies in how the PHP server boots and how requests are processed. In PHP-FPM, each PHP process is set up to handle one request at a time, while in Swoole the PHP server is set up to handle many requests asynchronously.

Conclusion

In this article, we explored using PHP for parallel and asynchronous programming. Parallel and asynchronous programming are techniques that can improve an application's performance and handle a large number of requests efficiently.

There are no hard rules, and parallel or asynchronous programming is not always the best solution to a problem. Still, it is always good to know the different techniques available and when to use them well.

I hope this article was useful and that you learned something new about parallel and asynchronous programming in PHP. In the future, I hope to write a more detailed article about each of these techniques, with more complex examples.

If you have any questions, corrections or suggestions, feel free to reach out. Thanks for reading this far!

References

Author

Luiz Schons