Копирование массива из миллиона элементов во вторую переменную перемещает  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()  на переменной, минус единица для самого вызова, скажет вам, разделяется ли что-либо на самом деле. Если счетчик равен единице, нет копии, которой нужно избегать, и ссылка только добавляет структуру и косвенный доступ. Если он больше единицы, вопрос заключается в том, какое имя записывает первым — а это вопрос о порядке операций в вашем коде, а не о размере массива.