Когда V8 аллоцирует Context (и чего это стоит)

Правило аллокации: захват и ничего больше

Context аллоцируется не потому, что вы открыли функцию или блок. Он аллоцируется только тогда, когда компилятор определяет, что переменная в этой области захвачена внутренней функцией — на неё ссылается вложенная функция или стрелка, которая может пережить текущий кадр. Если ни одна внутренняя функция ни над чем не замыкается, области вообще не нужен Context: её переменные живут в регистрах или слотах стека и не стоят ничего сверх кадра.

Это самая важная модель стоимости в этом юните. Большинство функций, которые вы пишете, аллоцируют ноль Context’ов, потому что они либо не определяют внутренних функций, либо определяют внутренние функции, которые ничего не захватывают. Цена появляется ровно в момент захвата.

function noCapture(xs) {
  let sum = 0;
  for (let i = 0; i < xs.length; i++) sum += xs[i];
  return sum;            // нет внутренней функции -> нет Context, всё в регистрах
}

function capture(xs) {
  let sum = 0;
  xs.forEach(x => sum += x); // стрелка захватывает 'sum' -> 'sum' context-allocated
  return sum;                // один Context для этой области
}

Ловушка на итерацию: let в цикле + захват

let и const, объявленные в заголовке for, создают свежую привязку на каждую итерацию. Это та возможность, которая убирает классический баг «все мои колбэки печатают последнее значение». Но у реализации есть цена, когда тело захватывает эту привязку.

const fns = [];
for (let i = 0; i < n; i++) {
  fns.push(() => i);   // захватывает 'i' ЭТОЙ итерации
}
// Каждый колбэк возвращает свой i: fns[3]() === 3. Корректно!
// Но: НОВЫЙ Context аллоцируется на каждую итерацию, чтобы держать её i.

Чтобы каждое замыкание видело свой i, i каждой итерации должен жить в отдельном месте — поэтому V8 аллоцирует свежий Context на итерацию и копирует туда привязку. При большом n и захватывающем теле это n кучевых аллокаций и n объектов для трассировки GC. Сравните с var, у которого одна привязка на весь цикл:

const fns = [];
for (var i = 0; i < n; i++) {
  fns.push(() => i);   // все захватывают ОДИН И ТОТ ЖЕ 'i'
}
// Каждый колбэк возвращает финальный i (=== n). Одна привязка, один Context.

var аллоцирует здесь максимум один Context (всё же один, потому что привязка захвачена) — но не умножает на n. Широко повторяемый совет «всегда используй let» верен для корректности, но в по-настоящему горячем цикле, создающем замыкания, Context на итерацию — это реальная, измеримая цена.

Что вынуждает Context и как его сократить

Что вынуждает аллокацию Context: любое замыкание над переменной, блок with, прямой eval (он может читать/объявлять локальные) и в некоторых случаях наблюдение arguments способами, которые мешают анализу. Рычаги, чтобы сократить это на горячих путях:

• Вынесите замыкание из цикла. Если колбэку на самом деле не нужна привязка каждой итерации, определите его один раз вне цикла. Никакого Context на итерацию.
• Передавайте данные аргументами вместо захвата. Функция, получающая x параметром, его не захватывает; параметры дешевле захваченного слота Context и держат форму вызова предсказуемой (следующий урок).
• Используйте индекс, а не захваченную привязку, когда нужно значение только в момент вызова. Иногда обычный for с var плюс явная копия — правильный инструмент в горячем цикле на миллион итераций — измеряйте.
• Держите большие или долгоживущие данные вне захваченных областей (урок об удержании) — отдельная забота от числа аллокаций, но та же дисциплина.

Применённые вместе, эти четыре рычага сокращают и количество объектов Context, которые GC обязан трассировать, и число кучевых аллокаций на горячую итерацию. Без выноса даже тривиальный () => i внутри тесного цикла тихо умножает аллокации на n — именно тот тип затрат, который появляется только в профиле аллокаций, но не в код-ревью.

// Горячий путь: избегаем n Context'ов на итерацию, когда захват не нужен.
function attach(handlers, fn) {            // fn определён ОДИН раз, ничего не захват. на итер
  for (let i = 0; i < handlers.length; i++) handlers[i].on(fn);
}