Четыре яруса и как работает разогрев

Четыре яруса, одна кривая «стоимость против скорости»

Обзорный урок четырёхъярусный JIT-конвейер V8 набросал лестницу; этот юнит открывает каждую ступень. Начнём с формы компромисса. Каждый ярус сидит в точке на одной оси: сколько времени уходит на то, чтобы произвести код, против того, как быстро этот код исполняется. Дешевле скомпилировать — медленнее исполнять; быстрее исполнять — дороже компилировать. V8 поставляет четыре яруса, потому что ни одна точка на этой кривой не подходит всему коду.

Ignition — это интерпретатор. Парсер передаёт ему AST; Ignition один раз понижает его до компактного регистрового байт-кода, а затем исполняет этот байт-код на виртуальной машине. Здесь вообще нет генерации машинного кода — исполнение это цикл диспетчеризации, который читает байт-код, прыгает в обработчик, исполняет его и сдвигается дальше. Стоимость входа фактически нулевая (вы уже заплатили за производство байт-кода), и это единственный ярус, который записывает обратную связь о типах, на которую опираются верхние ярусы. На операцию он примерно на порядок медленнее оптимизированного нативного кода, потому что каждый шаг платит за накладные расходы диспетчеризации интерпретатора — поиск в таблице и непрямой переход.

Sparkplug — это базовый (baseline) JIT, появившийся в V8 9.1 (2021). Это ступень, которую чаще всего понимают неправильно, поэтому будем точны: Sparkplug не делает оптимизаций. Он не строит промежуточного представления (IR), не делает инлайнинга, escape-анализа, специализации по типам. Он один раз обходит уже существующий байт-код и выпускает почти 1:1 шаблон машинных инструкций — на каждый байт-код фиксированный небольшой блок нативного кода плюс изредка вызов обратно в рантайм. Что он убирает — это ровно накладные расходы диспетчеризации интерпретатора: больше нет поиска в таблице и непрямого перехода на операцию, только прямолинейный нативный код. Одно это даёт примерно 1.5–2× над Ignition, а компилируется за микросекунды (около 1 мс на килобайт байт-кода). Поскольку компиляция настолько дёшева, код Sparkplug можно производить лениво — при первой «горячести» — или жадно.

Maglev — это среднеярусный оптимизирующий компилятор, появившийся в 2023. Это настоящий оптимизатор — он строит IR в форме SSA и использует записанную обратную связь о типах, чтобы специализировать загрузки свойств и арифметику, — но лёгкий. Он использует быстрый аллокатор регистров методом линейного сканирования и пропускает самые тяжёлые проходы TurboFan (escape-анализ, полиморфный инлайнинг, итеративное сужение типов). В результате он компилируется примерно в 10 раз быстрее TurboFan, достигая около 50–70% качества его кода: верный инструмент для «горячих, но не самых горячих» функций, где задержка компиляции TurboFan навредила бы сильнее, чем помогла бы его лишняя скорость.

TurboFan — это полный оптимизирующий компилятор: IR в виде «моря узлов» (sea-of-nodes), агрессивный инлайнинг, escape-анализ и всё прочее (урок 03 этого юнита открывает его). Он производит самый быстрый код, какой может сделать V8, ценой компиляции в десятки-сотни миллисекунд на функцию. Платить за это стоит только для кода, который и очень горячий, и стабилен по типам.

Как разогрев на самом деле запускает повышение яруса

Функция поднимается не из-за таймера по настенным часам. Она поднимается, потому что два счётчика пересекают бюджеты. Первый — счётчик вызовов (invocation count): сколько раз в функцию входили. Второй — счётчик обратных дуг (back-edge count): сколько раз исполнение прыгало назад к началу цикла внутри функции. V8 держит бюджет на функцию («бюджет прерывания» / бюджет обратной связи); каждый вызов и каждая обратная дуга цикла уменьшают его, и когда он достигает нуля, рантайм запускает проверку повышения яруса. Вот почему и горячие функции (часто вызываемые), и горячие циклы (часто повторяемые, даже внутри функции, вызванной однажды) могут запросить более высокий ярус — счётчик обратных дуг это то, что позволяет одному долго работающему циклу оптимизироваться, ни разу не вернувшись.

// Вызывается много раз -> счётчик вызовов запускает повышение яруса.
function distance(a, b) {
  const dx = a.x - b.x, dy = a.y - b.y;
  return Math.sqrt(dx * dx + dy * dy);
}
for (let i = 0; i < 1_000_000; i++) distance(p, q);

// Вызывается однажды, но обратные дуги цикла запускают повышение яруса ЭТОГО фрейма.
function sumTo(n) {
  let total = 0;
  for (let i = 0; i < n; i++) total += i; // каждая итерация = одна обратная дуга
  return total;
}
sumTo(100_000_000);

Пороги динамические и настраиваются от релиза к релизу — грубо говоря, Sparkplug включается после низких сотен вызовов, Maglev после низких тысяч, TurboFan после десятков тысяч, — но никогда не зашивайте число; относитесь к ним как к порядку, а не к константам.

Параллельная компиляция: интерпретатор никогда не блокируется

Если бы компиляция была синхронной, вы получали бы 100-мс заморозку каждый раз, когда функция доходит до TurboFan. Она не синхронная. Повышение яруса не останавливает вашу программу. Когда бюджет срабатывает, V8 ставит задачу компиляции в очередь, и фоновый поток запускает Maglev или TurboFan, пока главный поток продолжает исполнять функцию на её текущем ярусе. Когда оптимизированный код готов, V8 подменяет его при следующем входе (или прямо посреди цикла, через замену на стеке — урок 06). Вот почему вы никогда не видите 100-мс заморозку, когда функция повышается до TurboFan: заморозка случилась бы, если бы компиляция была синхронной, но она не такая. Цена проявляется вместо этого как фоновая нагрузка на CPU и короткое окно, где функция исполняется на старой скорости, хотя уже «запланирована» на новый ярус.

За всем этим можно наблюдать. --trace-opt логирует каждое решение об оптимизации (какая функция, какой ярус, почему); --no-opt целиком отключает оптимизирующие ярусы, чтобы сравнить с чистыми Ignition плюс Sparkplug. В Node: node --trace-opt --trace-deopt app.js. В d8 добавьте --allow-natives-syntax, чтобы вызвать %OptimizeFunctionOnNextCall(fn) и форсировать повышение яруса немедленно, а не разогревать вручную.