This talk discusses various issues of low-level PHP performance, such as: When is it more efficient to use arrays or objects? What causes catastrophic garbage collection? Does adding type annotations make PHP faster or slower? I will answer these types of question with a (shallow) dive into PHP internals, touching on various topics like value representation, bytecode optimization and GC.

1. PHP Performance Trivia
Nikita Popov

3. Opcache

4. Opcache
Method
Opcodes
Class
Method
Shared Memory

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

6. Opcache
Method
Opcodes
Class
Method Method
Class
Method
Shared Memory Per-Request Arena
copy
Modified during
inheritance

7. Opcache
Method
Opcodes
Class
Method Method
Class
Method
Shared Memory Per-Request Arena
copy
Modified during
inheritance
Registered in
class table

8. Preloading
Method
Opcodes
Class
Method
Shared Memory

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

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

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

12. Preloading
Method
Opcodes
Class
Method
Shared Memory ●
Classes must be fully inherited!
●
Parents/interfaces known
●
All constant expressions known
●
All-ish types known

13. Preloading
Method
Opcodes
Class
Method
Shared Memory ●
Classes must be fully inherited!
●
Parents/interfaces known
●
All constant expressions known
●
All-ish types known
●
Windows: lost cause (ASLR),
internal classes not "known"

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

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

16. Value Caching
PHP
PHP
PHP
Opcache
SHM
APCU
SHM

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

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

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

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

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

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

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

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

25. Opcache Reset
PHP
PHP
PHP
Opcache
SHM
Wait for requests to finish
SIGKILL

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

27. Opcache Reset
PHP
PHP
Opcache
SHM
Clear

28. Opcache Reset
PHP
PHP
Opcache
SHM

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

30. 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]

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

32. 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)
["first" => $a,
"second" => $b]
[$a, $b]
class Pair { public $first, $second; }

33. 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)
Number of properties/keys
Arraysize/objectsize

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

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

36. 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)
Number of properties/keys
Memoryusage(bytes)

37. Garbage Collection

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

39. Garbage Collection
●
Reference Counting
– Count how many times a value is used
– Destroy when count is zero
$x = "foobar"; // refcount=1
$y = $x; // refcount=2
unset($x); // refcount=1
unset($y); // refcount=0 ==> Destroy!

40. Garbage Collection
●
Reference Counting
– Count how many times a value is used
– Destroy when count is zero
$x = []; // refcount=1
$x[0] =& $x; // refcount=2
unset($x); // refcount=1
// Will never reach 0 due to cycle!

41. Garbage Collection
●
Cycle Collector
– Mark & sweep algorithm

42. Garbage Collection
●
Cycle Collector
– Mark & sweep algorithm
●
Start from "roots"
●
Simulate what would happen if they were released
●
If simulation results in refcount=0, actually destroy

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

44. Garbage Collection
●
Cycle Collector
– Mark & sweep algorithm
– PHP <= 7.2: Fixed root buffer with 10000 entries
●
10000 objects should be enough for everyone!
●
Cycle collector runs every time root buffer full
●
May walk graph with millions of objects each time

45. Composer + GC
Too many memes

46. 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;

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

48. Garbage Collection
●
Cycle Collector
– Mark & sweep algorithm
– PHP <= 7.2: Fixed root buffer with 10000 entries
– PHP >= 7.3: Dynamic root buffer
●
Root buffer automatically grows
●
Dynamic GC threshold
●
If GC collects little garbage, GC threshold grows

49. Type Declarations
●
Do they make PHP slower or faster?

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

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

52. 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 inference: int
Type inference: float

53. 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 inference: int
Type inference: float
→ Eliminated return type check

54. 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;
}
Use specialized
ZEND_PRE_INC_LONG
Use specialized ZEND_MUL_DOUBLE
+ eliminate compound operation
Use specialized
ZEND_IS_SMALLER_LONG

55. 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 inference: int
Type inference: float

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

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

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

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

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

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

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

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

64. Compile-time evaluation
<?php
namespace Foo;
function doSomething() {
if (version_compare(PHP_VERSION, '7.3', '>=')) {
// PHP 7.3 implementation
} else {
// Fallback implementation
}
}
Evaluated to
true/false by opcache

65. Compile-time evaluation
<?php
namespace Foo;
use function version_compare;
use const PHP_VERSION;
function doSomething() {
if (version_compare(PHP_VERSION, '7.3', '>=')) {
// PHP 7.3 implementation
} else {
// Fallback implementation
}
}
Evaluated to
true/false by opcache

66. Thank You!