Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://github.com/eftec/php-benchmarks below:

EFTEC/php-benchmarks: It is a collection of 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.

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).

• 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)

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;
}

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

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.

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;

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

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.

benchmark_arraymap_foreach.php

It tests the performance between foreach and array_map

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.

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)

Smaller is better.

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

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();
}

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.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)

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

benchmark_count_isarray

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

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_countable.php

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

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

$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.

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

benchmark_str_contains_vs_strpos.php

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

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.php

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

Windows:

Linux:

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

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

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.

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.

It is the result of the benchmarks in seconds

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

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

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.

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)

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

Conclusion: igbinary is a bit faster to unserialize

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"];
}

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4