Prefill vs decode: чому token one повільний
Prefill обмежений обчисленнями й визначає time to first token, а decode залежить від пропускної здатності пам’яті та tokens per second. Вимірюйте їх окремо.
Prefill і decode: в одному абзаці
Prefill і decode — це розрізнення, яке пояснює більшість питань щодо затримки self-hosted LLM (велика мовна модель). Prefill зчитує весь промпт за один прохід і обмежується обчислювальною потужністю. Decode генерує відповідь по одному токену за раз і обмежується пропускною здатністю пам’яті. Час до отримання першого токена — це показник prefill. Кількість токенів за секунду — це показник decode.
Обидві фази виконуються на тому самому GPU (графічний процесор), використовують ті самі ваги й працюють у тому самому процесі, тому їх природно розглядати як одне навантаження. Фактично вони поводяться як дві різні програми, що спільно використовують один пристрій. Якщо розділити ці фази, довгий список незрозумілих результатів більше не здаватиметься суперечливим.
Чому prefill обмежений обчисленнями?
Prefill один раз передає весь prompt через кожен шар. Prompt на 2,000 токенів дає кожному matrix multiply 2,000 рядків роботи, тому GPU виконує багато арифметичних операцій для кожного завантаженого байта ваг. Це співвідношення — кількість арифметичних операцій на переміщений байт — називається arithmetic intensity. У prefill воно високе. Пристрій працює майже на межі обчислювальної продуктивності, а memory bus має вільну пропускну здатність.
Prefill створює дві речі: KV cache (тензори key і value) для кожного токена prompt і перший вихідний токен. Читач не отримує даних, доки цей прохід не завершиться. Саме тому на сервері без навантаження prefill визначає більшу частину часу до першого токена (TTFT). У визначенні TTFT з benchmarking guide NVIDIA також враховано постановку запиту в чергу та мережеву затримку, тому на зайнятому сервері очікування в черзі може мати не менше значення, ніж довжина prompt.
Вартість prefill зростає разом із довжиною prompt. Лінійну частину становить робота matrix multiply на кожному шарі. Квадратичну частину становить attention, під час якого кожен токен враховує всі попередні токени. Вона стає помітною за великої довжини контексту. Тому подвоєння prompt щонайменше подвоює частину TTFT, пов’язану з prefill.
Це можна перевірити за одну хвилину. Надішліть на сервер prompt на 200 токенів, а потім prompt на 2,000 токенів, щоразу запитуючи однакову кількість вихідних токенів. TTFT різко зросте. Швидкість streaming після першого токена майже не зміниться.
Чому decode обмежений пропускною здатністю пам’яті?
Decode генерує один токен за крок. Щоб згенерувати цей токен, GPU має зчитати з пам’яті всі ваги моделі, використати кожну вагу для кількох операцій і відкинути її. Arithmetic intensity близька до 1, тому обчислювальні блоки більшу частину часу очікують.
Decode працює повільно, тому що для кожного токена потрібно зчитати з пам’яті всю модель. Отже, темп визначає шина пам’яті, а обчислювальні блоки простоюють.
Тому теоретичну верхню межу швидкості decode для одного потоку можна обчислити вручну. Розділіть пропускну здатність пам’яті на обсяг, який займають ваги.
Дані, на яких побудовано графік
[
{
"device": "CPU, dual channel DDR5-5600",
"mem_bandwidth_gb_s": 90,
"decode_ceiling_tok_s": 6
},
{
"device": "NVIDIA A10G",
"mem_bandwidth_gb_s": 600,
"decode_ceiling_tok_s": 38
},
{
"device": "NVIDIA L40S",
"mem_bandwidth_gb_s": 864,
"decode_ceiling_tok_s": 54
},
{
"device": "NVIDIA RTX 4090",
"mem_bandwidth_gb_s": 1008,
"decode_ceiling_tok_s": 63
},
{
"device": "NVIDIA A100 80GB SXM",
"mem_bandwidth_gb_s": 2039,
"decode_ceiling_tok_s": 127
},
{
"device": "NVIDIA H100 SXM",
"mem_bandwidth_gb_s": 3350,
"decode_ceiling_tok_s": 209
}
]У стовпці bandwidth наведено опубліковані специфікації кожного виробника. У стовпці ceiling це значення поділено на 16 GB — обсяг моделі з 8 billion параметрів, збереженої з точністю 16 bit. Це арифметичний розрахунок, а не результат бенчмарку. Фактична швидкість буде нижчою. Важливо знати, наскільки саме, оскільки це допомагає визначити, чи потрібно виправляти serving stack, чи оновлювати обладнання.
Перегляньте 6 рядків по порядку — закономірність очевидна. CPU із двоканальною DDR5 забезпечує близько 90 GB/s, що обмежує decode приблизно до 6 токенів за секунду для цієї моделі. Для L40S це значення становить приблизно 54. H100 SXM з опублікованою пропускною здатністю 3350 GB/s забезпечує приблизно 209.
Саме тому quantization є найефективнішим окремим способом підвищити швидкість decode. Якщо зберігати ті самі ваги в 8 bit замість 16 bit, кількість байтів ваг, які потрібно зчитати для кожного токена, зменшиться вдвічі, а отже, верхня межа швидкості приблизно подвоїться. Однак це не є фактичним результатом. KV cache усе одно зчитується у власному обсязі, а деякі 8 bit формати додають роботу для кожного токена. Наприклад, vLLM документує dynamic per token activation quantization для однієї зі своїх FP8 схем. Тому виміряний приріст зазвичай буде меншим за 2x. Цей спосіб працює з тієї самої причини, з якої змінюється верхня межа: потрібно переміщати менше даних у пам’яті.
Як виміряти кожну фазу на власному сервері?
Ollama повертає розподіл у тілі відповіді. Запросіть завершення без streaming і зчитайте лічильники.
curl -s http://localhost:11434/api/generate -d '{
"model": "llama3.2",
"prompt": "Explain memory bandwidth in two sentences.",
"stream": false
}' | jq '{prompt_eval_count, prompt_eval_duration, eval_count, eval_duration}'Використовуйте тег моделі, яку ви справді завантажили. Його покаже ollama list. prompt_eval_count і prompt_eval_duration стосуються prefill: кількості токенів запиту та часу, витраченого на них. eval_count і eval_duration стосуються decode. Тривалість указано в наносекундах, тому швидкість decode обчислюється як eval_count / eval_duration * 1e9, а швидкість prefill — як prompt_eval_count / prompt_eval_duration * 1e9. У довідці API Ollama зазначено, що prompt_eval_duration охоплює лише токени запиту, які не було взято з кешу. Тому визначайте швидкість prefill для запиту, якого сервер щойно не обробляв. Очікуйте, що швидкість prefill буде значно вищою за швидкість decode для того самого запиту. Цю різницю пояснює все інше в цьому матеріалі.
Для OpenAI-сумісного сервера, наприклад vLLM, curl може виміряти час до отримання першого байта.
curl -N -s -o /dev/null \
-w 'pretransfer %{time_pretransfer}s first_byte %{time_starttransfer}s\n' \
http://localhost:8000/v1/completions \
-H 'Content-Type: application/json' \
-d '{"model": "meta-llama/Llama-3.1-8B-Instruct", "prompt": "Explain memory bandwidth.", "max_tokens": 128, "stream": true}'time_starttransfer — це момент отримання першого байта тіла відповіді. Отже, разом із "stream": true це TTFT плюс встановлення з’єднання. Відніміть time_pretransfer, щоб виключити витрати на встановлення з’єднання. Виконайте запит двічі й використовуйте другий результат, оскільки перший виклик може включати холодне завантаження моделі.
vLLM також публікує розподіл у вигляді метрик Prometheus на /metrics. Виконайте curl -s http://localhost:8000/metrics | grep -E 'time_to_first_token|inter_token_latency', і отримаєте гістограми vllm:time_to_first_token_seconds та vllm:inter_token_latency_seconds. Додайте vllm:num_requests_running і vllm:num_requests_waiting для глибини черги, а vllm:kv_cache_usage_perc — для навантаження на кеш. Ці п’ять назв становлять усю панель моніторингу.
Під навантаженням vllm bench serve --model <name> --num-prompts 200 --request-rate 4 керує запущеним сервером і показує час до першого токена та затримку для кожного вихідного токена з розподілом за перцентилями. Це найпряміший спосіб побачити, як дві фази конкурують між собою в стеку, який ви вже використовуєте. NVIDIA's GenAI-Perf і LLMPerf вимірюють ті самі показники, якщо ви віддаєте перевагу окремому інструменту. Перш ніж щось оптимізувати, отримайте чистий базовий результат: метод із вимірювання tokens per second у локальній LLM дає результат, який зберігається після перезавантаження.
Чому довгий системний prompt збільшує час до появи першого токена, але не швидкість потокової генерації?
Тому що системний prompt — це робота на етапі prefill і не більше. Він обробляється один раз, під час того самого проходу, що й решта prompt, до появи першого токена. Після цього проходу він існує лише як записи KV cache, і decode зчитує їх разом з усіма іншими записами. Тому без prefix caching системний prompt на 3,000 токенів додає час до першого токена для кожного запиту, але майже не змінює кількість токенів за секунду.
Майже, але не зовсім. Ці додаткові записи KV cache зчитуються на кожному кроці decode, тому дуже довгий prompt трохи сповільнює decode. У наступному розділі це розглянуто докладніше.
Рішення — припинити повторно обчислювати той самий префікс. Сервер із prefix caching зберігає KV cache спільного префікса та повторно використовує його, тому другий запит із тим самим системним prompt повністю пропускає цю частину prefill. У vLLM це називається automatic prefix caching; перевірте vllm serve --help у своїй версії, оскільки значення за замовчуванням змінювалося між релізами. Цей KV cache у GPU — не те саме, що prompt cache, за який API-провайдер виставляє рахунок, а різницю між KV cache і prompt cache варто зрозуміти, перш ніж налаштовувати будь-який із них.
Чому декодування сповільнюється в міру заповнення контексту?
Причин дві, і обидві пов’язані з KV cache.
Перша причина — пропускна здатність пам’яті. На кожному кроці декодування attention читає ключі та значення всіх попередніх токенів. Ваги створюють фіксовані витрати для кожного токена. KV cache постійно збільшується. Його розмір можна обчислити за допомогою config.json моделі: кількість байтів на токен дорівнює 2, помноженому на num_hidden_layers, num_key_value_heads, розмір голови та кількість байтів на елемент. Використовуйте head_dim, якщо цей параметр указано в конфігурації. hidden_size, поділене на num_attention_heads, використовуйте лише за його відсутності, оскільки в деяких моделях ці два параметри задаються незалежно. Наприклад, Mistral NeMo має ширину 5,120 і 32 голови, але розмір голови дорівнює 128, а не 160. Початкове 2 означає один ключ і одне значення.
Для поширеної конфігурації на 8 мільярдів параметрів із 32 шарами, 8 головами ключів і значень у режимі GQA (grouped query attention), розміром голови 128 та точністю 16 біт це становить 2 x 32 x 8 x 128 x 2 = 131,072 байти, тобто приблизно 128 KiB на токен. Отже, діалог на 8,000 токенів містить приблизно 1 GB KV cache для кожного запиту.
Друга причина — місткість. Цей 1 GB пам’яті не можна використати для ваг або контексту іншого користувача. Сервер визначає розмір пулу KV один раз під час запуску, у vLLM — через --gpu-memory-utilization. Коли пул заповнений, нові запити очікують. Зростання vllm:num_requests_waiting, коли vllm:kv_cache_usage_perc тримається близько 1, є точною ознакою такого стану. Деякі стеки призупиняють поточний запит і пізніше повторно обчислюють його cache замість постановки запиту в чергу. Користувач сприймає це як затримку посеред потокової відповіді.
Довгий контекст має подвійну ціну: більше роботи під час prefill на початку та більше читання з пам’яті на кожен токен протягом решти відповіді.
Чому batching підвищує пропускну здатність, але погіршує tail latency?
Оскільки decode обмежений пропускною здатністю пам’яті, додаткові запити майже не збільшують навантаження на обчислення. Одне читання ваг може згенерувати токен для кожної послідовності в batch, тому загальна пропускна здатність зростає майже лінійно разом із розміром batch, доки не вичерпається KV pool або batch не стане достатньо великим, щоб знову перейти в режим обмеження обчисленнями. Continuous batching перебудовує batch на кожному кроці. Завершений запит виходить, а запит із черги приєднується, не очікуючи завершення сусідніх запитів.
Ціна цього проявляється в перцентилях. Наступний токен для кожного користувача тепер очікує найдовшу частину спільного кроку. Тому p50, тобто медіана, залишається прийнятним, а p99, тобто час для найповільнішого 1 запиту зі 100, зростає. Користувачі помічають саме p99, оскільки це пауза посеред речення.
Prefill робить цей ефект сильнішим. Великий prompt, що надходить під час генерації, займає пристрій на один довгий крок. Усі запити, для яких у цей момент генеруються токени, бачать паузу. Chunked prefill усуває більшу частину цієї проблеми. Він розділяє довгий prompt на частини та додає кожну частину до batch для decode. Станом на October 2026 engine vLLM V1 робить це за замовчуванням і керує балансом через --max-num-batched-tokens. У документації з налаштування vLLM цей компроміс описано прямо: менші значення, близько 2048, забезпечують кращу inter token latency (ITL), оскільки менше prefill-операцій перериває decode, а більші значення забезпечують кращий TTFT, оскільки в один batch поміщається більше prefill-токенів. Цей єдиний flag визначає співвідношення prefill і decode числовим значенням. Межа прийнятного p99 залежить від ємності системи, а скільки одночасних користувачів може обслуговувати self-hosted LLM визначається за тими самими метриками.
Чому потужніший GPU іноді нічого не змінює?
Тому що потужніший зазвичай означає більше обчислювальної потужності, а decode не потребує обчислень.
Порівняйте два рядки наведеної вище таблиці. A100 80GB має заявлену пропускну здатність 2039 GB/s, а L40S — 864 GB/s. Межа швидкості decode відповідає цьому співвідношенню: 127 токенів за секунду проти 54. RTX 4090 за більшістю показників є дуже швидкою картою, але її пропускна здатність 1008 GB/s обмежує швидкість на рівні 63. Незалежно від інших відмінностей між двома картами, decode для одного потоку визначається показником пропускної здатності у специфікації.
Отже, є два способи пришвидшити decode: читати менше байтів на токен — квантувати ваги або запускати меншу модель — або придбати GPU з більшою пропускною здатністю. Prefill працює навпаки. Він потребує обчислювальної потужності, тому швидша карта справді скорочує TTFT для довгих промптів. Якщо проблема полягає в тому, що перший токен з’являється через чотири секунди, потужніше обладнання може її усунути. Якщо проблема в тому, що текст виводиться повільно, найімовірніше, це не допоможе.
Чи варто запускати prefill і decode на окремих workers?
Великі стеки для обслуговування моделей саме так і працюють. Ця техніка називається розділенням prefill і decode. Один пул workers виконує лише prefill, другий — лише decode. KV cache, створений першим пулом, передається другому через швидке з’єднання. Це працює, оскільки для цих фаз потрібні різне обладнання та різне планування. Для prefill потрібні обчислювальні ресурси та великі пакети токенів. Для decode потрібні пропускна здатність пам’яті та багато одночасних послідовностей. Розділення дає змогу кожному пулу масштабуватися незалежно. Воно також не дозволяє одному великому prompt блокувати всі активні потоки.
На одному VPS (virtual private server) з одним GPU це майже ніколи не виправдано. Ви ділитимете один пристрій сам із собою, а передавання покажчика перетвориться на мережеве передавання гігабайтів cache. Техніка стає доцільною, коли у вас достатньо accelerator, щоб виділити окремі машини для кожної фази, і достатньо стабільного трафіку, щоб підтримувати роботу обох пулів. Якщо ресурсів менше, chunked prefill забезпечує майже таку саму ізоляцію за допомогою одного flag.
Що змінити, якщо показник незадовільний
Якщо TTFT зависокий:
- Скоротіть промпт. Вартість prefill залежить від кількості токенів у промпті, а без prefix caching системний промпт обробляється під час кожного запиту.
- Увімкніть prefix caching, щоб повторюваний префікс обчислювався один раз, а не під час кожного запиту.
- Збільште
--max-num-batched-tokens, щоб на кожному кроці виконувалося більше роботи prefill. - Перевірте чергу, перш ніж звинувачувати модель. Значення
vllm:num_requests_waitingпонад нуль означає, що обробка запиту ще не розпочалася. Це проблема пропускної здатності.
Якщо кількість токенів за секунду зависока:
- Квантизуйте ваги. Менше байтів на одну вагу означає менше даних для читання на кожен токен.
- Порівняйте опубліковану виробником пропускну здатність пам’яті вашої карти з наведеною вище діаграмою та перевірте, наскільки ви наблизилися до граничного значення.
- Зменште
--max-num-batched-tokens, щоб prefill рідше переривав decode. - Перевірте довжину контексту. Якщо розмова виросла до тисяч токенів, на кожному кроці з кешу KV зчитується значно більше даних.
Середовище виконання також має значення, оскільки Ollama та vLLM по-різному планують prefill і decode, а параметр, який допомагає одному з них, може не дати результату в іншому. Спочатку виконайте вимірювання в обох фазах, а потім змінюйте лише один параметр.
FAQ
Чому перший токен генерується кілька секунд, а решта надходить швидко?
Очікування — це prefill, а потокова генерація — decode. Під час prefill весь prompt обробляється за один compute-bound прохід до появи будь-якого результату, тому його тривалість зростає разом із довжиною prompt. Потім decode генерує один токен за крок зі швидкістю, яку визначає пропускна здатність пам’яті. Вона майже не залежить від довжини prompt. Найчастіша причина — довгий system prompt у кожному запиті. Prefix caching усуває повторну обробку цієї частини.
Чи сповільнює довший prompt генерацію токенів за секунду?
Трохи, але з іншої причини, ніж TTFT. На кожному кроці decode зчитуються keys і values усіх попередніх токенів. Тому більший KV cache означає більше байтів, які потрібно зчитати для кожного токена. Для поширеної конфігурації з 8 billion параметрів cache становить приблизно 128 KiB на токен. Отже, контекст із 8,000 токенів — це приблизно 1 GB даних, до яких звертаються на кожному кроці. Основний вплив довгого prompt усе одно припадає на TTFT, а не на швидкість потокової генерації.
Яка характеристика GPU передбачає швидкість decode?
Пропускна здатність пам’яті. Поділіть опубліковану пропускну здатність на обсяг weights у пам’яті — так ви отримаєте теоретичну межу для одного потоку. GPU з більшою обчислювальною потужністю, але з такою самою пропускною здатністю пам’яті, не генеруватиме токени швидше. Саме тому квантування weights до 8 bits приблизно вдвічі підвищує межу decode: кількість байтів weights, які потрібно зчитати для кожного токена, зменшується вдвічі. Фактичний приріст зазвичай менший, оскільки KV cache усе одно зчитується у своєму повному обсязі, а деякі формати 8 bit додають операції для кожного токена, наприклад квантування activations.
Чому throughput зростає після додавання користувачів, але кожен користувач відчуває повільнішу роботу?
Одне зчитування weights обслуговує токен для кожної послідовності в batch, тому загальна кількість токенів за секунду зростає разом із розміром batch. Водночас кожен окремий токен очікує на спільний крок, тому затримка для користувача також зростає. Відстежуйте p99 inter token latency, а не показник aggregate throughput, і перевіряйте vllm:num_requests_waiting, щоб визначити, чи запити стоять у черзі, а не виконуються.