The paper analyzes various versions of the popular PHP programming language. It is used in web development and there are many popular website engines and frameworks written in PHP. Many new and useful features of PHP 8, such as JIT compiler, error correction, etc., are described, which are useful for both users and developers. A testing system has been developed for diferent versions of PHP, which can be extended by other modules if necessary. The result of the system is time data reflecting the speed of the selected PHP version.
Nowadays, there are many programming languages such as JavaScript, goLang, Java, etc. They are diferent in purpose thus their use is also limited. When we talk about web development languages, we can’t mention PHP.
PHP is a widely used language for web implementations, which occupies more than 78% of
the market for server solutions [
PHP is an open source language, meaning users can modify or modify it. It can be used and distributed to other users and organizations.
PHP’s syntax is similar to C. Elements such as associative arrays and the foreach loop are borrowed from Perl. The execution of the program does not require the description of variables, modules, or etc, but this language supports OOP (fully from version 5). The program begins with the operator <?php, which indicates the start of script execution. There is also a shortened version to output the string <?=. Execution ends with the ?> operator, but if the entire file consists only of PHP code, then you do not need to use the closing operator.
Variable names begin with the $ character, without specifying the type of the variable itself, and are case sensitive.
When comparing PHP to JavaScript and its newer server-side implementations, PHP still comes out on top. PHP is interpreted by the web server into HTML code, which is transmitted to the client side. Unlike JavaScript, the user does not have access to the PHP code, which is an advantage from a security point of view, but significantly impairs the interactivity of the pages. However, nothing prohibits the use of PHP to generate JavaScript code that will be executed on the client side.
Many features are built into PHP that make it possible not to write them multi-line like in C or Pascal. There are libraries for working with many databases, such as MySQL, PostgreSQL, mSQL, Oracle, dbm, Hyperware, Informix, InterBase, Sybase, etc.
There is also the PHP Data Object – PDO module, which provides a simple and consistent
interface for accessing databases, which has many methods for using databases and protection
against SQL injections [
The attribute syntax consists of several parts. First, an attribute declaration always begins with the #[and ends]. Inside an enumeration of one or more comma-separated attributes. Attributes can be specified using partial, full, and absolute names.
Attribute arguments are optional, but if present, they are enclosed in braces (). Attribute arguments can be either specific values or constant expressions. Both positional and named argument syntax can be used for arguments. When an attribute is requested using the Reflection API, its name is interpreted as a class name, and arguments are passed to its constructor. Thus, for each attribute there must be a corresponding class.
However, there is a big problem with the PHP community. Many websites are still using
outdated and no longer supported versions of PHP. According to W3Techs [
This is achieved in work by developing a system, with the help of the results of which determine the most productive version of PHP among the specified ones. To achieve this the following tasks must be completed: • analyze the features of diferent versions PHP; • design a performance analysis system; • select mathematical and other operations for performance research; • implement the system; • analyze the performance of PHP of diferent versions on selected operations and visualize the obtained results; • analyze the obtained results.
The keyword class was reserved even in the third version of the language, in the fourth it was already possible to create classes and objects of these classes. Nevertheless, until the fifth version, the principles of OOP were not fully implemented, since all methods and properties were open privacy and were not a cheap wish on the part of the runtime.
The use of classes in PHP is similar to C, a class is declared by the keyword class, it can
have properties and methods of a certain privacy, namely public, which are available from
anywhere, protected, which the class itself and its successors have access to, and private, which
are not no one has access except the class itself. PHP supports all OOP mechanisms such as
encapsulation, polymorphism, and inheritance. Also the use of such keywords as final, abstract,
extend, implement [
Any class can have many interfaces that it implements, but can inherit only one of the classes. To solve this problem, version 5.4.0 introduced a code reuse mechanism called trait. Many traits can be used in a class using the use word, but it is not possible to get a trait object. At runtime, the trait’s code will be “mounted” to the class that uses it.
PHP 5 [
Starting with PHP 8.0.0, constructor parameters can be used to set the appropriate properties of an object. It is a fairly common practice to give object properties the parameters passed to the constructor without doing any additional transformations. In this case, defining the properties of the class in the constructor allows you to significantly reduce the amount of template code.
Starting with PHP 8.0.0, properties and methods can also be accessed using the “nullsafe” operator: ?->. The nullsafe operator works in the same way as a property or method access, except that if the variable that contained an object of class actually returns null, then null is returned instead of an exception being thrown. If the dereference is part of a string, the rest of the string is skipped. Similar to the conclusion of each call in is_null(), but more compact.
Performance improvements continued: the hash table (PHP’s main data structure) was optimized, specialization of certain opcodes in the Zend VM and specialization of certain sequences in the compiler were implemented, the optimizer (OpCache component) was continuously improved, and many other changes were made.
According to PHP developer Dmytro Stogov: “JIT is extremely simple, but in any case it
increases the level of complexity of PHP, the risk of new bugs appearing, and the cost of
development and maintenance” [
To carry out complex testing, it is necessary to develop a system that would perform operations
that require only one computer resource. These components are the CPU and hard disk. The
results of the tests will be time indicators, by which it will be possible to compare diferent
versions of the PHP language. Accordingly, shorter execution time is better [
To implement the system as a web page, it is necessary to have a web server that would perform the necessary actions on a request by URL address.
Apache and Nginx were considered among the local servers. These are the two most common open source web servers in the world. Together, they serve more than 50% of the world’s trafic. Both solutions are able to work with diferent work programs and interact with other applications to implement a complete web stack. Although Apache and Nginx have many similar qualities, they cannot be considered as completely interchangeable solutions, as each has its own capabilities.
Apache provides several multi-processing modules (MPM), which are responsible for how
the client’s request will be processed. This allows administrators to define connection handling
policies [
Nginx came later than Apache, so its developer was more aware of the competitive issues that sites face when scaling. Thanks to this knowledge, Nginx was originally designed based on asynchronous non-blocking event-driven algorithms. Nginx creates worker processes, each of which can serve thousands of connections. Workers achieve this result thanks to a mechanism based on a fast cycle in which events are checked and processed. Separating the main work from connection processing allows each Worker to do its job and be distracted from connection processing only when a new event occurs.
Looking at real-life examples, the main diferences between Apache and Nginx are how they
handle requests to static and dynamic content. Apache can serve static content using standard
ifle-based methods. Productivity of such operations depends on the selected MPM [
Nginx does not have the ability to handle dynamic content requests on its own. To handle requests to PHP or other dynamic content, Nginx must pass the request to an external processor for execution, wait for the response to be generated, and receive it. The result can then be sent to the client.
To test diferent versions of PHP, it is necessary to implement a system that includes classes that would present each type of test.
The following image (figure 1) shows a visual representation of the basic PHP execution process.
PHP execution is a 4-step process [
• interpretation – opcodes are interpreted and run on the Zend VM.
OPcache improves PHP performance by storing precompiled script bytes in shared memory, eliminating the need to load and parse PHP scripts for each request (figure 2).
The project does not require any frameworks. Structurally, the project will consist of a configuration file, a class for each module to be tested, a class for displaying results on the screen, and an executable file – the starting point.
The script can be called both from the console and as a web page. Calling the initial file will
in turn call an object of the Benchmark class, which starts the initialization of information about
the enabled modules for testing. Next, all the modules will be performed one by one with the
output of the results of their work [
To implement the project and meet the need for future scaling, we will broadly plan the project tree. It will consist of a configuration directory, modules, and the home classes for those modules.
First in line is the configuration file. It contains input data about the requested modules to be executed, as well as parameters to them. In this way, we can enable, disable or expand the functionality of the project without changing the existing code. Those modules considered to be CPU and Disk operations since they are considered as heavy one’s and access to which was changed from version to version of PHP.
Among the functions there were selected 12 math operations and 12 string conversions.
Those are abs, acos, asin, atan, bindec, floor, exp, sin, tan, is_finite, is_nan, sqrt for math and addslashes, chunk_split, metaphone, strip_tags, md5, sha1, strtoupper, strtolower, strrev, strlen, soundex and ord for string conversion.
The next section is the directory of the actual project. The first owned folder contains the Conifg class, which is responsible for receiving from it the data obtained from the YamlConfigLoader – the configuration file parsing class.
The following directory contains helper classes for system operation, such as: • Directory – creates a temporary directory during tests of writing files to disk and deletes them after the test; • Size – contains information about file weight units, as well as byte and format conversion methods; • Table – exists for the generating table borders for the presentation view; • Utility – implements the function of dynamically adding an argument for variable SQL operations; • Visual – a separate class designed to display information with a line separator parameter. The following directory contains the modules that will be executed, namely: • CPU – contains the logic of performing arithmetic operations, converting lines, calculating the execution time of cycles and if-else expressions. • Disk – creates files of a given weight, writes them to a temporary directory and deletes them after time measurements. • MySQL – a class for implementing and calculating the execution time of a random operation.
• PHP – providing information about the version of PHP.
Among the functions that will be executed by the CPU are such string conversion functions as: addslashes, chunk_split, metaphone, strip_tags, md5, sha1, strtoupper, strtolower, strrev, strlen, soundex, ord.
Among the functions that will be performed by the CPU are such mathematical functions as: abs, acos, asin, atan, bindec, floor, exp, sin, tan, is_finite, is_nan, sqrt.
The features identified are chosen because of their prevalence of use among their categories.
The following file volumes were written to disk: 512, 1024, 2048, 4096, 8192, 16384, 32678, 65536.
Next is the Benchmark class, which includes all the modules and starts their execution. In the root directory there is a file – the starting point for performing all tasks.
To use the project, you need to have an installed Composer – the application level package
manager for PHP. With its help, we can use ready-made package solutions, so as not to implement
them ourselves from scratch [
All defined packages, after they are requested by the composer, are placed in the vendor directory, which should not be added to Git commits, since the vendor folder can weigh many gigabytes. To work around this flaw, composer generates a composer.json file and a composer.lock file.
Json contains project dependencies for execution and is converted to a lock file, which is actually executed by the composer. Thus, only one file is needed to “transfer” the vendor, after cloning, or whatever, the project, we will only need to execute composer install and we will get all the dependencies to our local project.
You can get the results either by executing the benchmark.php file in the terminal as php benchmark.php, or by running a local server, on the web page of which we will see the same results – php -S localhost:8000 benchmark.php.
The project tree looks like this (figure 3):
Since an OOP approach was chosen for the implementation, all files are located according to their purpose and have namespaces to uniquely define each class.
The configuration file has the following structure (figure 4). It allows us to define each module’s parameters such as: • Enabled – defines whether the module will be used during the benchmark; • Disk cycles – the amount of read/write operations; • CPU math/strings/loops/ifElse count – the amount of recurring operations; • MySQL – describes the access to the database, it’s name and amount of allowed operations.
As you can see, we can set the number of repetitions of each operation, enable or disable any module, and set database connection options.
The Config class has several methods, but the main one is constructor initialization.
Initialization of the constructor of the Config class: public function __construct() { $locator = new FileLocator([
__DIR__ . DS . ’..’ . DS . ’..’ . DS . $this->directory ]); try { $loader = new YamlConfigLoader($locator); $this->config = $loader->load(
$locator->locate($this->file) ); } catch (\Exception $e) { Visual::print($this->file . ’ could not be loaded, please copy ’ . $this->directory . ’/config.yml.example to ’ . $this->directory . ’/’ . $this->file); }
The result of this method is an object of the Config class with certain properties obtained using the YamlConfigLoader. The properties of this class will be used many times in the future.
Next, the modules and their supporting classes should be implemented. The first module is the CPU. In order not to implement all mathematical functions manually, they can be called in a loop. The implementation of mathematical operations is given below.
Method of execution of mathematical functions: private function math(): void { foreach (self::$mathFunctions as $function) { $this->mathResults[’x’][$function] = 0; $start = \microtime(true); for ($i = 0; $i < $this->mathCount; $i++) {
\call_user_func_array($function, array($i)); } $this->mathResults[’x’][$function] +=
(\microtime(true) - $start); } } }
As a result of its execution, we will receive an array with the names of operations and their time indicators. The same goes for string conversion functions.
Method for performing string conversion functions: private function strings(): void { foreach (self::$stringFunctions as $function) { $this->stringsResults[’x’][$function] = 0; $start = \microtime(true); for ($i = 0; $i < $this->stringsCount; $i++) {
\call_user_func_array($function, array(self::$string)); } $this->stringsResults[’x’][$function] += There are also separate implementations for checking loops and logical operators.
Method for checking the speed of cycles: private function loops(): void { $start = \microtime(true); for ($i = 0; $i < $this->loopsCount; ++$i); for ($i = 0; $i < $this->loopsCount; ++$i); $this->loopsResults = (\microtime(true) - $start);
The speed test method of the IfElse statement: private function ifElse(): void { $start = \microtime(true); As a result of their execution, we will receive their results as properties of the CPU class. The next module is Disk. It contains a list of weights for the files being created. A property of the Disk class that describes file volumes: private $commonBlockSizesBytes = [ 512, 1024, 2048, 4096, 8192, 16384,
The main method of the Disk class: private function run(): void { $initial = \time(); $tmpDirectoryPath = \realpath(self::$path) . self::$tmpDirectory; try { // Create subdirectory Directory::create($tmpDirectoryPath); foreach ($this->commonBlockSizesBytes as $bytes) {
$this->counterFileCreation[’Run’][$bytes] = 0; } for ($c = $this->cycles; $c >= 0; $c--) { // Generate files with different block sizes foreach ($this->commonBlockSizesBytes as $bytes) { $prefix = $initial . ’_’ . $bytes; $content = $this->getRandomBytes($bytes); // Start the timer (measure only disk interaction, //not string generation etc) $start = \microtime(true); $file = \tempnam($tmpDirectoryPath, $prefix); \file_put_contents($file, $content); // Stop timer & append time to timer array // with this block size $this->counterFileCreation[’Run’][$bytes] +=
(\microtime(true) - $start); } } // Clean up
Directory::removeRecursively($tmpDirectoryPath); } catch (\Exception $e) {
Visual::print($e); }
} }
Getting a given weight file: private function getRandomBytes($bytes): string { return random_bytes($bytes);
When this code is executed, a temporary directory will be created in which the files with the tested weight size will be written. For each weight, a file is generated and written to disk, and the time used is added to the array along with the corresponding weight. The files are then deleted.
But since we have more than one file, the task of recursive deletion appears. To do this, we will create an auxiliary class Directory. It implements methods for creating a temporary directory and deleting files and the directory itself after they are written to disk. Their code is given below.
Recursive deletion of generated files and their directories: public static function removeRecursively($path): void { if (\file_exists($path)) { $dir = \opendir($path); if (\is_resource($dir)) { while ($file = \readdir($dir)) { if (($file !== self::$rootPath) &&
($file !== self::$parentPath)) { $full = $path . DS . $file; if (\is_dir($full)) {
self::removeRecursively($full); } else {
\unlink($full); }
} } \closedir($dir); } \rmdir($path);
Creating a temporary directory: } } } } public static function create($path, int $permissions = 0755): bool { if (!\file_exists($path) && !mkdir($path, $permissions) && !is_dir($path)) { throw new \RuntimeException(’Could not create directory: ’ . $path); In the following code, we open the directory and delete the path if it is a file, then exit the directory and delete the path itself.
Next is MySQL class. Its main methods are getting the current version of MySQL and executing an encoded random string.
Getting the current version of MySQL: private function getVersion(): void { $this->version = \mysqli_get_server_version($this->connection); Executing a random encoded string:
The next class is PHP. It implements the functions of obtaining the current parameters of the PHP environment. These methods include getting preloaded extensions, getting maximum file size before uploading, and memory limit.
Getting the maximum size of the uploaded file: private function getMaxUploadBytes(): int { static $max_size = -1; if ($max_size < 0) { // Start with post_max_size. $post_max_size = Size::formatToBytes(\ini_get(’post_max_size’)); if ($post_max_size > 0) {
$max_size = $post_max_size; } // If upload_max_size is less, then reduce. Except if upload_max_size // is zero, which indicates no limit. $upload_max = Size::formatToBytes(\ini_get(’upload_max_filesize’)); if ($upload_max > 0 && $upload_max < $max_size) {
$max_size = $upload_max; } } return $max_size; private function getMaxMemoryBytes(): int { return (int)Size::formatToBytes(\ini_get(’memory_limit’)); To count the input values specified in the ini-file, a separate Size class was created, which has the following methods.
Converting bytes to format and vice versa: public static function bytesToFormat(int $bytes): string { $power = $bytes > 0 ? \floor(\log($bytes, 1024)) : 0; return \number_format($bytes / (1024 ** $power), 2, ’.’,
’,’) . ’ ’ . self::$units[$power]; public static function formatToBytes(string $format): float { $unit = \preg_replace(self::$unitsRegexPattern, ’’, $format); $format = \preg_replace(self::$numberRegex, ’’, $format); return $unit ? \round($format * (1024 **
\stripos(self::$unitsPattern, $unit[0]))) : \round($format);
Thus, we obtained the maximum permissible file weight, which is specified in the configuration file of the executable version of PHP.
In the root directory there is a file - the starting point for performing all tasks, which contains the following code:
The main executable: <?php use DI\ContainerBuilder; use DI\DependencyException; use DI\NotFoundException; use Benchmark\Benchmark; const DS = DIRECTORY_SEPARATOR; require ’vendor’ . DS . ’autoload.php’; echo ’<pre>’; try {
(new ContainerBuilder())->build()->get(Benchmark::class); } catch (DependencyException | NotFoundException $e) {
\print_r($e); } echo ’</pre>’ . "\n";
As a result of this section, a system has been developed, the result of which is the time intervals of the performed operations, which are presented in a visual form. An example of the obtained result is given below (figure 5).
The table contains time measured results for each operation in seconds, lower is better.
There is a separate method for displaying information that uses a method from another class, namely line representation, to improve reading comprehension. Its implementation is given below.
The method of outputting the resulting information: public static function print(string $input, string $delimiter = "\n\n"): void {
\print_r($input . $delimiter); }
Benchmarks are used to achieve a competitive result with any other similar item. In our case, the diference is the version of PHP for the fastest execution. All results were entered into an Excel table, where comparative graphs were constructed.
Tests were conducted on the performance of disk (figure 6) and processor operations (figure 7)
and string conversion depending on the language version (figure 8). The results of the analysis
are shown below and represent the operations for each version of PHP, to identify the fastest.
For all tests, a lower value is better. Tests were performed on a local machine with: Ryzen
5600H, 2x8 GB 3200 MHz CL22 PC4-25600 RAM, Samsung M.2 512 GB SSD, Ubuntu 21.04 [
Checking the speed of cycle operations (figure 9) and speed test of If/Else statements (figure 10).
PHP will continue to be a popular language for the foreseeable future. It is used in web development, and there are many popular website engines and frameworks written in PHP. PHP 8 has become faster and more reliable. Compared to previous versions, PHP 8 has many new and useful features, such as JIT compiler, bug fixes, etc., which will definitely benefit both users and developers. A benchmark system has been developed for diferent versions of PHP, which can be extended by other modules if necessary. The result of the system’s operation is time data reflecting the speed of the selected PHP version. These results might not convince developers to keep PHP version up-to-date, but may give a focus on improvements they might seek to achieve using older versions.