SSD Nodes Learn Hosting plans →
Посібники Matt ConnorВід Matt Connor · Оновлено 2026-10-26

Чому self-hosted LLM зависає на 5 користувачах

Дізнайтеся, чому Ollama обробляє лише 1 запит за замовчуванням і як batching, KV cache, prefill та queue depth визначають межу для LLM-сервера.

Чому self-hosted LLM сповільнюється, коли підключається більше користувачів?

Якщо self-hosted LLM починає зависати вже за 5 одночасних користувачів, зазвичай сервер налаштований на генерацію лише однієї відповіді за раз, а решта чотири запити стоять у черзі. Документація Ollama прямо описує значення за замовчуванням: OLLAMA_NUM_PARALLEL — це «максимальна кількість паралельних запитів, які кожна модель обробляє одночасно; значення за замовчуванням — 1». Нічого не зламано, і serving software може одночасно обробляти кілька запитів. Четверо з п’яти користувачів чекають своєї черги, бо так задано в налаштуваннях.

Зазвичай вирішення проблеми — не потужніший сервер. Потрібен serving engine, який обробляє багато запитів у межах одного forward pass моделі, а також достатній запас пам’яті для зберігання контексту всіх розмов під час обробки. Важливі обидві складові. Саме друга фактично визначає граничне навантаження.

Дві фази, через які проходить кожен запит

Prefill зчитує весь prompt одночасно та створює для нього attention cache. Усі токени prompt проходять через модель разом, тому prefill — це одне велике матричне множення, обмежене арифметичною продуктивністю. Decode записує відповідь по одному токену за раз. Для кожного токена потрібно знову зчитати з пам’яті всі ваги моделі, тоді як обсяг обчислень для одного токена дуже малий. Decode обмежений пропускною здатністю пам’яті.

Саме ця асиметрія пояснює, чому batching працює. Decode для одного користувача зчитує, наприклад, 5 GB ваг для кожного токена, а більшість арифметичних блоків простоює. Додайте другий запит — і рушій один раз зчитає ті самі 5 GB, а потім обчислить на їх основі два токени. Другий користувач майже не збільшує час обробки. Послідовне обслуговування запитів повністю нівелює цю перевагу.

Відчуття користувача описують два показники. TTFT (time to first token) — це час очікування в черзі плюс prefill. ITL (inter-token latency) — це інтервал між токенами, що передаються потоком; його визначає decode. Повільний сервер зазвичай має проблеми з одним із цих показників, і способи їх усунення різні. Перед зміною будь-яких налаштувань варто визначити, з яким саме показником ви працюєте. Для цього потрібно окремо виміряти час prefill і decode.

Статичне пакетування змушує всіх чекати на найдовшу відповідь

Статичне пакетування — це наївний варіант, який ви отримуєте, якщо самостійно групуєте запити в коді застосунку. Рушій збирає N запитів, обробляє їх разом і утримує кожен слот, доки не завершиться найдовша генерація в групі.

Один користувач, який запитав резюме на 1,200 токенів, утримує в пакеті чотири однорядкові відповіді, оскільки пакет не звільняє слот, доки не завершиться його найдовший елемент.

Це спричиняє дві проблеми. Завершені послідовності й далі займають слоти, хоча не виконують корисних обчислень. Через це ефективна пропускна здатність знижується, коли довжина вихідних даних різниться; у чатах вона різниться дуже сильно. Запит, який надійшов через один крок після формування пакета, чекає, доки весь пакет завершить обробку, і лише після цього починає prefill. Отже, його TTFT визначається чужим довгим текстом.

Безперервний batching приймає та завершальне обробляє запити на кожному токені

Безперервний batching планує виконання на рівні одного кроку декодування. Після кожного кроку планувальник вилучає послідовності, які щойно згенерували токен завершення, а потім приймає запити з черги очікування у вільні слоти. Відповідь, яка завершується на кроці 40, звільняє свій слот на кроці 40, а не після завершення batch.

Це не екзотична можливість. llama-server описує -cb, --cont-batching як «чи увімкнути безперервний batching (також відомий як dynamic batching) (типово: увімкнено)», містить «Паралельне декодування з підтримкою кількох користувачів» серед своїх можливостей і після зміни, об’єднаної в листопаді 2025 року, типово запускається з 4 слотами (-np має типове значення -1, auto). vLLM побудований навколо цієї ідеї. Ollama також обслуговує паралельні запити. Типова конфігурація просто обмежує їх кількість до одного. Саме тому багато хто робить висновок, що їхнє обладнання не підтримує конкурентне виконання, хоча насправді це забороняла конфігурація.

Опубліковані результати для безперервного batching зазвичай вимірюють на серверних картах, які мають і вільні обчислювальні ресурси, і десятки гігабайтів для cache. Характер цих результатів переноситься і на ваш сервер. Їхній масштаб — ні. Причину пояснено нижче в розділі про пам’ять.

Prefill конкурує з decode за ті самі обчислювальні ресурси

Коли надходить новий запит, поки чотири відповіді передаються потоком, спочатку потрібно виконати prefill його промпту, а prefill потребує значних обчислень. Якщо планувальник виділяє цьому prefill окремий крок, чотири користувачі, які отримують потокові відповіді, протягом цього кроку не отримують жодного токена. Для довгого промпту це помітна пауза в кожному відкритому вікні. Саме це мають на увазі, коли кажуть, що сервер починає підвисати щоразу, коли хтось інший натискає кнопку надсилання.

Chunked prefill розбиває довгий промпт на частини та об’єднує кожну частину в один крок із decode для поточних запитів. У посібнику з налаштування vLLM цей компроміс описано безпосередньо: менші бюджети chunk "забезпечують кращий ITL, оскільки менше операцій prefill сповільнюють decode", а більші значення "забезпечують кращий час до першого токена (TTFT), оскільки за один batch можна обробити більше токенів prefill". Ви обираєте, чий досвід захистити: користувача, який чекає на початок відповіді, чи користувачів, які спостерігають за передаванням тексту потоком.

Довжина промпту визначає масштаб цієї проблеми. Промпт на 6,000 токенів із відповіддю на 200 токенів означає 6,000 токенів роботи prefill проти 200 кроків decode. Retrieval-augmented chat і довгі системні промпти часто призводять саме до такого співвідношення. Тому prefill перестає бути незначною складовою та стає основною операцією, завершення якої очікують користувачі. Prefix caching допомагає, коли довга частина повторюється: vLLM надає --enable-prefix-caching, який повторно використовує cache для спільного префікса промпту замість повторного обчислення для кожного запиту.

Першим вичерпується KV cache

Кожен токен у кожній активній розмові залишає key vector і value vector у кожному шарі моделі. Це KV cache (key/value cache), завдяки якому під час decode не потрібно повторно обчислювати весь prompt для кожного нового токена. Кількість кешованих значень на токен визначається архітектурою моделі: 2 (одне key і одне value), помножене на кількість шарів, кількість key/value heads і розмірність head. Ці значення можна отримати з config.json моделі. Помножте їх на кількість байтів на одне значення, щоб отримати розмір кешу. Останній множник задається під час роботи, а не є частиною моделі: llama-server за замовчуванням зберігає кеш у f16 (2 байти) і підтримує менші типи, наприклад q8_0, через -ctk і -ctv.

Виконайте цей розрахунок один раз — і верхня межа перестане бути загадкою. Типова модель 8B із 36 шарами, 8 key/value heads і head dimension 128, якщо кеш зберігається у 16-bit, потребує 2 36 8 128 2 байти на токен. Це 147,456 байт, або приблизно 144 KiB. Для однієї розмови на 8,192 токени потрібно приблизно 1.2 GB кешу. Для п’яти таких розмов потрібно приблизно 6 GB додатково до ваг моделі. Саме це визначає, скільки користувачів може обслуговувати система.

Паралельність множить обсяг контексту, і це прямо зазначено в документації. FAQ Ollama: "Паралельна обробка запитів для певної моделі збільшує розмір контексту пропорційно кількості паралельних запитів. Наприклад, контекст 2K із 4 паралельними запитами дає контекст 8K і потребує додаткового виділення пам’яті." Необхідний обсяг RAM масштабується як OLLAMA_NUM_PARALLEL, помножене на OLLAMA_CONTEXT_LENGTH. У llama-server стандартна кількість слотів, визначена автоматично, запускає всі слоти в одному спільному KV buffer, тому весь контекст -c є єдиним пулом, з якого слоти отримують пам’ять. Якщо задати -np вручну, спільний buffer вимикається, якщо також не передати --kv-unified. У такому разі контекст, заданий через -c, розподіляється між -np слотами, а збільшення кількості слотів саме по собі зменшує обсяг, доступний для кожного запиту. Читайте контекст на слот із startup log, а не припускайте його значення.

vLLM натомість заздалегідь виділяє пам’ять. --gpu-memory-utilization (за замовчуванням 0.92) — це "частка GPU memory, яку має використовувати model executor". Якщо не задати --kv-cache-memory-bytes, vLLM визначає розмір KV cache із цієї частки: залишок бюджету після врахування ваг і профільованої робочої пам’яті engine стає paged KV pool. Коли в цьому пулі закінчується місце, scheduler витісняє запит, а не завершує його з помилкою:

WARNING 05-09 00:49:33 scheduler.py:1057] Sequence group 0 is preempted by PreemptionMode.RECOMPUTE mode because there is not enough KV cache space.

У V1 engine vLLM режимом preemption за замовчуванням є RECOMPUTE. Тому після витіснення запиту його кеш видаляється, а під час повторного допуску запит знову проходить prefill. Ця робота виконується двічі. У документації зазначено, що "preemption і recomputation можуть негативно впливати на наскрізну затримку". Цей рядок журналу найкраще пояснює, чому один користувач чекав значно довше за інших, хоча середня затримка залишалася нормальною. Установіть disable_log_stats=False, щоб журналювати накопичувальну кількість, або прочитайте лічильник preemption у Prometheus metrics, які надає vLLM.

Що змінюється за 2, 5 і 20 одночасних користувачів

Два користувачі. На GPU із вільним місцем у cache вплив майже непомітний, оскільки другий потік декодування працює паралельно з першим і потребує зовсім небагато додаткового часу. На VPS лише з CPU та 4 to 8 GB RAM це не безкоштовно: обидва потоки використовують ті самі vCPU і пропускну здатність RAM, тому кожен користувач отримує приблизно половину tokens per second, а потреба в cache подвоюється за значно меншого доступного обсягу пам’яті.

П’ять користувачів. На цьому рівні стандартних параметрів уже недостатньо, і проблема спочатку перетворюється на чергу. Якщо OLLAMA_NUM_PARALLEL дорівнює 1, четверо користувачів чекають на того, хто запросив довгу відповідь, і кожен отримує нормальну швидкість, коли настає його черга. Збільшення кількості паралельних запитів змінює характер проблеми: п’ять слотів із контекстом 8K для кожного потребують cache на 40K токенів. Якщо він не вміщується у VRAM, engine вивантажує шари до системної RAM. Якщо його не вміщує і RAM, система починає використовувати swap, а tokens per second різко падає.

Двадцять користувачів. Двадцять людей у chat UI зазвичай не означають двадцять одночасних запитів. Це найважливіше зрозуміти перед придбанням обладнання. Людина читає відповідь і думає 20 to 60 секунд між повідомленнями, тому більшу частину часу її сесія простоює. Двадцять agents або двадцять завдань із підсумовування документів — це двадцять реальних потоків без жодного простою. Для цього потрібна інша конфігурація сервера. Розробник, який підключив coding agent до власного Ollama server, ближчий до другого сценарію, ніж до першого, оскільки agent безперервно надсилає запити, доки виконується завдання, і не має пауз на читання, які робить людина.

Ваші користувачі працюють одночасно чи лише авторизовані?

Спочатку визначте кількість запитів у процесі обробки, а вже потім підбирайте ресурси. Розрахунок простий: кількість запитів у процесі обробки дорівнює кількості користувачів, помноженій на кількість секунд генерації за один запит і поділеній на кількість секунд між запитами.

  1. Спочатку виміряйте швидкість для одного потоку на власному обладнанні — окремо для prefill і decode. Не використовуйте показник із чужої відеокарти: виміряйте кількість токенів за секунду на власному сервері і використайте отримане значення.
  2. Оцініть коефіцієнт використання. Для 20 користувачів чату, 12 секунд генерації на один запит і одного запиту кожні 90 секунд маємо 20 * 12 / 90, тобто приблизно 2.7 запитів у процесі обробки.
  3. Установіть кількість слотів трохи вищою за це значення, а потім перевірте її за обсягом пам’яті: кількість слотів, помножена на контекст одного запиту, має вміщуватися в доступну кількість cache tokens.
  4. Тримайте чергу короткою, щоб надлишкові запити швидко завершувалися з помітною помилкою.

Доступну кількість cache tokens визначають як обсяг вільної пам’яті після завантаження ваг, поділений на вартість одного токена з попереднього розділу. Відеокарта обсягом 24 GB із моделлю 8B у 16-bit витрачає приблизно 16 GB на ваги й має не більше приблизно 6 GB доступного cache за стандартного рівня використання пам’яті. Після резервування робочої пам’яті залишиться трохи менше. Цього вистачає приблизно на п’ять діалогів із контекстом 8K. Щоб умістити більше діалогів, зменште контекст одного запиту або зберігайте cache у 8-bit (llama-server займає --cache-type-k q8_0). В обох випадках ви збільшуєте кількість одночасних запитів ціною певних обмежень. Перед придбанням обладнання варто ознайомитися з реальним балансом: коли GPU VPS стає вигіднішим за API tokens.

Коли стандартних параметрів Ollama вже недостатньо

Збільшуйте кількість паралельних запитів через unit служби, оскільки експорт змінної в shell не буде доступний демону, яким керує systemd.

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_MAX_QUEUE=64"
sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=Environment
ollama ps

systemctl show має вивести три змінні, які ви щойно встановили. Якщо цього не сталося, drop-in не зберігся, і подальші дії не матимуть результату. ollama ps потім показує завантажену модель із розміром, більшим за самі ваги, оскільки чотири слоти по 8,192 токенів резервують додатково 32,768 токенів кешу. Якщо в колонці PROCESSOR частина моделі розміщена в CPU, хоча ви очікували повного розміщення на GPU, це означає, що для кешу потрібно більше пам’яті, ніж залишилося на карті. Зменште одне з двох значень. Зазвичай безпечніше зменшити контекст, але надто мале вікно непомітно обрізає довгі запити замість того, щоб повертати помилку. Тому варто свідомо визначити значення num_ctx, а не зменшувати його доти, доки модель не поміститься.

Стандартне значення черги потребує окремої уваги. Ollama ставить у чергу до OLLAMA_MAX_QUEUE запитів, і «стандартне значення — 512». Після цього вона повертає «помилку 503 із повідомленням, що сервер перевантажений». Черга глибиною 512 на сервері, який одночасно обслуговує чотири запити, — це невиконувана обіцянка, оскільки клієнт на позиції 300 дочекається тайм-ауту задовго до початку обробки. Коротка черга повертає помилку, яку застосунок може повторити або показати користувачеві. Це краще, ніж індикатор очікування, який ніколи не завершується.

Перевірте це на практиці. Надішліть два запити одночасно з двох терміналів і спостерігайте за обома. Якщо другий запит не дає результату, доки не завершиться перший, параметр паралельної обробки не застосувався.

Коли повноцінний рушій інференсу починає виправдовувати себе

vLLM виправдовує додаткове налаштування, коли у вас є GPU із вільним ресурсом і одночасно обробляється приблизно понад чотири запити. Його планувальник працює на рівні токенів, кеш розподіляється сторінками, тому вільні фрагменти можна повторно використовувати, а вільна VRAM перетворюється на паралельну обробку запитів, а не простоює. Станом на October 2026 документована інсталяція та запуск GPU-версії складаються з трьох команд. vllm download-kernels завантажує попередньо скомпільовані ядра, які vLLM інакше завантажував би та компілював під час запуску:

uv pip install vllm --torch-backend=auto
vllm download-kernels
vllm serve Qwen/Qwen2.5-1.5B-Instruct
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "Qwen/Qwen2.5-1.5B-Instruct",
        "messages": [{"role": "user", "content": "Say hello."}]
    }'

Відповідь, що містить масив choices, означає, що сервер запущений, а модель завантажена. Під навантаженням важливі два параметри: --max-num-seqs — «максимальна кількість послідовностей, які обробляються за одну ітерацію», і --max-num-batched-tokens — «максимальна кількість токенів, які можна обробити за одну ітерацію». Перший обмежує паралельність. Другий визначає бюджет chunked prefill, описаний вище.

Якщо одночасно обробляється менше приблизно чотирьох запитів, vLLM додає складності, але майже не дає переваг. GPU більше не обов’язковий: станом на October 2026 посібник з інсталяції для CPU описує «базовий інференс і обслуговування моделей» на x86 та Arm CPU, містить готові x86 wheels починаючи з версії 0.17.0 і надає CPU Docker image. Особливості використання пам’яті при цьому зберігаються. На CPU vLLM застосовує ту саму частку використання 0.92 до системної RAM, а решту пам’яті після розміщення ваг виділяє під KV cache. Тому за замовчуванням під час запуску він займає більшу частину пам’яті машини, якщо не обмежити кеш параметром --kv-cache-memory-bytes. Для VPS із 4–8 GB це неправильний компроміс. У такому випадку краще використати меншу модель із коротшим контекстом і чергою, якою ви керуєте самостійно. У розділі як відрізняються Ollama та vLLM як рушії інференсу наведено повне порівняння, а в розділі запуск Qwen 3 8B на VPS показано, які ресурси потребує модель середнього розміру ще до підключення хоча б одного додаткового користувача.

Компроміс, який приховує загальноприйнята думка

Continuous batching підвищує загальну пропускну здатність і зазвичай також покращує медіанну затримку, оскільки запит із черги починає виконуватися раніше. Tail latency змінюється в протилежний бік, але про цю частину рідко згадують.

Кожна додаткова послідовність у кроці додає трохи роботи, тому ITL зростає для всіх у міру заповнення batch. Prefill нового запиту займає частину кроку, яка інакше була б доступна користувачам зі streaming-виведенням. За дефіциту cache scheduler виконує preemption, через що частково згенерований запит повертається на початок свого prefill.

Chat UI показує tail latency, а не середні значення. Потік, який переривається на дві секунди посеред речення, виглядає несправним, навіть якщо загальний час до завершення хороший. Вимірюйте p95 TTFT і p95 ITL під навантаженням, яке ви очікуєте, а середню кількість tokens per second розглядайте як показник місткості, а не як опис користувацького досвіду.

Практичне налаштування випливає з цього. Обмежте concurrency трохи нижче рівня, який допускає доступна memory, щоб engine ніколи не був змушений виконувати preemption. Коротка передбачувана queue краща за глибокий batch, який постійно thrash-иться, оскільки користувачеві легше зачекати чотири секунди, а потім отримувати плавний stream, ніж почати одразу й двічі зіткнутися з паузою.

Що перевірити, якщо система працює повільно

Кожен запит обробляється нормально, але очікування довге. Це черга, а не проблема швидкодії. Спочатку перевірте параметр паралельності. Модель працює правильно, але обробляє по одному запиту за раз.

Ollama повертає HTTP 503. Черга заповнена. Або сервер справді досягнув граничного навантаження, або OLLAMA_MAX_QUEUE навмисно встановлено на низьке значення для відхилення надлишкового навантаження. Саме так цей параметр і має працювати.

Кількість токенів за секунду різко зменшується під навантаженням на сервері з CPU. Запустіть vmstat 1 під час проблеми. Ненульові значення у стовпцях si і so означають, що система використовує swap. Тому ваги моделі зчитуються з диска для кожного токена. Зміна конфігурації не усуне цю проблему. Зменште розмір моделі або кількість слотів.

Один із десяти користувачів очікує значно довше за інших. Знайдіть у журналі vLLM рядок preempted. Зазвичай причина полягає у витісненні та повторному обчисленні. Це означає, що кеш переповнений для дозволеної довжини контексту.

TTFT має високі значення, навіть коли сервер простоює. Це проблема prefill, а не паралельності. Обробка довгих промптів займає час до появи першого токена, тому спочатку перевірте розмір промпта та prefix caching, а вже потім — апаратне забезпечення. Якщо тривале очікування виникає лише для першого запиту після періоду бездіяльності, а всі наступні запити обробляються нормально, причина не в prefill. Ollama вивантажує модель і знову зчитує ваги з диска. Це можна перевірити, залишивши модель завантаженою між запитами.

FAQ

Чому мій self-hosted LLM працює повільніше, коли ним користується друга людина?

Найчастіше він взагалі не працює повільніше. Запити стають у чергу. Ollama постачається з параметром OLLAMA_NUM_PARALLEL, встановленим у значення 1, тому другий запит очікує, доки перший не згенерує останній токен. Щоб розрізнити ці два випадки, виміряйте швидкість потоку для одного користувача, поки інший очікує. Якщо після початку генерації швидкість у токенах за секунду нормальна, це черга, і збільшення кількості паралельних запитів вирішить проблему. Якщо обидва потоки працюють на половині швидкості, ви справді ділите пропускну здатність пам’яті. Це апаратне обмеження.

Скільки одночасних користувачів може обслуговувати одна невелика GPU?

Рахуйте не користувачів, а пам’ять. Спочатку врахуйте ваги моделі, потім KV cache. Для кожного токена та кожної активної розмови він потребує 2 × кількість шарів × кількість key/value heads × розмірність head × кількість bytes. Типова модель 8B із 36 шарами, 8 key/value heads і розмірністю head 128 потребує приблизно 144 KiB на токен у 16-бітному форматі. Тому для розмови на 8,192 токенів потрібно приблизно 1.2 GB. На карті 24 GB, де ця модель зберігається у 16-бітному форматі, для cache залишиться щонайбільше близько 6 GB. Цього вистачає приблизно на п’ять розмов із повним контекстом або на більшу кількість розмов, якщо скоротити контекст.

Чи робить continuous batching відповідь для кожного користувача повільнішою?

Медіанна затримка зазвичай зменшується, оскільки запити перестають чекати завершення всього batch. Затримка в хвості розподілу зростає. Кожна додаткова sequence додає роботу на кожному кроці декодування. Pre-fill нового запиту забирає частину кроку в користувачів, які отримують потокову відповідь, а перерваний запит має виконати pre-fill двічі. Вимірюйте p95 затримки між токенами, а не середнє значення. У вікні чату паузи помітні, тоді як середнє значення їх приховує.

Чи слід збільшити OLLAMA_NUM_PARALLEL або перейти на vLLM?

Спочатку збільште кількість паралельних запитів. Це не потребує додаткових витрат і налаштовується одним drop-in файлом. Так ви усунете поширений випадок, коли чотири користувачі стоять у черзі за однією довгою відповіддю. Обмеженням є пам’ять: паралельні запити збільшують обсяг контексту, який потрібно утримувати, тому стежте, чи не переміщуються шари до CPU. Переходьте на vLLM, коли у GPU є вільна VRAM і одночасно справді виконуються понад приблизно чотири запити. На цьому рівні paged cache і планування на рівні токенів дають більше переваг, ніж створюють накладних витрат.

Чи усунуть додаткові ядра CPU повільну роботу LLM-сервера?

Не для тієї частини роботи, яку користувачі помічають найбільше. Під час decode модель повністю зчитується з пам’яті для кожного токена, тому швидкість обмежена пропускною здатністю RAM. Додаткові ядра перестають допомагати, щойно пропускну здатність вичерпано. Pre-fill масштабується за кількістю ядер, тому більша їх кількість скорочує час до першого токена для довгих prompt. На VPS із 4–8 GB основним обмеженням зазвичай є обсяг пам’яті. Практичне рішення — менша модель або коротший контекст, а не збільшення кількості vCPU.

Чи була ця стаття корисною?