performance.txt

PHP 8.2 crazy performance benchmarks
@todo php 8.2 vs 8.3 vs 8.4
@todo move to clear EE Benchmark in ns

@author Maxim Miroshnichenko <max@miroshnichenko.org>

==============================================================

СУПЕР ВАЖНАЯ РЕМАРКА:
Тесты проводились в разное время и иногда на разных серверах.
Поэтому важно сравнивать не просто миллисекунды, а скорее соотношение "во сколько раз быстрее или медленне один подход от другого.

==============================================================

PHP 8.2.28 (cli) (built: Mar 13 2025 18:21:38) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.2.28, Copyright (c) Zend Technologies with Zend OPcache v8.2.28, Copyright (c), by Zend Technologies

AWS EC2 c6gn.xlarge // c8g.xlarge
Важная ремарка: в процессе тестов я менял сервер, но это всегда оставался ARM Gravition*.
Важно смотреть не на абсолютное значение в ms (тем более оно на 1М итераций), а на соотношение одного способа к другому:
так можно понять как писать надо/ненадо ради ультра-производительности.

PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"
NAME="Debian GNU/Linux"
VERSION_ID="12"
VERSION="12 (bookworm)"
VERSION_CODENAME=bookworm

==============================================================

Ключевое:
- локальные переменные быстрее свойств (0 ms vs 7 ms),
  свойства быстрее свойсв-массивов (7 ms vs 17 ms)
- собаки @ это пиздец, +17 ms минимум, запускают debug backtrace если даже ошибок нет
- иногда выгоднее копирнуть свойство или элемент массива в локальную переменную и дальше с ней работать,
  потому что доступ к локальной переменной 0 ms, а доступ к свойству всегда 7, а свойству-массива 17 ms.
  Это только доступ, то есть получение указателя на кусочек памяти.
  Если писать $this->array['key'] то всегда ищется array, затем в нем всегда ищется key.
  И если такого кода дофига - пиздец производительности, просто тратим силы на поиск переменных.
- foreach сильно быстрее for
- closure & lamda это ад
- call trees не оптимизируются, никакого инлайнера внутри нет

==============================================================

Время в ms для 1_000_000 итераций:
- сам цикл заниает 4 ms и эти 4 ms я удалил из теста, дальше только чистые данные
- jit+opcache tracing 0.8 ms цикл
- дальше время всегда в формате без-jit-opcache / jit+opcache

==============================================================

Использование оператора подавления ошибок (@) резко замедляет код.
Дело в том, что PHP при этом всегда начинает собирать дополнительную информацию через debug backtrace, даже если ошибки нет.

Правда есть нюанс - isset лучше не добавлять, все-таки собакен:
if (isset($data['result']) && $data['result'] == 'pong') {} // 15.8 ms
if ($data['result'] == 'pong') {} // 9.8 ms
if (@$data['result'] == 'pong') {} // 12.8 ms

// 18 ms
if (($this->_seqArray[$key] ?? -1) >= $j) {
    continue;
}
$this->_seqArray[$key] = $j;

// 25 ms
if (isset($this->_seqArray[$key]) && $j <= $this->_seqArray[$key]) {
    continue;
}
$this->_seqArray[$key] = $j;

// 30 ms
$link = &$this->_seqArray[$key];
if (isset($link) && $j <= $link) {
    continue;
}
$link = $j;

// 14 ms - но с notice разово << это самый лучший вариант, но надо инициировать ключи заранее
if ($j <= $this->_seqArray[$key]) {
    continue;
}
$this->_seqArray[$key] = $j;

// 16 ms
if ($j <= @$this->_seqArray[$key]) {
    continue;
}
$this->_seqArray[$key] = $j;

// 20 ms
$prev = @$this->_seqArray[$key];
if ($j <= $prev) {
    continue;
}
$this->_seqArray[$key] = $j;

==============================================================

isset vs empty
на самом деле они занимают абсолютно одинаковое время, разница только в 2 ns на операцию not
если надо проверить на наличие ключа - isset выгоднее чем !empty
на отстуствие - empty (хотя empty еще проверяет чтобы не было zero)

// если ключ существует
$this->_a['key1']; // 10 ns
if (isset($this->_a['key1'])) {} // 9 ns
if (!empty($this->_a['key1'])) {} // 11 ns
if (empty($this->_a['key1'])) {} // 10 ns

// если ключ НЕ существует
if (isset($this->_a['key2'])) {} // 9 ns
if (!empty($this->_a['key2'])) {} // 11 ns
if (empty($this->_a['key2'])) {} // 9 ns

==============================================================

Общий try-catch выгоднее на 11%

// 1454 ns
for ($j = 1; $j <= 100; $j++) {
    try {
        $this->_call();
    } catch (Exception $e) {

    } catch (Throwable $t) {

    }
}

// 1301 ns
try {
    for ($j = 1; $j <= 100; $j++) {
        $this->_call();
    }
} catch (Exception $e) {

} catch (Throwable $t) {

}

==============================================================

isset vs count

Если вам нужно проверить есть ли все нужные элементы в массиве - то сильно выгоднее использовать isset на нужный элемент.
Например:
$data = explode(';', $data);
вместо if (count($data) >= 10) лучше писать if (isset($data[9]))

Разница почти в 4 раза.

==============================================================

// получение указателя (доступ к пременной)
$a; // 0 ms локальная переменная
@$a; // 17 ms если учесть что переменная на самом деле инициирована; собака добавляет +17 ms на ровно месте
@$a; // 230 ms если переменная не инициирована, вот так собаки портят жизнь
$this->_a; // 7 ms / 5.42
@$this->_a; // 12 ms / 10.4

$a['key']; // 8 ms -- всегда поиск по ключу массива

$this->_a['key3']; // 17 ms / jit 7.74 ms -- тут сначала поиск свойства, затем поиск по ключу массива
$this->_a['key1']['key2']; // 29 ms
$this->_a['key4']['key5']['key6']; // 41 ms
$this->_a;$this->_a;$this->_a; // 37 ms _a это массив
@$this->_a;@$this->_a;@$this->_a; // 45 ms _a это массив
$this->_b;$this->_b;$this->_b; // 20 ms _b это int/float/bool/string
@$this->_b;@$this->_b;@$this->_b; // 35 ms _b это int/float/bool/string

// это только поиск элемента по ключу, элемент существует
$this->_a['key1'];$this->_a['key2']; // 36 ms
$this->_a[1];$this->_a[2]; // 32 ms, числовые ключи чуть быстрее
$this->_b1;$this->_b2; // 13-14 ms (сходится с доступом к одному свойству)

// присвоение, $j динамически меняется
$this->_a['key'] = $j; // 19 ms
$this->_a = $j; // 7 ms / 4.3 ms
$a = $j; // 4 ms / 0.1 ms << супер ускорение

// переприсванивание из свойства в локальльную переменную (дальше к ней доступ 0 ms будет)
$a = $this->_b1; // 8-9 ms, фактически сохранить себе указатель сильно дешевле // 4.6 ms

$this->_a = $a; // 5 ms, если массив инициирован заранее $a = [1,2,3]; - сильно дешевле вдуть его сразу
$this->_a[1] = $a[1];$this->_a[2] = $a[2];$this->_a[3] = $a[3]; // 68 ms пиздец долго, сплошные malloc

$this->_a = 1; // 6 ms // 4.4 ms
$this->_a = 1; $this->_a *= 1; // 19 ms // 5.2 ms

// статическое присвоение быстрее массивом
$this->_a['a'] = 1;$this->_a['b'] = 2;$this->_a['c'] = 3; // 61 ms // 26 ms
$this->_a = array( // 8 ms // 4.4 ms
    'a' => 1,
    'b' => 2,
    'c' => 3,
);

// но если массив надо собирать - жопа
$this->_a['a'] = $j;$this->_a['b'] = $j;$this->_a['c'] = $j; // 58 ms // 26 ms << оптимизируется
$this->_a = array( // 67 ms // 67 ms, не оптимизируется, странно
    'a' => $j,
    'b' => $j,
    'c' => $j,
);
// поэтому лучше ебнуть в свойства
$this->_a = $j;$this->_b = $j;$this->_с = $j; // 28 ms // 23 ms, но важно чтобы свойства были
// еще лучше конечно в локальны переменные
$a = $j; $b = $j; $c = $j; // 12 ms // 1 ms << локальные перемеррые вообще жесть

// собирать статический массив лучше целиком сразу
$a = []; $a['key1'] = 1; $a['key2'] = 2; // 56 ms
$a = array( // 5 ms
    'key1' => 1,
    'key2' => 2,
);

// собирать массив выгоднее всего сразу и с числовыми ключами
$a = []; $a['key1'] = $j; $a['key2'] = $j; // 58 ms // 37 ms
$a = array( // 50 ms / 50 ms не оптимизируется jit-ом
    'key1' => $j,
    'key2' => $j,
);
$a = [$j, $j]; // 41 ms // 40 ms << не оптимизируется
= return [a, b] лучше не делать, лучше уже записать this->a, $this->b а потом их прочитать
= потому что собрать массив 50 ms, а сохранить в свойства 7+7=14 ms
= затем читать элементы из массива это 17+17=34 ms, а из свойств 7+7 = 14 ms
= итого разница 50+34=84 vs 14+14=28, то есть x3 раза
= при включенном jit 17-18 ms

Я провел еще один тест:
создавать assoc-массив [int, string], чтобы передать его return-ом и дальше по нему делать foreach = 485 ms / jit 358 ms
но если не создавать его, а сразу для каждого элемента дергать метод и передавать значения в виде аргументов = 262 ms / jit 170 ms
это еще раз доказывает что делать return [array] - пиздец как плохо, никакой jit не поможет

// если массив $tmp инициирован заранее (динамический) $tmp = [$t, $t, $t]; то выгоднее его сразу присвоить
// чем переписывать по-элементно
// (скорее всего там срабатывает cow)
// поэтому если что-то вернуло массив - то лучше его сразу и сохранять
$this->_a = $tmp; // 8 ms
$this->_a[0] = $tmp[0]; // 76 ms
$this->_a[1] = $tmp[1];
$this->_a[2] = $tmp[2];

==============================================================

// по массивам очень странный результат: без jit лучше формировать сразу, а с jit по очереди
// см ниже DTO, оно лучше в 2-3 раза и работает с jit

// 128 ms // 111 ms jit
return array(
    'type' => $x,
    'ts_push' => $x,
    'datastream' => $x,
    'pair' => $x,
    'ts' => $x,
    'te' => $x,
    'sequence' => $x,
    'ask' => $x,
    'ask_size' => $x,
    'ask_breakout' => $x,
    'bid' => $x,
    'bid_size' => $x,
    'bid_breakout' => $x,
);

// 183 ms / 100 ms
$a = [];
$a['type'] = $x;
$a['ts_push'] = $x;
$a['datastream'] = $x;
$a['pair'] = $x;
$a['ts'] = $x;
$a['te'] = $x;
$a['sequence'] = $x;
$a['ask'] = $x;
$a['ask_size'] = $x;
$a['ask_breakout'] = $x;
$a['bid'] = $x;
$a['bid_size'] = $x;
$a['bid_breakout'] = $x;
return $a;

// 197 ms // 72 jit << самый медленный без jit, самый быстрый с jit
$a = $this->_template;
$a['type'] = $x;
$a['ts_push'] = $x;
$a['datastream'] = $x;
$a['pair'] = $x;
$a['ts'] = $x;
$a['te'] = $x;
$a['sequence'] = $x;
$a['ask'] = $x;
$a['ask_size'] = $x;
$a['ask_breakout'] = $x;
$a['bid'] = $x;
$a['bid_size'] = $x;
$a['bid_breakout'] = $x;
return $a;

где
    private array $_template = [
        'type' => null,
        'ts_push' => null,
        'datastream' => null,
        'pair' => null,
        'ts' => null,
        'te' => null,
        'sequence' => null,
        'ask' => null,
        'ask_size' => null,
        'ask_breakout' => null,
        'bid' => null,
        'bid_size' => null,
        'bid_breakout' => null,
    ];

// 157 ms // 130 ms jit
$a = new Data();
$a->type = $x;
$a->ts_push = $x;
$a->datastream = $x;
$a->pair = $x;
$a->ts = $x;
$a->te = $x;
$a->sequence = $x;
$a->ask = $x;
$a->ask_size = $x;
$a->ask_breakout = $x;
$a->bid = $x;
$a->bid_size = $x;
$a->bid_breakout = $x;
return $a;

// 210 ms // 180 ms << clone объектов это пиздец
$a = clone $this->_templateData;
$a->type = $x;
$a->ts_push = $x;
$a->datastream = $x;
$a->pair = $x;
$a->ts = $x;
$a->te = $x;
$a->sequence = $x;
$a->ask = $x;
$a->ask_size = $x;
$a->ask_breakout = $x;
$a->bid = $x;
$a->bid_size = $x;
$a->bid_breakout = $x;
return $a;

==============================================================

вытягивание ключей из массива:

когда пишем строчку типа $a['key1']['key2']['a'] - то ВСЕГДА происходит бинарный поиск по хеш-таблице массива.
И это не исправляет даже jit.
Ниже тесты без jit, с jit будет быстрее, но пропорция сохраняется.
Если что-то глубокое надо использовать больше одного раза - сильно выгоднее вытянуть это в локальную переменную.

// 70 ms
$a['key1']['key2']['a'];
$a['key1']['key2']['b'];
$a['key1']['key2']['c'];

// 40 ms
$x = $a['key1']['key2'];
$x['a'];
$x['b'];
$x['c'];

// 45 ms
$a['key1']['a'];
$a['key1']['b'];
$a['key1']['c'];

// 36 ms
$x = $a['key1'];
$x['a'];
$x['b'];
$x['c'];

// 31 ms
$a['key1']['a'];
$a['key1']['b'];

// 27 ms
$x = $a['key1'];
$x['a'];
$x['b'];

// кстати если 'a'/'b'/'c' надо будет юзать N раз - то выгоднее сохранить в локальную переменную его тоже

==============================================================

Вытягивание свойств (которые объекты в локальные переменные)
Да, разница есть даже для 2х вызовов.

// 19-20 ms
$this->_pairConfig->amountTick;
$this->_pairConfig->amountTick;

// 17-18 ms
$pc = $this->_pairConfig;
$pc->amountTick;
$pc->amountTick;

При 1м вызове - хуже.
При 2х - уже лучше (17 ms vs 19 ms)
При 3х - еще лучше (23 ms vs 30 ms)
И так далее.

То есть да, все что 2 раза вызывается - лучше вытягивать в locals.

==============================================================

bool vs int 0/1 in arguments:
ну хоть тут логично шо bool быстрее.

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        // 45 ns:
        $int = rand(0, 1);
        $bool = (bool) rand(0, 1);

        $this->_callBool($bool); // 64-45 = 19
        $this->_callInt($int); // 67-45 = 22 ns
    }

    public function _callInt($x) {
        if ($x) {

        } else {

        }
    }

    public function _callBool($x) {
        if ($x) {

        } else {

        }
    }

}

==============================================================

Ключевой прикол call-stack:
выгоднее сделать if a/b вместо передачи аргумента.

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        // 26:
        $int = rand(0, 1);
        $bool = (bool) $int;

        // 45 - 26
        //$this->_callIf($bool);

        // 42 - 26
        /*if ($bool) {
            $this->_callA();
        } else {
            $this->_callB();
        }*/
    }

    private function _callIf($x) {
        if ($x) {

        } else {

        }
    }

    private function _callA() {

    }

    private function _callB() {

    }

}

==============================================================

return 0/1 vs bool:
одинаково

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $this->_returnInt(); // 57
        $this->_returnBool(); // 57
    }

    public function _returnInt() {
        $int = rand(0, 1);
        $bool = (bool) rand(0, 1);
        return $int;
    }

    public function _returnBool() {
        $int = rand(0, 1);
        $bool = (bool) rand(0, 1);
        return $bool;
    }

}

==============================================================

to locals trick:

во всех случаях step = 0.5 float:
private $_step = 0.5;
private $_a = ['key' => 0.5];
private $_b = [1 => 0.5];

$this->_step; // 4 ns
$step = $this->_step; // 5 ns, 4 доступ + 1 ns запись в локальную переменную

// 9 ns
$step = $this->_step; // доступ к свойству 4, присвоение 1
$step * $step; // доступ к локальной переменной 1 - 2 штуки, умножение 2

// 8 ns
$this->_step * $this->_step; // это какой-то кривой тест, потому что умножение занимает 0?

// 11 ns
$step = $this->_step;
$step * $step * $step;

// 12 ns
$this->_step * $this->_step * $this->_step;

// 12 ns
$step = $this->_step;
$step * $step * $step * $step;

// 16
$this->_step * $this->_step * $this->_step * $this->_step;

// 14
$step = $this->_step; // 5
$step * $step * $step * $step * $step;

// 19
$this->_step * $this->_step * $this->_step * $this->_step * $this->_step;

Итого:
если переменная это float/int/string (не массив и не объект) - то вытягивать ее to locals выгодно начиная с 4х использований и больше.
Пока использований 3 или меньше - то выгоднее $this->_step.
При 4х использований появляется выгода to locals, на 3х - одинаково, на 2х - лучше не делать to locals.
Но это только для float/int/string.

$x = $this->_step; // 5
$x = $this->_a; // 8 ns - массив вытянуть в to locals сложнее
$x = $this->_b; // 8
$x = $this->_object; // 8 ns - объекты тяжело как и массивы

$x = $this->_a['key']; // 15 = 8 + 7
$x = $this->_b[1]; // 12 = 8 + 4, int-ключ в массиве быстрее на 2 ns/call
$x = $this->_x->seqSuffix; // 11 ns - это быстрее чем массив, неважно какой

// 17 = 8 + 9
$x = $this->_a; // 8
$y = $x['key']; // 9
(этот тест показал что выгоднее сразу делать to locals без промежуточной переменной)

// 14 = 8 + 6
$x = $this->_b; // 8
$y = $x[1]; // 6
(с int-ключами тоже быстрее)

А вот в случае с array-key делать to-locals trick надо всегда:

$this->_a['key'] * $this->_a['key']; // 26
$this->_a['key'] * $this->_a['key'] * $this->_a['key']; // 38
$this->_a['key'] * $this->_a['key'] * $this->_a['key'] * $this->_a['key']; // 50

$x = $this->_a['key']; // 15
$x * $x; // 19
$x * $x * $x; // 20
$x * $x * $x * $x; // 21

upd: для int/float to locals trick надо делать начиная с 2х использований

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        //$int = $this->_int; // 5 ns

        // 1 - 16
        // 2 - 32
        // 3 - 48
        //$this->_call($this->_int); // call 10, int-arg 2, доступ к свойству 4
        //$this->_call($this->_int);
        //$this->_call($this->_int);

        // 1 - 18
        // 2 - 31
        // 3 - 44
        $int = $this->_int; // присвоение 1, доступ к свойству 4
        $this->_call($int); // call 10, int-arg 2, доступ к локальной переменной 1
        $this->_call($int);
        $this->_call($int);
    }

    public function __construct() {
        $this->_int = rand();
    }

    private function _call($int) {

    }

    private $_int;

}

// пока два элемента - одинаково, на 3м уже выгоднее, но на одном - хуже
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        //$this->_int; // 3-4 ns
        //$x = $this->_int; // 5 ns

        //log($this->_int); // 16
        //log($this->_int); // 32
        //log($this->_int); // 48

        $x = $this->_int;
        log($x); // 18
        log($x); // 32
        log($x); // 46
    }

    public function __construct() {
        $this->_int = rand();
    }

    private $_int;

}

==============================================================

to locals trick for array/object:

1. вытащить объект - 7 ns
2. вытащить свойство сразу - 11 ns
3. object/array выгодно вытаскивать to locals начиная с 2х использований
4. еще выгоднее вытянуть сразу свойство там где это возможно

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $pc = $this->_pairConfig; // 7 ns

        // 15 ns
        $pc = $this->_pairConfig;
        $pc->minTotal * $pc->minTotal;

        // 19 ns
        $pc = $this->_pairConfig;
        $pc->minTotal * $pc->minTotal * $pc->minTotal;

        // 20 ns
        $pc = $this->_pairConfig;
        $pc->minTotal;
        $pc->minTotal;
        $pc->minTotal;

        // 17 ns
        $this->_pairConfig->minTotal;
        $this->_pairConfig->minTotal;

        // 26 ns
        $this->_pairConfig->minTotal;
        $this->_pairConfig->minTotal;
        $this->_pairConfig->minTotal;

        $x = $this->_pairConfig->minTotal; // 11 ns

        $x = $this->_pairConfig->minTotal; // 11 ns
        $x * $x * $x; // 15 ns

        // 18 ns
        $this->_pairConfig->minTotal * $this->_pairConfig->minTotal;

        // 27 ns
        $this->_pairConfig->minTotal * $this->_pairConfig->minTotal * $this->_pairConfig->minTotal;
    }

    public function __construct() {
        $this->_pairConfig = DatastreamService::Get()->getPairConfig('binancefp', 'XMRUSDT');
    }

    private PairConfig $_pairConfig;

}

==============================================================

to locals trick for resource:

выгоднее выстаскивать начиная с 2х использований

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        //$this->_socket; // 5 ns
        //$this->_stream; // 5 ns

        // 1 - 17
        // 2 - 34
        // 3 - 51
        //$this->_call($this->_socket);
        //$this->_call($this->_socket);
        //$this->_call($this->_socket);

        // 1 - 20
        // 2 - 33
        // 3 - 47
        $socket = $this->_socket;
        $this->_call($socket);
        $this->_call($socket);
        $this->_call($socket);
    }

    public function __construct() {
        $this->_socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);

        $this->_stream = stream_socket_server(
            'udp://127.0.0.1:3333',
            $errno,
            $errstr,
            STREAM_SERVER_BIND,
        );
    }

    private function _call($socket) {

    }

    private $_socket; // resource
    private $_stream; // resource

}

==============================================================

Работа с массивами - всегда остой.
Сильно лучше держать отдельные int/float/string свойства.
Массивы тяжелее вытягивать, тяжалее присваивать, тяжелее доставать.

На примере 3х свойств:
записать свойства 11-12 ns
прочитать все свойства и перенести в локальные переменные 15 ns,
только прочитать - 12 ns

А вот с массивами записать 34-37 ns, прочитать - в лучшем случае 27 ns.
И это int-ключи, со строковыми будет еще дольше.

class Tool2 implements Benchmark_Interface {

    public function process() {
        // 29 ns fixed
        $x = rand() / rand();

        // 63-29 = 34 ns
        $this->_a = [
            0 => $x,
            1 => $x,
            2 => $x,
        ];

        // 66-29 = 37 ns
        $a[0] = $x;
        $a[1] = $x;
        $a[2] = $x;

        // 34 ns
        $x = $this->_a[0];
        $y = $this->_a[1];
        $z = $this->_a[2];

        // 27 ns
        $a = $this->_a;
        $x = $a[0];
        $y = $a[1];
        $z = $a[2];

        // 40-29=11 ns
        $this->_x = $x;
        $this->_y = $x;
        $this->_z = $x;

        // 4 ns
        // если массив уже есть то его выгодно присводить сразу за 4 ns,
        // а если переписывать свойства - то 4 ns на запись каждого + 9 на чтение по ключу из массива;
        // и тут надо считать что лучше: переписать в свойства или таскать массив
        // (кстати таскать массив через аргументы метода тоже норм, всего один указатель)
        $this->_array = $array; // для объекта тоже самое

        // 15 ns
        $x = $this->_x;
        $y = $this->_y;
        $z = $this->_z;
    }

    public function __construct() {
        $this->_x = 1;
        $this->_y = 2;
        $this->_z = 3;

        $this->_a = [
            0 => 1,
            1 => 2,
            2 => 3,
        ];
    }

    private $_a;

    private $_x;
    private $_y;
    private $_z;

}

==============================================================

array int-keys vs array string-keys:

Это странные результаты:
1. int-ключи быстрее: 18 ns random-access если все ключи есть, 22 ns если половины нет.
2. для string такого нет - конструкция if ($x = $this->_arrayString[$x] ?? false) дает доступ за 33 ns независимо
   от структуры массива.
3. простой доступ по ключу - int 11 ns, string 26 ns, и разница колоссальная.
4. принудительно превращать string в int через crc32 (это самый быстрый способ) - но это один раз 15 ns/call.
   и дальше доступ станет 11 ns вместо 26 ns,
   и дальше все вызовы isset-конструкции станут 18-22 вместо 33 ns.
   То есть тут надо считать: покрывают ли затраты на crc32 преимущества дальшейнего int-замеса, но даже на глаз
   если будет 2 запроса по ключу - то -15 ns crc32, +15 ns на первый доступ.

class Tool2 implements Benchmark_Interface {

    public function process() {
        // === int keys ===

        // спецально 2000, чтобы в 50% случаев элемента не было
        //$x = rand(1, 1000); // 22 ns, int

        // 30 - 22 = 8 ns (если 1000 элементов и они всегда есть)
        // 36 - 22 = 14 ns (если 2000 элементов и в 50% случаев их нет)
        //if (isset($this->_arrayInt[$x])) {}

        // 42 - 22 = 20 ns
        //$x = $this->_arrayInt[$x] ?? false;

        // 42 - 22 = 20 ns, но при этом у меня есть x и я знаю что он есть, можно дальше писать код
        /*if (isset($this->_arrayInt[$x])) {
            $x = $this->_arrayInt[$x];
        }*/

        // 44 - 22 = 22 ns если элементоа 2000 и половины нет
        // 40 - 22 = 18 ns если элементов 1000 и все есть
        /*if ($x = $this->_arrayInt[$x] ?? false) {

        }*/

        // 33 - 22 = 11 ns
        //$element = $this->_arrayInt[$x];

        // === string keys ===

        // спецально 2000, чтобы в 50% случаев элемента не было
        //$x = 'class'.rand(1, 1000); // 52 ns, string
        //$x = crc32($x); // +15 ns for crc32

        // 77 - 52 = 25 ns
        //if (isset($this->_arrayString[$x])) {}

        // 82 - 52 = 30 ns
        //$x = $this->_arrayString[$x] ?? false;

        // 85 - 52 = 33 ns, если элементов 2000 и в 50% случаев их нет
        // 92 - 52 = 40 ns если элементоа 1000 и они всегда есть
        /*if (isset($this->_arrayString[$x])) {
            $x = $this->_arrayString[$x];
        }*/

        // 85 - 52 = 33 ns
        /*if ($x = $this->_arrayString[$x] ?? false) {

        }*/

        // 78 - 52 = 26 ns
        //$element = $this->_arrayString[$x];
    }

    public function __construct() {
        for ($j = 1; $j <= 1000; $j++) {
            $this->_arrayInt[$j] = $j;
            $this->_arrayString['class'.$j] = $j;
        }
    }

    private $_arrayString = [];
    private $_arrayInt = [];

}

==============================================================

В for всегда надо передавать локальные переменные, вынос to locals всегда лучше.
Даже если цикл на ОДИН элемент - лучше выносить, я проверял, у for какой-то глюк.

// 5290 ns для 1000 элементов
// 37 для 5 элементов
// 27 для 3 элементов
$x = 0;
for ($j = 0; $j < $this->_limit; $j++) {
    $x ++;
}

// 3560 для 1000 элементов
// 31 для 5 элементов
// 24 для 3 элементов
$x = 0;
$limit = $this->_limit;
for ($j = 0; $j < $limit; $j++) {
    $x ++;
}

Но при этом у foreach нет такого прикола:

// 5750
$x = 0;
foreach ($this->_b as $b) {
    $x ++;
}

// 5800
$x = 0;
$bx = $this->_b;
foreach ($bx as $b) {
    $x ++;
}

==============================================================

to locals + цикл который может оборваться:
не имеет значения выносить или нет, получается одинаково не важно какое количество кругов, если вероятность круга падает.
Но если количество кругов линейное - то выгоднее to locals.

// 31 ns
$rand = mt_rand(1, 100);
if ($rand <= 90) {
    $cnt = 1; // 90%
} elseif ($rand <= 99) {
    $cnt = 2; // 9%
} else {
    $cnt = 10; // 1%
}

// 62 - 31 = 31 ns
for ($j = 1; $j <= $cnt; $j++) {
    $this->_socket_read($this->_socket);
}

// 62-31 = 31 ns
$socket = $this->_socket; // 36-29 = 7 ns; вынос resource занимает 7 ns
for ($j = 1; $j <= $cnt; $j++) {
    $this->_socket_read($socket);
}

==============================================================

do-while vs while:

1. если важно выполнить код в начале - то do-while до первого исполнения кода быстрее чем while, потому что экономится
   проверка на условии if.
   Код выполняется чуть раньше в do-while: сначала код, потом if.
   если loop гарантированно должен сделать хотя бы одну итерацию - do while чуть выгоднее, потому что первая проверка уходит в конец.
2. if break внутри это жопа, сильно лучше перенести проверку самого while/do - разница в 1.63 раза.
3. главное не забыть что при do-while выполняется всегда хотя-бы раз, даже при n=0

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $n = 1000;

        // примерно одинаково
        /*do {
            $n --;
            if ($n == 0) {
                break;
            }
        } while (1);*/

        /*while (1) {
            $n --;
            if ($n == 0) {
                break;
            }
        }*/

        // 3300 vs 5400 ns - сильно быстрее
        /*do {
            $n --;
        } while ($n > 0);*/

        // 6 ns
        /*while ($n > 0) {
            break;
        }*/

        // 3 ns
        do {
            break;
        } while ($n > 0);
    }

}

==============================================================

Обход по счетчику:

Если уже есть счетчик элементов по которым надо пройти - то do-while самый быстрый способ.
Особенно актуально если надо пройти в обратном порядке: видимо for все-таки трахает отдельную переменную.
@todo не правильный тест - нет доступа к элементу

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $n = 1000;

        // 3197
        for ($j = 0; $j < $n; $j++) {

        }

        // 3176
        for ($j = $n; $j > 0; $j--) {

        }

        // 3165
        while ($n > 0) {
            $n --;
        }

        // 3122
        do {
            $n --;
        } while ($n > 0);

        // 5036
        // для сравнения foreach сильно дольше
        foreach ($this->_a as $x) {

        }
    }

    public function __construct() {
        for ($j = 1; $j <= 1000; $j++) {
            $this->_a[] = $j;
        }
    }

    private $_a = [];

}

==============================================================

to locals + if-tree

Это очень хитрый тест: для if-tree нет никакого смысла доставать переменную to locals.

При rand(0,1) я получу 50/50 0 или 1, и поэтому в 50% случаев достанется свойство 1 раз, в 50% достанется два раза.
EV = 0.5 * 1 * w + 0.5 * 2 * w = 1.5w (w это стоимость операции).
А если я сделаю to-locals: то я получу 1w на присвоении, но получу malloc, а затем работу с локальной переменной в 1.5x.

При rand(0,2) я получу 33/33/33
EV = 0.33 * 1 * w + 0.33 * 2 * w + 0.33 * 3 * w = 2w
При to-locals: EV = 1w + 2x.

Итого это выгодно только если if-tree реально большой И равномерный. Но тогда уже правильнее использовать switch hash table.

// 23 ns
$this->_state = rand(0, 2); // или rand(0,1) для 2-if

// 32-23 = 9 ns
if ($this->_state == 1) {}

// 34-23 = 11 ns
$state = $this->_state;
if ($state == 1) {}

// 39-23 = 16 ns для 2if
// 40-23 = 17 ns для 3if
if ($this->_state == 1) {
} elseif ($this->_state == 2) {
} elseif ($this->_state == 0) {
}

// 39 - 23 = 16 ns для 2if
// 41 - 23 = 18 ns для 3if
$state = $this->_state;
if ($state == 1) {

} elseif ($state == 2) {

} elseif ($state == 0) {

}

==============================================================

if-tree
Разница в 3 ns/call

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        // 87
        $ask = rand(0, 100);
        $bid = rand(0, 100);
        $askSize = rand(0, 100);
        $bidSize = rand(0, 100);

        // 105 - 87 = 18
        /*if ($bid > 0) {
            if ($ask > $bid) {
                if ($askSize > 0) {
                    if ($bidSize > 0) {
                        $this->_call($ask, $askSize, $bid, $bidSize);
                    }
                }
            }
        }*/

        // 108 - 87 = 21
        if ($ask <= 0) {
            return;
        } elseif ($ask <= $bid) {
            return;
        } elseif ($askSize <= 0) {
            return;
        } elseif ($bidSize <= 0) {
            return;
        } else {
            $this->_call($ask, $askSize, $bid, $bidSize);
        }
    }

    public function __construct() {

    }

    private function _call($ask, $askSize, $bid, $bidSize) {

    }

}

==============================================================

Динамическая типизация в if-ах

if ($x) {} // если $x = null; то 5.5 ms
if ($x > 0) {} // если $x = null; то 8.7 ms
if ($x) {} // если $x = 1.0; то 3.7 ms
if ($x > 0) {} // если $x = 1.0; то 3.7 ms
if ($x) {} // если $x = 1; (int) - то 4 ms
if ($x > 0) {} // если $x = 1; (int) то 3.7 ms
if ($x) {} // $x = true; 3.5 ms
if (!$x) {} // $x = false; 4.0 ms
if ($x > 0) {} // $x = false; 8 ms

Итого:
= надо избегать типизаци в if-ах
= надо избегать null
= лучше всего для сравниений >0 <0 использовать float, int почему-то типизируется хуже
= быстре всего if true с bool внутри.

==============================================================

// Операции сравнения с int float - не имеют значения
// Но это потому что результат надо приврдить в bool
// Если отдельно надо отнять/перемножить/поделить - то int быстрее в 2 раза

// float:
if ($a != $b) {} // 3.96
if ($a - $b != 0) {} // 5.5
if ($a - $b > 0) {} // 6.5

// int:
if ($a != $b) {} // 3.9
if ($a - $b != 0) {} // 5.5
if ($a - $b > 0) {} // 6.5

==============================================================

$x ++ сильно быстрее $x += 1;

$x ++; // 0.5 ms
$x += 1; // 3.6 ms

Для $x-- тоже самое.
++$x и $x++ одинаково быстро тоже.

==============================================================

Счетчик сильно быстрее в int

// 0.5 ms
$x = 1;
for ($j = 0; $j < 1_000_000; $j++) {
    $x++;
}

// 5.5 ms
$x = 'a';
for ($j = 0; $j < 1_000_000; $j++) {
    $x++;
}

==============================================================

round-robin trick

1. выгодно бесконечно увеличивать int-счетчик и брать % 5 от него все время
2. выгодно сразу подставлять в foreach (если нужно)

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        // 20 ns
        //$socketArray = $this->_socketArray[$this->_rr ++ % 5];

        // 25 ns
        //$socketArray = $this->_socketArray[rand() % 5];

        // 47 ns
        /*$socketArray = $this->_socketArray[rand() % 5];
        foreach ($socketArray as $socket) {

        }*/

        // 41 ns
        /*$socketArray = $this->_socketArray[$this->_rr ++ % 5];
        foreach ($socketArray as $socket) {

        }*/

        // 37 ns
        /*foreach ($this->_socketArray[$this->_rr ++ % 5] as $socket) {

        }*/
    }

    public function __construct() {
        for ($i = 0; $i < 5; $i++) {
            $this->_socketArray[] = [$i, $i, $i];
        }
    }

    private $_rr = 0;
    private $_socketArray = [];


}

==============================================================

Параллельные массивы лучше вложенных,
это объясняется дорогим доступом к $message[i],
а также очень тяжелой клейкой array = [a, b, c]

// 197-198 ms
$messageArray = [];
$n = rand(1,3);
for ($loop = 1; $loop <= $n; $loop++) {
    $messageArray[] = [$t, $j, $loop];
}
foreach ($messageArray as $message) {
    $this->_call($message[0], $message[1], $message[2]);
}

// 179 ms
$a = [];
$b = [];
$c = [];
$n = rand(1,3);
for ($loop = 1; $loop <= $n; $loop++) {
    $a[] = $t;
    $b[] = $j;
    $c[] = $loop;
}
for ($i = 0; $i < $n; $i++) {
    $this->_call($a[$i], $b[$i], $c[$i]);
}

==============================================================

Динамические свойства:
можно писать вслепую, читать вслепую.
Но желательно иметь прямой указатель.

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        // 1366
        /*for ($j = 1; $j <= 100; $j++) {
            $x = $this->_a[$j];
        }*/

        // 4979
        /*for ($j = 1; $j <= 100; $j++) {
            $name = 'p'.$j;
            $x = $this->{$name};
        }*/

        // 882
        /*for ($j = 1; $j <= 100; $j++) {
            $x = $this->p1;
        }*/

        // 11
        //$x = $this->_a[1];

        // 7 ns
        //$x = $this->p1;

        // 17 ns
        /*$name = 'p1';
        $x = $this->{$name};*/

        // 42 ns
        /*$index = 1;
        $name = 'p'.$index;
        $x = $this->{$name};*/

        $rand = rand(1, 100); // 23 ns

        // 33 ns
        //$x = $this->_a[$rand];

        // 73 ns
        $x = $this->{'p'.$rand};
    }

    public function __construct() {
        for ($j = 1; $j <= 100; $j++) {
            $this->_a[$j] = $j;

            $name = 'p'.$j;
            $this->{$name} = $j;
        }
    }

    private $_a = [];

}

==============================================================

Втягивние переменных внутрь метода

// 12 ns call пустого метода
private function _test() {}

// 22 ms если внутри метода один раз достать $this->_x;
private function _test() {
    $this->_x;
}

// 89 ms если 10 раз достать $this->_x;
// 64 ms jit
private function _test() {
    $this->_x;
    ...
    $this->_x; // 10 раз
}

// 24 ms если переписаь в локальную переменную $x и дальше 10-20-30 раз ее дернуть
// 12 ms jit
private function _test() {
    $x = $this->_x;

    $x; $x; ... // сколько угодно раз
}

// 1151 ms для цикла с $this->_x
// но 2712 ms если $this->_x не была проиницирована, то есть просто private $_x; вместо private $_x = 1;
// надо быть супер аккуратным с инициацией
// 287 jit
private function _test() {
    for ($i = 0; $i < 100; $i++) {
        if ($this->_x > $i) {

        }
    }
}

// 784 ms для цикла с локальным $x
// это доказывает что лучше втягивать в локальную переменную
// но 2054 ms если $this->_x не была проиницирована, то есть просто private $_x; вместо private $_x = 1;
// надо быть супер аккуратным с инициацией
// 113 ms jit
private function _test() {
    $x = $this->_x;

    for ($i = 0; $i < 100; $i++) {
        if ($x > $i) {

        }
    }
}

// 1860 ms - какая-то жопа с указателями
private function _test() {
    $x = &$this->_x;

    for ($i = 0; $i < 100; $i++) {
        if ($x > $i) {

        }
    }
}

// 34 ms
// 18 ms jit
private function _test() {
    $this->_x['key1'];
}

// 2318 ms
// 740 ms jit
private function _test() {
    for ($i = 0; $i < 100; $i++) {
        if ($this->_x['key1'] > $i) {

        }
    }
}

// 800 ms, быстрее в 4 раза
// доступ по ключу массива это пиздец конечно
// 120 ms jit
private function _test() {
    $x = $this->_x['key1'];

    for ($i = 0; $i < 100; $i++) {
        if ($x > $i) {

        }
    }
}

==============================================================

call tree inlining

Кто-бы что-бы там не пиздел, php даже с jit не умеет инлайнить методы.
Пример:
Есть method1, который вызывает method2, который вызывает method3, и уже в method3 выполняется присваивание свойств.
Больше методы нигде не юзаются, все в одном классе, просто по очереди дерево вызовов 1>2>3.
В замерах я удалил время которое занимает сама логика присвоения, оставил только время цепочки call-вызовов.

Тест на 1М вызовов:
method 1 > 2 > 3 = 36 ms / 13.8 ms jit
method 2 > 3 = 23.5 ms / 10 ms jit
method 3 = 11 ms / 4 ms jit

jit ускоряет, но не решает проблему полностью.
Хочешь быстро - пиши простынями :)

==============================================================

foreach vs for:

foreach быстрее for, $a это 100 элементов int 1
foreach ($a as $x) {} // 930 ms // 540 ms
foreach ($a as $index => $x) {} // 1244 ms, то есть лишний index это пиздец // 543 ms jit
for ($x = 0; $x < count($a); $x++) {} // 1009 ms, и при этом еще нет доступа к элементу массива // 219 ms
for ($x = 0; $x < count($a); $x++) {$a[$x];} // 1888 ms, это уже с доступом // 643 ms
for ($x = 0; $x < 100; $x++) {$a[$x];} // 1352 ms // 636 ms
for ($x = 0; $x < count($a); $x++) {$a[$x];} // 1363 ms, то есть count в цикле это пиздец // 640 ms
$cnt = count($a);for ($x = 0; $x < $cnt; $x++) {} // 455 ms, быстрее foreach, но без доступа к элементу // 82 ms

==============================================================

foreach быстрее for:

// 210 ms
$a = [];
$b = [];
$c = [];
$found = 0;
$cnt = rand(1,10);
for ($j = 1; $j <= $cnt; $j++) {
    $a[] = $j;
    $b[] = $j;
    $c[] = $j;
    $found ++;
}

// 333 - 210 = 123 ms
for ($n = 0; $n < $found; $n++) {
    $a[$n];
    $b[$n];
    $c[$n];
}

// 317 - 210 = 107 ms
foreach ($a as $n => $v) {
    $a[$n];
    $b[$n];
}

вот еще один пример:
// 253 ms, клеить такой мульти-массив тяжелее чем три линейных
$d = [];
$found = 0;
$cnt = rand(1,10);
for ($j = 1; $j <= $cnt; $j++) {
    $d[] = [$j, $j, $j];
    $found ++;
}

// 437 - 253 = 184 ms
for ($n = 0; $n < $found; $n++) {
    [$a, $b, $c] = $d[$n];
}

// 420 - 253 = 167 ms << это самый быстрый способ читать такой массив, хотя клеить его было тяжелее
foreach ($d as [$a, $b, $c]) {

}

// 452 - 253 = 199 ms
foreach ($d as $x) {
    [$a, $b, $c] = $x;
}

==============================================================

Еще один пример foreach vs for:

foreach для доступа к элементу быстрее в 2.6 раза.
То есть выгоднее не собирать счетчик found++, а бежать foreach по массиву.

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        // 5036
        /*foreach ($this->_a as $x) {

        }*/

        // 5042
        $a = $this->_a;
        foreach ($a as $x) {}

        // 13800
        /*for ($j = 0; $j < 1000; $j++) {
            $x = $this->_a[$j];
        }*/

        // 8832
        $a = $this->_a;
        for ($j = 0; $j < 1000; $j++) {
            $x = $a[$j];
        }
    }

    public function __construct() {
        for ($j = 0; $j < 1000; $j++) {
            $this->_a[] = $j;
        }
    }

    private $_a = [];

}

==============================================================

if + foreach

Часто возникают ситуации, что если есть массив и по нему надо сделать foreach, но массив может быть пустой.
И что выгоднее - if ($array) { foreach($array ...)
или сразу $foreach даже если массив пустой?

Правильный ответ зависит от того, что в вашем случае вероятнее: пустой массив или нет?
Потому что if ($array) для пустого массива 2.3 ms (на 1М вызовов)
а если в массиве что-то есть, то if ($array) будет 0.7 ms (что сильно быстрее).
В тоже время foreach для массива с 1м элементом - 10 ms,
для пустого массива - 4.4 ms.

Если вероятность пустого массива 50% - то
foreach    = 0.5 x 4.4 + 0.5 x 10 = 7.2 ms
if+foreach = 0.5 x 2.3 + 0.5 x (0.7 + 10) = 6.5 ms << наличие if оправдано

Если вероятность пустого массива 10%:
foreach    = 0.1 x 4.4 + 0.9 x 10 = 9.44 ms
if+foreach = 0.1 x 2.3 + 0.9 x (0.7 + 10) = 9.86 ms << if НЕ оправдан

Если вероятность пустого массива 90%:
foreach    = 0.9 x 4.4 + 0.1 x 10 = 4.96 ms
if+foreach = 0.9 x 2.3 + 0.1 x (0.7 + 10) = 3.14 ms << наличие if оправдано

Важно: это тест с массивом на 1 элемент. Если элементов больше - надо пересчитывать EV.

==============================================================

foreach ($this->_a as $x) {} // 26 ms

foreach ($this->getArray() as $x) {} // 38 ms
где public function getArray() {
    return $this->_a;
}

но разница в 12 ms сохраняется сколько бы элементов в массиве не было.
То есть, разница только на одном call method + return указатель на массив.
Главное, конечно, массив не тереть внутри цикла.

Итого: делать readonly public array смысла мало, если это не hotpath а какой-нибудь симулятор с большим количеством данных - то можно смело прятать данные в getArray()

==============================================================

Если надо закосить элементы из массива - unset в цикле сильно быстрее.
Перекладывание в другой массив - 1200 ms.
array_slice - 820 ms.

// 823 ms
$a = array_slice($a, -100, null, true);

// 20 ms
$b = $a;
foreach ($b as $k => $v) {
    if ($j < 5) {
        unset($b[$k]);
    } else {
        break;
    }
}

==============================================================

unset vs multi unset

multi unset - быстрее пропорционально

unset(
    $this->_handlerArray[$streamID],
    $this->_selectReadArray[$streamID],
    $this->_selectWriteArray[$streamID],
    $this->_selectExceptArray[$streamID],
    $this->_selectTimeoutToArray[$streamID]
);

==============================================================

min/max для массива float-ов быстрее чем перебор массива

$max = max($a); // 32 ns для массива в 5 элементов, 52 ns для 10 элементов

// 52 ns для 5 элементов; 88 ns для 10 элементов
$max = 0;
foreach ($a as $x) {
    if ($x > $max) {
        $max = $x;
    }
}

==============================================================

array_sum для массива int-float быстрее чем перебор массива.
Но надо быть аккуратным, потому что array_sum херово работает если в массиве есть false или шото такое.

$avg = array_sum($a) / 60; // 240 ns

// 500 ns/call
$sum = 0;
foreach ($a as $x) {
    $sum += $x;
}
$avg = $sum / 60;

==============================================================

null-colleasing оператор работает хуже старого if'a:

$x = $this->_a[$j] ?? 1; // 14 us

$x = isset($this->_a[$j]) ? $this->_a[$j] : 1; // 13 us

// разница есть, но она меньше 0.5 us:
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        // 40
        $a = [];
        if (rand(0, 1)) {
            $a[1] = 1;
        }

        // 50-40 = 10
        //$x = isset($a[1]) ? $a[1] : 0;

        // 50..51-40
        $x = $a[1] ?? 0;
    }

}

==============================================================

null-colleasing оператор:

1. вложенный isset + if = 8 ns
2. ?? дольше на 3 ns

<?php
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        // 41 ns
        $data = [];
        if (rand(0, 1) == 0) {
            $data['result'] = 'pong';
        }

        // 101 - 41 = 60 ns
        //if (@$data['result'] == 'pong') {}

        // 49 - 41 = 8 ns
        /*if (isset($data['result'])) {
            if ($data['result'] == 'pong') {

            }
        }*/

        // 53 - 41 = 12 ns
        /*if (isset($data['result']) && $data['result'] == 'pong') {

        }*/

        // 52 - 41 = 11 ns
        //if (($data['result'] ?? '') == 'pong') {} // главное не забыть скобки! а то приорите операторов ппц
    }

}

==============================================================

printы:

1M вызовов print '.';
это 1749 ms > file.log
это 400 ms > /dev/null
А если выводить в консоль stdout - еще больший пиздец

==============================================================

new ClassName медленнее чем создание [array]

// 9 ms, но это статический массив
$x = array(
    'a' => 1,
    'b' => 1,
);

// 50 ms, это динамический массив, его нельзя инлайнить
$a = array(
    'key1' => $j,
    'key2' => $j,
);

new TmpClass($j, $j) // 84 ms

class TmpClass {
    public function __construct($a, $b) {
        $this->a = $a;
        $this->b = $b;
    }

    public $a, $b;
}

// new stdClass медленее чем мой класс TmpClass, хотя это пиздец,
// сама суть stdClass по документациям в том чтобы сделать ультра-быструю структуру
// и это статический stdClass
$x = new stdClass(); // 93 ms
$x->a = 1;
$x->b = 1;

==============================================================

Вызов метода с множественными аргументами:

в php8 появилась возможность делать вот так:
public function ppp1(...$args) {}

Для array<int> это капельку быстрее чем передавать массив: потому что массив еще надо склеить.
Для array<string> выгоднее делать отдельные calls.
Но если array<string> условно статический - то лучше использовать multi args - это быстрее на несколько ns.

// 121 ns
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $this->_call(1,2,3,4,5,6,7,8,9,10);
    }

    private function _call(...$args) {
        foreach ($args as $arg) {

        }
    }

}

// 138 - 14 = 124 ns
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $x = rand(); // 14 ns

        $this->_call($x,$x,$x,$x,$x,$x,$x,$x,$x,$x);
    }

    private function _call(...$args) {
        foreach ($args as $arg) {

        }
    }

}

// 71 ns, но это статический массив
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $this->_call([1,2,3,4,5,6,7,8,9,10]);
    }

    private function _call($args) {
        foreach ($args as $arg) {

        }
    }

}

// 148 - 14 = 134 ns, тут динамический массив
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $x = rand(); // 14 ns

        $this->_call([$x,$x,$x,$x,$x,$x,$x,$x,$x,$x]);
    }

    private function _call($args) {
        foreach ($args as $arg) {

        }
    }

}

// 127 ns, отдельные call
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $this->_call(1);
        $this->_call(2);
        $this->_call(3);
        $this->_call(4);
        $this->_call(5);
        $this->_call(6);
        $this->_call(7);
        $this->_call(8);
        $this->_call(9);
        $this->_call(10);
    }

    private function _call($a) {

    }

}

// 142 - 14 = 128 ns
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $x = rand(); // 14 ns

        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
    }

    private function _call($a) {

    }

}

// 211 - 42 = 179 ns, это тест со строками
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $x = (string) rand(); // 42 ns

        $this->_call($x,$x,$x,$x,$x,$x,$x,$x,$x,$x);
    }

    private function _call(...$args) {
        foreach ($args as $arg) {

        }
    }

}

// 179 - 42 = 137 ns, это тест со строковым массивом
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $x = (string) rand(); // 42 ns

        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
    }

    private function _call($a) {

    }

}

// 196 - 42 = 154 ns, это тест со строковым массивом
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $x = (string) rand(); // 42 ns

        $this->_call([$x,$x,$x,$x,$x,$x,$x,$x,$x,$x]);
    }

    private function _call($args) {
        foreach ($args as $arg) {

        }
    }

}

// 137 - 2 = 135 ns
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $x = __DIR__.'string'; // 2 ns

        $this->_call([$x,$x,$x,$x,$x,$x,$x,$x,$x,$x]);
    }

    private function _call($args) {
        foreach ($args as $arg) {

        }
    }

}

// 133 - 2 = 131 ns
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $x = __DIR__.'string'; // 2 ns

        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
        $this->_call($x);
    }

    private function _call($a) {

    }

}

// 129 - 2 = 127 ns
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $x = __DIR__.'string'; // 2 ns

        $this->_call($x,$x,$x,$x,$x,$x,$x,$x,$x,$x);
    }

    private function _call(...$args) {
        foreach ($args as $arg) {

        }
    }

}


==============================================================

arrays vs DTO:
я конечно за все прекрасное ООП, но только вот DTO в 3 раза медленее чем array с ключами, особенно если есть jit.
jit ускоряет массивы, но никак не ускоряет DTO. Хоть самому инлайнер пиши.

// это долгий вариант, наличие конструктора и типизации свойств делает инициализацию объекта сильно долгим
class DTO {

    public function __construct($a, $b, $c) {
        $this->a = $a;
        $this->b = $b;
        $this->c = $c;
    }

    public readonly int $a;
    public readonly int $b;
    public readonly int $c;

}

$x = new DTO($j, $j, $j); // 86 ms
$x->a; // если читать ключи - то суммарно 99 ms // 92 jit не помогает
$x->b;
$x->c;

$x = array( // 40 ms
    'a' => $j,
    'b' => $j,
    'c' => $j,
);
$x['a']; // если читать ключи - то суммарно 61 ms // 42 jit помогает
$x['b'];
$x['c'];

$x = []; // 46 ms << это самый быстрый пособ при jit
$x['a'] = $j;
$x['b'] = $j;
$x['c'] = $j;
$x['a']; //  если читать ключи - то суммарн 69 ms /  34 ms jit
$x['b'];
$x['c'];

class DTO1 {

    public int $a = 1;
    public $b = 2;
    public readonly int $c;

    public function __construct() {
        $this->c = 3;
    }

}
$tmp->a;
$tmp->b;
$tmp->c;

итого: нет никакой разницы вообще, именно чтение свойств шо типизированные шо readonly не имеет значения.

// самый быстрый вариант: без типов данных и без констуктора
class DTO {

    public $a; // супер важно не писать тут типы данных
    public $b;
    public $c;

    // тут можно добавлять свои методы, на скорость не влияет
}

$x = $this->_dto1; // 21 ms / jit 8 ms << лучший вариант
$x->a = $j;
$x->b = $j;
$x->c = $j;

$x = $this->_dtoArray['binancefp-XMRUSDT']; // 29 ms / jit 12 ms << лучший вариант
$x->a = $j;
$x->b = $j;
$x->c = $j;

$x = new DTO(); // 42 ms / jit 24 ms
$x->a = $j;
$x->b = $j;
$x->c = $j;

$x = clone $this->_dto1; // 57 ms / jit 43 ms
$x->a = $j;
$x->b = $j;
$x->c = $j;

$a = array( // 40 ms / jit 37 ms
'a' => $j,
'b' => $j,
'c' => $j,
);

Итого:
1. DTO лучше массива если в нем нет типов данных (на свойствах) и если в нем нет конструктора
2. идеально иметь один объект DTO и все время в нем менять значения и выдавать его
3. clone использовать нельзя, просто очень долго
4. если нужно держать указатели на более чем 1 объект - то memory pool хорошее решение, даже с key-value массивом
5. чтение из DTO быстрее чем из массива, плюс IDE еще и подсказывает:
   чтение по ключу массива - 7-8 ms (без jit)
   чтение по свойству dto - 4-5 ms (без jit)
6. чем больше свойств в DTO - тем дольше инициализация new DTO(), но это все равно быстрее нового array.
7. в свойствах DTO нельзя добавлять типы данных
   и нельзя делать инициализацию public $c = 0.0;
   это приводит к заметному замедлению при new (именно при new)

==============================================================

new vs clone

<?php
class MyClass {

    /*public function __construct() {
        $this->_c = $this->_a + $this->_b;
    }*/

    private $_a = 1;
    private $_b = 2;
    private $_c;

}

// with constructor
$x = new MyClass(); // 52 ns
$x = clone $this->_x; // 44 ns

// without constructor
$x = new MyClass(); // 27 ns
$x = clone $this->_x; // 44 ns

Итого: если есть повторяемая логика в конструкторе - лучше clone. Если нет - лучше new.

==============================================================

class MyClass {

    /*public function __construct($a, $b, $c) {
        $this->a = $a;
        $this->b = $b;
        $this->c = $c;
    }*/

    public $a;
    public $b;
    public $c;

}

// 66 ns
$x = new MyClass(1, 2, 3);

// 41 ns
$x = new MyClass();
$x->a = 1;
$x->b = 2;
$x->c = 3;

Итого: присвоение полей с наружи быстрее, хотя код говно.

==============================================================

call:

просто вызов любого метода $this->_method1() // 16 ms // 0 ms
если передать параметры $this->_method1($j) // 18 ms // 0 ms
каждый следующий параметр +2 ms
и это метод еще нихера не делает внутри, просто пустой

$this->_call1($t); // 9 ms
$this->_call2($t); // 10 ms - один парамер
$this->_call5($t, $t, $t, $t, $t); // 18 ms - 5 параметров

==============================================================

call static vs:

$this->method2(); // 12.8 ms
self::Method1(); // 14.3 ms << вот это поворот, почему так долго?
Tool1::Method1(); // 12.5 ms << самый быстрый вариант

==============================================================

$this->method2(); // 12.8 ms на 1М вызовов
$this->bp->method2(); // 18 ms на 1М вызовов
и opcache это никак не ускоряет.

==============================================================

private function _format(&$price, &$amount) {
    $price += 1;
    $amount += 1;
}

$this->_format($price, $amount); // 33 ns на вызов (сам вызов)
// и это примерно на 3-4 ns быстрее чем сделать два call + return

==============================================================

DTO vs new DTO vs isset

// 59 ms
$this->_x = new DTO();
$x = $this->_x;
$x->a = $j;
$x->b = $j;
$x->c = $j;

$x = new DTO(); // 56 ms
$x->a = $j;
$x->b = $j;
$x->c = $j;
$this->_x = $x;

// 28 ms
if (empty($this->_x)) { // если не известно DTO инициирован или нет
    $this->_x = new DTO();
}
$x = $this->_x;
$x->a = $j;
$x->b = $j;
$x->c = $j;

// 24 ms
if ($this->_xEmpty) { // еще быстрее, потому что нет типизации объекта к bool
    $this->_x = new DTO();
    $this->_xEmpty = false;
}
$x = $this->_x;
$x->a = $j;
$x->b = $j;
$x->c = $j;

// 25 ms
if (!$this->_xInited) { // сильно легче заходить в true условия
    $this->_x = new DTO();
    $this->_xInited = true;
}
$x = $this->_x;
$x->a = $j;
$x->b = $j;
$x->c = $j;

// 21 ms
$x = $this->_x; // _x это DTO и он уже проинициирован
$x->a = $a;
$x->b = $b;
$x->c = $c;

// 17 ms
$this->_call($a, $b, $c); // << идеально всегда заменять на call и не заниматься присвоением хуйни в DTO или Array


==============================================================

int-cast сильно быстрее floor(), потому что это вызов функции.
Вместо floor($x) лучше писать (int) $x

==============================================================

closure & lambda:

interface IReceiver {
    public function run($ts, $j);
}
class Receiver implements IReceiver {
    public function run($ts, $j) {}
}

    private function _run1($ts, callable $f) {
        for ($j = 1; $j <= 1_000_000; $j++) {
            $f($ts, $j);
        }
    }

    private function _run2($ts, IReceiver $receiver) {
        for ($j = 1; $j <= 1_000_000; $j++) {
            $receiver->run($ts, $j);
        }
    }

    private function _run3($ts) {
        for ($j = 1; $j <= 1_000_000; $j++) {
            $this->_receiver->run($ts, $j);
        }
    }

    private function _run4($ts) {
        $receiver = $this->_receiver;
        for ($j = 1; $j <= 1_000_000; $j++) {
            $receiver->run($ts, $j);
        }
    }

    // ниже числа где 1 раз вызывается _runX
    // closure тяжело передается, а use +1 параметр добавляет +6 ms на один вызов, не на 1М вызовов
    $this->_run1($t, function($ts, $j) {}); // 38 ms - for 4 ms = 34 ms
    $this->_run1($t, function($ts, $j) use ($t) {}); // 44 ms - 4 = 40 ms
    $this->_run1($t, $fn); // 38 ms -4 = 34 ms
    $this->_run2($t, $receiver); // 31 - 4 = 27 ms << самый быстрый способ это передать receiver 1 раз, он станет локальным в методе
    $this->_run3($t); // 36 ms - 4 = 32 ms (дерганье объекта хуевое)
    $this->_run4($t); // 31 ms - 4 = 27 ms << тоже самый лучший варант

Другой тест: если 1М раз вызывать run, каждый раз передавая callback в виде function или receiver
    $this->_run(array($this, '_callback1')); // 280 ms
    $this->_run(function ($ts, $x) {}); // 214 ms, чуть быстрее
    $this->_run($receiver); // 125 ms объект с invoke
    $this->_run($receiver); // 111 ms без invoke, разница в 2.5 раз

Итого: closure как-то херово инлайнится внутрь, лучше от него избавляться.
А lamda-use вообще шляпа.
Правда вот современные либы типа Rachet/react все на этой блямбда-хуйне.

==============================================================

Битовая маска
Не смотря на то, что вызов call с кучей параметров стоит дорого, накопление битовой маски такая себе идея тоже

$a = (bool) rand(0, 1);
$b = (bool) rand(0, 1);
$c = (bool) rand(0, 1);
$d = (bool) rand(0, 1);
$e = (bool) rand(0, 1);

$t = microtime(true);

for ($j = 0; $j < 1_000_000; $j++) {
    //$this->_call1($a, $b, $c, $d, $e); // 22 ms

    $mask = 0;
    if ($a) $mask |= self::FLAG_A;
    if ($b) $mask |= self::FLAG_B;
    if ($c) $mask |= self::FLAG_C;
    if ($d) $mask |= self::FLAG_D;
    if ($e) $mask |= self::FLAG_E;
    $this->_call2($mask); // 25-33 ms
}

$t = microtime(true) - $t;
$t *= 1000;
var_dump($t);

==============================================================

== vs ===

=== добавляет примерно +1+2 ns

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        //$x = rand(0, 1); // 22 ns
        //if ($x == 1) {} // 28-22 = 6 ns
        //if ($x === 1) {} // 29-22 = 7 ns

        //$this->_x; // 3 ns
        //if ($this->_x == 1) {} // 4 - 3 = 1 ns
        //if ($this->_x === 1) {} // 6 - 3 = 3 ns
    }

    public function __construct() {
        $this->_x = rand(0, 1);
    }

    private $_x;

}

==============================================================

strings concatenations:

самые большие проблемы это автоприведение типов, на втором месте конкатенация.

$s = $int.$int.$int; // 139 ms // 4.54 ms jit
$s = "$int$int$int"; // 117 ms << лучше всего сразу в одну строку // 4.5 ms
$s = $int; $int .= $int; $s .= $int; // 143 ms, клеить заметно хуже // 4.5 ms

// если $a и $b string - то значения не имеет как склеивать
$s = $a.$b; // 27 ms
$s = "$a$b"; // 28 ms
$s = $a; $s .= $b; // 40 ms, клеить по очереди всегда пиздец

// но для длинных строк - все равно выгодно клеить в одну строку
$s = $a.$b.$a.$b.$a.$b.$a.$b.$a.$b.$a.$b; // 192..194 ms
$s = "$a$b$a$b$a$b$a$b$a$b$a$b"; // 139..140 ms << самый выгодный вариант
$s = "{$a}{$b}{$a}{$b}{$a}{$b}{$a}{$b}{$a}{$b}{$a}{$b}"; // 139..140 ms, нифига не меняется
$s = $a; $s .= $b, ... и так дофига раз // 700+ ms, пиздец вам всем, так делать не надо

Это все обясняется бесконечным memory alloc и перекладываем переменных из памяти в память в новую бОльшую ячейку.
При jit это все исправили.

==============================================================

Сравнение чисел, которые пришли из строк:

$old = '1753186451315114';
$new = '1753186451315114.001';

$x = ($new > $old); // 166 ms
$x = (strcmp($new, $old) == 1); // 19 ms

Сильно выгоднее сравнивать строками через strcmp.
Но важно чтобы количество знаков до плавающей точки было одинаковое, а само число было преставлено в правильном форматировании.

Важно: strcmp быстрее если это изначально string. Если это int, то все-таки быстрее $new > $old, php сам приведет к типам.

==============================================================

$s = implode(';', $array)
сильно быстрее чем
$s = $array[0].';'.$array[1].';'....;
Особенно если индексы строковые.
Разница в N раз, где N это количество элементов в массиве.
implode (он же formerly join) экономит операции конкатенации и экономит поиск ключей в массиве.

Если массив очень большой и надо какие-то ключи пропускать - то лучше всего foreach ($key => $value) и внутри клеить строку.
Хотя тоже хуйово, но это все-таки быстрее чем прямая склейка.

==============================================================

memory allocations

Если переменная нужна 1 раз - то ее лучше не аллоцировать.
$a = explode(';', getData());
будет в 2 раза быстрее чем
$a = getData(); $a = explode(';', $data);

Хотя конечно читабельность кода теряется, но php не умеет такое инлайнить.

==============================================================

typing

Типизация конкатенацией - лажа, лучше явно string перед ним.
$j.''; // 24.5 ms (это без jit)
(string) $j; // 19.5 (это без jit)
strval($j); // 19.5

==============================================================

cast int to string with concatenations

// 14 ms - if $a $b strings
$x = $a.$b;

// 96 ms - if $a $b ints
$x = $a.$b;

// 155 ms - if $a $b strings
$x = sprintf('%d%d', $a, $b);

// 77 ms - if $a $b ints
$x = sprintf('%d%d', $a, $b); << если у вас N int чисел, которые надо склеить как строку - сильно выгоднее sprintf

// 32 ms - cast int to string
$x = (string) $a;

==============================================================

Если у нас int или float находится в string, то самый быстрый способ это просто (int) $x или (float) $x.
Если $x уже был нужного типа - потеря максимум 4 ns.

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        //$x = rand().''; // string, 46 ns
        //$x = (int) rand(); // 16 ns
        //$x = rand() / 1000; // 17 ns
        $x = (rand() / 1000).''; // 153 ns

        //$x * 1.0; // 72 - 46 = 26 ns, 3 ns если уже int
        //(int)$x; // 68 - 46 = 22 ns, самый быстрый способ; 4 ns если уже int
        //$x + 0; // 72 - 46 = 26 ns; 3 ns если уже int

        //$x * 1.0; // 21-17 если уже float
        //$x * 1.0; // 196-153=43 если string
        //(float) $x; // 21-17 если уже float
        //(float) $x; // 177-153=24 если string

        // итого если тип верный - то лишний (cast) в него же занимает 4 ns;
        // а если цена в string - то пиздец
    }

}

==============================================================

поиск подстроки в строке:

if (substr_count($s1, $s2)) { $x++; } // 14.28 ms // 9.35 jit
if (str_contains($s1, $s2)) { $x++; } // 12.38 ms // 9.15 ms jit << без jit самое быстрое
if (strpos($s1, $s2) !== false) { $x++; } // 14.68 ms // 8.47 jit << с jit лучше испорльзовать strpos

==============================================================

ifы:
и это йибать странно, у меня нет объяснений

// быстрее прыгнуть в if чем за него, это заставляет писать if (true) {} else { logic here } если нужно false
if (true) {} // 1.28 ms
if (false) {} // 2.84 ms

// для int проблем нет, хотя они и медленее :)
if (1) {} // 4.45 ms
if (0) {} // 4.73 ms

Upd: Неожиданное поведение связано с предсказанием переходов процессора и внутренней реализацией PHP: пустой true быстрее пустого false.
Если много пустых условий (встречается редко), убедись, что горячие пути чаще истинны (branch prediction friendly).

==============================================================

if (true) быстрее чем if (false)
Причем самое интересное, что надо стараться писать просто if ($x) а не if ($x == true),
а также стараться писать код так, чтобы чаще срабатывал if-true (то есть без инвертированных переменных).

$x = true; // 2 ns
if ($x) {} // 4-2 = 2 ns
if ($x == true) {} // 5-2 = 3 ns
if ($x == false) {} // 5-2 = 3 ns
if (!$x) {} // 5-2 = 3 ns

$x = false; // 2 ns
if ($x) {} // 3-2 = 1 ns
if ($x == true) {} // 5-2 = 3 ns
if ($x == false) {} // 5-2 = 3 ns
if (!$x) {} // 5-2 = 3 ns

==============================================================

лучше делать инверсные флаги, потому что операция ! или сравнение на == false добавляет 1 ns

$x = true;

if (!$x) {} // 5 ns
if ($x == false) {} // 5
if ($x) {} // 4 ns

==============================================================

if + calls:

если надо сравнить что-то - то лучше это делать до call, хотя это не красиво и хочется чтобы метод проверял шо происходит.
ниже пример, где в call2 передаются чистые данные, а сравнение на правильность a & b делается до call2.
И это быстрее в 2 раза, не смотря на то что в call2 тоже передаются эти аргументы.
То есть call stack тот же, просто самих call меньше вдвое - и именно на этом экономия.
Если условия отсечения срабатывают реже - то разница будет не такая заметная.

При rand(1,100) условие проходит примерно в 25% случаев, значит 75% вызовов _call2() вообще не происходит. Поэтому и получается быстрее.

pre-filter before call.

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        // 44 ns
        $a = rand(1,100);
        $b = rand(1,100);

        // 69 - 44 = 25 ns
        $this->_call1($a, $b);

        // 57-44 = 11 ns
        if ($a >= 50) {
            if ($b >= 50) {
                $this->_call2($a, $b);
            }
        }
    }

    private function _call1($a, $b) {
        if ($a >= 50) {
            if ($b >= 50) {

            }
        }
    }

    private function _call2($a, $b) {

    }

}

==============================================================

XOR vs != for bool

$bool1 = true;
$bool2 = false;

// 17 ns
$x = $bool1 ^ $bool2;

// 20 ns
$x = (int) ($bool1 ^ $bool2);

// 14 ns
$x = ($bool1 != $bool2);

// 19 ns
$x = (int) ($bool1 != $bool2);

// 14 ns
if ($bool1 != $bool2) {
    $x = 1;
} else {
    $x = 0;
}

// 14 ns
if ($bool1 != $bool2) {
    $x = true;
} else {
    $x = false;
}

но для int все ровно

$int1 = 1;
$int2 = 0;

// 11 ns
$x = $int1 ^ $int2;

// 11 ns
$x = ($int1 != $int2);

// 11 ns
if ($int1 != $int2) {
    $x = 1;
} else {
    $x = 0;
}

==============================================================

IF vs MIN/MAX

Если кажется что выгоднее делать конструкцию типа $a = min($a, $b) - то нихуя.
// loop 3.16 ms
for ($j = 0; $j < 1_000_000; $j++) {
    $b = rand(); // rand 11.84 ms (loop + rand = 15 ms)
    //$a = max($a, $b); // 32-15 = 17 ms
    if ($b > $a) { // 2 ms, if сильно быстрее
        $a = $b;
    }
}

==============================================================

Вложенные IF и AND

$a = 1;
$b = 2;

if ($a > 0) {
    if ($b > 0} {
        ...
    }
}

быстрее чем if ($a > 0 && $b > 0) { ... }

if ($a > 0 && $b > 0) {} // 4.38 ms на 1М вызовов
if ($a > 0) { // 1.65 ms на 1М вызовов
    if ($b > 0) {
        // ...
    }
}

Сука блять, какого хера?
Upd: это как индексы в SQL, надо наперед выносить первый. Но если написать все сразу - то будет проверять все, потом еще и в AND лепить.

==============================================================

IF OR

OR таки работает как short-circuit, но все равно с какой-то хуйней:
if ($j > 0 || $j > 1 || $j > 2 || $j > 3 || $j > 4) {}
и чем больше я ставлю условий - тем медленее срабатыват этот йобанный if, хотя short-circuit реально срабатывает только на 1м условии:
я пробовал заменить $j на функцию с принтом, чтобы понять какая вызовется.

// 13 ms -- и продолжает расти если увеличиваю количество условий
// хотя реально проверяется только первое истинное условие (short circuit)
if ($j > 0 || $j > 1 || $j > 2 || $j > 3 || $j > 4) {}

// 5 ms -- такая конструкция сильно быстрее и задержка не растет с количеством if-ов, хоть 100 штук поставь
if ($j > 0) {
} elseif ($j > 1) {
} elseif ($j > 2) {
} elseif ($j > 3) {
} elseif ($j > 4) {
}

Но, тут очень важный момент: переходить с OR на elseif выгоднее если чаще всего все условия true.
Хотя на большом количестве параметров if-elseif все равно быстрее.
Я пробовал даже писать if (1 || ...300_бессмысленных_условий) - начинается мрак на 700 ms

В примерах ниже $j и $t больше нуля всегда и меняются динамически:

// 8.44 ms
if ($j < 0 || $t < 0) {}

// 8.44 ms - тут будет проверка всех условий, поэтому скорости не добавляет для двух операций
if ($j < 0) {
} elseif ($t < 0) {
}

// 6.7 ms
if ($j > 0 || $t > 0) {}

// 5.6 ms - тут сработает только первый if
if ($j > 0) {
} elseif ($t > 0) {
}

// 16.5 ms
if ($j < 0 || $t < 0 || $amount < 0 || $price < 0) {}

// 13.6 ms << все равно быстрее если параметров больше, и дело не в типизации, типы одинаковые
if ($j < 0) {
} elseif ($t < 0) {
} elseif ($amount < 0) {
} elseif ($price < 0) {
}

// 11 ms
if ($j > 0 || $t > 0 || $price > 0 || $amount > 0) {}

// 5.6 ms << еще быстрее
if ($j > 0) {
} elseif ($t > 0) {
} elseif ($amount > 0) {
} elseif ($price > 0) {
}

// 7.8 ms
$x = ($a || $b);

// 7.75 ms, но $x заранее инициирован в false
if ($b) {
    $x = true;
} elseif ($b) {
    $x = true;
}

Итого: чем больше параметров - тем выгоднее переходить на if elseif.
Так и до goto label недалеко докатиться.

==============================================================

$x = ($j > 100); // 6.23 ms

if ($j > 100) { // 5.8 ms, потому что экономится одно присвоение false
    $x = true;
}

==============================================================

Не выебуйся с присвоениями:

$changeAsk = $changeBid = true; // 7.7 ms

$changeAsk = true; $changeBid = true; // 7.4 ms

==============================================================

if vs switch:
Это конечно эпичный пиздец, следите за магией:

Если у вас два значения (типа 0 или 1) - то лучше писать
if ($x == 1) { } else {}
это будет 57-58 ms на 10М вызовов, в зависимости от того куда нужно попасть - в true или в false.
И можно менять приоритет - указывая if (x == 1) или if (x == 0), главное не херачить перевороты типа !$x - это усложняет все.

Если значения $x может быть три и они int - то надо прикинуть равнозначны они или нет.
Типа если вероятность условно 33/33/33 - то делаем switch, он по int быстрее.
Если не равнозначны - то выгоднее if-elseif-elseif и так можно расставить приоритеты, можно получить первый if за 57 ms.
Равнозначный switch даст 80 ms на 1М вызовов.
Если значений уже 5 или выше - то switch займет 146 ms на 1М вызовов, видимо там по другому будет построена hash-таблица.
Опять-таки надо смотреть нужны приоритеты или нет.

Если надо switchем сравнивать string - то это сразу лютый пиздец, if-else даст 58-60 ms, примерно на +2 ms больше за счет того что это строки.
Но стоит помнить как php делает строки внутри, там все аля-константы.
Строковый switch это полная жопа, потому что там все двигается линейно по-строкам, чем больше данных в switch - тем сложнее прыжок вниз. Короче полная шляпа.

При этом opcache и jit ничего не меняют. Стает быстрее, но пропорции сохраняются.

==============================================================

switch vs if-or

$x = rand(1, 5);

// 114 ms
switch ($x) {
    case 1:
    case 2:
    case 3:
    case 4:
       break;
    default:
        break;
}

// 7 ms
if ($x != 5) {}

// 138 ms
if ($x == 1 || $x == 2 || $x == 3 || $x == 4) {}

Тут важный нюанс: если x может принимать значения только от 1 до 5 - то выгоднее if,
если or до 4 значений - дешевле or
если or от 5 значений - то выгоднее switch

==============================================================

switch vs short if

На 10М вызовов:

// 82-135 = 108.5 avg если не выносить to locals
// 92-112 = = 102 avg если выносить
$action = $this->_action;
if ($action == AMM_Const::ACTION_BUY) {

} elseif ($action == AMM_Const::ACTION_SELL) {

}

// 210 ms - и не важно выносить или нет
$action = $this->_action;
switch ($action) {
    case AMM_Const::ACTION_BUY:
        break;
    case AMM_Const::ACTION_SELL:
        break;
}

==============================================================

switch и типы данных

// супер важно чтобы тип данных в $x и case совпадал.
// если совпадает - 17 ms, если не совпадает - 60 ms (это все без jit).
// лучше всего сделать $x = (int)$x; switch ($x) - так будет 45 ms. Иначе оно походу типизирует под каждый case. Нахуя, не понятно.
// chatgpt утверждает что switch сравнивает на ==, а не ===, но все равно там внутри какая-то шляпа
// см string typing

switch ($x) {
    case 1:
        break/return; // а вот разницы return или break - значения никакого.
    case 2:
        break/return;
}

==============================================================

switch ($a.'-'.$b) { ...

$key = $a.'-'.$b;
switch ($key) { ... // быстрее в 3 раза тоже, видимо оно как-то неэффективно каждый раз сравнивает, пиздец блять

==============================================================

// 25 ms
if ($j > rand(0, 100)) {
    $rejected = true;
} else {
    $rejected = false;
}

// 24 ms
$rejected = ($j > rand(0, 100));

==============================================================

consts:

if (defined('myconst')) {} // 3.9 ms если false, 1.27 ms если true. Что тоже пиздец как логично ж
if ($this->_boolVar) {} // 4.88 ms

==============================================================

switch ($string)
    case CONST_STRING: ...
vs
switch ($int)
    case CONST_INT: ...

string const = 15-17 ms на 1М вызовов
int const = 4 ms на 1М вызовов
int const сильно лучше (но см где константы обявлены)


==============================================================

Доступ к константам:

1. обращаю внимание что в этом тесте есть if и присвоение, но они демонстрируют доступ к константе в зависимости от того
   где именно она расположена.
2. константы надо выносить в отдельный const-класс и делать include его, без autoload: это самый быстрый способ.
   причем если записать константы в этот же класс и сделать его include - это не помогает, то есть константы
   должны быть объявлены ДО того как будет инклудится класс в котором эти константы юзаются.

// контанта в этом же класса (self лучше не юзать)
if (self::AAA) {} // 6 ns
$x = self::AAA; // 7 ns

// если указать имя класса точно, и это текущий класс
if (Tool1::AAA) {} // 4 ns
$x = Tool1::AAA; // 5 ns

// константа обявлена в родителе,
// не важно final или нет,
// не важно указать этот класс или родительский
if (Tool1::AAA) {} // 4 ns
$x = Tool1::AAA; // 5 ns

// супер глобальная константа, в include без autoload
if (AAA) {} // 1 ns
$x = AAA; // 2 ns

// супер глобальная константа перед классом, class autoloaded
if (AAA) {} // 3 ns
$x = AAA; // 4 ns

// отдельный класс с autoload
if (MyConstAutoload::AAA) {} // 4 ns/call
$x = MyConstAutoload::AAA; // 5 ns/call

// отдельный класс, include_once, БЕЗ autoload
if (MyConst::AAA) {} // 1 ns
$x = MyConst::AAA; // 2 ns

При этом такой хуйни с вызовом методов и свойств через $this->... тупо нету.
А вот self эпично загоняется именно с константами, на статических методах тоже есть, но не так заметно:
Tool1 extends Tool0, SM0 в Tool0, SM1 в Tool1:
self::SM0(); // 149 ms
Tool0::SM0(); // 130 ms
self::SM1(); // 142 ms
Tool1::SM1(); // 125 ms
итого: надо всегда вместо self указывать конкретное имя класса.

Главная причина: self::/parent::/static:: — это не просто текстовая подстановка. PHP трактует такие обращения как специальные статические/forwarding references в контексте класса; у static:: ещё и late static binding. Документация прямо выделяет self::, parent::, static:: как особые формы статического вызова/биндинга.

==============================================================

fill массивов:

for ($j = 0; $j < 1_000_000; ++$j) {
    $this->_test();
}

// 1098 ms
// 110 ms << при jit  это самый быстрый способ, без jit - самый медленный
private function _test() {
    $x = rand(1, 100);
    $a = [];
    for ($i = 1; $i <= $x; $i++) {
        $a[$i] = $i;
    }
}

// 930 ms - без индекса быстрее на 10%
// 499 ms << лучше с индексом при jit
private function _test() {
    $x = rand(1, 100);
    $a = [];
    for ($i = 1; $i <= $x; $i++) {
        $a[] = $i;
    }
}

// 1010 ms, если массив уже заполнен и я его копирую - трохи быстрее
// 490 ms
private $_bucket = array_fill(0, 100, 0);
private function _test() {
    $x = rand(1, 100);
    $a = $this->_bucket;
    for ($i = 1; $i <= $x; $i++) {
        $a[$i] = $i;
    }
}

// 865 ms, тоже самое, только bucket по указателю
// это странно конечно, работает только с массивами, с обычными переменными делает сильно хуже
// надо быть аккуратным, по перетирарается сам $this->_bucket
private $_bucket = array_fill(0, 100, 0);
private function _test() {
    $x = rand(1, 100);
    $a = &$this->_bucket;
    for ($i = 1; $i <= $x; $i++) {
        $a[$i] = $i;
    }
}

// 1180 ms, то то есть вызов $this->xxx пиздец тяжелый
// 406 ms
// но если надо таки записать в свойство, то лучше так чем собирать массив у себя локально потом присваивать - 506 ms jit
private $_bucket = array_fill(0, 100, 0);
private function _test() {
    $x = rand(1, 100);
    for ($i = 1; $i <= $x; $i++) {
        $this->_bucket[$i] = $i;
    }
}

==============================================================

Наиболее эффективный способ оценки пустого массива:

$socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
$a = [$socket];

if (!empty($a)) {$x++;} // 6.1 ms / 3.21 ms jit << быстрый если массива нет (переменная не инициирована)
if ($a) {$x++;} // 4.38 ms / 2.18 ms jit << это самый быстрый способ
if (count($a) > 0) {$x++;} // 7.4 ms / 2.21 ms jit

==============================================================

array_merge
$a = [
    'a' => 1,
    'b' => 2,
    'c' => 3,
];

$x = $a + ['x' => $j]; // 60 ns
$x = array_merge($a, ['x' => $j]); // 67 ns

$x = $a + ['x' => $j, 'y' => $j]; // 72 ns
$x = array_merge($a, ['x' => $j, 'y' => $j]); // 80 ns

==============================================================

array_merge быстрее array copy в 5+ раз
class Tool2 implements Benchmark_Interface {

    public function process() {
        // 2300 ns/call
        $x = array_merge($this->_a, $this->_b);

        // 11800 ns/call
        $x = $this->_a;
        foreach ($this->_b as $v) {
            $x[] = $v;
        }
    }

    public function __construct() {
        for ($i = 0; $i < 1_000; $i++) {
            $this->_a[] = $i;
            $this->_b[] = $i;
        }
    }

    private $_a = [];
    private $_b = [];

}

==============================================================

array_chunk - работает быстрее чем разбивка вручную, не важно 100 элементов или 1000.

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        array_chunk($this->_a, 20); // 869 ns для 100 элементов
        array_chunk($this->_a, 20, true); // 1044 ns для 100 элементов, с сохранением ключей дольше

        // 890 ns
        foreach (array_chunk($this->_a, 20) as $a) {

        }

        // 925 ns если есть временная переменная
        $tmp = array_chunk($this->_a, 20);
        foreach ($tmp as $a) {

        }

        // 1555 ns - вручную больше
        $a = [];
        $cnt = 0;
        foreach ($this->_a as $x) {
            $a[] = $x;
            $cnt ++;
            if ($cnt == 20) {
                $cnt = 0;
                $a = [];
            }
        }
    }

    public function __construct() {
        $this->_a = array_fill(0, 100, 1);
    }

    private $_a;

}

==============================================================

echo vs print

извечный срач.
echo быстрее на 1.1% чем print, потому что print еще делает return 1,
и на уровне zendvm echo - это одна opcode команда, а print - две.

==============================================================

sprintf vs number_format
sprintf быстрее примено на 20% и требует меньше памяти
Тест на 1M вызовов, без jit и без opcache
number_format(123456.123456789123, 12, '.', ''); // 375 ms
sprintf('%.12f', 123456.123456789123); // 326 ms

==============================================================

sprintf('%.2f', $price); // 185 ns на вызов

// 87 ns на вызов - самый топ
// а если сделать ее static в final static class и сделать его include - то будет -3 ns на вызов
function number_format_fast($value, $precision, $precision_power10) {
    // важно: отрицательные оно не хавает
    // важно: без round не сработает $value = 0.059999999999999; $p = 3;, а во float может быть такая хуйня

    //$n = (int) ($value * $precision_power10);

    // ручное округление вместо round() дало -20ns
    //$n = (int) round($value * $precision_power10);
    $x = $value * $precision_power10;
    if ($x >= 0) {
        $n = (int) ($x + 0.5);
    } else {
        $n = (int) ($x - 0.5);
    }

    if ($precision == 0) {
        // upd: даже форматировать в string не надо, это -2 ns
        return (string) $n;
    }

    // тут только сравнение по int, без strlen
    if ($n < $precision_power10) {
        return '0.' . str_pad((string) $n, $precision, '0', STR_PAD_LEFT);
    }

    // сюда попадаем только когда len > precision → тут уже нужен strlen
    $s = (string) $n;
    return substr_replace($s, '.', strlen($s) - $precision, 0);
}

// для времени лучше быстро переводить в int
function number_format_fast_ts($value) {
    //return ((int) ($value * 1_000_000)); // 10**6, // 24 ns, из которых 18 ns это просто пустой call()

    // best of:
    return substr_replace((string)((int) ($value * 1_000_000)), '.', -6, 0); // 82 ns, из которых 18 пустой call
}

==============================================================

round vs floor vs ceil

$x = round($tx); // 34 ns
$x = floor($tx); // 10 ns
$x = (int) floor($tx); // 14 ns
$x = ceil($tx); // 10 ns
$x = (int) ceil($tx); // 14 ns
$x = (int) $tx; // 7 ns, но это по сути truncate. Условные 5.99999999999 он приведет в int 5, а не в int 6.

==============================================================

ini_set('zend.enable_gc', 0);
gc_disable();

Убирает запуск garbage collector, все становится чуть сложнее, но циклы стабильне.

gc_collect_cycles(); // 72 ns

Идеальная стратегия:
выключить gc, но в loop раз в минуту дергать gc_collect_cycles() чтобы избежать ситуации где я что-то забыл

==============================================================

time() быстрее чем microtime(true)
Скорее всего это связано с int/float, сравнение int работает быстрее, да и сам time выдает результат быстрее

if (microtime(true) > $this->_workTimeLimit) {} // 46-48 ms
if (time() > $this->_workTimeLimit) {} // 38 ms

==============================================================

time и microtime равны, просто один выдает int, второй float.
Но само по себе вызов time/microtime - это аж 40 ms на 1М вызовов, и получается сам факт замера времени все херит :)

time(); // 40 ms
microtime(true); // 41 ms
hrtime(true); // 40-41 ms с дрейфом, но это не часы

==============================================================

1M вызовов:
microtime(true); // 41.7 ms
hrtime(true); // 41.7 ms

При этом hrtime точнее, но он отличается от сервера к серверу.
Удобнее получать в начале microtime+hrtime, а потом по hrtime мерять разницу.

==============================================================

unpack при разных типах данных требует указывать имена ключей в массиве.
При этом чем короче ключи - тем быстрее разбор.

// 166 ms
unpack("Ca/eb/Vc/ed/Ve/Vf/eg/eh/ei/el/em/en", $message);

// 312 ms
unpack("atype/dts_push/Npair_id/dts_event/Nsequence/Nsuffix/dask/dask_size/dask_breakout/dbid/dbid_size/dbid_breakout", $message);

==============================================================

Вариации pack + unpack:
1. unpack с короткими ключами быстрее;
2. unpack с именоваными ключами быстрее, но я получаю массив где доступ к элементам сложнее
3. самый быстрый способ это короткие именованные ключи, а затем переписать to locals или передавать дальше этот массив целиком

<?php
class Tool2 implements Benchmark_Interface {

    public function process() {
        // 207 ns
        //$x = unpack('e10', $this->_message);

        // 148 ns
        //$x = unpack('ea/eb/ec/ed/ee/ef/eg/eh/ei/ej', $this->_message);

        // 228 ns
        /*$x = unpack('ea/eb/ec/ed/ee/ef/eg/eh/ei/ej', $this->_message);
        $a = $x['a'];
        $b = $x['b'];
        $c = $x['c'];
        $d = $x['d'];
        $e = $x['e'];
        $f = $x['f'];
        $g = $x['g'];
        $h = $x['h'];
        $i = $x['i'];
        $j = $x['j'];*/

        // 186 ns
        //$x = array_values(unpack('ea/eb/ec/ed/ee/ef/eg/eh/ei/ej', $this->_message));

        // 248
        /*$x = array_values(unpack('ea/eb/ec/ed/ee/ef/eg/eh/ei/ej', $this->_message));
        $a = $x[0];
        $b = $x[1];
        $c = $x[2];
        $d = $x[3];
        $e = $x[4];
        $f = $x[5];
        $g = $x[6];
        $h = $x[7];
        $i = $x[8];
        $j = $x[9];*/

        // 255
        //[$a, $b, $c, $d, $e, $f, $g, $h, $i, $j] = array_values(unpack('ea/eb/ec/ed/ee/ef/eg/eh/ei/ej', $this->_message));
    }

    public function __construct() {
        // 108 ns
        $this->_message = pack(
            'eeeeeeeeee',
            1,
            2,
            3,
            4,
            5,
            6,
            7,
            8,
            9,
            10
        );
    }

    private $_message;

}

==============================================================

Сравнение производительности hash-функций
Тестировалось вызовом hash('murmur3a', microtime(true)+rand())
Результаты на 100_000 вызовов в секундах

crc32 = 32 = 0.030
md2 = 128 = 0.46
md4 = 128 = 0.051
md5 = 128 = 0.055 (0.05 если вызывать md5())
fnv164 = 64 = 0.04
fnv1a64 = 64 = 0.038
xxh3 = 64 = 0.039
xxh64 = 64 = 0.045
xxh128 = 128 = 0.045
haval128,3 = 0.10
haval128,4 = 0.12
haval128,5 = 0.14
sha1 = 160 = 0.057 (0.052 если вызывать sha1)
ripemd128 = 128 = 0.07
tiger128,3 = 128 = 0.054
snefru = 128 = 0.30
gost = 256 = 0.24
murmur3f = 128 = 0.042
murmur3a = 32 = 0.038
murmur3c = 64 = 0.043

== выводы ==
Если аналог md5 (128 bit) - то murmur3f
Если можно более коротких хеш (64 bit) - то fnv1a64
Если не важны коллизии - то crc32

upd: кормите int
hash('fnv1a64', microtime(true)+rand()); // 234 ms
hash('fnv1a64', (int)(microtime(true))+rand()); // 234 ms
hash('fnv1a64', $t+rand()); // 180 ms
hash('fnv1a64', (int)($t*1000)); // 180 ms
hash('fnv1a64', rand()); // 96 ms

==============================================================

Рандомное число (тест на 1М вызовов):

rand(1, 9999999); // 22 ms
rand(1, PHP_INT_MAX); // 24 ms
uniqid(); // 1000 ms << самое медленное
rand(); // 12 ms << самое быстрое
hash('murmur3a', microtime(true)+rand()); // 230 ms

rand(); // 10 ns
mt_rand(0, 4); // 19-20 ns << говорят что rand == mt_rand но нифига

rand(0, 4); // 16 ns
(rand() % 5); // 12-13 ns << сильно выгоднее % N
random_int(0, 4); // 337 ns << трындец
rand() & 3; // 11-12 ns << тоже быстро, но это &3 &7 &15 ...

rand(5,7); // 19 ns
(5 + rand() % 3); // 15 ns << лучше так

+0.01 позволяет хитро получить float не делая type-casting, который дороже
class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        // 26 ns
        //$x = (float) rand(5, 7);

        // 24 ns
        $x = rand(5, 7) + 0.01;

        // 17 ns
        //$x = 5.01 + rand() % 3; //rand(5, 7);
    }

}

==============================================================

deflate с самым минимальным сжатием - 5 us
inflate - 680-700 ns на распаковку (очень быстро)

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        // 67 ns
        $s = '{"method": "bookTicker_update", "params": [[1781127255.6309509, 1781127255.6317029, "XMR_USDT", '.rand().', "327.11", "3", "327.86", "3"]], "id": null}';

        // 5658 - 67  ns
        $x = gzdeflate($s, 1);

        // 6365 - 5658 = 707 ns
        $y = gzinflate($x);
    }

}

==============================================================

Это 1М вызовов:

$data = json_decode($payload, true); // 945 ms
$data = json_decode($payload); // 1020 ms
$data = json_decode($payload, true, 5, JSON_OBJECT_AS_ARRAY | JSON_INVALID_UTF8_IGNORE);
$data = simdjson_decode($payload, true); // 490 ms, simdjson
$data = simdjson_decode($payload, true); // 455 ms, simdjson_plus

==============================================================

assoc json parse vs stdclass json parse

assoc-массив быстрее, даже не смотря на то, что доступ к свойству это 5 ns, а поиск по ключу массива - 9-10 ns

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        // 60 ns
        $payload = '{"e":"bookTicker","u":10055087633111,"s":"XMRUSDT","b":"345.23","B":"0.625","a":"345.24","A":"0.064","T":'.rand().',"E":1772812163287}';

        // 428 - 60 = 368
        //$data = simdjson_decode($payload, true);
        //$u = $data['u']; // 437, одна операция 9 ns
        // 368 + 5 x 6 = 398

        // 455 - 60 = 395
        //$data = simdjson_decode($payload);
        //$u = $data->u; // 460, одна операция 5 ns
        // 395 + 5 x 6 = 425
    }

}

==============================================================

$half = intdiv(rand(), 2); // 10 ns/call
$half = floor(rand() / 2); // 21 ns/call, плюс floor какого-то хера возвращает float вместо int
$half = (int) (rand() / 2); // 15 ns/call
$half = (rand()) >> 1; // 1/ns call, самый быстрый способ, но только для /2 и положительных чисел

(эти замеры уже исключают rand и присвоение, который занимает 13..14 ns/call)

==============================================================

int vs float

//$aInt = rand();
//$bInt = rand(); // 27.5 incl loop
//$aFloat = rand() / rand();
//$bFloat = rand() / rand(); // 57.8 incl loop

//if ($aInt > $bInt) {} // 33.8-27.5 = 6.3 ns
//if ($aInt == $bInt) {} // 29.5 = 2 ns
//if ($aInt != $bInt) {} // 28.5 = 1 ns
//$x = $aInt - $bInt; // 31.1 = 3.6 ns
//$x = $aInt + $bInt; // 31.1 = 3.6 ns
//$x = $aInt * $bInt; // 31.3 = 3.8 bs
//$x = $aInt / $bInt; // 33.5 = 6 ns

//if ($aFloat > $bFloat) {} // 66.2 = 8.4 ns
//if ($aFloat == $bFloat) {} // 59.2 = 1.4 ns
//if ($aFloat != $bFloat) {} // 58.5 = 0.7 ns
//$x = $aFloat - $bFloat; // 60.5 = 2.7 ns
//$x = $aFloat + $bFloat; // 60.5 = 2.7 ns
//$x = $aFloat * $bFloat; // 60.9 = 3.1 ns
//$x = $aFloat / $bFloat; // 63.5 = 5.7 ns

Операции сравнения больше/меньше чуть быстрее в int,
операции сравнения == быстрее в float, но они не точные.
Математические операции быстрее во float, что странно :)

НО!
//$x = (string) $aInt; // 27.5
//$x = (string) $aFloat; // 141.2 ns и это супер не точно
//$x = $this->number_format_fastX($aFloat, 2); // 99 ns, см код выше
//$x = sprintf('%.2f', $aFloat); // 134 ns
По сути, если вам нужно куда-то писать float число - то перевести его в string сильно геморно.
Куда выгоднее все делать в int, или на крайняк помножить float на 10**precision и дальше передавать int.

НО! Если использовать pack - то он double LE пакует и распаковывает быстрее:

$message = pack('e', $aFloat); // 37 ns, double (machine dependent size, little endian byte order), ARM
$message = pack('P', $aInt); // int64: 41 ns, unsigned long long (always 64 bit, little endian byte order), ARM
$message = pack('V', $aInt); // int32: 40 ns, unsigned long (always 32 bit, little endian byte order)

unpack('e', $message); // 45 ns
unpack('P', $message); // 48 ns
unpack('V', $message); // 46 ns

В тестах я использовал LE и ARM, чтобы совпадала архитектура cpu. Если не совпадает - будет дольше.

==============================================================

float to string

$x = 3.33; // float, 3 ns на инициализацию

$y = $x.''; // 115-3 ns
$y = (string)$x; // 106..109-3 ns
$y = strval($x); // 106..109 - 3 ns

==============================================================

в $s хранится строка, которая по сути int/float число.
Нам надо превратить ее в число float И умножить на multiplier.
Выгоднее всего множить сразу без типизаций.
Но если нужна только типизация - то лучше (int) или (float) cast.

$x = (int) $s; // 15 ns
$x = $s * 1; // 22 ns
$x = (float) $s; // 17 ns
$x = $s * 1.0; // 22 ns

$x = $s * $this->_multiplier; // 23 ns, _multiplier = 1.0 float;

// 24 ns
if ($this->_multiplier == 1) {
    $x = (float) $s;
} else {
    $x = $s * $this->_multiplier;
}

==============================================================

Смена типа данных переменной.
Такое бывает нужно редко, но тем не менее:
1. если есть переменная mixed в которой может быть string/int/float, но по своей сути это всегда число
   то самый выгодный вариант это *= 1.0 - так получаем float сразу же.
2. но если там точно string - то выгоднее всего (float) $x

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        //$x = '100'; // 2 ns
        //$x *= 1.0; // 17-2 = 15 ns
        //$x = (float) $x; // 15-2 = 13 ns
        //settype($x, 'float'); // 21-2 = 19 ns

        //$x = 100; // 2 ns, int
        //$x *= 1.0; // 6-2 = 4 ns
        //$x = (float) $x; // 9-2 = 7 ns
        //settype($x, 'float'); // 24-2 = 22 ns

        //$x = 100.11; // 2 ns, float
        //$x *= 1.0; // 6-2 = 4 ns
        //$x = (float) $x; // 8-2 = 6 ns
        //settype($x, 'float'); // 24-2 = 22 ns
    }

}

==============================================================

Вызов метода и передача параметров:

1. вызов метода без аргументов - 10 ns,
2. каждый следующий аргрумент это 3-4 ns (3 int, 4 string)

class Tool_Benchmark implements Benchmark_Interface {

    public function process() {
        $this->_call0(); // 10 ns

        // 66 ns:
        //$x = rand();
        //$s = rand().'x';

        //$this->_call1($x); // 78-66 = 12 ns
        //$this->_call2($x, $x); // 81-66 = 15 ns
        //$this->_call3($x, $x, $x); // 84-66 = 18 ns

        //$this->_call1($s); // 78-66 = 12 ns
        //$this->_call2($s, $s); // 82-66 = 16 ns
        //$this->_call3($s, $s, $s); // 86-66 = 20 ns
    }


    public function _call0() {}
    public function _call1($a) {}
    public function _call2($a, $b) {}
    public function _call3($a, $b, $c) {}

}

==============================================================

Количество потоков

Конечно это не всегда изи сделать, но если у вас есть 10 скриптов, которые суммарно зажирают 50% от 1 vcpu,
то лучше слепить это в один скрипт, и он станет жрать примерно 40% от 1 vcpu.
Это объясняется context-switching-ом: чем меньше переключений процессов, тем больше непрерывного времени у вашего процесса,
и тем выше вероятность попасть в NUMA-aw + branch-prediction: это когда ваши данные затянутся в L-кеш проца.
Такого можно добиться просто за счет того, что процесс один.

Второй важный момент: надо стараться писать код так, чтобы инструкций в процессор было как можно меньше.
Можно поймать магию: например, ваш код это 200 инструкций cpu. Переключение контекста - 50 инструкций. Окно контекста 100. (цифры для примера, зависят от операционки, гипервизора и еще кучи всего)
То ваш процесс (который на 200 инструкций) на самом деле выполняется: 100 (ваших) + 50 на переключение контекста + 100 на другой процесс + 50 на переключение + 100 на ваш процесс.
Итого 200 превращаются в 400 минимум.
А если ужаться до окна (100) - то будет 100, без потерь.

==============================================================

Параметризированный доступ к свойству

$this->_name; // 4 ns
$this->{$x}; // 11 ns

==============================================================

OPCACHE + JIT

NB! шо opcache+jit это жопа с eval, если есть eval smarty - всему пизда сразу же

Синтетический тест на вызовы методов и доступ к свойствам:
php -f 1.php // 791 ms
php -d opcache.enable=1 -d opcache.validate_timestamps=1 -d opcache.revalidate_freq=0 -d opcache.enable_cli=1 -f 1.php // 642 ms opcache only
php -d opcache.enable=1 -d opcache.validate_timestamps=1 -d opcache.revalidate_freq=0 -d opcache.enable_cli=1 -d opcache.jit_buffer_size=100M -d opcache.jit=function -f 1.php // 244 ms
php -d opcache.enable=1 -d opcache.validate_timestamps=1 -d opcache.revalidate_freq=0 -d opcache.enable_cli=1 -d opcache.jit_buffer_size=100M -d opcache.jit=tracing -f 1.php // 114 ms

aws gn vs g сетевухи
Если не использовать DPDK/Kernel-by-pass то нет никакой разницы между gn или g для реального подключения по ws/udp.
Но вот скорость обработки самого сетевого стека сильно зависит от cpu и тут c8g выигрывает с ебейшим отрывом у всего остального.
Тестировал на подключении к fstream к одному IP из кластера c7gn, c7g, c8g.

m5zn.xlarge (intel xeon 4.5Ghz tokyo-only)
php 472 ms
php +opcache 333 ms
php +opcache +jit 78ms
network
no-jit  0.017221922	0.016291	0.010026	0.039792
jit	    0.016803216	0.015686	0.009896	0.03596

c7a.xlarge (top of amd 3.7Ghz)
php 491 ms
php +opcache 402 ms
php +opcache +jit 59 ms << супер быстрая математика
network
no-jit  0.023317672327672	0.02271	0.00912	0.0398
jit     не тестил, потому что проигрывает

c8g.xlarge << top of all
php 608 ms
php +opcache 384 ms
php +opcache +jit 75-80 ms << математика быстрая, но сеть просто ебическая
network << самый быстрый, IGW тоже топ
no-jit 0.0088250438247012	0.0080535	0.005574	0.033326 << монстр по сети, в 2.5 раза быстрее c6gn, в 1.5 раза быстрее c7g*
jit    0.008585994011976	0.007398	0.005503	0.032228 << не особо меняет

c8g.metal-24xl (arm, 96 vcpu)
php 607 ms
php +opcache 384 ms
php +opcache +jit 76 ms (чуть быстрее из-за отсутсвия context switching)
network
no-jit  0.005952433	0.005753	0.004636	0.014024 << top of network and performance, еще в 1.5 быстрее чем c8g shared, количество ядер решают на сетевой стек
jit     0.005866824	0.005636	0.004512	0.015603

c7gn.xlarge, c7g.xlarge (arm, 2.6Ghz, L-1M)
php 655 ms
php +opcache 435 ms, stable
php +opcache +jit 88 ms
network c7gn.xlarge
no-jit 	0.011871339	0.010371	0.007511	0.037104
jit 	0.012685706	0.0107155	0.007691	0.269821 делает чуть хуже?
network c7g.xlarge
no-jit  0.011913541	0.0101565	0.007481	0.036936 не похоже что чем-то отличется от c7gn
jit     0.012632865	0.0106905	0.007413	0.285803 делает чуть хуже, но нет разницы с c7gn

c7gn.metal (arm,  64 vcpu, 2.6Ghz, L-1M) - bare metal, без context-switching'a
php 655 ms
php +opcache 435 ms
php +opcache +jit 88 ms << больше ядер никак не помогает php-процессу и это логично
network
no-jit 	0.008225013986014	0.007976	0.006318	0.020987 << а вот не bare-metal у меня нет context-switching и больше ядер, сеть стала быстрее на +37%
jit     0.0079046816367265	0.0077845	0.006264	0.020894

c6gn.xlarge (arm, 2.5 GHz)
php 789 ms
php +opcache 641 ms
php +opcache +jit 114 ms
php +compiled 8.2.28 - 790 ms (= сборка php -O3 native не помогает)
php +compiled +opcache - 638 ms
php +compiled +opcache + jit 114 ms
network 0.0227 ms/udp loopback << это нитро сетевуха ENA, без ENA express
no-jit  0.02284175386 avg	0.02055975 med	0.01138 min 	0.4851 max
jit     0.02276954401 avg	0.020537 med	0.011126 min	0.37818 max не стабильное, но медиана самая низкая

c6a.xlarge (amd, 2.65 Ghz)
php 528 ms
php +opcache 380..574 ms, странно делает хуже и прыгает
php +opcache +jit 65 ms, стабильно << best of
network 0.045 ms/udp loopback, сеть вдвое хуже чем arm/intel
no-jit	0.048085801198801 avg	0.051471 med	0.01847 min	0.183734 max
jit 	0.045852571428571 avg	0.046251 med	0.02055 min	0.095102 max

c6i.xlarge (intel, 3.5 Ghz, сильно больше L-кешей)
php 520 ms
php +opcache 396 ms
php +opcache +jit 90 ms
network 0.0233 ms/udp loopback
no-jit  0.025813836 avg	0.0254155 med	0.011826 min	0.052407 max
jit     0.023273431 avg	0.022677 med	0.010959 min	0.054387 max    самое стабильное, но на 2% хуже arm

a1.metal (old arm)
php 2090 ms
php +opcache +jit 183 ms (ускоренеи норм, но все равно лажа с c6*)
сеть 0.03 ms/udp loopback, хуже в 1.5 раза