Процессы flang поехали на настоящей BEAM: печать в Elixir и сверка по набору исходов

Процесс flang печатается в GenServer, надзор — в дерево супервизоров OTP,
почтовый ящик — в почтовый ящик процесса BEAM. Своей машины под конкурентность
не пишется: контракт (flang/conc/SPEC.md, «Свою BEAM писать не надо») решает
печатать в чужую, и вытеснение по счёту редукций, куча со своим сборщиком у
каждого процесса, планировщик на каждое ядро и горячая загрузка достаются в
настоящем виде, а не в приблизительном.

ТРИ СУПЕРВИЗОРА OTP НА ОДИН НАДЗОР FLANG — не нагромождение, а перевод. У OTP
интенсивность перезапусков принадлежит супервизору, а в flang стратегия названа
за каждым ребёнком по отдельности, и «передать выше» настройкой ребёнка не
выражается вовсе. Поэтому дети «перезапустить» живут под супервизором с порогом
отказов, дети «передать выше» — под супервизором с интенсивностью 0 (первое же
падение обязывает его перезапустить, а перезапускать нельзя — он умирает и
уносит надзор наверх), дети «остановить» — :temporary напрямую. Процесс при этом
:transient, а не :permanent: остановка «норма» обязана оставить его
остановленным. Вложенный надзор наоборот :permanent: умирает он с причиной
:shutdown, а её :transient считает нормальным концом.

«Продолжить» совпало с BEAM точно: handle_continue выполняется перед любым
сообщением из ящика, но уже после возврата обработчика — ровно «в голову ящика,
отдав управление». Притворяться не пришлось ничем.

Ящик, переживающий перезапуск, пришлось печатать руками: на BEAM он умирает
вместе с процессом, а контракт обещает обратное. Умирающий процесс вычерпывает
остаток в хранилище, следующее воплощение забирает его в init. Без этого прогон
«третий отказ в окне» дал бы один отказ вместо трёх.

Запас витков остался, и это решение, а не инерция. Вытеснение спасает соседей, а
не сам процесс: незавершающийся обработчик на BEAM не остановится никогда — он
съест память узла, и никакого исхода из этого не следует, а контракт требует
именно исхода. Счётчик при этом лежит в словаре процесса, а словарь у процесса
BEAM свой: два обработчика не мешают друг другу по устройству, а не по
договорённости.

СВЕРКА. Сравнивать значения нельзя: семантика — любое чередование атомарных
пробегов, а семени у планировщика BEAM нет. Поэтому эталон гоняется на тысяче
семян, из итогов собирается множество исходов и множество журналов доставки, и
каждый запуск на настоящей BEAM обязан в них попасть. Отдельно проверено, что
множество насыщено (половина сетки даёт тот же набор) и узко (изменение одного
числа выводит исход из набора; наборы разных прогонов не пересекаются).

Измерение, которого в контракте не было: редукционный квант BEAM много больше
пробега обработчика. На race.flang сорок запусков дают одно чередование, а
триста — четыре, и все четыре лежат в наборе эталона из 84. Значит сверка
доказывает включение, а не покрытие, и перебор семян прогоном на настоящей
машине не заменяется.

Что не влезло и записано в контракт: остальные семь целей процессов не печатают;
порог отказов у OTP считает только перезапуски одной группы, а окно измеряется
секундами, а не пробегами; таймер идёт по настоящим часам, и журнал программы с
таймером поэтому не сверяется; «покой» на BEAM — вывод из наблюдения, а не
знание; между смертью процесса и регистрацией нового воплощения есть окно, в
котором сообщение пропадает; ожидания прогона в напечатанный код не едут, потому
что они про одно чередование, а на BEAM законно любое.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01P6ehGNnEcrkCK1V5iMHNYi

Author: Marat Zimnurov

README.md

@@ -658,7 +658,7 @@ in [`flang/cat/SPEC.md`](flang/cat/SPEC.md) and are not implemented.
 
 ---
 
-## Concurrency: two steps of seven
+## Concurrency: four steps of seven
 
 Values are immutable by construction, so two computations looking at one value cannot interfere:
 there are no data races to lose, because there is nothing to build one out of. What the language
@@ -699,14 +699,32 @@ flang test flang/conc/examples/counter.flang --pretty
 ```
 
 The contract is [`flang/conc/SPEC.md`](flang/conc/SPEC.md), and it names a seven-step plan of
-which **steps one, two and three are done**: the surface, the checks, the reference scheduler and
-supervision. Strategies are applied for real: a restart returns the state to the very same initial
-value, the failure threshold is counted in the scheduler's virtual time, and "escalate" reaches the
-supervisor one step up — or, if there is none above, stops the whole program with the outcome
-`"отказ дошёл доверху"`. Processes are not printed into any target — emitting such a program gives
-the handlers as ordinary functions and nothing more. The examples are in
+which **the first four are done**: the surface, the checks, the reference scheduler, supervision
+and emission to Elixir. Strategies are applied for real: a restart returns the state to the very
+same initial value, the failure threshold is counted in the scheduler's virtual time, and
+"escalate" reaches the supervisor one step up — or, if there is none above, stops the whole program
+with the outcome `"отказ дошёл доверху"`. The examples are in
 [`flang/conc/examples/`](flang/conc/examples).
 
+No virtual machine is being written for this: the language already targets **Elixir**, so a flang
+process is printed as a BEAM process and supervision as an OTP supervisor tree. Preemption by
+reduction count, a heap with its own collector per process, a scheduler per core, distribution and
+hot code loading all come for real, not approximately.
+
+```bash
+flang emit flang/conc/examples/counter.flang --target elixir --out /tmp/counter
+cd /tmp/counter && make build
+echo '{"run":"два прибавления и доклад"}' | elixir -pa _build -e 'Flang.Cli.main(["SchyotchikIZhurnal"])'
+```
+
+The emitted program cannot be checked against the reference by value: the semantics is *any*
+interleaving of atomic handler runs, and the BEAM scheduler takes no seed. So the check is on the
+*set*: the reference sweeps a thousand seeds to build the set of outcomes and the set of delivery
+logs, and every outcome of a real BEAM run must land inside it. Both weak spots are covered — the
+set is shown to be saturated (half the seed grid gives the same set) and narrow (change one number
+in an outcome and it falls out). The other seven targets do not print processes yet: there, a
+program with `процесс` gives the handlers as ordinary functions and nothing more.
+
 ---
 
 ## The shell and the language server

README.ru.md

@@ -671,7 +671,7 @@ FLANG_COMPOSE_MISMATCH: композиция «оформить» не стык
 
 ---
 
-## Конкурентность: два шага из семи
+## Конкурентность: четыре шага из семи
 
 Значения неизменяемы по устройству, поэтому два вычисления, глядящие на одно значение, не могут
 помешать друг другу: гонок по данным нет не потому, что их ловит анализ, а потому, что их нечем
@@ -712,13 +712,30 @@ flang test flang/conc/examples/counter.flang --pretty
 ```
 
 Контракт — [`flang/conc/SPEC.md`](flang/conc/SPEC.md), и в нём порядок работ из семи шагов, из
-которых **сделаны первый, второй и третий**: поверхность, проверки, планировщик эталона и надзор.
-Стратегии применяются по-настоящему: перезапуск возвращает состояние к тому же самому начальному
-значению, порог отказов считается по виртуальному времени, «передать выше» доходит до надзора
-ступенью выше, а если выше никого — останавливает всю программу с исходом
-`"отказ дошёл доверху"`. Процессы не печатаются ни в одну цель: печать такой программы даёт
-обработчики как обычные функции и больше ничего. Примеры лежат в
-[`flang/conc/examples/`](flang/conc/examples).
+которых **сделаны первые четыре**: поверхность, проверки, планировщик эталона, надзор и печать в
+Elixir. Стратегии применяются по-настоящему: перезапуск возвращает состояние к тому же самому
+начальному значению, порог отказов считается по виртуальному времени, «передать выше» доходит до
+надзора ступенью выше, а если выше никого — останавливает всю программу с исходом
+`"отказ дошёл доверху"`. Примеры лежат в [`flang/conc/examples/`](flang/conc/examples).
+
+Своей виртуальной машины под это не пишется: у языка уже есть цель **Elixir**, и процесс flang
+печатается в процесс BEAM, а надзор — в дерево супервизоров OTP. Вытеснение по счёту редукций,
+куча со своим сборщиком у каждого процесса, планировщик на каждое ядро, распределённость и горячая
+загрузка достаются при этом в настоящем виде, а не в приблизительном.
+
+```bash
+flang emit flang/conc/examples/counter.flang --target elixir --out /tmp/счётчик
+cd /tmp/счётчик && make build
+echo '{"run":"два прибавления и доклад"}' | elixir -pa _build -e 'Flang.Cli.main(["SchyotchikIZhurnal"])'
+```
+
+Сверять напечатанное с эталоном по значению нельзя: семантика определена **любым** чередованием
+атомарных пробегов, а семени у планировщика BEAM нет. Поэтому сверяется набор: эталон на тысяче
+семян даёт множество исходов и множество журналов доставки, и каждый исход настоящего запуска на
+BEAM обязан в это множество попасть. Проверено и то, что множество насыщено (половина сетки семян
+даёт тот же набор), и то, что оно узко (достаточно изменить в исходе одно число, и он из набора
+выпадает). Остальные семь целей процессов пока не печатают: там программа с `процесс` даёт
+обработчики как обычные функции и больше ничего.
 
 ---