Копирование массива из миллиона элементов во вторую переменную перемещает memory_get_usage()
на ноль байт. Запись одного элемента в любую из переменных перемещает его на 16 793 680 байт —
весь массив, что списывается на то имя, которое выполнило запись первым.
<?php
declare(strict_types=1);
$baseline = memory_get_usage();
$rows = range(0, 999_999);
printf("build %+d bytes\n", memory_get_usage() - $baseline);
$baseline = memory_get_usage();
$copy = $rows;
printf("second name %+d bytes\n", memory_get_usage() - $baseline);
$baseline = memory_get_usage();
$copy[0] = 1;
printf("first write %+d bytes\n", memory_get_usage() - $baseline);
$baseline = memory_get_usage();
$copy[1] = 1;
printf("second write %+d bytes\n", memory_get_usage() - $baseline);
build +16793680 bytes
second name +0 bytes
first write +16793680 bytes
second write +0 bytes
Две записи, один счет. Между ними в массиве ничего не изменилось, и ничто в исходном коде их не различает. Изменилось число, которое находится рядом с массивом, а не внутри какой-либо из переменных, и сами переменные — это то, с чего стоит начать, потому что они меньше, чем кажутся.
Как снимались эти показатели
PHP 8.5.10, NTS, arm64, сборка Homebrew, на ноутбуке Apple M4 Pro с 24 ГБ ОЗУ и
12 логическими ядрами под управлением macOS (без изолирования процессов). OPcache и JIT отключены
для всех приведенных ниже цифр, а memory_limit увеличен до 2G, чтобы
кейсы с миллионом элементов помещались в память — за исключением одного места далее, где указан
другой лимит, что и является целью того измерения. Остальная часть архива
измерялась на 8.5.9 на той же машине.
Показатели памяти представляют собой одиночные точные значения, а не медианы: два последовательных
запуска всего скрипта выдали одинаковый с точностью до байта результат, поэтому разброса
данных нет. Замеры времени — это медиана 15 чередующихся прогонов с отбрасыванием трех прогревочных
запусков, снятая с помощью hrtime() внутри процесса, а диапазон указан
для каждого значения. Когда в таблице хронометрируется одно выражение из последовательности,
таймер охватывает только это выражение, а подготовка вокруг него выполняется без замеров. Считывайте
замеры времени как относительные друг к другу, а не как абсолютные для вашего железа —
причины описаны в статье
бенчмаркинг PHP без самообмана.
Шестнадцать байт, что бы вы в них ни положили
Переменная в пользовательском коде — это zval ,
и в 64-битной сборке она занимает шестнадцать байт: восьмибайтное объединение (union), хранящее
значение, четырехбайтное слово с тегом типа и
его флагами, и еще четыре байта, которые движок использует для служебных нужд, таких как
следующая запись в цепочке коллизий хэша. Объединение имеет ширину в одно машинное слово, поэтому
integer или float живут непосредственно внутри него, тогда как string, array или
object являются указателями на что-то другое.
Ничто из этого не является именем переменной. Компилятор присваивает каждому именованному локальному значению нумерованный слот в кадре вызова, который дамп опкодов печатает как скомпилированную переменную CV0, и шестнадцать байт — это то, что содержит данный слот.
То, что слот никогда не меняет размер, можно измерить из пользовательского кода, поскольку упакованный массив (packed array) представляет собой просто ряд zval — структура за каждым массивом PHP хранит значение и вычисляет ключ на основе позиции. Заполнение одного из них миллионом значений четырех различных типов:
appended 1,000,000 integers 16.79 bytes/element
appended 1,000,000 floats 16.79 bytes/element
appended 1,000,000 booleans 16.79 bytes/element
appended 1,000,000 nulls 16.79 bytes/element
Четыре типа, одна цифра, с точностью до байта. Это 16,79, а не 16,00, потому что массив выделил емкость под 1 048 576 элементов плюс заголовок сверху; сохранение 1 048 576 целых чисел вместо миллиона дало те же 16 793 680 байт, что составляет 1 048 576 слотов по шестнадцать байт плюс 16 464 байта таблицы.
Null — это случай, на котором стоит остановиться. null — это тег типа без полезной нагрузки, и
он все равно стоит целого слота, потому что элемент массива — это и есть слот. То же самое
верно для true и false : у движка есть отдельные теги типов для них, поэтому
boolean даже не использует объединение значений.
Счетчик живет со значением, а не с переменной
Один байт из этого четырехбайтного слова — это тег типа, а один содержит флаги. Один флаг там определяет все вышесказанное: используется ли для объекта, на который указывает объединение, подсчет ссылок. Integers, floats, booleans и null — нет, потому что указывать не на что. Strings, arrays и objects — да, и счетчик для них живет в восьмибайтном заголовке структуры, на которую указывает ссылка, а не в переменной.
debug_zval_dump() выводит этот заголовок, когда он есть:
<?php
declare(strict_types=1);
$number = 42;
$alsoNumber = $number;
debug_zval_dump($number);
$name = 'elephant';
debug_zval_dump($name);
$built = strrev('tnahpele');
debug_zval_dump($built);
$rows = range(1, 3);
debug_zval_dump($rows);
$alsoRows = $rows;
debug_zval_dump($rows);
Каждый дамп массива также выводит три его элемента; ниже эти строки заменены многоточием.
int(42)
string(8) "elephant" interned
string(8) "elephant" refcount(2)
array(3) packed refcount(2){ ... }
array(3) packed refcount(3){ ... }
Для целого числа счетчик вообще не выводится под двумя именами, потому что копия
целого числа — это копия восьми байт, и делиться нечем. Строковый
литерал выводит interned вместо счетчика: строка, буквально присутствующая в
исходном коде, дедуплицируется в буфер интернирования и живет до тех пор, пока не завершится
запрос, поэтому у движка нет причин считать ссылки на нее. Только строка,
созданная во время выполнения, содержит число.
Стоит упомянуть два артефакта этого метода, прежде чем вы начнете его использовать. debug_zval_dump()
принимает аргумент по значению, что добавляет единицу к каждому выводимому счетчику —
строка, созданная во время выполнения под одним именем, читается как refcount(2) . А массив, записанный как
литерал, также удерживается таблицей скомпилированных литералов, поэтому $rows = [1, 2, 3]
выводится на единицу выше, чем range(1, 3) выше, а [1, 2, $x] , который
компилятор не может свернуть в литерал, читается так же, как range() . Считывайте
разницу, а не абсолютные значения.
Платит запись, а не присваивание
Присваивание значения с подсчетом ссылок увеличивает его счетчик и сохраняет тот же указатель. Запись в него сначала делает кое-что другое: если счетчик больше единицы, движок разделяет данные (разделение/separation) — выделяет новую копию, уменьшает счетчик у старого значения и выполняет запись в копию. Вот почему вторая запись в самом первом измерении была бесплатной. Первая уже уменьшила счетчик обратно до единицы.
Счетчик, достигший нуля, освобождает значение на месте — именно так освобождается почти вся память в PHP. Исключением является пара значений, ссылающихся друг на друга, где ни один из счетчиков не может достичь нуля, и второму механизму приходится искать их.
Движок понятия не имеет, какая переменная является «оригиналом», поэтому и вы не должны этого знать.
Присваивание $copy = $rows и последующая запись в $rows списывает 16 793 680
байт на $rows . Кто записывает первым, тот и платит, и если три имени разделяют один
массив, первые две записи платят сполна, а третья получает ее бесплатно.
Разница между двумя путями весьма существенна:
| Измеряемое выражение | 131 072 элемента | 1 048 576 элементов |
|---|---|---|
$copy = $rows; и unset($copy); вместе |
3,353 нс (3,019–3,694) | 3,299 нс (3,048–3,411) |
$sole[0] = $i; без другого владельца |
3,632 нс (3,311–3,813) | 3,556 нс (3,329–3,921) |
$copy[0] = 1; , пока $rows все еще удерживает его |
135,229 мкс (131,262–143,856) | 1 163,279 мкс (1 140,960–1 226,146) |
unset($copy); на копии, сделанной этой записью |
73,982 мкс (70,830–75,539) | 598,305 мкс (585,449–624,754) |
Первые две строки не меняются с ростом размера массива, поскольку инкремент
счетчика и запись в слот, которым вы уже владеете, являются
операциями с константным временем. Последние две меняются: в восемь раз больше элементов стоят в 8,60 раз дороже
при разделении и в 8,09 раз при освобождении. Одно и то же выражение, $copy[0] = 1 , занимает
здесь либо 3,6 наносекунды, либо 1,16 миллисекунды — разница примерно в 327 000 раз,
которая определяется числом, невидимым в исходном коде.
Четвертая строка — это половина, которую легко забыть. Разделение выделяет второй массив, и кто-то должен вернуть его обратно; при миллионе элементов это освобождение стоит еще 598 мкс, так что одна запись в разделяемые данные обходится суммарно примерно в 1,76 ms, в два разных момента времени.
Аргументы функций — это присваивания
Параметр, передаваемый по значению, связывается таким же образом, вот почему передача большого массива в функцию бесплатна, и его чтение остается бесплатным:
readOnly(array $rows) resident 0 peak 0
writes(array $rows) resident 0 peak 16,793,256
writesByRef(array &$rows) resident 32 peak 0
writesByRef() again resident 0 peak 0
Средняя строка — это то, на чем подлавливаются разработчики. writes() скопировала массив,
записала один элемент в копию и сбросила копию при возврате — так что резидентный
показатель остался неизменным до и после, и единственным доказательством существования копии является
пик. Он показывает на 424 байта меньше собственного размера массива в 16 793 680 байт, потому что
пик уже находился ровно настолько выше резидентного показателя на момент
начала вызова; копия — это весь массив.
Приложение, сообщающее о memory_get_usage() после запроса, сообщает о том,
что уцелело, а не о том, что было выделено, и функция, которая тихо удваивает пиковую
память на время вызова, невидима в этом числе.
memory_get_peak_usage() — это то, что зафиксировало это. Ни одно из них не является значением,
с которым сравнивается memory_limit , представляющим собой
третье число, которое ведет движок и о котором не упоминается в
документации.
Копия достаточно реальна, чтобы стать фатальной. При 24M в memory_limit и почти
восемью мегабайтами запаса в момент вызова:
<?php
declare(strict_types=1);
function writes(array $rows): int
{
$rows[0] = 1;
return $rows[0];
}
$rows = range(0, 999_999);
printf("resident before the call %s bytes\n", number_format(memory_get_usage()));
writes($rows);
resident before the call 17,276,352 bytes
Fatal error: Allowed memory size of 25165824 bytes exhausted (tried to allocate 16777224 bytes) in limit.php on line 7
Абсолютный путь заменен именем файла выше; остальное без изменений.
Строка 7 — это $rows[0] = 1 , и 16 777 224 байта, которые она запросила, — это массив, который
ей передали, скопированный ради изменения одного элемента.
Ссылка — это третий тип сущности
Строка writesByRef() в этой таблице — это то место, где амперсанд показывает свою цену.
Ссылка в PHP — это не флаг на переменной и не второй указатель на массив.
Это другой тип значения:
тег типа переменной меняется на reference, а объединение указывает на
структуру zend_reference , которая содержит заголовок подсчета
ссылок, один собственный zval и одно слово для источников типов свойств, которые
движок отслеживает для типизированных свойств. Восемь плюс шестнадцать плюс восемь — это 32, что
ровно соответствует стоимости связывания одной ссылки:
$r = &$a 32 bytes
$b = $a (while $a is referenced) 0 bytes
$b[0] = 1 16,793,680 bytes
$a[0] = 1 (through the reference) 0 bytes
Вторую строку стоит перечитать дважды. Связывание ссылки не мешает разделению
массива: $b все еще получил его даром, а первая запись $b
все так же оплатила полное разделение. Что дала ссылка, так это зеркальное отражение третьей строки —
после того как $b выполнил разделение, $a снова стал единственным владельцем, и его
собственная запись ничего не стоила.
Таким образом, амперсанд не убирает копирование. Он смещает запись вниз к значению,
которое переменная больше не содержит напрямую, за 32-байтовую обертку, через которую должно
проходить каждое обращение. Это
правильный инструмент, когда функция должна изменить переменную вызывающей стороны, что является
семантическим требованием, а не требованием к памяти. Использовать его только потому, что массив
большой — значит использовать не тот рычаг. То, что он делает с foreach , который
ссылается на свой элемент, измеряется в следующем посте этой серии, где выясняется,
что цикл оставляет одну из этих 32-байтовых оберток в каждом элементе
массива.
Объекты — это дескрипторы, а clone — поверхностный
Объекты используют тот же механизм для достижения противоположного поведения. Переменная содержит
указатель на один zend_object , и присваивание копирует этот указатель, но ничто
никогда не разделяется:
new Batch(range(0, 999999)) 16,793,736 bytes
$two = $one 0 bytes
$two->rows[0] = 1 0 bytes
clone $one 56 bytes
$three->rows[0] = 2 (after clone) 16,793,680 bytes
$two->rows[0] = 1 ничего не выделил, а $one->rows[0] читается как 1 . Два
имени, один объект, и запись через любое из них видна через оба —
счетчик увеличился, и никакая копия никогда не собиралась создаваться. В этом и заключается вся
разница между «разделять до записи» и «разделять навсегда», и в исходном коде
оба варианта обозначаются $b = $a .
Оба конца этого блока сходятся во мнении о собственном размере объекта. Batch , содержащий
массив, стоил 16 793 736 байт против 16 793 680 байт у массива, а clone стоит 56
байт для этого класса — что является размером zend_object , несущего свой заголовок,
дескриптор, флаги, запись класса, таблицу обработчиков, указатель на хэш свойств и один
слот свойства. Клонирование является поверхностным: свойство rows нового объекта
указывает на тот же массив, и 16 793 680 байт появляются только тогда, когда
кто-то производит в него запись.
Этот единственный слот свойства является единицей, из которой строится вся форма записи, и он меньше, чем ключ массива, который он обычно заменяет.
Что это меняет в коде, который вы пишете
Смотрите на запись, а не на присваивание. Передача массива другой переменной, функции или конструктору — это инкремент счетчика независимо от того, что содержит массив, и поиск выделения памяти заканчивается на первой строке, которая изменяет значение, удерживаемое более чем одним именем. Эта строка обычно не является той, что отображается в колонке памяти профайлера, потому что к тому моменту, когда профайлер делает замер, копия уже сделана, а счетчик снова равен единице.
Считывайте пиковое значение наряду с текущим. memory_get_usage() после запроса
говорит вам о том, что все еще удерживается; memory_get_peak_usage() — это число, которое
фиксирует копию, созданную и уничтоженную внутри одного вызова, а memory_limit ,
срабатывающий на запросе, чье сообщаемое использование выглядит нормальным, описывает разницу между
этими двумя показателями.
Прежде чем добавлять амперсанд для производительности, выведите счетчик. debug_zval_dump()
на переменной, минус единица для самого вызова, скажет вам, разделяется ли что-либо
на самом деле. Если счетчик равен единице, нет копии, которой нужно избегать, и
ссылка только добавляет структуру и косвенный доступ. Если он больше единицы,
вопрос заключается в том, какое имя записывает первым — а это вопрос о порядке
операций в вашем коде, а не о размере массива.
Комментарии (0)
Пока нет комментариев — будьте первым.