В экосистеме реактивных библиотек для JavaScript сложились два разных подхода к тестированию производительности:

  1. Синтетические графы с тривиальной нагрузкой (например, js-reactivity-benchmark - сьюты kairo, dynamic, cellx, s). Внутри узлов выполняется простое сложение чисел, поэтому замеряются чистые накладные расходы самого ядра: создание узлов, переброска указателей в списках подписчиков и работа планировщика. В таких тестах закономерно лидируют минималистичные движки-примитивы вроде alien-signals и @preact/signals-core. 
  2. Графы с тяжёлыми вычислениями и пересозданием структур - классический пример по мотивам статьи Big State Managers Benchmark и репозитория github.com/b-on-g/collider. Здесь в нескольких узлах вызывается ресурсоёмкая функция hard(), а промежуточный узел на каждый чих заново собирает массив объектов через .map().

На таком графе побеждает не тот движок, у которого быстрее цикл по указателям, а тот, который умеет не делать лишнюю работу: пропускать невостребованные ветки и гасить обновления при неизменном содержимом структур.

По следам разбора PR #1 в $bog_collider мы собрали автономный воспроизводимый стенд github.com/pravosleva/mol-collider-benchmark, чтобы сравнить в одинаковых условиях среды Node.js 10 решений - от эталонных низкоуровневых примитивов до полнофункциональных стейт-менеджеров:

  • @pravosleva/reactive-engine
  • @vue/reactivity
  • @angular/core (Signals)
  • MobX
  • $mol (mol_wire_lib)
  • alien-signals
  • @preact/signals-core
  • Reatom (@reatom/core)
  • SolidJS 2 (@solidjs/signals)
  • Effector

Топология графа и две ловушки для реактивности

Граф состоит из двух входных сигналов (A, B), пяти вычисляемых узлов (C, D, E, F, G) и трёх побочных эффектов (H, I, J):

        ┌─────────┐               ┌─────────┐
        │ Signal A│               │ Signal B│
        └────┬────┘               └────┬────┘
             │ \                     / │
             │  \                   /  │
             │   ▼                 ▼   │
             │  ┌───────────────────┐  │
             │  │    Computed C     │  │
             │  │  (A % 2 + B % 2)  │  │
             │  └────┬─────────┬────┘  │
             │       │         │       │
             ▼       ▼         │       ▼
         ┌───────────────┐     │  ┌───────────────────────────┐
         │  Computed E   │     │  │        Computed D         │
         │ hard(C+A+D)│     │  │ map({ x: i + A%2 - B%2 }) │
         └───────┬───────┘     │  └──┬──────────┬──────────┬──┘
                 │             │     │          │          │
       (только если C == 0)    │     │          │          ▼
                 │             │     │          │  ┌───────────────┐
                 │             │     │          │  │  Computed F   │
                 │             │     │          │  │ hard(D||B) │
                 │             ▼     ▼          │  └───────┬───────┘
                 │      ┌──────────────────┐    │          │
                 └─────►│    Computed G    │◄───┼──────────┤
                        │ C+(C||E%2)+D+F│    │          │
                        └────┬────────┬────┘    │          │
                             │        │         │          │
                             ▼        ▼         │          ▼
                        ┌────────┐ ┌────────┐   │     ┌────────┐
                        │Effect H│ │Effect I│   │     │Effect J│
                        │hard(G) │ │  (G)   │   │     │hard(F) │
                        └────────┘ └────────┘   │     └────────┘

В каждой итерации выполняются два синхронных батча:

  1. Шаг 1: B = 1, A = 1 + i * 2
  2. Шаг 2: A = 2 + i * 2, B = 2

Здесь заложены две архитектурные проверки:

  1. Ленивое отсечение невостребованной ветки (C E % 2): На первом шаге A и B нечётные, поэтому C = 1 + 1 = 2 (истинно). В выражении C E % 2 правая часть не вычисляется. Хотя узел E напрямую зависит от A и D, его значение никому не нужно. Если движок откладывает вычисления до фактического чтения (Pull / Hybrid Push-Pull), он пропустит hard() в узле E. Движки со статическим графом (вроде combine в Effector) вынуждены пересчитывать E на каждом шаге.

  2. Структурное гашение пересоздаваемых массивов (D): Узел D вычисляется по формуле:

    numbers.map(i => ({ x: i + A%2 - B%2 }))
    • На старте (A=0, B=0): 0 - 0 = 0
    • На шаге 1 (A=1, B=1): 1 - 1 = 0
    • На шаге 2 (A=2, B=2): 2 - 2 = 0

На каждом шаге D возвращает новую ссылку на массив, но содержимое элементов { x } остаётся прежним. Без структурного компаратора узел F и эффект J будут перезапускаться вхолостую.

Теоретический минимум вызовов hard() за два шага составляет 3 вызова: H на первом шаге и E, H на втором.

Почему глубокий equals не стоит вшивать по умолчанию

В $mol структурное сравнение ($mol_compare_deep) встроено в каждый атом по умолчанию. В большинстве других движков (SolidJS, Preact Signals, Angular Signals, MobX, @pravosleva/reactive-engine) базовым сравнением остаётся быстрый Object.is, а глубокое сравнение подключается опционально.

Причина проста: рекурсивный обход объектов и массивов имеет свою цену. В сьютах с частыми обновлениями крупных списков или графов без пересоздания DTO встроенный deepEqual начинает тратить заметное процессорное время даже там, где ссылки не менялись или менялись намеренно.

Поэтому в @pravosleva/reactive-engine мы оставили Object.is в горячем пути по умолчанию (нулевые накладные расходы), но добавили опцию { equals } в computed и signal, а также экспортировали готовые хелперы shallowEqual и deepEqual (с защитой от циклических ссылок через WeakMap):

import { ReactiveEngine, deepEqual as equals } from '@pravosleva/reactive-engine'

const engine = new ReactiveEngine()
const A = engine.signal(0)
const B = engine.signal(0)

const C = engine.computed(() => (A.value % 2) + (B.value % 2))
const D = engine.computed(
  () => numbers.map((i) => ({ x: i + (A.value % 2) - (B.value % 2) })),
  { equals }
)

Устройство стенда mol-collider-benchmark

Чтобы исключить влияние браузерных расширений и ручных замеров, весь пайплайн в репозитории mol-collider-benchmark автоматизирован одной командой:

bash bench.sh

Что произойдет:

  1. Прогрев V8 JIT: Перед замером каждый движок выполняет 500 прогревочных итераций. Это позволяет V8 перевести горячие функции в оптимизированный машинный код и стабилизировать скрытые классы.
  2. Серия из 3 прогонов (в результате которых будет получено Best Time): Каждый движок прогоняется 3 раза по 5 000 двухшаговых итераций. В итоговую таблицу попадает минимальное время, что отсекает случайные фоновые прерывания планировщика ОС и троттлинг CPU.
  3. Замер памяти node --expose-gc 👇
    • Alloc (B/iter) - объём временных аллокаций в куче V8 за одну итерацию до вызова сборщика мусора;
    • Retained (B/iter) - остаточный прирост памяти в пересчёте на итерацию после принудительного двойного вызова global.gc();
  4. Автогенерация артефактов: После прогона run.mjs сохраняет сырой слепок в ./results/last-benchmark.json, скрипт generate-svg.mjs рендерит векторную диаграмму ./results/last-benchmark.svg, а update-readme.mjs обновляет сводную таблицу в README.md.

Результаты замеров

Более подробно можно ознакомиться здесь: https://github.com/pravosleva/mol-collider-benchmark

Среда выполнения: Node.js v22.20.0 (linux x64), Intel Core i7-8550U @ 1.80GHz, 5 000 итераций × 3 прогона.

Первая четверка будет всегда в топе, обмениваясь местами с разницей в несколько микросекунд за одну 2-шаговую итерацию, что является нормальным фоновым джиттером планировщика Linux на ноутбуке. Что примечательно, $mol всегда пятый.

Поясняющие детали

  • hard() calls - количество и порядок вызовов fib(18) за одну 2-шаговую итерацию. Теоретический минимум - 3 (H,E,H)
  • Best Time (ms) - минимальное время выполнения 5 000 итераций из 3 прогонов после JIT-прогрева V8 (меньше — лучше);
  • ops/sec - пропускная способность в полных двухшаговых итерациях в секунду (больше - лучше);
  • Alloc (B/iter) - объём временных аллокаций в куче V8 за одну итерацию до сборки мусора (включает пересоздание массива из 5 объектов в узле D и внутренние структуры планировщика движка);
  • Ratio - отношение Best Time текущего движка к лучшему результату в таблице (1.00× — лидер прогона).