Почему лимит памяти нужно держать вне процесса
Проектная записка из mlx-guard: чего не может обещать защита памяти внутри процесса на единой
памяти Apple и какой внешний супервизор построен для внешнего кольца
Обновление от 2026-11-13: что изменилось в mlx-guard с 0.2 по 0.5
Вывод остаётся в силе и для mlx-guard v0.5.0 (опубликован 2026-11-12): лимит должен жить вне
процесса. Основной текст описывает v0.1.0; более поздние версии в нём не рассматриваются.
В 0.2.0 изменились три вещи (список изменений). Тайм-аут подтверждения кооперативного checkpoint вырос со 100 ms до 1 s. Код выхода 70 по-прежнему означает отказ супервизора, но дочерний процесс, который завершился до первой проверки идентичности, теперь сохраняет собственный статус. Теперь pid и метка запуска проверяются заново непосредственно перед доставкой сигнала checkpoint; TERM и KILL, как и раньше, отправляются группе процессов по её номеру (управление процессами).
На том же M1 Max ошибка видимого приращения footprint (памяти процесса по учёту ОС) для буфера Metal в 64 MiB составила 1.929% на v0.1.0, 4.028% на 0.3.1 и 3.272% на 0.5.0 (пакет измерений) при границе в 10%. Модуль опроса с интервалом 50 ms занимал от 2.58% до 2.89% одного ядра CPU в шести 30-минутных отладочных прогонах на macOS 27.2. Четыре самых ранних прогона не уложились в действовавшую тогда границу в 2%; один из них шёл на сборке 0.3.1, так что рост нельзя списать только на код 0.5.0. Причина не установлена, и целевого значения у этой величины теперь нет. Остальные строки пакета отличаются на величины, малые по сравнению с их целевыми значениями.
README называет один отказ, о котором основной текст не говорит: ошибку драйвера IOGPU, из-за которой macOS 26.4 и новее под нагрузками Metal падает в kernel panic (панику ядра ОС). По данным README, на конец августа 2026 года ошибка не исправлена. Она может сработать, когда footprint заведомо укладывается в любой лимит, и никакой внешний супервизор до неё не дотянется (ограничения).
Рабочая нагрузка на MLX, у которой память пошла вразнос, не падает вежливо. На единой памяти
(unified memory) процесс, оконный сервер и GPU-драйвер ядра ОС черпают из одного пула. Прогон,
который вычерпал этот пул до дна, может закончиться лавиной подкачки, зависшей машиной или kernel
panic, а не ошибкой выделения памяти, которую нагрузка могла бы перехватить. Отсюда записка выводит
одно проектное утверждение: последний рубеж защиты от вышедшей из-под контроля нагрузки не может
находиться внутри её собственного процесса. Им должен быть отдельный супервизор, который следит за
числом, начисляемым операционной системой, владеет группой процессов и переживает нагрузку, чтобы
записать, что произошло. mlx-guard — инструмент, построенный
вокруг этого утверждения, а здесь изложены доводы в пользу его устройства, включая те части задачи,
которые проект сознательно не берётся решать.
Записка документальная. Каждое измерение mlx-guard в основном тексте взято из пакета измерений,
зафиксированного в репозитории на v0.1.0 (на каждый есть ссылка). Это ограниченный калибровочный
прогон на 10-ядерном Apple M1 Max с 32 GB единой памяти, macOS 26.6.1
(пакет эталонного хоста),
и ограниченный прогон интеграции с потребителем на той же записанной конфигурации с MLX 0.32.0 и
mlx-lm 0.31.3
(пакет интеграции).
Для этой записки ничего не перезапускалось. Цифры инцидентов в разделе 1 принадлежат авторам
исходных отчётов, здесь их не измеряли. В основном тексте ссылки на исходники, контракты и данные
mlx-guard привязаны к публичному тегу v0.1.0. Исключение — оговорка о SIGKILL для супервизора в
разделе 4: она, как и источники обновления, приведена по тегу v0.5.0. Рисунок 1 и его исходник
PlantUML берутся из main, а сопутствующие записки и issues в апстриме даны по их публичным адресам.
1. Два публичных инцидента, одна картина отказа
Два независимых отчёта о проблемах в стеке MLX очерчивают задачу лучше любой синтетической демонстрации.
В MLX issue #3896 потоковая нагрузка, считавшая
карты значимости (saliency) для MoE-модели (mixture-of-experts) на 198 миллиардов параметров, следила
за памятью собственным счётчиком фреймворка. mx.get_peak_memory() показывал примерно 46 GB, а
утилита macOS footprint — примерно 109 GB выделений IOAccelerator (GPU) и phys_footprint
(собственный учёт ОС: сколько памяти держит процесс) примерно в 110 GB, то есть занижение
примерно в 2.4×. Из-за того, что этому счётчику доверяли как сигналу давления на память, процесс
дважды вышел за безопасный рабочий набор машины: один раз дело кончилось тайм-аутом GPU watchdog
(сторожевого таймера GPU) на командном буфере Metal, другой — полной жёсткой перезагрузкой.
Этот issue закрыт, и загадки в объяснении нет. get_peak_memory() учитывает только активные байты
аллокатора, поэтому буферы, которые MLX удерживает в своём пуле кэша (всё ещё резидентные, всё ещё
«грязные» на GPU), в это число не попадают никогда. Мейнтейнер MLX закрыл отчёт с пояснением:
счётчик предназначен для измерения одной модели, где доля попаданий в кэш близка к 100%, а при
долгом или параллельном обслуживании запросов нужно читать get_active_memory() + get_cache_memory().
Тест одного из контрибьюторов с интенсивным перевыделением памяти показал, что эта пара отслеживает
цифру ОС с точностью до 0.14 GB — на прогоне, где пиковая память показывала 1.00 GB при footprint
в 60.19 GB. Исправление настоящее, но исправлено чтение: даже исправленный счётчик описывает
аллокатор одного процесса и по-прежнему работает внутри процесса, за которым должен надзирать.
Эксплуатационный урок от этого не меняется: любое решение, привязанное к счётчику, который эта
нагрузка на самом деле читала, принималось бы более чем на 60 GB ниже числа, которое операционная
система начисляла процессу.
В mlx-lm issue #883 экземпляр mlx_lm.server с
30B-моделью за долгую агентную сессию неограниченно наращивал KV-кэш. В момент падения footprint
процесса составлял 83.23 GB на машине с 96 GB, а 80.14 GB памяти были закреплены (wired):
такую память ОС не может вытеснить в подкачку. Машина упала в kernel panic в IOGPUMemory.cpp:550
(completeMemory() prepare count underflow) и принудительно перезагрузилась.
Ни один из инцидентов не контрольный эксперимент для какого-либо защитного инструмента, и записка не утверждает, что супервизор спас бы хоть одну из машин. Инциденты свидетельствуют о сигналах и границах. Первый показывает, что счётчик фреймворка и учёт ОС могут расходиться на десятки гигабайт как раз на тех нагрузках, которым лимит нужнее всего. Второй показывает, чем заполняется пустота, когда вне отказывающего процесса никакой границы нет.
2. Ограничение внутри процесса уже пробовали
Предшествующая статья, When an MLX Memory Cap Is Not a Safety Boundary, описывает машину для бенчмарков обучения, которая упала в kernel panic при установленных ограничениях памяти MLX, и внутрипроцессный watchdog, который проект добавил после этого; сама статья называет его защитой по мере возможности (best-effort). Её вывод: ограничение или watchdog внутри отказывающего процесса не является границей безопасности. Путь аварийной остановки, который должен быть надёжнее отказывающей нагрузки, не может быть потоком внутри неё. Это должен быть другой процесс.
3. Счётчик, за которым следят, — не тот счёт, который оплачивают
Внутрипроцессная защита почти всегда следит за счётчиками фреймворка: это те числа, которые процесс
видит дёшево. Какой именно счётчик она читает, важно. #3896 — как раз предостерегающий пример, и
чтение get_active_memory() + get_cache_memory() закрывает бо́льшую часть именно этого разрыва. Но
даже правильно прочитанная сумма аллокатора — это взгляд аллокатора на один процесс. Операционная
система ведёт собственный учёт для каждого процесса, phys_footprint, и в него входит не только то,
что выделил фреймворк: калибровка ниже видит в нём и обычное анонимное выделение, и буфер Metal.
Кроме того, этот учёт можно прочитать и для процессов, которыми фреймворк вообще не управляет:
загрузчика данных, сервиса токенизации, запущенного шага конвертации.
Контракт интеграции с mlx-train-perf
говорит то же самое о собственном внутрипроцессном запасном механизме того проекта: этот механизм
опрашивает только mx.get_active_memory(), кэш MLX — отдельный удерживаемый пул, которого этот
потолок может не увидеть, а всё, что ОС начисляет процессу сверх этого, покрывает footprint по учёту
ОС, который читает внешний супервизор.
Поэтому mlx-guard читает память так же, как ОС: phys_footprint через
proc_pid_rusage(RUSAGE_INFO_V0)
для каждого процесса, с суммированием по группе процессов, которой владеет супервизор. В v0.1
счётчики фреймворка не читаются вовсе, а общесистемные сигналы — давление на память, подкачка,
компрессор, суммарный объём закреплённой памяти — записываются как справочный контекст, а не как
входные данные для контроля: ни один из них нельзя отнести к контролируемой команде. Порог
сравнивается с суммой phys_footprint всех участников группы супервизора. Страницы, общие для
нескольких процессов дерева, в этой сумме могут учитываться дважды, и контракты подают её как
воспроизводимый вход для решения о вмешательстве, а не как число уникальных страниц.
Калибровка v0.1.0, зафиксированная в репозитории, оценивает погрешность этого выбора на эталонном хосте под macOS 26.6.1: наибольшая наблюдаемая ошибка составила 0.073% на анонимном выделении в 64 MiB и, по десяти прогонам, 1.929% на видимом приращении footprint для буфера Metal в 64 MiB. Это максимумы ограниченного прогона на одной машине, а не статистические и не межхостовые границы. Сигнал не идеален (его пределам посвящён раздел 8), но это правильная величина, проверенная на известных выделениях.
4. Защита гибнет вместе с тем, что защищает
Если поместить цикл контроля внутрь процесса, он унаследует худшие моменты этого процесса. Цикл работает в потоке того же адресного пространства, его планирует та же задыхающаяся машина, его убивает тот же SIGKILL. А именно, внутрипроцессная защита:
- не может пережить процесс, чтобы рассказать, что случилось. После OOM-kill, падения или паники не остаётся потока, который написал бы отчёт. Данные для разбора — что росло, как быстро, что решила защита, пытались ли завершить процесс — умирают вместе с процессом, то есть ровно тогда, когда они нужны.
- зависит от планировщика той самой машины, которую должна защищать. Во время лавины подкачки watchdog — всего лишь ещё один поток процесса, который сам упирается в страничные отказы, и приоритета над нагрузкой, за которой он следит, у него нет. Ни один опубликованный прогон не показывает watchdog, которому нехватка процессорного времени помешала прервать работу, но ничто в устройстве этого не исключает.
- охраняет один процесс. Программа запуска бенчмарков, пул загрузчиков данных или запущенный шаг конвертации — это дерево процессов; лимит, установленный внутри одного из них, не видит остальных.
- умирает раньше, чем успевает прибраться. Если защищаемый процесс — корень дерева, его смерть оставляет сиротами дочерние процессы, которые он должен был ограничивать.
Внешний супервизор снимает первый, третий и четвёртый пункты. Оставшееся исключение — его собственная гибель: если супервизор убить сигналом SIGKILL, команда продолжит работать, а итоговый отчёт записан не будет (README на v0.5.0). Второй пункт он лишь смягчает: маленький отдельный процесс не делит с нагрузкой ни адресное пространство, ни блокировки, хотя зависание всей машины не переживёт ни один инструмент в пространстве пользователя. К этому пределу вернётся раздел 8.
Контракт управления процессами запускает команду лидером новой группы процессов, которой владеет супервизор; TERM и KILL адресованы проверенной группе, а не одному PID. Контракт отчётов по мере событий пишет из родительского процесса журнал с контрольными суммами и синхронизацией на диск. Поэтому после гибели нагрузки на уцелевшем и читаемом носителе остаётся восстановимое начало журнала.
Если отказывает носитель самого супервизора, это другой случай, и отчёта для него контракт не обещает. Запись прекращается, отчёт больше не объявляется полным, и прогон завершается с кодом частичного артефакта. Именно это и показывает сценарий потери носителя, зафиксированный в репозитории: файла отчёта нет вовсе. Если же супервизор и его носитель уцелели, артефакт появляется быстро. На эталонном хосте на v0.1.0 внешний TERM, отправленный самому супервизору, всё равно давал итоговый отчёт с p95 60.8 ms. Отчёт очищается от чувствительных данных до записи на диск: в схеме v1 нет полей для сырого argv, значений переменных окружения, путей, промптов или идентификаторов моделей. Из всего, что идентифицирует команду, сохраняются только базовое имя исполняемого файла и число аргументов, плюс необязательный хеш для корреляции. Так убираются категории, утечка которых наиболее вероятна, но безопасным для публикации файл от этого автоматически не становится. Перед тем как им делиться, его нужно прочитать; страница поддержки просит прикладывать к issue очищенный отчёт.
Пакет эталонного хоста v0.1.0 измеряет и утверждение «супервизор переживает рабочий процесс» в самой дешёвой форме. Среди сценариев жизненного цикла были рабочие процессы, игнорирующие TERM, быстрый выход корневого процесса, потеря носителя посреди прогона и тайм-аут checkpoint. В каждом сценарии, где уцелели сам супервизор и его носитель, он завершил отчёт, валидный по схеме. А четыре безопасные нагрузки отработали до конца, и ложных вмешательств было ноль.
5. macOS даёт группу процессов, а не cgroup
На Linux этот инструмент был бы маленьким: поместить дерево в cgroup, задать memory.max, и ядро
ОС само держит границу в момент начисления памяти, без всякого цикла опроса. По крайней мере для
памяти на стороне CPU: у выделений драйверов устройств и там своя история. В macOS аналога для
дерева процессов нет. Правда, ядро macOS поддерживает лимиты памяти для отдельных процессов
(memorystatus — механизм, на котором работает jetsam), и taskpolicy -m запускает одну программу под таким лимитом, как
показывает сопутствующая методическая записка
Measuring a macOS process tree honestly.
Но это потолок для одного процесса, превышение которого для процесса смертельно, и задаётся он при
запуске через закрытый интерфейс. Бюджетом на всё дерево он не является.
Зато macOS даёт супервизору набор инструментов POSIX: группы процессов, сигналы, опрос через
libproc. У каждого из них по отдельности есть дыры. PID можно переиспользовать, как только родитель
забрал статус завершившегося процесса (reaping), а для процессов, которые супервизор не запускал
сам, этот момент он не контролирует. Потомок может покинуть группу одним вызовом setsid и начать
новую сессию за пределами группы супервизора. Перечисление дерева процессов не атомарно: дерево
может измениться, пока его обходят. Стабильного дескриптора процесса в духе pidfd в macOS тоже нет;
чего это стоит, разбирает сопутствующая записка.
Проектный вывод отсюда не «сдаться», а «держать ту границу, которую можно удержать, а остальное
записывать как свидетельства».
Контракт идентичности
привязывает каждый наблюдаемый процесс к паре (pid, process_start_abstime), поэтому участник
группы, у которого сменилась метка запуска, записывается как устаревший: его не учитывают и ему не
доверяют.
Пути сигналов стоит описать точно, потому что гарантии у них разные. В рантайме v0.1.0 TERM и KILL отправлялись группе процессов по её номеру, сохранённому и проверенному при запуске; для checkpoint-запроса членство в группе перепроверялось непосредственно перед доставкой (исходник на v0.1.0). Ни один из путей не перепроверял метку запуска в момент системного вызова. Поэтому переиспользованный PID внутри живой группы или переиспользованный номер группы после того, как группа супервизора опустела, оставались реальным, хотя и узким окном на платформе без стабильного дескриптора процесса.
Потомков ищут при каждом замере. Потомок, замеченный вне группы супервизора, записывается как побег, и этот флаг действует на весь прогон: более поздняя чистая проверка, что группа опустела, уже не позволит тихо объявить, что дерево процессов удержано. Смена родителя и смена идентичности тоже записываются — как события удержания, а не как побеги. Потомка, который отделился раньше, чем его хоть раз заметили, можно пропустить целиком.
Сумма подчиняется тому же правилу честности, что и опрос: если хотя бы одного участника группы не
удалось измерить, итог помечается как incomplete, сохраняется для диагностики и никогда не
сравнивается с порогом так, будто он полный.
В этом и состоит структурная разница между границей, которую обеспечивают принудительно, и границей, подкреплённой свидетельствами. macOS допускает вторую. Инструмент, который заявляет первую для дерева процессов на этой платформе, описывает механизм, которого у платформы нет.
6. Проектные решения, которые из этого следуют
Нативный родительский процесс, а не библиотека. Супервизор — скомпилированный исполняемый файл, который ничего не импортирует из нагрузки: ни Python, ни MLX, никакой привязки к версии фреймворка. Цикл контроля никогда не работает внутри контролируемого процесса. Python-пакет — типизированный клиент, который запускает бинарник; никакого контроля в нём нет.
Явный лимит, а не придуманный. Ни одно число не безопасно для всех машин и нагрузок сразу,
поэтому
режим наблюдения
измеряет нагрузку, ни разу не вмешиваясь, записывает наибольшую полную сумму и скорость роста в
калибровочный артефакт с пометкой safety_certified: false, а оператор выбирает рабочий лимит по
наблюдавшимся пикам плюс сознательный запас. Угадывать инструмент отказывается.
Детерминированная политика, которую можно проверить. Контракт политики — чистый конечный автомат: на входе события замеров, на выходе действия. Каждый переход записывается с меткой времени, парой состояний и суммой, которая наблюдалась в тот момент; пороги, с которыми его сравнивали, приводятся в отчёте один раз. Все полосы v0.1 выводятся из единственного лимита, который задал оператор: предупреждение на шаг полосы ниже него, аварийная полоса на шаг выше, и прежде чем что-то произойдёт, нужны два нарушения подряд. Дальше эскалация идёт так: предупреждение → необязательный кооперативный checkpoint (тайм-аут подтверждения 100 ms на v0.1.0) → TERM (отсрочка 1 s) → KILL, а замер в аварийной полосе сразу ведёт к KILL. Замеры, которым супервизор не может доверять, никогда не считаются нулём. Три непригодных замера подряд — отсутствующих, устаревших, с обратным ходом часов или со слишком широким окном — переводят контроль в отказ в безопасную сторону (fail closed): супервизор посылает TERM, записывает типизированную ошибку супервизора и, если процесс ещё жив, доводит эскалацию до KILL. Временные сценарии исполняемы и зафиксированы в репозитории как эталонные (golden) тесты.
Сохранить работу, прежде чем её уничтожить. Рабочий процесс, подключившийся к
протоколу checkpoint,
получает просьбу сохраниться до того, как придёт TERM. Прогон интеграции, зафиксированный в
репозитории, показывает кооперативные ступени от начала до конца. Бенчмарк слоя функции потерь MLX
на 1,000 повторений шёл под намеренно крошечным лимитом времени по часам (wall-clock) в 500 ms;
к лимиту footprint в 512 MiB он даже не приблизился, пиковая сумма была около 46 MiB. На
505 ms его попросили сохраниться; он закончил повторение 336, записал и синхронизировал на
диск частичный результат, подтверждение пришло на 527 ms, а на 553 ms прогон был
принудительно завершён с итоговым отчётом. В сохранённом артефакте — 336 завершённых повторений. Контрольного прогона, который показал бы, что
спасла бы остановка без супервизора, нет (собственный watchdog потребителя тоже пишет результат
прерванного прогона), поэтому продемонстрировано именно сохранение артефакта, а не спасение с нуля.
Словарь свидетельств в протоколе остаётся честным: одна лишь доставка записывается как
requested_unverified, и даже совпавшее подтверждение даёт только
acknowledged_unverified_durability — это заявление рабочего процесса, а не доказательство, что
байты надёжно записаны.
Отчёт, который выживает. Журнал разобран в разделе 4; итог передают типизированные коды выхода (собственный код дочернего процесса, если ничего не случилось, 75 при вмешательстве политики, отдельные коды для отказов супервизора и артефактов), так что скрипты и CI могут ветвиться по тому, что на самом деле произошло. На v0.1.0 оставалось открытым одно известное исключение: дочерний процесс, который завершался раньше первой проверки идентичности супервизором, мог вернуть код отказа супервизора вместо собственного статуса.
7. Супервизор должен обходиться дешевле проблемы, за которой следит
Внешнее кольцо, которое конкурирует с нагрузкой за охраняемый ресурс, само становится частью
проблемы. Пакет эталонного хоста v0.1.0 оценивает стоимость супервизора на хосте M1 Max и сравнивает
каждое измерение с заявленным для него целевым значением; все измерения в свои цели уложились:
максимальный RSS супервизора 2.98 MiB; загрузка CPU модулем опроса при интервале 50 ms на группе
из 16 процессов — 1.69% одного ядра CPU; один вызов proc_pid_rusage — 1.25 µs по p95; окно
замера на 16 процессов — 0.183 ms по p95; рост footprint супервизора за 30 минут — 80 KiB;
задержка от решения до первого сигнала — 8.2 µs по p95. В том релизе интервал опроса по
умолчанию в 50 ms давал примерно двадцать наблюдений в секунду ценой примерно одной шестидесятой ядра
и трёх мегабайт памяти на этом хосте. Это достаточно дёшево, чтобы держать супервизор перед тяжёлым
прогоном, а только там от предохранителя и есть толк. Другие поколения Apple Silicon не
откалиброваны, и контракт поддержки оставляет ожидания по производительности привязанными к
конкретному хосту и нагрузке.
8. Чего не может обещать даже внешний супервизор
Внешнее положение устраняет отказ из-за общей судьбы и исправляет учёт. Атомарным контроль оно не делает, и те же пакеты измерений, которые оценивают стоимость супервизора, измеряют и его пробелы.
У опроса есть окно, и выделения памяти его не ждут. При контролируемом синтетическом нарастании со скоростью 128 MiB/s перелёт за порог по p95 составил 12.77 MiB, а худший из наблюдавшихся за двадцать прогонов — 13.19 MiB. Это число растёт вместе со скоростью нарастания: нагрузка MLX может материализовать гигабайты за один шаг ленивого вычисления, а одно выделение может целиком перескочить порог между двумя замерами. Политика записывает максимальный наблюдаемый перелёт для каждого прогона.
Сигнал процессу не возвращает память сразу — насколько это удалось наблюдать. Во всех десяти калибровочных прогонах с Metal буфер Metal в 64 MiB сразу после освобождения оставался начисленным процессу, с максимальным остатком 65.2 MiB (68,403,272 байта), и ни в одном из двадцати прогонов с нарастанием после сигнала вмешательства не появился замер footprint с численно меньшим значением. Эти наблюдения цензурированы справа: прогоны закончились раньше, чем удалось увидеть возврат памяти. Это не доказывает, что возврат не происходит никогда, и пакет говорит ровно это. Проектный вывод: после TERM и KILL супервизор продолжает опрос, пока действительно не увидит выход процесса, и ни одна часть отчёта не приравнивает доставку сигнала к возврату памяти.
Группа принадлежит супервизору, но не запечатана. Потомок, вызвавший setsid, может уйти;
поиск может пропустить процесс, который успевает сделать fork, сбежать и завершиться между
снимками. Отчёт содержит свидетельства побегов, а не гарантию удержания, а
модель угроз ограничивает
весь инструмент одной доверенной командой, которая отказывает случайно, — но не злонамеренной.
Общесистемный отказ сильнее всего остального. Супервизор — процесс пространства пользователя. Во время kernel panic, отказа драйвера или зависания всей машины его могут вообще не планировать, и последняя запись журнала может оказаться единственным артефактом. Это честный потолок для любого решения в пространстве пользователя на этой платформе, внешнего или нет.
Поэтому сам проект говорит «OS-accounted footprint» (footprint по учёту ОС), «sampled intervention threshold» (порог вмешательства по замерам) и «reduces risk» (снижает риск) — и никогда «hard boundary» (жёсткая граница). Ценность внешнего положения не в том, что граница становится жёсткой. Она в том, что перечисленные пробелы измеряются там, где их можно наблюдать, и записываются процессом, который переживает нагрузку, а не исчезают вместе с ней.
9. Слои, а не замена
Ничто в этой аргументации не отправляет внутренние защиты в отставку. Wired limit (лимит закреплённой памяти) по-прежнему ограничивает резидентность невытесняемой памяти — того класса памяти, исчерпание которого остаётся одним из задокументированных путей к панике. Рекомендательный лимит памяти по-прежнему влияет на поведение аллокатора. Внутрипроцессный watchdog в обычном случае по-прежнему останавливает прогон с честным артефактом и по-прежнему работает, когда супервизор не установлен. Внутри контролируемого рабочего процесса он тоже продолжает работать: контракт интеграции оставляет watchdog потребителя активным как запасной механизм, а супервизор добавляет вокруг него владение группой процессов и footprint по учёту ОС. Слои безопасности MLX внутри приложения, такие как MetalGuard, занимают то же внутреннее кольцо и знают о фреймворке гораздо больше. Внешний супервизор сознательно нейтрален к приложению и ничего не знает о фреймворке — именно поэтому он может обернуть немодифицированную команду. Кольца измеряют разные величины и отказывают независимо друг от друга, а ради этого кольца и нужны.
10. Выводы
Лимит, который живёт внутри ограничиваемого процесса, — лишь совет. Предшествующая статья показала, что ограничения фреймворка не остановили панику на той машине. Эта записка добавляет, что любой внутрипроцессный механизм — ограничение или watchdog — делит с процессом планировщик, адресное пространство и время жизни, а значит, и судьбу.
Смотреть надо на число, которое начисляет ОС. Счётчики фреймворка охватывают только то, что отслеживает аллокатор, а счётчик, за который нагрузка хватается первым, может охватывать ещё меньше: публичное расхождение в 2.4× дал счётчик пиковой памяти, который не учитывает удерживаемый пул кэша. Чтение правильной пары сокращает этот разрыв, но счёт выставляет phys_footprint, и сумма по группе супервизора охватывает каждого её участника, включая память, которую фреймворк никогда не выделял.
Путь аварийной остановки должен пережить то, что он останавливает. Отдельный нативный родительский процесс может действовать, пока рабочий процесс завис, прибрать всю группу и — чего внутрипроцессная защита не сможет никогда — написать отчёт после того, как рабочего процесса не стало.
На macOS удержание — это свидетельства, а не примитив. Нет ни cgroup, ни pidfd: идентичность приходится перепроверять, побеги — записывать, а неполное измерение должно отказываться выдавать себя за полное. Инструмент, который не может унаследовать границу от ядра ОС, обязан доказывать ту, что держит сам.
Сначала назвать пробелы, потом их измерить. У перелёта за порог есть p95. У невозврата памяти есть остаток и оговорка о цензурировании. У доли ложных вмешательств на безопасных нагрузках есть число (ноль на четырёх нагрузках).
Ссылки и заметки об источниках
mlx-guardна теге v0.1.0: опрос, идентичность и удержание, управление процессами, политика, вмешательство, наблюдение и калибровка, протокол checkpoint, отчёты и приватность, модель угроз, поддержка, контракт интеграции с mlx-train-perf, исходник управления процессами, эталонные временные сценарии политики.- Данные, зафиксированные в репозитории на v0.1.0: пакет эталонного хоста M1 Max 32 GB (точность, задержка, накладные расходы, перелёт за порог, длительная работа, сценарии жизненного цикла, корпус безопасных нагрузок); пакет интеграции с mlx-train-perf (временная шкала checkpoint, пути отказов).
mlx-guardна теге v0.5.0, для обновления и оговорки о SIGKILL в разделе 4: README, список изменений, управление процессами, пакет эталонного хоста M1 Max 32 GB (macOS 27.2, рядом приведены цифры 0.3.1).- Публичные отчёты об инцидентах: MLX #3896 (расхождение счётчика пиковой памяти и phys_footprint; два превышения, один тайм-аут GPU watchdog и одна жёсткая перезагрузка; закрыт 2026-08-08 с рекомендацией апстрима читать активную память плюс кэш); mlx-lm #883 (неограниченный KV-кэш, footprint 83.23 GB, kernel panic).
- Сопутствующие записки: When an MLX Memory Cap Is Not a Safety Boundary (предшественница, раздел 2); Measuring a macOS process tree honestly (методическая записка, раздел 5).
- Смежные инструменты: MetalGuard (слой безопасности MLX внутри приложения; дополняющая граница).
Подготовлено 2026-08-14. Последнее обновление 2026-11-13. Denis Ineshin.
