Аннотация
Приложения платят за изоляцию скоростью: отдельные процессы, обмен сообщениями, сериализация и копии буферов на каждой границе. В предлагаемой архитектуре приложение только описывает, какие данные в какие должны превратиться, а считают чистые функции-пакеты в общей памяти, разделённые аппаратными ключами защиты памяти. Оркестратор один раз собирает план вызовов, подбирает бинарник под процессор, кэширует результаты для всех приложений и откатывается на стабильную реализацию при сбое. Разбираем, как это устроено, что оно даёт и где конструкция трещит.
Цена изоляции
Изоляция в привычных системах покупается за скорость. Каждый компонент, который хочется оградить от соседнего, отправляется в отдельный процесс, а вместе с ним появляются обмен сообщениями, сериализация и копирование буферов. На границе двух модулей, которые в монолите обменялись бы указателем, вдруг возникает очередь, формат сообщения и несколько копий одних и тех же данных. Плата взимается на каждом вызове, даже когда оба компонента написаны одним человеком и живут в одном приложении.
При этом сама по себе граница между компонентами не требует отдельного адресного пространства. Нужно не «другая память», а запрет читать и писать чужую, и такой запрет современные процессоры умеют накладывать аппаратно — ключами защиты памяти. Ключ действует в пределах потока и переключается одной инструкцией, без системного вызова и без смены таблиц страниц. Значит, изоляцию можно получить там же, где идёт вычисление, не вынося компонент в отдельный процесс.
Дальше возникает вопрос: если компоненты больше не разделены процессами, что мешает им залезть в чужое состояние? Ответ — не доверие к автору кода, а модель вычислений: компонент получает данные на вход и отдаёт результат, не имея ни глобального состояния, ни доступа к файлам и сети. Из этого ограничения и вырастает вся конструкция, о которой пойдёт речь.
Приложение, которое ничего не считает
В предлагаемой модели приложение не содержит логики преобразования данных. Оно владеет локальным состоянием — переменными, настройками, историей вычислений — и формулирует запрос: вот такие данные, вот такой тип результата. Как именно результат будет получен, приложение не знает и знать не должно. Это переворачивает привычную роль кода: вместо последовательности вызовов мы описываем цель, а маршрут к ней прокладывает система.
Считают пакеты — чистые функции вида «входные данные → выходные данные». У пакета нет глобального состояния, файловой системы и сети, поэтому его результат определяется только входом. Это не пожелание к стилю кода, а контракт, нарушение которого аппаратура пресекает на месте. Взамен пакет получает право на бессрочное переиспользование: если такой вход уже где-то считали, считать второй раз незачем.
Связывает всё это система типов. Каждый тип данных описан строго и опознаётся по глобальному идентификатору, а граф вычислений никто не рисует вручную: оркестратор собирает его сам, сопоставляя идентификаторы входов и выходов доступных пакетов. Нужен звук другой частоты дискретизации, а следом фильтр — цепочка соберётся из тех пакетов, у которых типы стыкуются. Приложение при этом не называет ни одного пакета по имени.
Пакет как единица поставки
Пакет поставляется целиком и самодостаточно. В манифесте лежат идентификаторы входных и выходных типов, метаданные, версия и криптографическая подпись: по ним оркестратор понимает, куда пакет можно поставить и можно ли ему верить. Рядом с манифестом не один бинарник, а набор — одна и та же логика, скомпилированная под разные уровни возможностей процессора. Базовый вариант работает везде, следующий использует векторные инструкции AVX2, самый быстрый — AVX-512 или ARM NEON.
{
"package": "audio.resample",
"version": "1.4.2",
"inputs": ["9f1c…:pcm.f32", "3ab7…:rate.u32"],
"outputs": ["9f1c…:pcm.f32"],
"binaries": ["baseline", "avx2", "avx512", "neon"],
"signature": "ed25519:…"
}
Выбор делает оркестратор при сборке плана: он берёт самый быстрый бинарник из тех, что гарантированно запустятся на этом процессоре. Пропадает и сборка под минимальный общий знаменатель, и ручная пересборка под конкретную машину, и вечный вопрос пользователя, почему на его ноутбуке всё тормозит. Разница между обычным и векторным кодом на обработке звука или картинки — разы, и получать её автоматически приятнее, чем объяснять в readme, какую сборку скачать.
Сборка плана вместо разбора графа
Первый запрос или изменение набора пакетов запускает сборку плана исполнения. Оркестратор разрешает зависимости, подбирает реализации и бинарники, выстраивает порядок шагов и раздаёт данным фиксированные места в общей области памяти — арене. Каждый шаг после этого хранит указатель на функцию, смещения входа и выхода и ключ защиты. Вся работа по поиску и выбору заканчивается здесь, один раз.
Дальнейшее выполнение — проход по массиву шагов: переключить ключ, вызвать функцию по указателю, перейти к следующему. Ни поиска по именам, ни проверок совместимости типов, ни аллокаций в горячем пути: данные лежат там, где их положили, и передаются смещением, а не копией. По смыслу это ближе к линковке, чем к интерпретации: символы один раз разрешаются в адреса, дальше остаются только вызовы. Похожим образом СУБД один раз строит план запроса, чтобы не разбирать дерево на каждой строке.
struct Step {
void (*fn)(void const *in, void *out);
uint32_t in_offset, out_offset;
uint16_t key;
};
for (Step const &s : plan) {
set_key(s.key);
s.fn(arena + s.in_offset, arena + s.out_offset);
}
Генерации машинного кода здесь нет, и это стоит оговорить отдельно. Пакеты скомпилированы заранее, а «компилируется» только граф — в том смысле, что все решения принимаются один раз и застывают в плане. Настоящая склейка пакетов в одну функцию с инлайнингом между шагами возможна, но это отдельная задача, и смешивать её с планом не стоит.
Ключи защиты памяти вместо процессов
Изоляцию обеспечивают ключи защиты памяти: у Intel это инструкция WRPKRU, у ARM — расширение прав доступа с регистром POR_EL1. Страницы арены, отведённые под вход и выход текущего шага, помечаются своим ключом, а остальная память остаётся под другими. Активный набор прав живёт в регистре потока, поэтому переключение стоит одну инструкцию и не требует ни системного вызова, ни смены адресного пространства. Именно это отличает такой домен от процесса: граница есть, а платы за переход через неё почти нет.
Вызов выглядит так. Оркестратор переключает ключ потока, оставляя пакету доступ только к его входу и выходу, и передаёт управление по указателю. Пакет работает, и любая попытка прочитать состояние приложения или данные соседнего пакета упирается в аппаратный запрет — процессор сам поднимает ошибку. После возврата ключ сбрасывается, и следующий шаг получает уже свою пару страниц. Домен, таким образом, открыт не постоянно, а ровно на время вызова.
Цена вопроса — десятки тактов на переключение ключа туда и обратно. Это заметно больше, чем пустой вызов функции, и заметно меньше, чем поход в другой процесс через очередь сообщений с копированием буфера. Для цепочки из десятков шагов, которая гоняет мегабайты звука или кадров, разница между копией на каждой границе и смещением в арене решает всё.
Параллельные вычисления
Параллелизм здесь не прикручивается сбоку, а выпадает из самой модели. Граф уже разложен на шаги с явными зависимостями, поэтому оркестратор при сборке плана раскладывает их по волнам: всё, что не связано ребром, может считаться одновременно. Чистота пакетов снимает главную головную боль многопоточного кода — общего изменяемого состояния нет, а значит, нет и блокировок между шагами, нет гонок и нет недетерминированного результата. Порядок исполнения волн может отличаться от запуска к запуску, но результат остаётся тем же побайтово, и кэш по-прежнему не врёт.
Тонкость прячется в ключах защиты. Права доступа живут в регистре каждого потока, поэтому рабочий поток просто выставляет свой ключ перед вызовом — никакого общего состояния защиты и никаких системных вызовов. Но номер ключа записан в страницах, а страницы у всех потоков одни и те же: если два одновременно работающих пакета получат один номер, первый поток сможет читать страницы второго. Значит, параллельные домены обязаны жить под разными ключами, и шестнадцать доступных ключей ограничивают не только число доменов, но и ширину параллелизма. Смещения в арене при этом стоит выравнивать по линиям кэша, иначе соседние шаги начнут драться за одну линию, и вся экономия на отсутствии копий уйдёт в когерентность.
Отдельный вопрос — размер шага. Вызов по указателю стоит единицы наносекунд, а передача задачи другому потоку — заметно дороже, поэтому мелочь параллелить вредно: оркестратор использует уже собранную статистику стоимости шагов и решает, отдать ветку в пул потоков или выполнить её на месте, склеив цепочку мелких пакетов в одну волну. Второй ось параллелизма остаётся векторный код внутри пакета: набор бинарников под AVX-512 и NEON даёт параллелизм по данным, и на небольших массивах он часто выигрывает у любого разделения по потокам. Эти две оси оркестратор выбирает независимо, и обе достаются приложению бесплатно.
Общий кэш и интерфейс в параллельной картине ведут себя прилично. Если две ветки запросили одно и то же вычисление, считать его дважды незачем: первая ветка регистрирует ключ как «в работе», вторая ждёт готового результата — детерминизм делает такое ожидание безопасным. Конкурирующие реализации можно даже столкнуть лбами на одном входе и взять ту, что отработала быстрее, не боясь расхождения результатов. Цикл отрисовки при этом читает опубликованный неизменяемый снимок макета, пока рабочие потоки собирают следующий, — без блокировок и без остановки кадра, а сбой одного пакета откатывает его ветку, не трогая соседние.
Интерфейс как обычное преобразование
Интерфейс в этой модели ничем не привилегирован. Пакет визуализации принимает данные состояния и отдаёт дерево макета — описание того, что должно быть на экране, без единого вызова к графической системе. Шаг кэшируется и повторяется только тогда, когда данные изменились, поэтому статичный экран не стоит ничего. Отрисовкой занимается отдельный цикл внутри процесса: готовый макет передаётся движку по указателю, без копий и без обмена между процессами.
Обратно события идут тем же путём. Клик или ввод оркестратор превращает в новые входные данные, они меняют состояние приложения, и цикл замыкается. Получается, что и картинка на экране, и звук в буфере — результаты одинаковых по природе преобразований, с теми же правилами кэширования и изоляции. Побочный эффект приятный: интерфейс можно пересобрать другим пакетом, не трогая приложение.
Конкуренция реализаций и откат
Одно и то же преобразование типов могут предоставлять несколько пакетов, и это не конфликт, а штатный режим. Оркестратор выбирает между ними по общей статистике скорости и стабильности, а не по единственному «правильному» имени в манифесте. Новый пакет попадает в систему не вместо старого, а рядом с ним, и получает шанс показать себя на реальных данных. Так оптимизация перестаёт быть событием релиза и становится непрерывным процессом.
Сбой обрабатывается так же буднично. Если пакет полез за пределы своей памяти, оркестратор перехватывает SIGSEGV, возвращает указатели графа к предыдущей стабильной реализации и понижает рейтинг надёжности виновника. Приложение в этот момент теряет скорость, но не останавливается и не требует от пользователя ничего. Сравните с обычным сценарием, где падение одного плагина уносит весь процесс, а разбор полётов начинается с ручного отката версии.
Общий кэш результатов
Результаты всех вычислений попадают в общий кэш. Ключ — криптографический хеш от идентификатора типа результата и отсортированного списка идентификаторов входных данных. Он не привязан ни к приложению, ни к узлу графа, поэтому одинаковое вычисление из двух разных программ или из двух ветвей одного графа выполняется ровно один раз. Второй запрос просто получает готовый результат по указателю.
Работает это только потому, что пакеты чистые. Если бы результат зависел ещё и от скрытого состояния, времени суток или порядка вызовов, кэш начал бы врать, и вся конструкция потеряла бы смысл. Чистота здесь не эстетическое предпочтение, а условие, на котором держатся и кэш, и переиспользование, и безопасный откат на другую реализацию.
Бонус: языковая модель как ещё один клиент оркестратора
У этой архитектуры есть свойство, которое проявилось не сразу: она необычайно удобна для языковой модели. Каталог пакетов с манифестами — это готовый, машиночитаемый список инструментов с явно описанными входами и выходами, и модели не нужно писать код, чтобы им воспользоваться. Достаточно собрать запрос: такие данные на вход, такой тип результата на выход. Дальше работу делает оркестратор, а совместимость типов служит формальной проверкой ответа модели: если цепочка не стыкуется, она просто не соберётся, и это ловится до исполнения, а не в виде исключения посреди расчёта.
Интерфейс в такой схеме тоже становится ответом на задачу, а не заранее свёрстанной панелью. На просьбу «покажи, где за неделю вырос расход памяти» модель подбирает цепочку вычислений и пакет визуализации, а на выходе получается дерево макета под конкретный вопрос: нужный график, нужная таблица, нужные кнопки. Макет — это данные, поэтому он проходит те же правила кэширования и отрисовки, что и любой другой результат, и собирается ровно один раз на изменившиеся данные. Приложение перестаёт содержать все экраны на все случаи жизни: экран живёт ровно столько, сколько нужна задача, а удачные компоновки оседают в кэше и переиспользуются.
Самое приятное — цена ошибки. Модель по природе своей перебирает варианты, и в процессной архитектуре каждый пробный прогон стоил бы запуска, обмена сообщениями и копий буфера; здесь пробная цепочка исполняется в общей памяти под своим ключом, а при сбое указатели графа откатываются к стабильной реализации. Детерминизм и общий кэш делают повторные и параллельные попытки почти бесплатными, а план исполнения, будучи данными, можно показать пользователю, сохранить, воспроизвести и сравнить с прошлым. Поскольку пакеты чистые и побочных эффектов у них нет по контракту, все реальные действия сосредоточены на границе приложения — значит, и подтверждение пользователя требуется не на каждый вызов, а на узкий список операций, которые действительно меняют мир.
Где конструкция трещит
Ключи запрещают доступ к данным, но не запрещают коду пакета самому выполнить инструкцию переключения ключа и открыть себе всю память. Значит, бинарник придётся проверять до загрузки: и на такие инструкции, и на попытки уйти в чужой код. Без этого изоляция остаётся защитой от случайной ошибки, а не от злого умысла, и обещать большее нечестно. Шестнадцать ключей — это потолок не только для числа доменов, но и для числа одновременно исполняющихся пакетов, и на широком графе ключи приходится переиспользовать между волнами, аккуратно перекрашивая страницы арены.
Что в итоге
Конструкция снимает привычный выбор между скоростью и безопасностью там, где вычисления складываются в цепочки преобразований. План указателей даёт стоимость вызова, близкую к монолиту, набор бинарников вытаскивает из процессора то, что он умеет, а ключи защиты памяти ставят границу между компонентами без процессов и копий. Взамен приходится принять строгую модель: чистые функции, строгие типы, отказ от скрытого состояния — и честно оговорить границы доверия.
Интереснее всего это там, где надёжность и скорость нужны одновременно: научные вычисления, звук и видео в реальном времени, сложные интерфейсы, периферийные устройства на разнородном железе.
Комментарии 0