Linux убивает локальную нейросеть: как найти причину Killed, OOM и нехватки видеопамяти

Linux убивает локальную нейросеть: как найти причину Killed, OOM и нехватки видеопамяти

Нейросеть нормально запускается, принимает запрос, несколько секунд генерирует ответ и внезапно исчезает. Терминал показывает одно слово Killed. Иногда появляется код 137, иногда сообщение CUDA out of memory. При этом команда free -h показывает несколько гигабайт доступной оперативной памяти.

Пользователь начинает уменьшать модель, добавлять swap или отключать OOM Killer. Но свободная память компьютера ещё не означает, что конкретному процессу разрешено её использовать. Служба может упереться в лимит cgroup, видеокарта может исчерпать собственную VRAM, а системный менеджер systemd-oomd способен завершить приложение до глобального OOM ядра.

Linux убивает локальную нейросеть

Разберём, как отличить эти ситуации, собрать доказательства сбоя и настроить локальную LLM так, чтобы она не мешала остальным процессам Linux.

Почему нейросеть может завершиться при свободной RAM

Когда движок загружает языковую модель, память расходуется на несколько компонентов. Веса нейросети занимают RAM или VRAM, вычислительные буферы используются во время обработки запросов, а KV-кеш хранит промежуточные данные механизма внимания для уже обработанных токенов.

Размер GGUF-файла не равен потреблению оперативной памяти. Например, квантованная модель размером 500 МБ может потребовать заметно больше ресурсов при большом контексте и нескольких одновременных запросах. Точный расход зависит от архитектуры модели, движка, размещения слоёв и настроек кеша.

В Linux есть несколько независимых причин аварийного завершения.

ПричинаЧто происходитКак распознать
Глобальный OOMЯдро не может выделить достаточно системной памяти и выбирает процесс для завершенияСообщения OOM в журнале ядра, данные о состоянии памяти хоста
Лимит cgroupПроцесс исчерпывает выделенную группе память, хотя на хосте остаётся свободная RAMmemory.max, рост memory.events, журнал ядра
systemd-oomdСистемная служба отправляет SIGKILL при сильном давлении на памятьЖурнал systemd-oomd, данные PSI и oomctl
Недостаточно VRAMGPU-бэкенд не может выделить память для модели или буферов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-размещении
EFP16 вместо 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 от исчерпания памяти лучше сохранить: она ограничивает последствия ошибки приложения, а не является её первопричиной.

Alt text
Обращаем внимание, что все материалы в этом блоге представляют личное мнение их авторов. Редакция SecurityLab.ru не несет ответственности за точность, полноту и достоверность опубликованных данных. Вся информация предоставлена «как есть» и может не соответствовать официальной позиции компании.
SECLAB / TG
LIVE SecurityLab.ru
Вы зашли хитро.
Дальше — совсем просто.
Одна кнопка — и SecurityLab в вашей ленте. Новости про взломы без лишних маршрутов.
Подписаться @SecLabnews