Перейти к содержимому
Документация

Продакшен и производительность

Во что обходится фреймворк во время выполнения и как собрать, настроить и выкатить кеш, чтобы в продакшене платить только за вызовы с behaviors.

Перевод с английского. Эталоном считается английская версия страницы. Читать оригинал

Фреймворк один раз компилирует ваши классы вместе с их behaviors (поведениями) и сохраняет результат в виде обычных PHP-файлов. Дальше эти файлы работают как любой другой код: OPcache их кеширует, Composer загружает, а парсер, рефлексия и eval() во время запроса не запускаются. Продакшен-запрос на прогретом кеше читает один файл метаданных, передаёт сгенерированные классы Composer и платит только за вызовы, которые действительно перехватываются. Методы и свойства без behaviors не стоят ничего.

На этой странице — измеренные цифры, объяснение того, откуда берутся затраты, и способы выкатить кеш: прогрев при деплое, OPcache, Composer, Docker и Kubernetes. Параметры ядра (kernel) описаны на странице Конфигурация и CLI. Наглядная сводка — на странице о производительности.

Все цифры на этой странице взяты из upstream-файла docs/performance.md репозитория goaop/framework. Они измерены на одной машине, поэтому читайте их как соотношения между режимами: на другие машины переносятся именно соотношения.

  • Небольшое приложение интернет-магазина: около 250 файлов в include paths (94 компилируемых класса), 120 библиотечных классов вне их и 6 behavior classes (классов поведений) с #[Before], #[Around], #[AfterThrowing] и behaviors для свойств.
  • Один запрос оформляет 50 заказов. Это ~2 600 перехваченных вызовов методов и ~950 перехваченных обращений к свойствам.
  • PHP 8.5.12 NTS, 4 CPU, OPcache в общей памяти, opcache.jit=disable, opcache.file_update_protection=0.

Полная методика описана ниже, в разделе Воспроизведение бенчмарков.

Три состояния кеша:

  • горячий: скомпилированный кеш на месте, OPcache заполнен. Устойчивое состояние продакшен-воркера.
  • тёплый: скомпилированный кеш на месте, OPcache пуст. Только что запущенный PHP-FPM или новый под.
  • холодный: ещё ничего не закешировано. Первый запрос компилирует каждый класс, который загружает.
Режим горячий тёплый Пиковая память (горячий)
debug => false + PREBUILT_CACHE 5,4 мс 59 мс 1,3 МБ
debug => false 5,5 мс 62 мс 1,3 МБ
debug => true 13,0 мс 63 мс 2,2 МБ
То же приложение без фреймворка (behaviors не выполняются) 2,1 мс 36 мс 0,7 МБ
  • ~3 500 перехватов с настоящими телами behaviors (логирование, обращения к кешу, таймеры) добавляют к запросу ~3,3 мс. Из них ~0,15 мс уходит на загрузку ядра.
  • Один перехваченный вызов стоит около трети микросекунды, каждый следующий behavior на нём — ~70 нс.
  • Весь кеш собирается командой cache:warmup:aop меньше чем за полсекунды. Приложение из 2 000 файлов собирается за 1,1 с на 4 воркерах.
  • Контейнеры стартуют горячими. С заранее прогретым файловым кешем OPcache первый запрос нового PHP-FPM занимает 19 мс вместо 71 мс. С предзагрузкой поверх него — 10 мс, столько же, сколько у обычного приложения без фреймворка (9 мс).

Эти цифры получены с пустыми behaviors, поэтому они измеряют только работу самого фреймворка: call context (контекст вызова), цепочку перехватчиков и вызов исходного метода.

Вызов Накладные расходы на вызов
Метод или свойство без behavior в скомпилированном классе 0
Метод с одним #[Before] или #[Around] ~0,33 мкс
Метод с тремя #[Around] ~0,48 мкс
Статический метод с одним #[Around] ~0,34 мкс
Чтение свойства с одним #[Around] ~0,22 мкс
Запись свойства с одним #[Around] ~0,26 мкс

Миллион перехваченных вызовов стоит около трети секунды. Типичный запрос с несколькими сотнями перехватов платит долю миллисекунды.

Каждый CLI-процесс стартует с пустым OPcache. С прогретым opcache.file_cache короткоживущие команды запускаются почти так же быстро, как горячий веб-запрос.

Время скрипта на процесс OPcache выключен OPcache включён (только в памяти) opcache.file_cache, прогретый
PREBUILT_CACHE 33 мс 69 мс 21 мс
debug => false 30 мс 69 мс 22 мс
Без фреймворка 19 мс 34 мс 10 мс

Прокси переопределяет только те члены класса, у которых есть behaviors. Все остальные методы и свойства — это ваш исходный код, и он работает на полной скорости: накладные расходы равны 0. Классы, которые не выбирает ни одно matching rule (правило выбора), не компилируются вовсе.

Перехваченные вызовы и несколько behaviors на одном методе

Заголовок раздела «Перехваченные вызовы и несколько behaviors на одном методе»

Каждый перехваченный метод объявляет один статический call context:

static $__joinPoint = InterceptorInjector::forMethod(...)

Call context и его список перехватчиков строятся при первом вызове. Каждый следующий вызов — это один $__joinPoint->__invoke($this, [$args]). В списке лежат first-class callables, которые указывают прямо на методы ваших behavior classes, поэтому нет ни поиска behaviors, ни рефлексии, ни __call().

Первый behavior на методе стоит ~0,33 мкс. Каждый следующий добавляет ~70 нс, так что три behaviors #[Around] стоят ~0,48 мкс. Статический метод с одним #[Around] стоит ~0,34 мкс.

Рефлексия для behaviors (getMethod(), getField()) создаётся, только когда behavior её запрашивает.

Перехват свойств компилируется в нативные хуки get и set из PHP 8.4 на прокси. Никакой магии __get() или __set() и никакой рефлексии при каждом обращении. Чтение свойства с одним #[Around] стоит ~0,22 мкс, запись — ~0,26 мкс.

В бенчмарке загрузка ядра занимает ~0,15 мс. Сервисы фреймворка, трансформеры и ваши behavior classes регистрируются как фабрики — по одной записи в массив на каждый. Во время загрузки ничего не автозагружается, не исследуется рефлексией и не создаётся, поэтому тёплый запрос никогда не загружает ни парсер, ни грамматику matching rules, ни механизм сопоставления behaviors, ни трансформеры.

  • Индекс кеша (CachePathManager) — единственный сервис, который строится в init(), потому что автозагрузчик сразу читает карту классов.
  • Behavior classes создаются при первом вызове одного из их behaviors, как нативные ленивые объекты PHP 8.4. Compile step (этап компиляции) и прогрев кеша никогда не создают behavior class, а только читают его.
  • В продакшене не подключается ни один слушатель регистрации. Режим отладки отслеживает изменения файлов behavior classes через слушатель, который находит файлы через Composer, не загружая сами классы.
  • Таблица разбора грамматики matching rules — это сгенерированный PHP-код, а сами правила разбираются только при первом использовании.

Тёплый запрос (скомпилированный кеш на месте, OPcache пуст) с PREBUILT_CACHE занимает 59 мс против 36 мс у обычного приложения. Сократить его помогают прогретый opcache.file_cache и предзагрузка, см. Docker и Kubernetes.

Холодный запрос компилирует каждый загружаемый класс. Если кеш собран при деплое и включён PREBUILT_CACHE, продакшен-запрос никогда ничего не компилирует.

Компиляция выполняется один раз, при деплое.

  • Кеш приложения из бенчмарка собирается меньше чем за полсекунды.
  • Приложение из 2 047 файлов собиралось 2,2 с на одном воркере и 1,1 с на 4 воркерах на 4 CPU.
  • Каждый разобранный файл, который хранится в памяти во время компиляции, занимает ~0,2 МБ. Параметр ядра parsedFilesLimit (по умолчанию 100) ограничивает, сколько таких файлов хранится.

Что делает компиляцию быстрой:

  • При попадании в кеш ничего не разбирается. Свежая запись отдаётся как закешированное содержимое ещё до того, как появится хоть один трансформер. Stream filter и цепочка трансформеров строятся только при первом промахе.
  • Все правила переписывания используют один общий обход синтаксического дерева. Правило, чей маркер в исходнике не встречается в файле, пропускается, а файл, к которому не применимо ни одно правило, вообще не обходится. Таких файлов большинство.
  • Механизм включают ваши behavior classes. Выражения new переписываются, только пока зарегистрировано правило initialization(...). Прокси функций существуют только для правил на функции.
  • Проверка behavior class, которая проходит рефлексией по всем предкам, выполняется только для классов с behaviors.
  • Behaviors одного behavior class кешируются в обычный PHP-файл из статических выражений конструкторов: он загружается примерно вдвое быстрее, чем unserialize().
  • Прокси строятся как синтаксические деревья и печатаются один раз (−43 % времени компиляции). Сгенерированный трейт получается правкой токенов, которая сохраняет ваши номера строк для Xdebug.
Шаг debug => false (+ PREBUILT_CACHE) debug => true
init() ядра опции, контейнер, фабрики сервисов (ничего не создаётся) то же, плюс отслеживание изменений файлов ядра и behavior classes
_include.cache (карта классов, skip set) один include из OPcache, без stat() каталога кеша то же
Скомпилированный класс карта классов Composer → закешированный файл из OPcache проверка свежести, затем stream filter, чтобы точки останова Xdebug и магические константы указывали на ваши исходные файлы
Нетрансформированный класс в include paths skip set → исходный файл из OPcache проверка свежести → исходный файл из OPcache
Парсер, трансформеры, stream filter никогда не загружаются stream filter зарегистрирован, трансформеры не строятся
Изменённый исходный файл кеш, собранный при деплое, отдаётся как есть перекомпилируется при следующем запросе

Вызовы файловой системы за один горячий запрос, по подсчёту профилировщика:

Вызов PREBUILT_CACHE debug => false debug => true Без фреймворка
filemtime / filesize 0 0 323 / 239 0
file_get_contents 0 0 94 0
file_exists (Composer PSR-4) 307 307 412 357

Продакшен-запрос не проверяет ни одного исходного файла. Ему даже нужно меньше поисков в Composer, чем обычному приложению, потому что сгенерированные классы берутся прямо из карты классов. Оптимизированная карта классов Composer убирает и оставшиеся поиски, см. Автозагрузчик Composer.

Ещё две детали индекса времени выполнения:

  • _include.cache содержит только то, что нужно запросу: карту классов, skip set (набор пропускаемых файлов) и include map (карту подключений). Полные записи сборки лежат в _transformation.cache, который продакшен никогда не читает.
  • Оба файла метаданных — это массивы, выгруженные через var_export(), с путями относительно __DIR__. OPcache держит их неизменяемыми в общей памяти, поэтому при подключении ничего не копируется, а кеш остаётся валидным, когда каталог приложения переезжает.

Режим отладки предназначен для разработки. Его горячие запросы в бенчмарке занимают ~13 мс, продакшен — ~5,5 мс. Режим отладки по-прежнему подключает свежий нетрансформированный файл по его исходному пути, так что OPcache его кеширует (~38 мкс → ~10 мкс на файл, отладочные запросы быстрее на 27–40 %).

  1. Установите 'debug' => false и 'features' => Features::PREBUILT_CACHE.

  2. Собирайте кеш при деплое или при сборке образа командой cache:warmup:aop.

  3. Держите includePaths узкими: ваш src/, а не vendor/.

  4. Регистрируйте behavior classes через addLazyService().

  5. Устанавливайте зависимости командой composer install --no-dev --classmap-authoritative.

  6. Запускайте OPcache с opcache.validate_timestamps=0, достаточным объёмом памяти и числом слотов под сгенерированные файлы.

  7. В контейнерах встраивайте кеш в образ и добавьте прогретый opcache.file_cache или предзагрузку.

Продакшен-ядро:

public/index.php
use Go\Aop\Features;
ApplicationAspectKernel::getInstance()->init([
'debug' => false,
'appDir' => __DIR__ . '/..',
'cacheDir' => __DIR__ . '/../var/cache/aop',
'includePaths' => [__DIR__ . '/../src'],
'features' => Features::PREBUILT_CACHE,
]);
Окно терминала
rm -rf var/cache/aop
vendor/bin/aspect cache:warmup:aop public/index.php --workers=$(nproc)

Начинайте с пустого каталога, чтобы в кеше было ровно содержимое текущего релиза. Аргумент — это файл, который инициализирует ваше ядро: фронт-контроллер или bootstrap-файл. Команда выполняет его, поэтому ядро стартует с теми же параметрами, что и в продакшене.

Команда:

  • компилирует каждый файл в includePaths (за вычетом excludePaths) и записывает сгенерированные файлы, прокси, кеши behavior classes и оба файла метаданных;
  • сообщает в stderr о каждом файле, который не удалось скомпилировать, и завершается с ненулевым кодом, так что скрипт деплоя или docker build останавливается на этом месте, а не выкатывает неполный кеш.

Пересобирайте кеш при каждом изменении кода, behavior classes, параметров ядра или composer.lock. На практике это значит — при каждом деплое. Режиму отладки пересборка не нужна: он сам перекомпилирует изменённые классы, behavior classes и файлы ядра.

Полная сигнатура команды:

cache:warmup:aop [<loader>] [--fail-fast] [--workers=N] [--cached-files=N] [--cache-dir=DIR] [--preload[=FILE]]

Внутри приложения, которое уже инициализировало своё ядро (консоль интеграции с фреймворком), аргумент loader опускается, и команда использует ядро текущего процесса. См. страницу Интеграции.

--workers=N компилирует в N рабочих процессах, начиная с самых больших файлов. По умолчанию 1: компиляция идёт в процессе самой команды. Указывайте число CPU. Координатор записывает метаданные один раз, а каждый процесс держит в памяти ограниченное число синтаксических деревьев.

--cached-files=N задаёт это ограничение на процесс. По умолчанию оно равно параметру ядра parsedFilesLimit (100). Больше кешированных файлов — меньше повторных разборов; меньше файлов — меньше памяти. Добавьте -v, чтобы вместо индикатора прогресса выводился список всех файлов.

--cache-dir=DIR собирает кеш с нуля в другом каталоге, пока ядро продолжает обслуживать запросы из своего. Так можно подготовить кеш следующего релиза рядом с работающим и атомарно переключиться на него, например заменой символической ссылки.

Кеш, собранный таким образом, полон и не зависит от расположения, даже если его собирает продакшен-ядро при прогретом собственном кеше. Компилятор всегда читает исходники классов, которые исследует рефлексией, и никогда — сгенерированные файлы, которые Composer отдаёт в продакшене.

Если запустить команду над существующим каталогом, она перекомпилирует каждый файл, исходник которого изменился (размер или время модификации), а остальные оставит. Это верно и с PREBUILT_CACHE: кешу как есть доверяют только запросы, команда прогрева — нет.

PREBUILT_CACHE и файловые системы только для чтения

Заголовок раздела «PREBUILT_CACHE и файловые системы только для чтения»

Features::PREBUILT_CACHE заставляет запросы полностью доверять кешу, собранному при деплое. С ним пропускаются:

  • проверки каталога кеша и его доступности на запись;
  • сравнения filemtime исходников;
  • проверки отслеживаемых ресурсов;
  • проверки свежести кешей behavior classes.

Запрос никогда не компилирует и никогда не пишет в каталог кеша, поэтому работает на файловых системах только для чтения. Значит, кеш должен быть полным. Класс или подключаемый файл в include paths, о котором в кеше нет записи, или запись, чей закешированный файл пропал, валит запрос с WeavingException ещё до какой-либо компиляции. Это касается и файла, добавленного после сборки, даже если его не нужно компилировать.

Файлы, которые компилятор никогда не берёт, загружаются как есть: файлы вне include paths, исключённые файлы и файлы не .php, например подключаемый шаблон.

Каждый файл кеша записывается в уникальный временный файл, переименовывается на место, а затем инвалидируется в OPcache. Параллельные запросы никогда не видят наполовину записанный файл, блокировки не нужны, а параллельные писатели метаданных объединяют свои записи.

Классы, которые не компилируются, Composer находит как обычно. С оптимизированной картой классов каждый поиск — это обращение к массиву вместо file_exists(), а карта сгенерированных классов вливается в неё через addClassMap(). Сгенерированные и нетрансформированные классы тогда отдаются одинаково.

Горячий запрос бенчмарка:

Автозагрузчик PREBUILT_CACHE debug => false Без фреймворка
PSR-4 (composer install) 5,5 мс 6,7 мс 2,3 мс
--optimize-autoloader (-o) 5,2 мс 5,0 мс 1,6 мс
--classmap-authoritative (-a) 4,8 мс 4,6 мс 1,9 мс

С --classmap-authoritative Composer никогда не ищет класс за пределами карты классов. Запускайте dump-autoload после любой генерации кода и перед прогревом.

Каждый скомпилированный класс превращается в два закешированных файла: его исходное тело в виде трейта и прокси. Каждый behavior class получает собственный файл кеша. Оставьте OPcache место под них.

Настройка Значение для продакшена Зачем
opcache.enable 1 Сгенерированный код — обычный PHP, он кешируется как остальное приложение.
opcache.memory_consumption 128–256 (МБ) Проверяйте opcache_get_status()['memory_usage'] под нагрузкой.
opcache.interned_strings_buffer 16–32 (МБ) Прокси и сгенерированные трейты используют одни и те же имена классов и методов.
opcache.max_accelerated_files ≥ 2 × число PHP-файлов приложения и vendor/ Каждый скомпилированный класс добавляет один файл.
opcache.validate_timestamps 0 Неизменяемые релизы и контейнеры: никакого stat на каждый include. Перезагружайте PHP-FPM после деплоя.
opcache.file_update_protection 0 Фреймворк записывает каждый файл кеша атомарно, поэтому OPcache может кешировать свежесгенерированные файлы сразу, а не ждать 2 секунды (значение по умолчанию).
opcache.file_cache каталог Кеш второго уровня на диске: новый мастер PHP-FPM или CLI-процесс загружает скомпилированные скрипты, а не компилирует их заново. Прогрейте его при сборке.
opcache.preload по желанию Один раз при старте сервера линкует сгенерированные классы, см. Предзагрузка.
realpath_cache_size / realpath_cache_ttl 4096K / 600 При validate_timestamps=1: меньше поисков путей на каждый include.

Сгенерированный код — обычный PHP, и JIT компилирует его так же, как остальное приложение. Типичный веб-запрос тратит время на множество коротких вызовов, где JIT выигрывает мало, поэтому сначала измерьте, а потом включайте.

Сгенерированные файлы — обычные объявления классов, поэтому собранный заранее кеш можно предзагрузить. --preload записывает скрипт opcache.preload для собираемого кеша: _preload.php в каталоге кеша или файл, указанный как --preload=FILE.

Окно терминала
vendor/bin/aspect cache:warmup:aop public/index.php --workers=$(nproc) --preload
opcache.ini
opcache.preload=/app/var/cache/aop/_preload.php
opcache.preload_user=www-data

--preload без значения должен идти после аргумента loader, иначе он примет loader за своё значение.

При старте PHP-FPM скрипт подключает автозагрузчик Composer, передаёт ему карту сгенерированных классов и линкует в OPcache каждый скомпилированный класс, его прокси и каждый нетрансформированный класс, известный кешу.

  • Автозагрузки files из Composer (вспомогательные функции, bootstrap-файлы полифиллов) не предзагружаются. Запросы подключают их как раньше.
  • В скрипте нет ни одного абсолютного пути. Всё находится через __DIR__, как и в файлах метаданных, поэтому кеш, перемещённый вместе с приложением, остаётся валидным.
  • Скрипт перечисляет классы ровно того кеша, с которым собран. Пересобирайте его вместе с кешем.
  • Класс, который не удаётся слинковать при предзагрузке (не хватает опциональной зависимости), записывается в журнал ошибок и остаётся автозагрузчику запроса.
  • Класс с behavior на статической инициализации тоже остаётся автозагрузчику: этому behavior нужно ядро, поэтому класс загружает запрос.

Ядро по-прежнему инициализируется на каждом запросе; просто автозагрузчику никогда не приходится загружать предзагруженные классы. В бенчмарке предзагрузка сократила число подключаемых файлов на запрос с 517 до 174, горячий запрос — с 5,2 мс до 4,9 мс, а первый запрос после старта сервера — с 71 мс до 24 мс (10 мс вместе с прогретым файловым кешем).

Предзагруженные классы меняются только с перезапуском PHP-FPM, а контейнеры и так деплоятся именно так. В CLI ничего не предзагружается, если не задано opcache.enable_cli=1.

Встраивайте кеш фреймворка в образ. Тогда каждый контейнер стартует с полным кешем только для чтения, каждая реплика отдаёт ровно тот же сгенерированный код, и ни один под ничего не компилирует. В shop demo эта схема собрана в рабочий образ.

Dockerfile
FROM php:8.5-fpm
# OPcache is part of PHP 8.5, no docker-php-ext-install needed
COPY docker/opcache.ini /usr/local/etc/php/conf.d/opcache.ini
COPY --from=composer:2 /usr/bin/composer /usr/bin/composer
WORKDIR /app
COPY composer.json composer.lock ./
RUN composer install --no-dev --no-scripts --no-autoloader --prefer-dist
COPY . .
RUN composer dump-autoload --no-dev --classmap-authoritative
# 1. The framework's cache: generated classes, proxies, behavior caches, metadata, owned by the user that serves it
# (cache files get the `cacheFileMode` kernel option, by default 0770 minus the umask)
RUN rm -rf var/cache/aop \
&& php vendor/bin/aspect cache:warmup:aop public/index.php --workers="$(nproc)" --preload \
&& chown -R www-data:www-data var/cache/aop \
&& chmod -R a-w var/cache/aop
# 2. The OPcache file cache: a new PHP-FPM master loads compiled scripts instead of compiling them.
# Built in the final image, as the file cache belongs to this PHP build and these paths.
RUN mkdir -p /var/cache/opcache \
&& php -d opcache.enable_cli=1 -d opcache.file_cache_only=1 -d opcache.file_cache=/var/cache/opcache \
vendor/bin/aspect cache:warmup:opcache public/index.php --file-cache=/var/cache/opcache --entry=public/index.php \
&& chown -R www-data /var/cache/opcache
USER www-data

cache:warmup:opcache компилирует то, что загружает приложение: кеш фреймворка (сгенерированные файлы, прокси, кеши behavior classes и метаданные), карту классов и автозагружаемые файлы Composer, некомпилируемые исходники в include paths, загрузочный файл и точки входа, переданные через --entry.

  • Скомпилированные скрипты записываются на диск только процессом, запущенным с opcache.enable_cli=1, opcache.file_cache_only=1 и opcache.file_cache=DIR. Эти настройки нельзя задать во время выполнения. Команда проверяет их, а также то, что --file-cache=DIR совпадает с настроенным каталогом, и иначе выводит точную команду для запуска.
  • Кеш фреймворка, загрузочный файл и точки входа обязаны компилироваться, иначе команда завершается с ошибкой. Файл из карты классов Composer, который не компилируется (тестовая заглушка из vendor, написанная под более новый PHP), выводится в список и пропускается; ошибку компиляции записывает в журнал PHP.
  • Запускайте её после cache:warmup:aop, в финальном образе, тем же бинарником PHP, который обслуживает запросы. Файловый кеш привязан к сборке PHP и к абсолютным путям файлов.
docker/opcache.ini
opcache.enable=1
opcache.memory_consumption=192
opcache.interned_strings_buffer=32
opcache.max_accelerated_files=50000
opcache.validate_timestamps=0
opcache.file_cache=/var/cache/opcache
opcache.file_cache_consistency_checks=0
; PHP 8.5: the primed file cache is only read at runtime, also on a read-only root file system
opcache.file_cache_read_only=1
; required on PHP 8.5.11 / 8.5.12, see "JIT"
opcache.jit=disable
; optional, see "Preloading" (written by cache:warmup:aop --preload)
; opcache.preload=/app/var/cache/aop/_preload.php
; opcache.preload_user=www-data

Ядро в образе — это продакшен-ядро из чек-листа: debug => false, includePaths ограничены src/, и Features::PREBUILT_CACHE.

В бенчмарке такая конфигурация отдаёт первый запрос свежего сервера за 19 мс с файловым кешем и за 10 мс с файловым кешем и предзагрузкой — против 71 мс без них. Поды работают быстро с первого же запроса.

  • Корневая файловая система только для чтения (readOnlyRootFilesystem: true). PREBUILT_CACHE читает кеш, встроенный в образ, и ничего не пишет во время выполнения.
  • Один образ — один кеш. Держите кеш внутри образа, а не на общем томе, чтобы каждый релиз отдавал ровно тот код, из которого собран.
  • Rolling updates (поэтапные обновления) не требуют ничего особенного. Новые поды приносят свой кеш, старые сохраняют свой.
  • Если образ не может содержать кеш, запускайте cache:warmup:aop в init-контейнере, который пишет в том emptyDir, смонтированный по пути кеша в контейнере приложения. PREBUILT_CACHE при этом остаётся, и под становится готовым уже с полным кешем.
  • CLI-контейнеры (обработчики очередей, cron-задачи) используют тот же образ и тот же кеш. Включите opcache.enable_cli=1 вместе с прогретым opcache.file_cache, см. CLI-процессы.

Долгоживущие воркеры (RoadRunner, режим воркера FrankenPHP, Swoole, ReactPHP) загружают ядро один раз на воркер. Call contexts остаются инициализированными от запроса к запросу.

  • Выбирайте точно. Перехватываются только выбранные члены класса и компилируются только выбранные классы, поэтому точное правило — это быстрое правило. execution(public App\Service\*->*(*)) выбирает и конструкторы. Добавьте && !execution(**->__construct(*)), если они вам не нужны.
  • Предпочитайте правила на методы правилам initialization(...). Пока зарегистрировано правило initialization, каждый new в сгенерированных файлах проходит через трансформер. Класс без behaviors на инициализацию (и с публичным конструктором) по-прежнему создаётся нативным new, что стоит примерно на 130 нс больше, чем обычный new. Класс с behaviors на инициализацию проходит через полный call context.
  • Регистрируйте behavior classes лениво через addLazyService(). Behavior class и его зависимости создаются при первом вызове behavior, а не на каждом запросе.
  • Делайте behaviors дешёвыми. getMethod() и getField() создают объект рефлексии при первом использовании в каждом call context. Извлеките из него атрибуты или имена один раз и храните их в behavior class с ключом class::method.
  • Форматируйте call contexts лениво. (string) $invocation строит строку при каждом вызове. Используйте его только для сообщений, которые действительно записываются.
  • Нативные include. Features::INTERCEPT_INCLUDES пропускает include/require в сгенерированных файлах через компилятор: это нужно для легаси-кода, который загружается не через Composer. С этой опцией include файла, известного кешу, в продакшене обслуживается по его исходному или закешированному пути, без stream filter (~250 мкс → ~11 мкс на include).

Behavior class с ленивой регистрацией:

src/ApplicationAspectKernel.php
use Go\Core\AspectContainer;
use Go\Core\AspectKernel;
use Psr\Log\LoggerInterface;
class ApplicationAspectKernel extends AspectKernel
{
protected function configureAop(AspectContainer $container): void
{
// Runs when one of its behaviors first runs, after the application container is attached
$container->addLazyService(
MonitorAspect::class,
static fn(AspectContainer $container) => new MonitorAspect($container->getService(LoggerInterface::class)),
);
}
}

Как писать behaviors и matching rules, описано на странице Поведения и правила выбора.

Сообщение или симптом Что это значит и что делать
cache:warmup:aop пишет ошибки в stderr и завершается с ненулевым кодом Файл не компилируется. Деплой или docker build останавливается, чтобы неполный кеш никогда не попал в продакшен. Исправьте файл и снова запустите прогрев.
WeavingException: ... is missing from the prebuilt AOP cache in ... С PREBUILT_CACHE у класса или подключаемого файла в include paths нет записи в кеше, либо его закешированный файл пропал. Пересоберите кеш командой cache:warmup:aop.
cache:warmup:opcache выводит команду вместо прогрева кеша Процесс запущен без -d opcache.enable_cli=1 -d opcache.file_cache_only=1 -d opcache.file_cache=DIR, или --file-cache указывает на другой каталог. Запустите выведенную команду.

PHP сообщает о проблемах предзагрузки один раз, при старте мастера PHP-FPM (или php -S), в своём журнале ошибок.

Сообщение Что это значит и что делать
Fatal Error "opcache.preload" requires "opcache.preload_user" when running under uid 0 Мастер работает от root. Укажите в opcache.preload_user пользователя, от которого работают воркеры (www-data).
Failed opening required '.../_preload.php' Скрипта нет: кеш собран без --preload, или opcache.preload указывает на другой каталог кеша. Пересоберите командой cache:warmup:aop --preload.
Go! AOP preload: <class> is left to the autoloader: ... Скрипт не смог загрузить класс из кеша — чаще всего потому, что не установлена опциональная зависимость (образ с --no-dev). Это безвредно: класс не предзагружается, и запрос, которому он нужен, как обычно получает его через автозагрузчик.
Can't preload unlinked class <class>: Unknown parent/trait/interface <name> in <file> OPcache не смог слинковать класс из файла, подключённого при предзагрузке, по той же причине. Для класса из кеша это сообщение приходит вместе со строкой выше. Это безвредно: класс просто не предзагружается.
Can't preload unlinked class class@anonymous: Unknown trait ... во вспомогательном файле из vendor Анонимный класс из автозагрузки files Composer, например из Illuminate/Reflection/helpers.php в Laravel. Скрипт кеша эти файлы не подключает; предупреждение исходит от другого скрипта, который подключает vendor/autoload.php раньше него. Подключайте скрипт кеша первым: тогда Composer возвращает уже созданный загрузчик и не подключает файлы повторно.

Приложение, скрипты бенчмарков и Docker-образ лежат в goaop/shop-demo. Один скрипт воспроизводит все таблицы этой страницы:

Окно терминала
bash bench/run-all.sh
  • Приложение: ~45 написанных вручную классов (домен, репозитории, сервисы, контроллеры, инфраструктура в памяти), 40 сгенерированных модулей (сервис и репозиторий компилируются; DTO, валидатор и событие — нет) и 120 библиотечных классов вне include paths.
  • Behavior classes: логирование (#[Before] на атрибут), кеширование и транзакции (#[Around] на атрибуты), мониторинг (#[Around] на репозитории, #[AfterThrowing] на сервисы), аудит остатков на складе (#[Around] на свойство), безопасность (#[Before] на сервисы модулей).
  • Базовая линия: тот же код без ядра. Его behaviors не выполняются.
  • Окружение: PHP 8.5.12 NTS, 4 CPU, OPcache с opcache.jit=disable и opcache.file_update_protection=0.
  • Веб-запросы: встроенный веб-сервер (php -S, один воркер, общая память OPcache сохраняется между запросами). Тёплый — первый запрос только что запущенного сервера (7 замеров); горячий — медиана 350 запросов. Время измеряется внутри скрипта через hrtime().
  • Профили: прогоны Xdebug 3.5 с xdebug.mode=profile во всех режимах и состояниях; по ним подсчитаны вызовы и распределение времени. Сами времена получены в прогонах без Xdebug.

На другие машины переносятся именно соотношения между режимами.

© 2026 Alexander Lisachenko