Нейросеть нормально запускается, принимает запрос, несколько секунд генерирует ответ и внезапно исчезает. Терминал показывает одно слово Killed. Иногда появляется код 137, иногда сообщение CUDA out of memory. При этом команда free -h показывает несколько гигабайт доступной оперативной памяти.
Пользователь начинает уменьшать модель, добавлять swap или отключать OOM Killer. Но свободная память компьютера ещё не означает, что конкретному процессу разрешено её использовать. Служба может упереться в лимит cgroup, видеокарта может исчерпать собственную VRAM, а системный менеджер systemd-oomd способен завершить приложение до глобального OOM ядра.
Разберём, как отличить эти ситуации, собрать доказательства сбоя и настроить локальную LLM так, чтобы она не мешала остальным процессам Linux.
Почему нейросеть может завершиться при свободной RAM
Когда движок загружает языковую модель, память расходуется на несколько компонентов. Веса нейросети занимают RAM или VRAM, вычислительные буферы используются во время обработки запросов, а KV-кеш хранит промежуточные данные механизма внимания для уже обработанных токенов.
Размер GGUF-файла не равен потреблению оперативной памяти. Например, квантованная модель размером 500 МБ может потребовать заметно больше ресурсов при большом контексте и нескольких одновременных запросах. Точный расход зависит от архитектуры модели, движка, размещения слоёв и настроек кеша.
В Linux есть несколько независимых причин аварийного завершения.
| Причина | Что происходит | Как распознать |
|---|---|---|
| Глобальный OOM | Ядро не может выделить достаточно системной памяти и выбирает процесс для завершения | Сообщения OOM в журнале ядра, данные о состоянии памяти хоста |
| Лимит cgroup | Процесс исчерпывает выделенную группе память, хотя на хосте остаётся свободная RAM | memory.max, рост memory.events, журнал ядра |
| systemd-oomd | Системная служба отправляет SIGKILL при сильном давлении на память | Журнал systemd-oomd, данные PSI и oomctl |
| Недостаточно VRAM | GPU-бэкенд не может выделить память для модели или буферов | CUDA out of memory, ошибки GPU-бэкенда, мониторинг видеокарты |
| Ошибка приложения | Движок завершает работу после неудачного выделения памяти или другого сбоя | Журнал программы, код завершения, отсутствие подтверждённого OOM |
Особенно часто путают первые два случая. OOM Killer ядра может завершить процесс при глобальном дефиците памяти либо при достижении жёсткого предела конкретной cgroup. Во втором случае на сервере может оставаться много доступной RAM.
Контроллер памяти cgroup v2 использует два основных ограничения. memory.high задаёт порог, после которого ядро начинает активнее освобождать память и замедлять выделения. memory.max устанавливает жёсткий предел. Если удержать потребление ниже предела не получается, возможен локальный OOM. Механизм подробно описан в документации ядра.
Ещё один источник путаницы связан с кодом 137. Для оболочки он обычно означает, что дочерний процесс завершился сигналом SIGKILL, номер 9. Но SIGKILL может отправить не только OOM Killer. Поэтому запись Exit code 137 сама по себе не доказывает нехватку памяти.
Эксперименты с искусственным ограничением памяти выполняйте только на тестовой системе или в изолированной службе. Не отключайте OOM Killer и не создавайте глобальный дефицит RAM на рабочем сервере. Аварийное завершение процессов может привести к потере несохранённых данных.
Проверяем проблему на небольшой модели
Для теста возьмём открытую Qwen2.5-0.5B-Instruct в формате GGUF с квантованием Q4_K_M. Файл занимает 491 МБ. Модель достаточно небольшая для CPU-стенда, а через llama.cpp можно менять контекст, число параллельных запросов и размещение слоёв на GPU.
Сначала соберём конфигурацию компьютера.
cat /etc/os-release
uname -r
free -h
swapon --show
# Проверяем cgroup v2
stat -fc %T /sys/fs/cgroup
# Если используется NVIDIA
nvidia-smi
Команда stat должна показать cgroup2fs. Если используется cgroup v1, пути и механизм учёта памяти будут отличаться. Проверки ниже рассчитаны на cgroup v2 и systemd.
Далее установим зависимости сборки, получим исходники llama.cpp и соберём CPU-версию сервера. Пример подходит для Debian и Ubuntu.
sudo apt update
sudo apt install -y git cmake build-essential curl
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build --target llama-server -j 4
./build/bin/llama-server --help
Исходный код проекта и параметры сборки доступны в руководстве llama.cpp. Для повторяемых сравнений зафиксируйте идентификатор коммита через git rev-parse --short HEAD. Параметры движка меняются между версиями.
Скачаем модель из репозитория Qwen.
curl -L --fail
-o model.gguf
"https://huggingface.co/Qwen/Qwen2.5-0.5B-Instruct-GGUF/resolve/main/qwen2.5-0.5b-instruct-q4_k_m.gguf"
ls -lh model.gguf
sha256sum model.gguf
Для указанного файла SHA-256 в репозитории равен 74a4da8c9fdbcd15bd1f6d01d621410d31c6fc00986f5eb687824e7b93d7a9db. Проверка суммы поможет исключить повреждение или неожиданную замену файла.
Запустим сервер без GPU, чтобы сначала исследовать системную память.
./build/bin/llama-server
-m ./model.gguf
-c 2048
-np 1
-ngl 0
--host 127.0.0.1
--port 8080
Параметр -c 2048 задаёт размер контекста, -np 1 оставляет один слот сервера, а -ngl 0 отключает перенос слоёв на GPU. Сервер слушает только локальный интерфейс и не доступен напрямую из внешней сети.
Во втором терминале проверим готовность и отправим запрос через совместимый с OpenAI интерфейс.
curl -sS http://127.0.0.1:8080/health
curl -sS http://127.0.0.1:8080/v1/chat/completions
-H "Content-Type: application/json"
-d '{
"messages": [
{
"role": "user",
"content": "Объясни разницу между RAM и VRAM."
}
],
"max_tokens": 128
}'
Теперь посмотрим, сколько памяти занимает процесс.
PID=$(pgrep -n -x llama-server)
ps -p "$PID" -o pid,rss,vsz,%mem,etime,cmd
grep -E 'VmRSS|VmHWM|VmSize'
/proc/$PID/status
cat /proc/$PID/cgroup
free -h
cat /proc/pressure/memory
VmRSS показывает резидентную память процесса, а VmHWM хранит максимальное зафиксированное значение RSS. Показатель VSZ отражает виртуальное адресное пространство и не означает, что весь такой объём физически занят.
llama.cpp обычно использует mmap для отображения весов модели в адресное пространство процесса. Страницы файла могут попадать в файловый кеш и освобождаться при давлении на память. Контроллер cgroup учитывает больше категорий памяти, чем показывает один RSS, поэтому для службы нужно отдельно измерять memory.current и memory.peak.
Показатели MemAvailable из free и PSI из /proc/pressure/memory характеризуют состояние хоста, но не заменяют диагностику ограничений конкретной службы.
Находим OOM через журналы ядра и memory.events
Если модель неожиданно завершилась, сначала проверьте последние сообщения ядра.
sudo journalctl -k -b --since "15 minutes ago"
| grep -Ei 'oom|out of memory|killed process|memory cgroup'
При подтверждённом OOM могут появиться сообщения Out of memory: Killed process или Memory cgroup out of memory. Изучайте полный блок сообщений, а не одну найденную строку. Для определения причины нужны сведения о cgroup, процессе и состоянии памяти в момент сбоя.
Если LLM работает под systemd, проверьте журнал и результат завершения соответствующей службы.
sudo journalctl -u local-llm.service
-b -n 100 --no-pager
systemctl show local-llm.service
-p Result
-p ExecMainCode
-p ExecMainStatus
-p MemoryCurrent
-p MemoryHigh
-p MemoryMax
-p EffectiveMemoryMax
Замените local-llm.service реальным именем службы. Здесь особенно полезен EffectiveMemoryMax: конечное ограничение может оказаться меньше указанного в самой службе из-за лимитов родительской группы.
Для анализа cgroup получим её путь и прочитаем статистику.
CG=$(systemctl show local-llm.service
-p ControlGroup --value)
echo "$CG"
sudo cat "/sys/fs/cgroup${CG}/memory.current"
sudo cat "/sys/fs/cgroup${CG}/memory.max"
sudo cat "/sys/fs/cgroup${CG}/memory.high"
sudo cat "/sys/fs/cgroup${CG}/memory.events"
sudo cat "/sys/fs/cgroup${CG}/memory.events.local"
# Если поддерживается ядром
sudo cat "/sys/fs/cgroup${CG}/memory.peak"
Эти команды нужно выполнять, пока служба и её cgroup существуют. После полного завершения временной службы каталог статистики может исчезнуть. В старых ядрах отдельные файлы и счётчики также могут отсутствовать.
Главный диагностический файл здесь memory.events. Он содержит накопленные значения нескольких событий.
| Поле | Значение |
|---|---|
| high | Превышение порога memory.high с принудительным освобождением памяти и замедлением выделений |
| max | Попытка выйти за предел memory.max |
| oom | Ситуация, когда выделение памяти упирается в предел группы и может завершиться отказом |
| oom_kill | Процессы группы, завершённые OOM Killer ядра, включая глобальные и локальные события |
| oom_group_kill | Групповые завершения через механизм OOM |
Допустим, после нагрузки счётчик max вырос, а oom_kill не изменился. Следовательно, группа пыталась превысить предел, но подтверждённого завершения процесса OOM Killer по этим данным нет. Ядро могло успешно освободить память.
Если одновременно увеличились oom и oom_kill, а журнал сообщает Memory cgroup out of memory, признаки указывают на локальный OOM. Увеличение одного oom_kill недостаточно, чтобы исключить глобальный OOM хоста.
memory.events учитывает события вложенных групп, тогда как memory.events.local показывает только локальные события. Для сложных служб с дочерними cgroup нужно проверить оба файла и при необходимости дочерние каталоги.
Проверим работу ограничителя на отдельной временной службе. Сначала остановите сервер, запущенный вручную, чтобы освободить порт 8080. Затем зададим искусственно низкие лимиты.
BIN=$(realpath ./build/bin/llama-server)
MODEL=$(realpath ./model.gguf)
sudo systemd-run
--unit=llm-oom-test
--uid="$(id -un)"
-p MemoryAccounting=yes
-p MemoryHigh=400M
-p MemoryMax=550M
"$BIN"
-m "$MODEL"
-c 8192
-np 1
-ngl 0
--host 127.0.0.1
--port 8080
Это намеренно ограниченный тест, а не рекомендуемая конфигурация. При недостатке памяти сервер может завершиться ещё при загрузке модели, во время запроса или вернуть ошибку выделения памяти. Конкретный исход зависит от сборки, модели, mmap, файлового кеша и настроек ядра. Гарантировать срабатывание OOM Killer нельзя.
Пока временная служба работает, в другом терминале прочитайте счётчики.
CG=$(systemctl show llm-oom-test.service
-p ControlGroup --value)
sudo cat "/sys/fs/cgroup${CG}/memory.events.local"
sudo cat "/sys/fs/cgroup${CG}/memory.current"
sudo cat "/sys/fs/cgroup${CG}/memory.peak"
sudo journalctl -u llm-oom-test.service
-b -n 50 --no-pager
Если служба уже остановилась и каталог cgroup исчез, изучите журнал ядра и systemd. Для повторного эксперимента можно повысить предел до 700 или 900 МБ либо уменьшить его ещё сильнее, сохраняя тест внутри отдельной службы. Счётчики нужно фиксировать перед запросами и после них, пока группа существует.
Отдельно проверим systemd-oomd. Этот компонент использует метрики PSI и может завершать группы процессов, если для соответствующих служб или их предков включены механизмы ManagedOOMMemoryPressure или ManagedOOMSwap.
systemctl status systemd-oomd.service
sudo journalctl -u systemd-oomd.service
-b --no-pager
oomctl dump
Если журнал systemd-oomd подтверждает отправку SIGKILL, не приписывайте завершение автоматически OOM Killer ядра. Условия работы механизма описаны в руководстве systemd-oomd.
Как отличить нехватку VRAM и уменьшить потребление памяти LLM
Для NVIDIA ситуация проверяется отдельно. Если сервер сообщает CUDA out of memory или ошибку cudaMalloc, начните с расхода видеопамяти.
nvidia-smi
nvidia-smi
--query-gpu=index,name,memory.total,memory.used
--format=csv
nvidia-smi
--query-compute-apps=pid,process_name,used_gpu_memory
--format=csv
Общее использование VRAM включает другие приложения. Кроме того, часть памяти может резервироваться драйвером и вычислительными библиотеками. Поэтому свободная RAM компьютера и число из nvidia-smi описывают разные ресурсы.
CPU-сборка llama.cpp из нашего теста не использует CUDA. Для отдельного эксперимента на NVIDIA понадобится CUDA Toolkit и сборка с поддержкой CUDA.
cmake -B build-cuda
-DCMAKE_BUILD_TYPE=Release
-DGGML_CUDA=ON
cmake --build build-cuda
--target llama-server -j 4
./build-cuda/bin/llama-server
-m ./model.gguf
-c 2048
-np 1
-ngl all
--host 127.0.0.1
--port 8080
Ключ -ngl all разрешает размещать слои модели на GPU. При нехватке VRAM можно задать меньшее количество слоёв, например -ngl 12, оставив остальные вычисления на CPU. Это обычно снижает потребление видеопамяти, но может ухудшить скорость генерации.
Для сопоставления RAM и VRAM проведите несколько запусков одной модели.
| Тест | Параметры | Что измерить |
|---|---|---|
| A | -c 2048 -np 1 -ngl 0 | Базовый расход RAM |
| B | -c 8192 -np 1 -ngl 0 | Влияние увеличенного контекста |
| C | -c 8192 -np 4 -ngl 0 | Пиковый расход и задержки при четырёх запросах |
| D | -c 2048 -np 1 -ngl all | Расход VRAM при GPU-размещении |
| E | FP16 вместо Q4_K_M | Влияние формата весов |
В третьем варианте одного запроса недостаточно. Для проверки параллелизма отправьте четыре запроса одновременно, например через xargs.
seq 4 | xargs -P4 -I{} curl -sS
-o /tmp/llm-response-{}.json
http://127.0.0.1:8080/v1/chat/completions
-H "Content-Type: application/json"
-d '{
"messages": [
{"role":"user","content":"Объясни OOM Killer."}
],
"max_tokens": 128
}'
При этом одинаковое значение -c 8192 не гарантирует одинаковое распределение KV-кеша между слотами во всех версиях llama.cpp. Сравнивайте пиковую память, фактическое использование кеша и время ответа. Не следует заранее считать, что четыре запроса увеличат расход памяти ровно в четыре раза.
Для проверки FP16 можно скачать соответствующий GGUF из того же репозитория Qwen. Его размер около 1,27 ГБ. Сравнивайте с Q4_K_M при одинаковом контексте, числе слотов и размещении слоёв.
Результаты удобно записать в таблицу с колонками memory.peak, VmHWM, пик VRAM, время ответа, код завершения и изменения memory.events. Без реального запуска на конкретном оборудовании численные результаты такого сравнения приводить нельзя.
Квантование сокращает объём памяти для хранения весов, но не уменьшает все остальные выделения в той же пропорции. KV-кеш может оставаться в FP16 или другом формате, а вычислительные буферы зависят от движка. Дополнительные параметры настройки GPU приведены в руководстве llama.cpp.
После измерений можно настроить постоянную службу. Допустим, на вашем сервере измеренный пик потребления одной LLM составляет 2,4 ГиБ. Это условный пример для расчёта, а не результат нашего теста. В качестве первоначальной конфигурации можно проверить MemoryHigh=3G и MemoryMax=3584M, если сервер располагает достаточным резервом для остальных процессов.
Для уже существующей постоянной службы откройте редактор конфигурации.
sudo systemctl edit local-llm.service
В открывшийся файл добавьте следующие параметры.
[Service]
MemoryAccounting=yes
MemoryHigh=3G
MemoryMax=3584M
После сохранения перезапустите службу в согласованное время и проверьте действующие значения.
sudo systemctl daemon-reload
sudo systemctl restart local-llm.service
systemctl show local-llm.service
-p MemoryHigh
-p MemoryMax
-p EffectiveMemoryMax
-p MemoryCurrent
Имя local-llm.service здесь условное. Если движок запускается через Docker или другой менеджер контейнеров, ограничения обычно настраиваются в его конфигурации. Для временных служб systemd-run постоянные настройки лучше не смешивать с параметрами эксперимента.
Размер MemoryMax выбирайте по реальным пикам с запасом. Значение MemoryHigh должно позволять обычной нагрузке работать без постоянного вытеснения памяти. Дополнительно отслеживайте memory.swap.current, memory.pressure и динамику счётчиков high и max. Длительный рост этих показателей без аварийного завершения тоже может означать проблемы с производительностью.
Увеличение swap иногда помогает при нехватке RAM, но способно резко замедлить генерацию. Для дискретной VRAM обычный swap не является универсальным решением. Отключать OOM Killer или защищать модель через oom_score_adj=-1000 тоже не следует: тогда дефицит памяти может затронуть другие важные службы.
Частые вопросы
Почему Linux пишет Killed, но в журнале нет Out of memory?
Процесс мог получить SIGKILL от systemd-oomd, администратора или менеджера контейнеров. Также сообщения ядра могут быть недоступны без соответствующих прав или уже отсутствовать в доступном журнале. Проверяйте источник сигнала и журнал службы.
Всегда ли код 137 означает нехватку памяти?
Нет. Код 137 обычно означает завершение сигналом SIGKILL, но причина сигнала может быть разной. Для подтверждения OOM нужны записи ядра, данные cgroup или сведения от системного менеджера, завершившего процесс.
Почему memory.events показывает max, но модель работает?
Счётчик max фиксирует попытки превысить жёсткий лимит. Если ядро смогло освободить память, процесс продолжит работу. Сравнивайте изменения max, oom и oom_kill, а не трактуйте отдельное событие как подтверждённый сбой.
Может ли локальная LLM получить OOM при свободных 16 ГБ RAM?
Да. Например, контейнеру или systemd-службе разрешено использовать только 2 ГиБ. Достижение локального жёсткого предела может вызвать OOM независимо от оставшейся памяти хоста.
Почему CUDA out of memory появляется при свободной оперативной памяти?
При выделении памяти на дискретной видеокарте приложение ограничено доступными ресурсами GPU. Системная RAM и VRAM управляются раздельно. Проверьте занятость видеокарты другими процессами, размер контекста, KV-кеш и количество слоёв на GPU.
Почему LLM работает в терминале, но завершается в Docker?
Контейнер может использовать отдельную cgroup с меньшим лимитом памяти. Сравните его memory.max, memory.current и memory.events с параметрами запуска вне контейнера. Проверьте также доступ к GPU и ограничения родительских групп.
Поможет ли увеличение swap при запуске большой нейросети?
Иногда swap помогает избежать нехватки системной памяти, но интенсивная подкачка заметно замедляет работу. При этом cgroup может отдельно ограничивать использование swap, а проблему нехватки дискретной VRAM увеличение файла подкачки обычно не решает.
Можно ли рассчитать необходимую RAM по размеру GGUF?
Только приблизительно. Весам нужны дополнительные вычислительные буферы и KV-кеш. Реальное потребление зависит от контекста, параллелизма, формата модели и движка. Для выбора лимита службы измеряйте пиковое потребление на целевом оборудовании.
Если Linux завершает локальную нейросеть, сначала проверьте журнал ядра, состояние cgroup и ошибки GPU-бэкенда. Эти источники позволяют отделить глобальный OOM от локального ограничения памяти и ошибки выделения VRAM.
При подтверждённой нехватке памяти разумнее начать с уменьшения контекста, числа параллельных запросов и расхода KV-кеша. Затем проверить квантование и размещение слоёв между CPU и GPU. Жёсткий лимит службы устанавливайте по измеренным пикам с запасом для рабочей нагрузки. Защиту Linux от исчерпания памяти лучше сохранить: она ограничивает последствия ошибки приложения, а не является её первопричиной.
