SSD Nodes Learn Hosting plans →
Руководства Matt ConnorАвтор: Matt Connor · Обновлено 2026-10-20

Разница между prefill и decode в LLM

Фаза prefill ограничена вычислениями и влияет на время первого токена. Фаза decode зависит от пропускной способности памяти. Измеряйте их отдельно для оптимизации GPU.

Различие между prefill и decode в одном абзаце

Различие между prefill и decode — это ключевой фактор, объясняющий большинство вопросов о задержках при работе с self-hosted LLM (large language model). Фаза prefill считывает весь промпт за один проход и ограничена вычислительной мощностью. Фаза decode генерирует ответ по одному токену за раз и ограничена пропускной способностью памяти. Время до получения первого токена (time to first token) определяется фазой prefill. Количество токенов в секунду (tokens per second) определяется фазой decode.

Обе фазы выполняются на одном и том же GPU (graphics processing unit), используют одни и те же веса и работают в рамках одного процесса, поэтому их естественно рассматривать как единую нагрузку. Однако по факту они ведут себя как две разные программы, совместно использующие одно устройство. Если разделить эти понятия, длинный список запутанных результатов перестанет вызывать вопросы.

Почему этап prefill ограничен вычислительной мощностью?

На этапе prefill весь промпт однократно проходит через каждый слой модели. Промпт из 2,000 токенов создает для каждого матричного умножения объем работы в 2,000 строк, поэтому GPU выполняет значительный объем вычислений на каждый байт загруженных весов. Это соотношение — количество арифметических операций на байт переданных данных — называется арифметической интенсивностью, и у prefill она высока. Устройство работает на пределе своих вычислительных возможностей, в то время как шина памяти остается недозагруженной.

Результатом prefill являются два компонента: KV cache (тензоры ключей и значений) для каждого токена промпта и первый выходной токен. Данные не поступают к пользователю до завершения этого прохода, поэтому на незагруженном сервере prefill составляет основную часть времени до первого токена (TTFT). Согласно руководству NVIDIA по бенчмаркингу, TTFT также включает время ожидания запроса в очереди и сетевые задержки, поэтому на нагруженном сервере время ожидания в очереди может быть не менее значимым, чем сам промпт.

Стоимость prefill растет вместе с длиной промпта. Линейная составляющая определяется матричными вычислениями в каждом слое. Квадратичная составляющая относится к механизму attention, где каждый токен взаимодействует с каждым предыдущим, и она начинает играть заметную роль при работе с длинным контекстом. Таким образом, увеличение промпта вдвое как минимум удваивает ту часть TTFT, которая приходится на prefill.

Вы можете убедиться в этом за одну минуту. Отправьте на сервер промпт из 200 токенов, а затем из 2,000 токенов, запрашивая одинаковое количество выходных токенов в обоих случаях. Значение TTFT резко возрастет. При этом скорость потоковой передачи после получения первого токена практически не изменится.

Почему декодирование ограничено пропускной способностью памяти?

Декодирование генерирует один токен за шаг. Чтобы создать этот единственный токен, GPU должен считать из памяти каждый вес модели, использовать каждый вес для пары операций и отбросить его. Арифметическая интенсивность близка к 1, поэтому вычислительные блоки большую часть времени простаивают в ожидании.

Декодирование работает медленно, так как каждый токен требует считывания всей модели из памяти. Шина памяти определяет скорость, а вычислительные блоки простаивают.

Это делает теоретический предел скорости декодирования в одном потоке простой арифметической задачей. Разделите пропускную способность памяти на объем, занимаемый весами.

ГрафикPublished memory bandwidth and the decode ceiling it implies for a 16 GB model
Данные, на которых построен график
[
  {
    "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
  }
]

В столбце пропускной способности указаны опубликованные спецификации каждого производителя. Столбец предела — это данное значение, деленное на 16 GB, размер модели с 8 миллиардами параметров, хранящейся с 16-битной точностью. Это расчет, а не результат бенчмарка. Ваша измеренная скорость будет ниже этого значения, и понимание того, насколько именно, полезно: это подскажет, нужно ли оптимизировать стек обслуживания или менять оборудование.

Изучите 6 строк по порядку, и закономерность станет очевидной. CPU с двухканальной памятью DDR5 обеспечивает около 90 GB/s, что ограничивает декодирование примерно 6 токенами в секунду для данной модели. L40S достигает около 54. H100 SXM с опубликованной пропускной способностью 3350 GB/s находится около 209.

Именно поэтому квантование является самым эффективным рычагом для ускорения декодирования. Если хранить те же веса в 8 битах вместо 16, вы сократите вдвое количество байтов весов, считываемых на токен, поэтому предел примерно удвоится. Однако предел — это не итоговый результат. KV-кэш по-прежнему считывается в полном объеме, а некоторые 8-битные форматы добавляют вычисления на каждый токен, например, динамическое по-токеновое квантование активаций, описанное в документации vLLM для одной из схем FP8, поэтому измеренный прирост обычно оказывается меньше 2x. Этот рычаг работает по той же причине, по которой сдвигается предел: вы переместили меньше данных в памяти.

Как измерить каждую фазу на собственном сервере?

Ollama возвращает разделение времени в теле ответа. Запросите генерацию без потоковой передачи (non-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 управляет работающим сервером и сообщает время до первого токена и задержку на каждый выходной токен с учетом перцентилей. Это самый прямой способ увидеть, как две фазы конкурируют друг с другом в стеке, который вы уже используете. Инструменты GenAI-Perf и LLMPerf от NVIDIA измеряют те же показатели, если вы предпочитаете использовать отдельное решение. Прежде чем приступать к настройке, получите чистые базовые показатели: метод, описанный в измерении количества токенов в секунду на локальной LLM, позволит вам получить данные, которые сохранятся после перезагрузки.

Почему длинный системный промпт задерживает появление первого токена, но не влияет на скорость потоковой передачи?

Потому что системный промпт — это исключительно этап предварительного заполнения (prefill). Он обрабатывается один раз, в том же проходе, что и остальная часть промпта, до появления первого токена. После этого прохода он существует только в виде записей в KV-кэше, и процесс декодирования считывает их наравне с остальными данными. Поэтому без использования кэширования префиксов (prefix caching) системный промпт объемом 3000 токенов увеличивает TTFT (время до первого токена) для каждого отдельного запроса, при этом скорость генерации токенов в секунду остается практически неизменной.

Практически, но не совсем. Эти дополнительные записи в KV-кэше считываются снова на каждом шаге декодирования, поэтому очень длинный промпт все же немного замедляет процесс. Следующий раздел посвящен этому вопросу.

Решение заключается в том, чтобы прекратить повторные вычисления одного и того же префикса. Сервер с поддержкой кэширования префиксов сохраняет KV-кэш общего префикса и повторно использует его, поэтому второй запрос с тем же системным промптом полностью пропускает этап prefill для этой части. vLLM называет это автоматическим кэшированием префиксов; проверьте vllm serve --help для вашей версии, так как настройки по умолчанию менялись в разных релизах. Этот KV-кэш, находящийся в GPU, отличается от кэша промптов, за который выставляют счета API-провайдеры, и разницу между KV-кэшем и кэшем промптов стоит изучить перед настройкой любого из них.

Почему процесс декодирования замедляется по мере заполнения контекста?

Существует две причины, обе связаны с KV cache.

Первая — пропускная способность. На каждом шаге декодирования механизм внимания считывает ключи и значения для всех предыдущих токенов. Веса модели — это фиксированные затраты на каждый токен. Размер 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 cache один раз при запуске, в vLLM это настраивается через --gpu-memory-utilization, и когда пул заполняется, новые запросы переходят в очередь ожидания. Рост vllm:num_requests_waiting при значении vllm:kv_cache_usage_perc, близком к 1, является точным признаком такого состояния. Некоторые стеки прерывают выполнение текущего запроса и пересчитывают его кэш позже вместо постановки в очередь, что пользователь воспринимает как зависание в середине генерации ответа.

Длинный контекст обходится дорого дважды: требуется больше вычислительных ресурсов на этапе prefill в начале и больше операций чтения из памяти на каждый токен при генерации остальной части ответа.

Почему пакетная обработка увеличивает пропускную способность, но ухудшает хвостовую задержку?

Поскольку процесс декодирования ограничен пропускной способностью памяти, дополнительные запросы практически не требуют вычислительных затрат. Одно чтение весов позволяет сгенерировать токен для каждой последовательности в пакете, поэтому общая пропускная способность растет почти линейно с увеличением размера пакета, пока не исчерпается пул KV-кэша или пока пакет не станет настолько большим, что снова упрется в вычислительные мощности. Метод continuous batching пересобирает пакет на каждом шаге: завершенный запрос покидает очередь, а новый добавляется, не дожидаясь завершения соседних.

Расплата наступает в показателях перцентилей. Теперь генерация следующего токена для каждого пользователя ожидает завершения самой медленной части общего шага. В результате p50 (медиана) остается приемлемой, а p99 (самый медленный 1 запрос из 100) увеличивается. Пользователи замечают именно p99, так как это ощущается как пауза в середине предложения.

Этап prefill делает проблему более выраженной. Большой промпт, поступивший в процессе генерации, занимает устройство на один длительный шаг, и все пользователи, получающие поток токенов, сталкиваются с задержкой. Метод chunked prefill устраняет большую часть этого эффекта, разбивая длинный промпт на части и включая каждую часть в пакеты декодирования. По состоянию на октябрь 2026 года движок vLLM V1 делает это по умолчанию и позволяет управлять балансом через --max-num-batched-tokens. В документации по настройке vLLM этот компромисс описан прямо: меньшие значения, около 2048, обеспечивают лучшую задержку между токенами (ITL), так как меньше операций prefill прерывают декодирование, а большие значения улучшают TTFT, так как в один пакет помещается больше токенов prefill. Этот единственный флаг определяет баланс между prefill и декодированием, представленный в виде числа, которое можно изменять. Вопрос о том, при каком значении p99 перестает быть приемлемым, зависит от емкости системы, и в статье сколько одновременных пользователей может обслуживать одна self-hosted LLM этот процесс подробно разобран с использованием тех же метрик.

Почему более мощный GPU иногда не дает прироста производительности?

Потому что «более мощный» обычно означает больше вычислительных ресурсов, а для декодирования вычислительная мощность не является критическим фактором.

Сравните две строки в таблице выше. Для A100 80GB заявленная пропускная способность составляет 2039 ГБ/с, а для L40S — 864 ГБ/с; предел декодирования меняется пропорционально: 127 токенов в секунду против 54. RTX 4090 — очень быстрая карта по большинству показателей, и её 1008 ГБ/с обеспечивают предел в 63. Независимо от других различий между картами, скорость декодирования одного потока напрямую зависит от пропускной способности памяти, указанной в спецификации.

Таким образом, есть два способа ускорить декодирование: считывать меньше байтов на токен (квантование весов или использование меньшей модели) либо увеличить пропускную способность памяти. Для этапа prefill ситуация обратная. Он требует вычислительных мощностей, поэтому более быстрая карта действительно сокращает TTFT при длинных запросах. Если проблема в том, что первый токен генерируется четыре секунды, более производительное оборудование может её решить. Если же жалоба на то, что текст выводится медленно, замена оборудования, скорее всего, не поможет.

Стоит ли запускать prefill и decode на разных воркерах?

Крупные стеки обслуживания делают именно так; этот метод называется дезагрегацией prefill и decode. Один пул воркеров выполняет только prefill, второй — только decode, а KV cache, созданный первым пулом, передается второму через высокоскоростное соединение. Это работает, так как для этих фаз требуются разные аппаратные ресурсы и разные стратегии планирования. Prefill требует вычислительной мощности и обработки больших пакетов токенов. Decode требует пропускной способности памяти и поддержки множества одновременных последовательностей. Разделение позволяет масштабировать каждый пул независимо и предотвращает ситуацию, когда один огромный промпт блокирует все активные потоки.

На одном VPS (virtual private server) с одним GPU это почти никогда не имеет смысла. Вы будете делить одно устройство само с собой и превратите передачу указателя в сетевую передачу гигабайтов кэша. Этот метод становится эффективным, когда у вас достаточно ускорителей, чтобы выделить целые машины под каждую фазу, и достаточно стабильный трафик, чтобы загрузить оба пула. При меньших масштабах chunked prefill обеспечивает практически такую же изоляцию с помощью одного флага.

Что изменить, если показатели неудовлетворительны

Если TTFT слишком высок:

  • Сократите промпт. Стоимость префилла зависит от количества токенов в промпте, и без использования prefix caching системный промпт оплачивается при каждом запросе.
  • Включите prefix caching, чтобы повторяющийся префикс вычислялся один раз, а не каждый раз заново.
  • Увеличьте --max-num-batched-tokens, чтобы в каждом шаге выполнялось больше работы по префиллу.
  • Проверьте очередь, прежде чем винить модель. Значение vllm:num_requests_waiting выше нуля означает, что запрос еще не был запущен, что указывает на нехватку ресурсов.

Если количество токенов в секунду слишком мало:

  • Используйте квантование весов. Меньше байт на вес означает меньший объем данных, считываемых для генерации каждого токена.
  • Сравните пропускную способность памяти вашей карты с данными из таблицы выше и оцените, насколько вы близки к пределу.
  • Уменьшите --max-num-batched-tokens, чтобы префиллы реже прерывали процесс декодирования.
  • Проверьте длину контекста. При диалоге, разросшемся до тысяч токенов, на каждом шаге считывается значительно больший объем KV cache.

Среда выполнения также имеет значение, поскольку Ollama и vLLM планируют префилл и декодирование по-разному, и настройка, помогающая одному инструменту, может не дать эффекта для другого. Сначала проведите измерения для обеих фаз, и только после этого меняйте один параметр за раз.

FAQ

Почему генерация первого токена занимает секунды, а последующие выводятся быстро?

Ожидание вызвано фазой prefill, а потоковый вывод — фазой decode. На этапе prefill модель обрабатывает весь промпт целиком за один вычислительный проход до появления первого токена, поэтому затраты времени растут вместе с длиной промпта. Затем на этапе decode модель генерирует по одному токену за шаг со скоростью, определяемой пропускной способностью памяти, которая почти не зависит от длины промпта. Обычно причиной задержки является длинный системный промпт в каждом запросе. Использование кэширования префикса (prefix caching) позволяет исключить повторяющуюся часть этих затрат.

Снижает ли длинный промпт скорость генерации токенов в секунду?

Незначительно, и по другой причине, чем TTFT. На каждом шаге decode модель считывает ключи и значения (KV cache) всех предыдущих токенов, поэтому больший размер KV cache означает больше байтов, считываемых для каждого токена. Для стандартной архитектуры с 8 миллиардами параметров кэш занимает около 128 KiB на токен, так что контекст в 8,000 токенов — это примерно 1 GB данных, к которым происходит обращение на каждом шаге. Однако основной эффект от длинного промпта по-прежнему проявляется в TTFT, а не в скорости потоковой генерации.

Какая характеристика GPU определяет скорость decode?

Пропускная способность памяти. Разделите заявленную пропускную способность на размер весов в памяти, и вы получите теоретический предел для одного потока. Видеокарта с большей вычислительной мощностью, но такой же пропускной способностью не будет генерировать токены быстрее. Именно поэтому квантование весов до 8 бит примерно удваивает предел скорости decode: оно вдвое сокращает объем байтов весов, считываемых для каждого токена. Реальный прирост обычно меньше, так как KV cache по-прежнему считывается в полном объеме, а некоторые 8-битные форматы добавляют дополнительные операции на каждый токен, например, квантование активаций.

Почему общая пропускная способность растёт при добавлении пользователей, но каждый из них ощущает замедление?

Одно считывание весов позволяет сгенерировать токен для каждой последовательности в батче, поэтому общее количество токенов в секунду растет вместе с размером батча. При этом каждый отдельный токен ожидает завершения общего шага, поэтому задержка для пользователя одновременно увеличивается. Отслеживайте p99 inter-token latency, а не совокупный показатель пропускной способности, и проверяйте vllm:num_requests_waiting, чтобы понять, стоят ли запросы в очереди или они уже выполняются.

Была ли эта статья полезной?