TOPZNANIE

Цифровая практика без сложностей

Выберите город
MET Norway · CC BY 4.0
← На главную

· Общий обзор

Говорят «Реактивность не бесплатна»

И первым делом добавляют в язык GC, с подсчетом ссылок в куче и оптимизируют “stop the world”. Мы же сегодня задумаемся не об оптимизации байтиков, а об оптимизации архитектуры.

Но у нас же уже есть безопасный яп дома, папа!

Да, Rust экономит на сборщике мусора, но чето он слишком сложный: borrow checker, лайфтаймы и отдельная возня, как только объекты складываются в граф. Zig отдаёт память программисту, как и С, плюсы. Остальные живут с GC и его издержками.

Предлагаю попробовать добавить реактивность в это семейство.

Реактивный граф всегда знает, что и кого нужно дропнуть, а сборщик выясняет то же самое только обходом кучи. Значит, граф может сам освобождать память и ресурсы, и сборщик ему не нужен. Это мой эксперимент исследовательская деятельность: я попробовал сделать язык wire, где есть только граф. И конечно сделал замеры. Наглядный пример:

Excel, самый популярный реактивный ЯП в мире

Формулы в Excel это чисто функциональная программа, а с LAMBDA ещё и полная по Тьюрингу. Excel строит дерево зависимостей между ячейками, изменили ячейку — всё зависимое помечается dirty и пересчитывается. Никто не подписывается на A1 и никто от неё не отписывается, ссылка в формуле и есть подписка. Стёрли формулу и её зависимости исчезли вместе с ней. Сборщика мусора для формул там нет и никогда не было. Им бы только виртуальный рендеринг добавить

Бухгалтеры так живут с VisiCalc 1979 года. А мы пишем subscribe() в каждом компоненте.

Откуда реактивные ноги растут

У Алана Кэя в Smalltalk главное это сообщения и позднее связывание, он так сформулировал в письме 2003 года: «OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things». Кто ответит решается в момент обращения, но актуальность состояния поддерживают руками, MVC придумали чтобы удобнее контролировать состояние как раз. Pull-реактивность доводит позднее связывание до значения: сколько это равно, тоже решается в момент обращения.

Дмитрий Карловский в 2017 году назвал эту парадигму Объектно Реактивным Программированием (ОРП). Метод при вызове запоминает что прочитал, кеширует результат и сбрасывает кеш когда прочитанное поменялось.

Сборщик не всегда спасает от утечек

Граф знает что значение больше никто не читает, он может не только выкинуть кеш, но и закрыть то что за этим значением стоит: сокет, таймер или подписку. Сборщик так не умеет. Для него важна только достижимость, а подписка держит замыкание, замыкание держит компонент, и всё это прекрасно достижимо хотя никому не нужно)

Сборщик убирает память и ничего не знает про сокеты, файлы и таймеры. В Java для этого был finalize(), его признали ошибкой, и с Java 18 (JEP 421) финализацию собираются удалить. Поэтому в языках со сборщиком ресурсы закрывают руками: try-with-resources, using, defer.

Отдадим должное Erlang. Процесс владеет своими портами и ETS-таблицами, умер процесс и всё его закрылось, куча у каждого процесса своя, поэтому общего stop-the-world нет. Косяк в том, что рантайм не знает нужен ли кому то этот процесс. Еще и руками нужно значения проталкивать

Аутбокс это костыль, который нам навязали

Типичный кейс: сервис заказов пишет в базу и событие в Кафку, между двумя записями падает, это dual write. Лечат это через transactional outbox: событие кладут в таблицу той же транзакцией, а воркер фоном шлёт его в Кафку. Потом кто-то читает из Кафки и пишет свой аутбокс, чтобы отослать данные дальше. И так далее и так далее…

А зачем всё это? Например, складу нужно знать сколько соли свободно. Это просто «было минус заказали». В Excel это одна формула со ссылкой на ячейку с заказами. На бэке вместо ссылки цепочка из таблиц, воркеров и Кафки, только чтобы склад узнал, что заказы поменялись. Ещё и следят, чтобы одно событие не пришло дважды, а то два раза спишется.

На wire остаток читает заказы, как формула ячейку:

object $bog_wire_salt_orders { solid ids( next?: list text ) { return next ?? [] } solid order( id: text, next?: int ) { return next ?? 0 } sum(): int { return ids.map( order ).sum } action add( id: text, count: int ) { ids( [ …ids, id ] ) order( id, count ) } } object $bog_wire_salt_balance { orders: $bog_wire_salt_orders total(): int { return 10 } free(): int { return total — orders.sum } } object $bog_wire_salt { solid orders() { return $bog_wire_salt_orders() } solid balance() { return $bog_wire_salt_balance { orders <= orders } } } object $bog_wire_salt_app { solid salt() { return $bog_wire_salt() } action main() { salt.orders.add( «o1», 3 ) salt.orders.add( «o2», 2 ) print( «свободно {salt.balance.free}» ) \ свободно 5 salt.orders.order( «o2», 5 ) print( «свободно {salt.balance.free}» ) \ свободно 2 salt.orders.order( «o1», 0 ) print( «свободно {salt.balance.free}» ) \ свободно 5 } }

Нативная программа на wire начинается с action main().

order это канал, как в $mol. Один метод и читает, и пишет:

  • order( «o2» ) читает заказ, а если его не было, отдаёт 0;

  • order( «o2», 5 ) записывает 5, и всё, что читало этот заказ, пересчитается.

Откуда balance берёт заказы? orders: $bog_wire_salt_orders это свойство без тела, его задаёт владелец через orders <= orders, как в view.tree.

free считается, когда его читают. Поменяли заказ, и следующий print выводит новое число. Событий нет, дублей нет.

Отмена это просто order( «o1», 0 ), без «компенсацииСАГИ» и прочей ерунды.

Пример лежит в репозитории, вместе с тестами.

wire: реактивный ЯП без GC

Реализация реактивности взята из $mol_wire, но там TS всё таки, невозможно полностью на реактивный граф перейти: переменную или таймер всегда можно завести мимо него. Поэтому я сделал wire, там мимо графа ничего не положить:

  • переменных нет, лямбд нет, в map, find, upsert передаются именованные методы;

  • состояние это параметр next?, писать в него можно только из action;

  • тела мемо чистые, это проверяет компилятор;

  • solid это модификатор метода, а не вызов где-то в теле.

Ссылка на объект может лежать только в значении метода, значит граф видит каждую. Объект принадлежит первому атому, который его вернул, и умирает вместе с ним. Значения неизменяемые и считаются счётчиком ссылок, цикл из неизменяемых значений не собрать, так что он не течёт.

Компилятор на TS, генерирует C и собирает его zig cc. Каждый метод становится обычной функцией, вся реактивность сидит в wire_read. Вот free из примера с солью:

static void F_bog_wire_salt_balance__free( wire_obj* self, const wire_val* keys, const wire_val* next, wire_val* out ) { wire_val t77 = wire_read( self, &M_bog_wire_salt_balance__total, NULL, NULL ); wire_val t79 = wire_read( self, &M_bog_wire_salt_balance__orders, NULL, NULL ); wire_val t80 = wire_read( t79.obj, &M_bog_wire_salt_orders__sum, NULL, NULL ); wire_val t76 = { .i = t77.i — t80.i }; *out = t76; }

Это free(): int { return total — orders.sum }. Так можно писать и руками на C против rt/rt.h, язык нужен только чтобы компилятор не дал завести таймер мимо графа)

Весь «сборщик мусора» рантайма:

static void reap( void ) { while( rt.touched.len || rt.orphans.len ) { wire_ids touched = ids_take( &rt.touched ); for( int i = 0; i < touched.len; ++i ) evict( touched.items[ i ] ); ids_free( &touched ); wire_ids orphans = ids_take( &rt.orphans ); for( int i = 0; i < orphans.len; ++i ) { wire_node* node = get( orphans.items[ i ] ); if( node && !node->has_owner && !node->root ) destroy( orphans.items[ i ] ); } ids_free( &orphans ); } }

Никакого обхода кучи: рантайм смотрит только на узлы, которые тронули в этом такте, и на тех, кто остался без владельца.

Сколько это стоит

Сделал бенч с солью: список ids и канал order( id ) на каждый заказ. 10 000 заказов добавить, перезаписать, отменить и после каждой фазы посчитать сумму. На каждый заказ создаётся строка, которая читает свой заказ и должна умереть после отмены. Одно и то же на пяти стеках:

  • wire, граф без сборщика;

  • rust-wire, Rust с моим wire.rs, тот же граф на арене;

  • Node.js с $mol_wire, тот же граф поверх сборщика;

  • Go обычным push: подписка на заказ и ручная отписка при отмене;

  • Rust без всякой реактивности: вектор, словарь и цикл.

Процессор померил в инструкциях, память по пику занятой оперативки. macOS, arm64:

  • wire: 5,5 млрд инструкций, 24 МБ памяти;

  • rust-wire: 3,2 млрд инструкций, 19 МБ;

  • Node.js: 523 млрд инструкций, 385 МБ;

  • Go: 0,12 млрд инструкций, 10 МБ;

  • Rust: 0,45 млрд инструкций, 2,8 МБ.

После всех отмен живых строк ноль на всех стеках, то есть утечек нет нигде.

Репо: wire/bench

Ноду легко обогнать) а вот Go быстрее wire в 46 раз. Часть этого разрыва в самом бенче: в графе ids( [ …ids, id ] ) копирует весь список на каждом добавлении, а отмена вычёркивает заказ проходом по списку, тогда как Go правит сумму на разницу. Остальное это цена графа: каждое чтение идёт через wire_read и узел атома. Куча работы ещё в общем

Где граф не поможет

Граф освобождает то, что стало ненужным. Иногда нужно держать по другой политике: кеш «пока хватает памяти», предзагрузка ассетов до того, как их кто-то прочитал, вариации анимаций, которые вот-вот понадобятся. Такую политику всё равно придётся описать, граф её не угадает. Описать её можно тоже реактивно, «что лежит в очереди, то и загружено», но думать о ней придётся.

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

Реактивность не бесплатна ?

Нет, как и GC. Я вижу большой потенциал для развития, а вы ? Пишите в комментариях

На Rust есть демо. Потом хочу сделать что то подобное на Go, С, С++, Zig

Кого начать препарировать первым ?)

Пишу про реактивность, $mol и свой язык в тг-канале @Dev_cmuser

Только зарегистрированные пользователи могут участвовать в опросе. Войдите, пожалуйста.Нравиться ли вам идея с реактивными ЯП?0%да00%нет0 Никто еще не голосовал. Воздержавшихся нет. Теги:

  • reactivity
  • $mol
  • compiler
  • computer science

Хабы:

  • $mol
  • Компиляторы
  • Ненормальное программирование
  • ООП
  • Программирование