PHP benchmarks

It is a collection of PHP benchmarks. Those benchmarks are aimed to be executed in most machines without any special installation or configuration. It only requires a single library (to draw the table) and nothing else much. It doesn't require composer or any other extra component. Just download (or copy and paste) and run.

Awards

PHP Benchmarks: Evaluate the speed of PHP running different tasks - PHP Classes

It is tested under PHP 7.4 / PHP 8.0 + 64bits + Windows 64 bits but you could download it and test it by yourself (it is the idea).

Table of contents

• PHP benchmarks
  • Table of contents
  • Benchmark 1, Reference vs No Reference
    • Result (smaller is better)
  • Bechmark 2 Hash speed
    • Result (short time is better)
  • JSON vs Serialize
    • Result (less is better)
  • DEFINE / CONST / ENV
    • Result (less is better)
  • array_map vs foreach
    • Result 7.x (less is better)
    • Result 8.x (less is better)
  • isset vs @ at
    • Result (smaller is better)
  • Type hinting
    • Result (smaller is better)
  • Benchmark eval
    • Result (smaller is better)
  • Benchmark count vs is_array and count
    • Result (smaller is better)
  • Benchmark is_array vs is_countable
    • Result (smaller is better)
  • Benchmark array_key_exists vs isset
    • Result (smaller is better)
  • Benchmark str_contains vs str_pos
    • Result (smaller is better)
  • Benchmark file_exists vs is_file
    • Result (smaller is better)
  • Benchmark array_merge vs others
    • Result (smaller is better)

Benchmark 1, Reference vs No Reference

Is it fast to use a reference argument or return a value?

reference_vs_no_reference.php

function reference(&$array) {
    $array['a1']=2;
    $array['a2']='bbbb';
    $array['a4']=55555;
}
function noReference($array) {
    $array['a1']=2;
    $array['a2']='bbbb';
    $array['a4']=55555;
    return $array;
}

Result (smaller is better)

Conclusion: Using a reference argument is faster than using an argument by value

Bechmark 2 Hash speed

We test the benchmark of the generation of hash.

benchmark_hash.php

HEX means that the result is resulted in HEXADECIMAL.

RAW means the result is binary. Sometimes HEX=RAW.

Result (short time is better)

JSON vs Serialize

It benchmark to serialize and de-serialize variables

json_vs_serialize.php

array

$data=['field1'=>"hello",'field2'=>450,'field3'=>['field4'=>'hello','field5'=>450]];

object StdClass

$data=new stdClass();
$data->field1="hello";
$data->field2=450;
$data->field3=new stdClass();
$data->field3->field4="hello";
$data->field3->field5=450;

object (defined by a class)

$data=new MyClass();
$data->field1="hello";
$data->field2=450;
$data->field3=new MyClass2();
$data->field3->field4="hello";
$data->field3->field5=450;

Result (less is better)

DEFINE / CONST / ENV

We test the performance between to read an environment variable or to use a constant.

Result (less is better)

Conclusion, define() and const have practically the same performance (at least in PHP 7.4), while getEnv() is considerably bad. However,getEnv() is acceptable even when it is 10000% slower (50000 getEnv() took 50ms.).

We also tested to call a function and it is way fast than getEnv()

Conclusion: getEnv() is not cached neither it is loaded into PHP. Instead, it is calculated each time when it is called.

array_map vs foreach

benchmark_arraymap_foreach.php

It tests the performance between foreach and array_map

Result 7.x (less is better)

Result 8.x (less is better)

Conclusion: Foreach is still faster. Between array_map and array_map (static), there is not a big difference. And using array_map with a function is slightly fast.

isset vs @ at

benchmark_isset_vs_at.php

This test could be a bit misleading but the goal is to benchmark the speed even when both ways returns different values.

$r=isset($var); // isset (it returns true if the variable exists)
$r=@$var // at
$r= $var ?? null; // nullcol php >7.0
$r= @$var ? $exist : null; // ternary
$r=isset($var) ?? $var; // issetnull7 php>7.0
$r=isset($var) ? $var : null; // issetnull5 php>7.0
!isset($var) and $var=null; // hacky but it works (however it doesn't assigns value if the value does not exists)

Result (smaller is better)

Smaller is better.

Conclusion: @ is between 1 and 2 order of magnitude slower.

Type hinting

How type hinting affects the performance?

benchmark_types_arguments.php

Let's say the next code

/**
 * @param DummyClass $arg1
 * @param DummyClass $arg2
 *
 * @return DummyClass
 */
function php5($arg1,$arg2){
    return new DummyClass();
}
function php7(DummyClass $arg1,DummyClass $arg2): DummyClass {
    return new DummyClass();
}

Result (smaller is better)

Smaller is better.

Conclusion: In general, type hinting is around 10% slower but both methods are enough fast to made any difference.

While it could be useful but if you are using a proper IDE, then you could rely on PHPDoc, it's verbose but it is more complete and without affecting the performance.

Benchmark eval

benchmark_eval.php

$r=ping("pong"); // no eval
eval('$r=ping("pong");'); // eval 
$r=eval('return ping("pong");'); // eval 2

$fnname='ping';
$r=$fnname("pong"); // dynamic_function (calling a function using a variable)

Result (smaller is better)

Conclusion: Eval is considerably slow and it should be avoided if possible

Benchmark count vs is_array and count

benchmark_count_isarray

$r=@count($array1);
$r=is_array($array1)? count($array1) : null;
is_array($noarray) and $r=count($noarray);

Result (smaller is better)

Conclusion: @ is consistently bad in an order of magnitude. We could gain a bit of performance using a logic operator (it only assigns the value if the value is an array)

Note: @count($array) crashes in PHP 8 when $array is not an object

Benchmark is_array vs is_countable

benchmark_is_array_countable.php

$r=is_countable($array1);
$r=is_array($array1);
$r=gettype($noarray);
$r=get_debug_type($noarray);

Result (smaller is better)

Conclusion: is_countable is surprisingly bad. Also, get_debug_type() is slower than gettype()

Benchmark array_key_exists vs isset

$r=array_key_exists('repeated',$array1);
$r=isset($array1['repeated']);

benchmark_array_key_exists_vs_isset.php

Note: if the key exists $array1['repeated'] but the value is null, then isset() returns false while array_key_exists returns true. So they are not exactly the same.

Result (smaller is better)

Conclusion: isset() is the fastest by usually an 40-80%.

Benchmark str_contains vs str_pos

benchmark_str_contains_vs_strpos.php

$r=str_contains($text,'mary');
$r=strpos($text,'mary');

Result (smaller is better)

They give the same performance but conceptually (if you want to see if a string exists inside other) str_contains is better because it always returns a boolean while strpos returns an int or a false.

Benchmark file_exists vs is_file

benchmark_file_exists_vs_is_file.php

This benchmark measures the speed of both functions where the file exists and where the file does not exist.

Result (smaller is better)

Windows:

Linux:

Conclusion: is_file() is faster in almost the double of speed and Linux is faster than Windows.

Benchmark array_merge vs others

benchmark_array_merge_vs_plus.php

We compare array_merge() versus the rest. We should notice that they could return different results considering if we have duplicates or if the value stored is not indexed. So, they are not always interchangeable.

  $r=array_merge($array1,$array2); // array merge
  $r=array_replace($array1,$array2); // array_replay
  $r= $array1 + $array2; // plus
  $r= foreachMerge($array1,$array2); // foreach concatenates the two values using a foreach loop

Result (smaller is better)

note: the number between parenthesis indicates the number of elements returned.

array_merge(['a'=>'1','b'=>'2',1,2],['a'=>'1','b'=>'2',1,2]) returns the values ['a'=>'1','b'=>'2',1,2,1,2]. Array_replace, plus and foreach does not duplicates the values without indexes.

Conclusion: plus is better than array_replace and it does a similar job. array_merge generates an acceptable performance (even the arrays has duplicates). Also, you don't want to create your own merge using foreach.

Benchmark array versus object

This benchmark tests the next functionalities:

• Create a variable.
• Then, it reads a simple value
• And it adds to the list (the list is created every round)

$array_numeric=[$hello,$second,$third];

$array_not_numeric=['hello'=>$hello,'second'=>$second,'third'=>$third];

$object_constructor=DummyClass('world',0,20.3);

$object_no_constructor=new DummyClass2();
$object_no_constructor->hello='world';
$object_no_constructor->second=0;
$object_no_constructor->third=20.3;

What is a factory? A factory is a function used for creating an entity (in this case, an array).

what is a constructor? A constructor is part of a class and is used to initialize the instance of the object.

Result (smaller is better)

It is the result of the benchmarks in seconds

Result in percentage compared with the smaller result.

Conclusion:

• The difference between an array numeric and an associative array is a mere 5%, so you can say that they are the same.
• The use of an object is +100% slower but it is still acceptable in most conditions (aka it uses the double of time).
• The call to a method or the use of a constructor increases the value considerably. Also, it's better to use an object/constructor than an array/factory. Why? I don't know.
• The use of setter/getters impacts the performance considerably. If you can then you should avoid that.
• The use of magic setters and getters is horrible (almost 10 times slower). Is it the reason why Laravel is slow?
  • Also, the setters and getters are vanilla, they don't validate if the field exists of any other validation.
• And the use of a stdClass (anonymous class) is also bad but not as bad as to use setter and getters.

ps: The test ran 1 million times and the difference is smaller than 0.3 seconds, so is it important?

Let's say we have 100 concurrent users (not a small number but not impossible), and we are processing and returning a list with 1000 values. It is 100x1000 = 100'000 objects. So, if we consider 100'000 objects, then the difference is less than 0.03 seconds in the worst case. However, our systems process more than a single operation, so if we are showing a list of objects, then we also validating, showing other values, validating, reading from the database and storing into the memory and returning to the customer via a web or serialized, so this value could considerable and the use of the CPU is on-top of other processes. It is not a big deal for a small project, but it is important for a big project.

tl/dr

$customer[0]='john'; // faster but it is hard to understand
$customer['name']='john'; // almost as fast as the first one but it is clear to understand (it also uses more memory)
$customer->name='john'; // (where $customer is an object of the class Customer) slower but it still acceptable.
$customer->name='john'; // (where $customer is an object of the class stdClass) the double of slower than to use a class. 
$customer=new Customer('john'); // (constructor) even slower but is still acceptable;
$customer=factory('john'); // (where factory is an array that returns an array). Slower than the use of constructor.
$customer->setName('john'); // bad performance
$customer->name='john'; // (where the class uses a magic method) awful performance, avoid this one.

https://github.com/EFTEC/php-benchmarks/blob/master/benchmark_array_vs_object.php

Echo vs Concat vs Implode

Which is faster for multiples concatenation?

In conclusion, all of them are pretty similar.

https://github.com/EFTEC/php-benchmarks/blob/master/benchmark_echo_vs_strings.php

Constant vs variable vs literal

We compare the use of a constant versus a variable and a literal. All of them stores a string.

The literal is defined for each cycle.

const HELLO = 'HELLO WORLD';
$variable = 'HELL WORLD';
'HELLO WORLD'

Conclusion: the constant is a bit slow in practically every case. The use of a variable or a literal is the same, even when the literal is apparently created many times.

Serializations

https://github.com/EFTEC/php-benchmarks/blob/master/benchmark_serialization.php

We benchmark the serialization using different methods.

• serialize (PHP serialization function)
• igbinary (pecl)
• json
• msgpack (pecl)

It is the data that was serialized

$input = array();
for ($i = 0; $i < 1000; $i++) {
    $input["k-$i"] = [$i];
    $input["k-$i"]['k1'] =['a','b','c'];
    $input["k-$i"]['k1']['k2'] =['a','b',10,20,30,true];
}

It is complex but not really complex. It's not a huge array, just 1000 arrays with multiples dimensions (the equivalent to show a table with 1000 data and some relations)

Serialize: (in seconds less is better)

Conclusion: igbinary is a bit faster to serialize but the different is not as big.

De-serialize: (in seconds less is better)

Conclusion: igbinary is a bit faster to unserialize

Size: (in bytes less is better)

Conclusion: igbinary hands down (at least in my test machine)

Iwill try it again but with a different input value (without nested values)

$input = array();
for ($i = 0; $i < 1000; $i++) {
    $input["k-$i"] = ["k-$i"];
}

Serialize: (in seconds less is better)

De-serialize: (in seconds less is better)

Size: (in bytes less is better)

Input is equals to output: (no means error)

Conclusion: msgpacker is faster serializing and in size, while igbinary is faster unserializing.