PHP Performance Trivia

PHP Performance Trivia
Nikita Popov

Opcache
Method
Opcodes
Class
Method
Shared Memory

Opcache
Method
Opcodes
Class
Method Method
Class
Method
Shared Memory Per-Request Arena
copy

Opcache
Method
Opcodes
Class
Method Method
Class
Method
copy
Modified during
inheritance

Opcache
Method
Opcodes
Class
Method Method
Class
Method
copy
Modified during
inheritance
Registered in
class table

Preloading
Method
Opcodes
Class
Method
Shared Memory

Preloading
Method
Opcodes
Class
Method
Shared Memory MAP area
Static properties
Runtime cache

Preloading
Method
Opcodes
Class
Method
Shared Memory MAP area
Static properties
Runtime cache
Cleared on each request

Preloading
Method
Opcodes
Class
Method
Shared Memory ●
Classes must be fully inherited!

Preloading
Method
Opcodes
Class
Method
Shared Memory ●
●
Parents/interfaces known
●
All constant expressions known
●
All-ish types known

Preloading
Method
Opcodes
Class
Method
Shared Memory ●
●
Parents/interfaces known
●
All constant expressions known
●
All-ish types known
●
Windows: lost cause (ASLR),
internal classes not "known"

Preloading
Method
Opcodes
Class
Method
Shared Memory ●
No way to clear preload state
●
Opcache reset not enough
●
FPM reload not enough

Value Caching
●
Only about completely static data here…
– Say a composer class map

Value Caching
PHP
PHP
PHP
Opcache
SHM
APCU
SHM

Value Caching
PHP
PHP
PHP
Opcache
SHM
APCU
SHM
Direct accessRequires copying!

Value Caching
PHP
PHP
PHP
Opcache
SHM
APCU
SHM
Direct accessRequires copying!
Data never removed (*)Supports deletion

Value Caching
●
Only about completely static data here…
– Say a composer class map
●
APCU very inefficient for large data
– Requires unserialization and copying
●
(Ab)use opcache as a data cache

Value Caching
<?php
return [
"foo" => "bar",
"bar" => "baz",
];
Array stored as "immutable array"
in shared memory

Opcache Reset
●
Invalidated files remain in opcache
●
Only cleared on full reset

Opcache Reset
PHP
PHP
PHP
Opcache
SHM
Wait for requests to finish

Opcache Reset
PHP
PHP
PHP
Opcache
SHM
SIGKILL

Opcache Reset
PHP
PHP
Opcache
SHM

Opcache Reset
PHP
PHP
Opcache
SHM
Clear

Opcache Reset
PHP
PHP
Opcache
SHM

Opcache Reset
●
Cache not used during reset
●
Needs to be repopulated from scratch
●
File cache can help mitigate

Arrays vs Objects
● Array: ["first" => $a, "second" => $b]
●
Packed array: [$a, $b]
●
Object with declared properties
– class Test { public $first, $second; }
●
Object with dynamic properties
– (object)["first"=>$a, "second"=>$b]

Memory Usage
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
0
100
200
300
400
500
600
700
800
Array Array (packed) Object
Number of properties/keys
Memoryusage(bytes)

Memory Usage
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
0
100
200
300
400
500
600
700
800
Array Array (packed) Object
Memoryusage(bytes)
["first" => $a,
"second" => $b]
[$a, $b]
class Pair { public $first, $second; }

Memory Usage (Ratio)
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
0
1
2
3
4
5
6
7
Ratio Ratio (packed)
Arraysize/objectsize

Caveat: Properties table
●
Some operations materialize properties table
– foreach ($object as $propName => $value)
– (array) $object
– var_dump($object)
– …

Caveat: Properties table
●
Some operations materialize properties table
– foreach ($object as $propName => $value)
– (array) $object
– var_dump($object)
– …
●
You pay the price for both object and array
●
No way to remove once created

Memory Usage
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
0
100
200
300
400
500
600
700
800
Array Array (packed) Object Object (dyn)
Memoryusage(bytes)

Garbage Collection
●
Reference Counting
– Count how many times a value is used
– Destroy when count is zero

Garbage Collection
●
Reference Counting
$x = "foobar"; // refcount=1
$y = $x; // refcount=2
unset($x); // refcount=1
unset($y); // refcount=0 ==> Destroy!

Garbage Collection
●
Reference Counting
$x = []; // refcount=1
$x[0] =& $x; // refcount=2
unset($x); // refcount=1
// Will never reach 0 due to cycle!

Garbage Collection
●
Cycle Collector
– Mark & sweep algorithm

Garbage Collection
●
Cycle Collector
●
Start from "roots"
●
Simulate what would happen if they were released
●
If simulation results in refcount=0, actually destroy

Garbage Collection
●
Cycle Collector
– PHP <= 7.2: Fixed root buffer with 10000 entries
●
10000 objects should be enough for everyone!

Garbage Collection
●
Cycle Collector
●
10000 objects should be enough for everyone!
●
Cycle collector runs every time root buffer full
●
May walk graph with millions of objects each time

Composer + GC
commit ac676f47f7bbc619678a29deae097b6b0710b799
Author: Jordi Boggiano <j.boggiano@seld.be>
Date: Tue Dec 2 10:23:21 2014 +0000
Disable GC when computing deps, refs #3482
diff --git a/src/Composer/Installer.php b/src/Composer/Installer.php
index b76155a5..1b2a6772 100644
--- a/src/Composer/Installer.php
+++ b/src/Composer/Installer.php
@@ -160,6 +160,8 @@ public function __construct(...
*/
public function run()
{
+ gc_disable();
+
if ($this->dryRun) {
$this->verbose = true;
$this->runScripts = false;

Composer + GC
commit ac676f47f7bbc619678a29deae097b6b0710b799
Author: Jordi Boggiano <j.boggiano@seld.be>
Date: Tue Dec 2 10:23:21 2014 +0000
Disable GC when computing deps, refs #3482
diff --git a/src/Composer/Installer.php b/src/Composer/Installer.php
index b76155a5..1b2a6772 100644
--- a/src/Composer/Installer.php
+++ b/src/Composer/Installer.php
@@ -160,6 +160,8 @@ public function __construct(...
*/
public function run()
{
+ gc_disable();
+
if ($this->dryRun) {
$this->verbose = true;
$this->runScripts = false;
2x speedup

Garbage Collection
●
Cycle Collector
– PHP >= 7.3: Dynamic root buffer
●
Root buffer automatically grows
●
Dynamic GC threshold
●
If GC collects little garbage, GC threshold grows

Type Declarations
●
Do they make PHP slower or faster?

Type Declarations
●
Do they make PHP slower or faster?
●
Type declarations need to be checked
●
Type declarations allow more optimizations

Type Optimization
<?php
function powi(float $base, int $power): float {
if ($power == 0) return 1.0;
$result = $base;
for ($i = 1; $i < $power; $i++) {
$result *= $base;
}
return $result;
}

Type Optimization
<?php
$result = $base;
for ($i = 1; $i < $power; $i++) {
$result *= $base;
}
return $result;
}
Type inference: int
Type inference: float

Type Optimization
<?php
$result = $base;
for ($i = 1; $i < $power; $i++) {
$result *= $base;
}
return $result;
}
Type inference: int
Type inference: float
→ Eliminated return type check

Type Optimization
<?php
$result = $base;
for ($i = 1; $i < $power; $i++) {
$result *= $base;
}
return $result;
}
Use specialized
ZEND_PRE_INC_LONG
Use specialized ZEND_MUL_DOUBLE
+ eliminate compound operation
Use specialized
ZEND_IS_SMALLER_LONG

Type Optimization
<?php
function powi( $base, $power) {
$result = $base;
for ($i = 1; $i < $power; $i++) {
$result *= $base;
}
return $result;
}
Type inference: int|float
Type inference: mixed

Type Optimization
●
For this example:
– Without opcache: Performance ~same with and
without types
– With opcache: With types 2.5x faster
– Type check cost: Once
– Type optimization benefit: Multiple loop iterations

Type Optimization
●
For this example:
– Without opcache: Performance ~same with and
without types
– With opcache: With types 2.5x faster
– Type check cost: Once
– Type optimization benefit: Multiple loop iterations
●
But: Does not happen often in practice.

Global Namespace Fallback
<?php
namespace Foo;
var_dump(strlen("foobar"));
// Might be strlen()
// Might be Foostrlen()

Global Namespace Fallback
<?php
namespace Foo;
var_dump(strlen("foobar"));
// Might be strlen()
// Might be Foostrlen()
Actual function cached on first call
→ Not particularly expensive

Specialized Functions
●
Some functions have optimized VM instruction
– strlen() and count()
– is_null() etc
– intval() etc
– defined()
– call_user_func() and call_user_func_array()
– in_array() and array_key_exists()
– get_class(), get_called_class() and gettype()
– func_num_args() and func_get_args()

Specialized Functions
●
Some functions have optimized VM instruction
●
Can only be used if function known
●
Requires fully qualified name or "use function"

Compile-time evaluation
<?php
namespace Foo;
function doSomething() {
if (version_compare(PHP_VERSION, '7.3', '>=')) {
// PHP 7.3 implementation
} else {
// Fallback implementation
}
}
Can't evaluate due to
namespace fallback

<?php
namespace Foo;
} else {
}
}
Evaluated to
true/false by opcache

<?php
namespace Foo;
use function version_compare;
use const PHP_VERSION;
} else {
}
}
Evaluated to
true/false by opcache

PHP Performance Trivia

More Related Content

What's hot

Similar to PHP Performance Trivia

More from Nikita Popov

Recently uploaded

PHP Performance Trivia