Когда в Node.js появилась JIT-компиляция?

JIT-компиляция в Node.js

Это интересный технический вопрос о глубинной архитектуре Node.js и V8 движка.

Краткий ответ

JIT-компиляция в Node.js существует уже очень давно — она встроена в V8 движок, который используется Node.js.

Основной V8 JIT:

• Introduced: 2008 году (V8 v0.1)
• Когда в Node.js: с самого начала (2009)
• Текущая реализация: TurboFan (2015+)

Как работает JIT в V8

Основная идея

Интерпретатор → Профайлер → JIT Компилятор → Machine Code

Когда код исполняется:

1. Interpreter (Ignition) начинает исполнять bytecode
2. Profiler отслеживает горячие функции (часто вызываемые)
3. JIT Compiler скомпилирует горячие функции в машинный код
4. Machine Code исполняется намного быстрее

Пример с тайм-лайном

// Эта функция исполнится 100000 раз
function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

// Вызовы: 1-10000 — интерпретируется
for (let i = 0; i < 10000; i++) {
  fibonacci(10);
}

// После ~10000 вызовов V8 заметит, что это горячая функция
// Включится JIT компилятор
// Следующие 90000 вызовов будут в скомпилированном коде
for (let i = 10000; i < 100000; i++) {
  fibonacci(10);  // вот здесь уже машинный код!
}

История JIT компиляции в Node.js

2008-2010: ранние дни

V8 v0.1+ (2008) — первый JIT
↓
Node.js v0.1 (2009) — унаследовал V8 JIT

2010-2015: эволюция

V8 v2.0 (2010) — улучшения JIT
↓
Crankshaft (2010) — второе поколение JIT

2015+: современность

TurboFan (2015) — третье поколение JIT
↓
Node.js 4.0+ — интегрирована TurboFan

Текущее состояние: TurboFan

Архитектура современного V8

┌─────────────────┐
│   JavaScript    │
└────────┬────────┘
         │
    ┌────▼────┐
    │ Parser  │  парсит код
    └────┬────┘
         │
    ┌────▼──────────┐
    │ Interpreter   │  исполняет bytecode
    │ (Ignition)    │  медленно, но быстро начинает
    └────┬──────────┘
         │
    ┌────▼────────────────┐
    │ Profiler отслеживает│
    │ горячие функции     │
    └────┬─────────────────┘
         │
    ┌────▼───────────────┐
    │ JIT (TurboFan)     │  скомпилирует в машинный код
    │ Compiler           │
    └────┬────────────────┘
         │
    ┌────▼────────────────┐
    │ Machine Code        │  исполняется быстро!
    │ (x64, ARM, etc)     │
    └─────────────────────┘

Как это выглядит на практике

Простой бенчмарк

// benchmark.js
function sum(arr) {
  let total = 0;
  for (let i = 0; i < arr.length; i++) {
    total += arr[i];
  }
  return total;
}

const arr = new Array(1000000).fill(1);

// Первый проход (интерпретируется)
console.time('first');
for (let i = 0; i < 100; i++) {
  sum(arr);
}
console.timeEnd('first');  // медленнее

// Второй проход (уже JIT скомпилировано)
console.time('second');
for (let i = 0; i < 100; i++) {
  sum(arr);
}
console.timeEnd('second');  // быстрее!

$ node benchmark.js
first: 150ms    (интерпретация + JIT компиляция)
second: 50ms    (уже скомпилировано)

Специальности TurboFan

1. Speculative Optimization

V8 предполагает типы и оптимизирует:

function processValue(value) {
  return value * 2;  // V8 предполагает number
}

// Если всегда передавать numbers
for (let i = 0; i < 1000000; i++) {
  processValue(42);  // V8 скомпилирует думая что это number
}

// Но если вдруг передать string
processValue('hello');  // "hellohello"
// V8 выбросит предположение и придется перекомпилировать!

2. Inline Caching

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
}

function getDistance(point) {
  return Math.sqrt(point.x * point.x + point.y * point.y);
}

// V8 закэшировает что point это Point и может быстро достать x/y
const p = new Point(3, 4);
for (let i = 0; i < 1000000; i++) {
  getDistance(p);  // очень быстро
}

Как посмотреть JIT оптимизацию

# Запустить с флагами для отладки
node --trace-opt --trace-deopt code.js

# Вывод:
# [opt] compiling sum (5 ticks, 0% unoptimized)  # скомпилировано
# [deopt] sum (line 10, position 15)              # перекомпилировано

Как V8 решает НЕ компилировать

Есть функции, которые V8 никогда не будет компилировать:

// ❌ Too complex
function complex() {
  with (object) {  // deprecated, V8 не оптимизирует
    // ...
  }
}

// ❌ Too large
function huge() {
  // 10000+ строк кода
  // V8 решит что не стоит компилировать
}

// ❌ eval внутри
function withEval() {
  eval('some code');  // динамичный код, не компилируется
}

// ✅ Компилируется
function simple(x) {
  return x * 2;  // простая, горячая функция
}

Практический совет для разработчиков

Как помочь JIT компилятору

// ✅ Хорошо: стабильные типы
function calculate(x) {  // всегда number
  return x * 2;
}

for (let i = 0; i < 1000000; i++) {
  calculate(42);
}

// ❌ Плохо: смешанные типы
function process(value) {
  return value * 2;  // когда number, когда string
}

for (let i = 0; i < 500000; i++) {
  process(42);          // number
  process('hello');     // string — JIT отбросит оптимизацию!
}

// ❌ Плохо: много динамики
function dynamicMethod(obj, method) {
  return obj[method]();  // какой метод? V8 не может оптимизировать
}

// ✅ Хорошо: явная структура
class Service {
  calculate(x) {  // явная структура, компилируется
    return x * 2;
  }
}

Миф: JIT медленный в Node.js

Это неправда. Node.js с TurboFan очень быстрый:

Benchmark (fibonacci(35)):
  Python:        15 секунд
  JavaScript:    1.5 секунды (благодаря JIT)
  Rust:          0.05 секунд

Итог

Когда появилась JIT в Node.js: с самого начала (2009)

Текущая версия: TurboFan (с 2015)

Ключевая идея: V8 сначала интерпретирует код, потом JIT компилирует горячие функции в машинный код.

Результат: Node.js может быть очень быстрым для вычислений благодаря JIT оптимизациям.

Это одна из причин, почему JavaScript на Node.js может конкурировать по скорости с Go и Java на некоторых задачах.