Управление памятью в V8: Heap, Garbage Collection и профилирование утечек

Архитектурная база#

Управление оперативной памятью в Node.js целиком делегировано виртуальной машине Google V8. Для построения высоконадежных бэкенд-сервисов, способных работать месяцами под непрерывной нагрузкой без деградации и аварийного завершения по Out of Memory (OOM), инженеру необходимо понимать, как именно V8 сегментирует память процесса на уровне операционной системы.

Вся память запущенного процесса Node.js описывается метрикой Resident Set Size (RSS) — объемом физической памяти RAM, выделенной операционной системой процессу:

+-----------------------------------------------------------------------+
|                 Resident Set Size (RSS) OS Memory                     |
+-----------------------------------------------------------------------+
|  Node.js / C++ Memory   |           Google V8 Managed Memory          |
|  - Node.js Core Code    | +-----------------------------------------+ |
|  - C++ Buffers / I/O    | | V8 Stack (Execution frames & primitives)| |
|  - Thread Pool stacks   | +-----------------------------------------+ |
|  - External Memory      | | V8 Heap (Object allocations)            | |
|    (ArrayBuffer, WASM)  | | - New Space (Nursery / Intermediate)    | |
|                         | | - Old Pointer Space                     | |
|                         | | - Old Data Space                        | |
|                         | | - Large Object Space (LOS)              | |
|                         | | - Code Space (JIT compiled)             | |
|                         | | - Map/Cell Space (Hidden classes)       | |
|                         | +-----------------------------------------+ |
+-----------------------------------------------------------------------+

1. Stack (Стек вызовов): хранит примитивные значения (number, boolean, указатели на ссылки) и фреймы вызова текущих функций. Выделяется и освобождается автоматически по принципу LIFO с нулевыми накладными расходами.
2. External Memory (Внешняя память): память, выделенная через C++ структуры за пределами кучи V8. Именно здесь хранятся бинарные буферы Buffer.allocUnsafe() и разделяемые сегменты ArrayBuffer.
3. Heap (Управляемая куча): динамическая память, в которой размещаются все ссылочные типы JavaScript (объекты, массивы, функции, замыкания). Именно куча обслуживается алгоритмами сборщика мусора (Garbage Collector).

Ментальная модель#

Организация кучи V8 основана на слабой гипотезе о поколениях (Weak Generational Hypothesis): подавляющее большинство вновь создаваемых объектов в программе являются короткоживущими и становятся недостижимыми практически сразу после своего создания (например, переменные тела обработчика HTTP-запроса).

Куча V8 физически разделена на изолированные сегменты (Spaces):

+--------------------------------------------------------------------+
|                         V8 Heap Structure                          |
+--------------------------------------------------------------------+
| New Space (Young Generation: 1-64 MB)                              |
| +--------------------------------+-------------------------------+ |
| |   From Space (Nursery)         |   To Space (Intermediate)     | |
| +--------------------------------+-------------------------------+ |
|                 | (Выживание после 2 циклов Minor GC)              |
|                 v                                                  |
| Old Space (Old Generation: до --max-old-space-size)                |
| +----------------------------------------------------------------+ |
| | Old Pointer Space: объекты, содержащие ссылки на другие объекты| |
| | Old Data Space: сырые данные без ссылок (строки, числа)        | |
| +----------------------------------------------------------------+ |
| Specialized Spaces:                                                |
| +----------------------------------------------------------------+ |
| | Large Object Space: объекты больше порога, минующие New Space  | |
| | Code Space: машинные инструкции, скомпилированные TurboFan     | |
| | Map/Cell Space: скрытые классы (Shapes) и метаданные типов     | |
| +----------------------------------------------------------------+ |
+--------------------------------------------------------------------+

• Полный объем оперативной памяти процесса, включающий кучу V8, стек, внешний C++ код и нативные буферы.
• Быстрый полупространственный алгоритм сборки мусора Чейни, очищающий и перемещающий объекты внутри New Space.
• Комплексный сборщик мусора старшего поколения (Old Space), маркирующий граф достижимости, очищающий мертвые объекты и выполняющий дефрагментацию памяти.
• Архитектурная инициатива команды V8 по замене монолитных stop-the-world пауз на параллельную, конкурентную и инкрементальную сборку мусора.
• Граф удержания ссылок в памяти, связывающий исследуемый объект с корнями сборщика мусора (GC Roots: глобальный контекст, активный стек, дескрипторы DOM/C++).

На практике применяется#

1. Предотвращение OOM-крашей в контейнерах Kubernetes: корректная синхронизация флага --max-old-space-size с лимитами resources.limits.memory пода подавляет срабатывание Linux OOM Killer.
2. Профилирование утечек памяти в долгоживущих микросервисах: автоматическое снятие Heap Snapshots через v8.writeHeapSnapshot() при достижении 85% заполнения кучи и локализация Retainer Tree в Chrome DevTools.
3. Оптимизация высоконагруженного кэширования: замена неограниченных объектов Map на двухуровневые LRU-структуры с жестким ограничением объема или на связки WeakRef / FinalizationRegistry.
4. Устранение утечек слушателей в EventEmitter: аудит жизненного цикла соединений WebSocket и SSE с принудительной отпиской через единый AbortSignal.

Как это работает#

1. Алгоритмы сборки: Minor GC (Scavenger) vs Major GC#

Minor GC: алгоритм Чейни (Cheney's Copying Algorithm)

New Space разделен на два одинаковых полупространства: From-space и To-space.

1. Новые объекты всегда аллоцируются в области Nursery пространства From-space.
2. Когда From-space заполняется, инициируется Scavenger.
3. Алгоритм начинает обход от корней (GC Roots). Достижимые живые объекты копируются в непрерывный блок памяти To-space (этим достигается мгновенная дефрагментация). Недостижимые объекты просто игнорируются.
4. Если объект переживает вторую сборку Scavenger, он продвигается (promotion) в Old Space.
5. Роли пространств From-space и To-space меняются местами. Занимает единицы миллисекунд.

Major GC: Mark-Sweep-Compact

Old Space очищается по трехфазному алгоритму:

1. Marking (Маркировка): обход графа объектов с использованием трехцветной раскраски (Tri-color marking):
   • Белый: кандидат на удаление (еще не обнаружен сборщиком).
   • Серый: объект достижим, но его дочерние ссылки еще не исследованы.
   • Черный: объект достижим, все его дочерние ссылки проверены.
2. Sweeping (Очистка): сборщик добавляет адреса белых объектов в списки свободной памяти (Free Lists).
3. Compacting (Дефрагментация): перемещение выживших черных объектов в начало страниц памяти для устранения фрагментации адресного пространства.

2. Эволюция проекта Orinoco: минимизация пауз Stop-The-World#

Исторически сборка мусора полностью замораживала выполнение JavaScript (Stop-The-World). Проект Orinoco внедрил три параллельных механизма:

1. Parallel GC (Параллельная сборка):
   Главный поток:   ---[ STOP ]========================[ RESUME ]--->
   Потоки-помощники:   ---[ Worker 1: Mark/Compact ]--->
                       ---[ Worker 2: Mark/Compact ]--->

2. Incremental GC (Инкрементальная маркировка):
   Главный поток:   ---[JS]---[Mark 1]---[JS]---[Mark 2]---[JS]---[Sweep]--->

3. Concurrent GC (Конкурентная фоновая сборка):
   Главный поток:   ---[ JS Execution непрерывно продолжается ]------>
   Фоновые потоки:  ---[ Concurrent Marking & Concurrent Sweeping ]--->

3. Сравнение поколений памяти в куче V8#

4. Архитектурный поток снятия и анализа Heap Snapshot#

5. Production-Ready сторожевой таймер памяти (Memory Watchdog)#

В микросервисной архитектуре критично снять диагностический дамп памяти до того, как контейнер будет уничтожен сигналом SIGKILL от Linux OOM Killer.

import v8 from 'node:v8';
import path from 'node:path';
import fs from 'node:fs';
import { EventEmitter } from 'node:events';

export interface MemoryWatchdogConfig {
  checkIntervalMs: number;
  heapUsageThresholdPercent: number;
  snapshotsDirectory: string;
  cooldownMs: number;
}

export class MemoryWatchdog extends EventEmitter {
  private timer: NodeJS.Timeout | null = null;
  private lastSnapshotTime = 0;
  private isGenerating = false;

  constructor(private readonly config: MemoryWatchdogConfig) {
    super();
    if (!fs.existsSync(config.snapshotsDirectory)) {
      fs.mkdirSync(config.snapshotsDirectory, { recursive: true });
    }
  }

  public start(): void {
    if (this.timer) return;

    this.timer = setInterval(() => {
      this.evaluateHeapUsage();
    }, this.config.checkIntervalMs);

    this.timer.unref();
  }

  public stop(): void {
    if (this.timer) {
      clearInterval(this.timer);
      this.timer = null;
    }
  }

  private evaluateHeapUsage(): void {
    const stats = v8.getHeapStatistics();
    const currentHeapUsed = stats.used_heap_size;
    const maxHeapAvailable = stats.heap_size_limit;
    const usageRatio = currentHeapUsed / maxHeapAvailable;
    const usagePercent = Math.round(usageRatio * 100);

    this.emit('heartbeat', {
      usedMb: Math.round(currentHeapUsed / 1024 / 1024),
      totalMb: Math.round(stats.total_heap_size / 1024 / 1024),
      limitMb: Math.round(maxHeapAvailable / 1024 / 1024),
      usagePercent,
    });

    if (usagePercent >= this.config.heapUsageThresholdPercent) {
      this.triggerSnapshot(usagePercent, stats);
    }
  }

  private triggerSnapshot(usagePercent: number, stats: v8.HeapInfo): void {
    const now = Date.now();
    
    // Защита от шторма дампов (cooldown)
    if (this.isGenerating || (now - this.lastSnapshotTime < this.config.cooldownMs)) {
      return;
    }

    this.isGenerating = true;
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    const filename = `heap-oom-warning-${process.pid}-${timestamp}.heapsnapshot`;
    const fullPath = path.join(this.config.snapshotsDirectory, filename);

    this.emit('snapshot-start', {
      usagePercent,
      targetPath: fullPath,
      heapStats: stats,
    });

    try {
      // v8.writeHeapSnapshot() пишет дамп потоково, минимизируя пиковый оверхед
      const actualPath = v8.writeHeapSnapshot(fullPath);
      this.lastSnapshotTime = Date.now();
      
      this.emit('snapshot-complete', {
        path: actualPath,
        durationMs: this.lastSnapshotTime - now,
      });
    } catch (err) {
      this.emit('snapshot-error', err);
    } finally {
      this.isGenerating = false;
    }
  }
}

6. Паттерн безопасного кэширования через WeakRef и FinalizationRegistry#

Для кэширования тяжелых вычисленных структур данных без риска утечки памяти используются слабые ссылки, позволяющие сборщику мусора V8 беспрепятственно удалять объекты при дефиците памяти:

/**
 * EphemeralCache: кэш с использованием слабых ссылок (WeakRef).
 * Не удерживает объекты в памяти, позволяя сборщику мусора V8
 * удалять их при очистке кучи.
 */
export class EphemeralCache<K, V extends object> {
  private readonly storage = new Map<K, WeakRef<V>>();
  private readonly registry: FinalizationRegistry<K>;

  constructor() {
    // Реестр финализации уведомляет, когда сборщик мусора очистил объект
    this.registry = new FinalizationRegistry<K>((key) => {
      const ref = this.storage.get(key);
      if (ref && !ref.deref()) {
        this.storage.delete(key);
      }
    });
  }

  public set(key: K, value: V): void {
    // Регистрируем значение в WeakRef и FinalizationRegistry
    this.storage.set(key, new WeakRef(value));
    this.registry.register(value, key, value);
  }

  public get(key: K): V | undefined {
    const ref = this.storage.get(key);
    if (!ref) {
      return undefined;
    }

    const value = ref.deref();
    if (!value) {
      // Объект уже уничтожен GC, удаляем мертвый ключ
      this.storage.delete(key);
      return undefined;
    }

    return value;
  }

  public has(key: K): boolean {
    return this.get(key) !== undefined;
  }
}

Распространённые ошибки#

function leakContext() {
  const hugeBuffer = Buffer.alloc(100 * 1024 * 1024); // 100 MB
  const smallData = 'status_ok';

  setInterval(() => {
    // Это долгоживущее замыкание использует только smallData,
    // но V8 удержит весь контекст с hugeBuffer в куче навсегда!
    console.log(smallData);
  }, 1000);

  return function unused() {
    return hugeBuffer;
  };
}