Инференс · Производительность GPU
Измеряем скорость decode LLM через пропускную способность памяти

Скорость генерации токенов у большой языковой модели часто упирается не в количество CUDA-ядер, а в то, как быстро GPU успевает прочитать веса и KV-cache. Поэтому до запуска длинного benchmark можно оценить порядок величины через traffic budget — бюджет трафика памяти на один decode-шаг.
Метод не заменяет измерение в реальном рантайме: kernel fusion, квантование, форма батча и служебные операции меняют результат. Но он помогает заранее ответить на два инженерных вопроса: сколько токенов в секунду разумно ожидать от конкретной карты и при каком batch дальнейшее увеличение параллелизма перестанет помогать.
1. Что именно мы оцениваем
В режиме decode модель получает по одному новому токену на каждую последовательность в батче. Для каждой последовательности она выполняет примерно один проход по весам модели и обращается к уже накопленному KV-cache. Если обозначить:
B— размер decode-батча;P— число параметров модели;sw— байт на параметр с учётом формата весов;L— число слоёв;Hkv— число KV-heads;D— размер head;skv— байт на элемент KV-cache;T— длина контекста одной последовательности;BW— измеренная или заявленная пропускная способность памяти GPU, байт/с,
то минимальный traffic budget на один decode-шаг можно приблизить так:
Q ≈ P · sw + B · 2 · L · Hkv · D · skv · T
Первый член — чтение весов. Второй — чтение ключей и значений из KV-cache. Множитель 2 учитывает K и V. Это упрощённая модель: она не включает повторное чтение, выравнивание, метаданные, временные буферы и запись нового KV. В реальной системе полезно добавить коэффициент эффективности η:
tokens/s ≈ η · BW / Q
Для предварительной оценки берите η как диапазон, а не как константу. Например, можно рассмотреть 0,5–0,8 и затем заменить диапазон измеренным значением. Это пример методики, а не факт о конкретном GPU или модели.
2. Сначала определите формат весов и KV-cache
Формат параметров и формат KV-cache влияют на разные части бюджета. Квантование весов уменьшает первый член, а KV-квантизация — второй. При этом размер KV-cache обычно зависит не от общего числа attention-heads, а от числа KV-heads: в MQA или GQA он может быть существенно меньше.
| Компонент | Что считать | Типичные обозначения |
|---|---|---|
| Вес модели | Байт на параметр после упаковки и служебных накладных расходов | FP16/BF16 ≈ 2; INT8 ≈ 1; INT4 ≈ 0,5 как идеализированная оценка |
| KV-cache | Байт на элемент K или V | FP16/BF16 ≈ 2; FP8 ≈ 1; INT8 ≈ 1 |
| Временные данные | Не входят в базовую формулу напрямую | Учитываются через η и запас VRAM |
Значение 0,5 байта на параметр для INT4 — только нижняя оценка упаковки. Scale, zero-point, групповые параметры и выравнивание увеличивают фактический размер. Если точного размера нет, измерьте размер файлов или буферов в памяти и разделите его на число параметров.
3. Рассчитайте traffic budget
Для воспроизводимости зафиксируйте одну конфигурацию: модель, число параметров, число слоёв, GQA-параметры, тип весов, тип KV-cache, batch и длину контекста. Не смешивайте prefill и decode: prefill имеет другую арифметику и обычно лучше использует вычислительные блоки.
Безопасный локальный пример расчёта на Python не запускает модель и не изменяет систему:
from dataclasses import dataclass
@dataclass
class Config:
params: float # число параметров
weight_bytes: float
layers: int
kv_heads: int
head_dim: int
kv_bytes: float
batch: int
context: int
bandwidth_gib_s: float
efficiency: float
def estimate(c: Config):
weight_traffic = c.params * c.weight_bytes
kv_per_sequence = 2 * c.layers * c.kv_heads * c.head_dim * c.kv_bytes * c.context
total_traffic = weight_traffic + c.batch * kv_per_sequence
bandwidth = c.bandwidth_gib_s * (1024 ** 3)
tok_s = c.efficiency * bandwidth / total_traffic
return {
"weight_traffic_gib": weight_traffic / 1024**3,
"kv_per_sequence_gib": kv_per_sequence / 1024**3,
"total_traffic_gib": total_traffic / 1024**3,
"estimated_decode_tokens_s": tok_s,
}
cfg = Config(
params=7e9,
weight_bytes=2.0,
layers=32,
kv_heads=8,
head_dim=128,
kv_bytes=2.0,
batch=8,
context=4096,
bandwidth_gib_s=800,
efficiency=0.65,
)
print(estimate(cfg))
Числа в примере демонстрационные. Они нужны только для проверки формул и не являются измерением конкретной модели или видеокарты. Для своей конфигурации замените все поля на значения из документации модели, рантайма и фактического профиля памяти.
4. Оцените скорость decode
В первом приближении скорость decode на один поток определяется тем, сколько байт можно пропустить через память за секунду. Если KV-cache мал относительно весов, увеличение batch позволяет использовать одну загрузку весов сразу для нескольких последовательностей. Поэтому суммарная производительность растёт, а latency отдельной последовательности может ухудшаться.
Разделите два показателя:
- aggregate tokens/s — сколько новых токенов в секунду генерирует весь батч;
- tokens/s per sequence — скорость одной последовательности, приблизительно aggregate tokens/s, делённая на batch при равномерной работе.
Формула η · BW / Q даёт aggregate throughput для выбранного батча, если все последовательности имеют одинаковый контекст. При разной длине контекста используйте среднее или, лучше, отдельно считайте короткие и длинные запросы: KV-traffic растёт линейно с T.
5. Найдите ridge batch
Ridge batch — практическая граница, после которой добавление последовательностей начинает приносить всё меньше throughput. В упрощённой memory-bound модели её можно связать с равенством весового и KV-трафика:
P · sw ≈ Bridge · 2 · L · Hkv · D · skv · T
Отсюда:
Bridge ≈ (P · sw) / (2 · L · Hkv · D · skv · T)
Это не универсальный порог, а ориентир. До него повторное использование чтения весов обычно особенно выгодно. После него KV-cache становится сопоставимым или доминирующим источником трафика. На практике стройте небольшую таблицу по batch и ищите точку, где прирост aggregate throughput на удвоение batch становится малым, а задержка и расход VRAM продолжают расти.
Для серверного планировщика полезно считать ridge batch отдельно для нескольких значений контекста: 1K, 4K, 8K и максимального рабочего окна. Один и тот же GPU может иметь высокий ridge batch на коротких запросах и очень низкий — на длинных.
6. Рассчитайте критическую длину контекста
Критическая длина контекста — значение, при котором KV-трафик одного батча сравнивается с трафиком весов:
Tcritical ≈ (P · sw) / (B · 2 · L · Hkv · D · skv)
Ниже этой длины доминирует чтение весов. Выше неё доминирует чтение KV-cache, и ускорение от уменьшения размера весов становится менее заметным. Зато уменьшение KV-cache с FP16 до FP8 или INT8 примерно вдвое снижает соответствующий член формулы, если рантайм действительно хранит и читает cache в этом формате.
Важно различать логическую и физическую длину контекста. При paged KV-cache блоки выделяются страницами, поэтому фактический расход может быть округлён вверх. При sliding-window attention старые токены перестают участвовать в attention, и в формулу нужно подставлять эффективное окно, а не всю историю диалога.
7. Сравните типы KV-cache и весов
Удобно рассматривать четыре сценария. Ниже не приведены готовые цифры: итог зависит от архитектуры, рантайма и реального размера буферов.
| Весы | KV-cache | Что изменится в модели | Главный риск |
|---|---|---|---|
| FP16/BF16 | FP16/BF16 | Большой весовой и KV-бюджет | Быстрый рост VRAM при batch и контексте |
| INT8 | FP16/BF16 | Снижается весовой трафик, KV остаётся прежним | KV становится ограничителем раньше |
| INT4 | FP16/BF16 | Весовой трафик ещё ниже | Накладные расходы упаковки и качество декодирования |
| INT4 или INT8 | FP8/INT8 | Снижаются оба основных источника трафика | Поддержка формата, точность и фактическая реализация kernels |
Если модель использует GQA, уменьшение Hkv часто даёт больший эффект для длинного контекста, чем дальнейшее уменьшение размера весов. Поэтому сравнивайте не только типы чисел, но и архитектурные параметры KV.
8. Воспроизводимые шаги измерения
- Зафиксируйте версии драйвера, CUDA, рантайма, модели и параметры квантования.
- Убедитесь, что модель и KV-cache помещаются в VRAM с запасом. Не запускайте benchmark на production-сервисе.
- Прогрейте рантайм несколькими короткими запросами, исключив время загрузки модели.
- Измерьте decode отдельно от prefill: задайте достаточно длинный prompt, дождитесь заполнения cache, затем считайте только генерацию.
- Повторите замер для batch 1, 2, 4, 8 и последующих значений до безопасного лимита.
- Повторите серию для нескольких длин контекста и одинакового числа генерируемых токенов.
- Запишите aggregate tokens/s, tokens/s на последовательность, peak VRAM и ошибки out-of-memory.
Набор диагностических команд должен быть только читающим. Например, для NVIDIA можно посмотреть состояние устройства так:
nvidia-smi
nvidia-smi --query-gpu=name,memory.total,memory.used,utilization.gpu,utilization.memory --format=csv
Эти команды не меняют состояние GPU. Не используйте в эксперименте команды, которые завершают чужие процессы, очищают кэш или перезапускают сервис, если у вас нет отдельного окна обслуживания.
Для каждого прогона сохраняйте конфигурацию рядом с результатом. Минимальная строка журнала: дата, GPU, модель, формат весов, формат KV, batch, context, generated tokens, wall time, aggregate tokens/s, peak VRAM и статус завершения.
9. Как проверить результат
Сначала сравните порядок величины измерения с формулой. Если наблюдаемая скорость сильно выше теоретического бюджета, проверьте единицы: GB/s и GiB/s различаются, а «токены в секунду» иногда означает скорость одной последовательности, а не всего батча.
Затем проверьте монотонность:
- рост контекста не должен уменьшать KV-трафик;
- рост batch должен увеличивать или сохранять aggregate throughput до насыщения;
- per-sequence throughput обычно снижается при увеличении batch;
- переход на меньший KV-формат должен уменьшать расчётный KV-budget;
- peak VRAM не должен превышать доступный лимит даже при коротком benchmark.
Если кривая throughput имеет резкий скачок, ищите смену kernel, границу размера workspace, другую схему распределения страниц KV-cache или переход модели на CPU. Такой скачок нельзя объяснять только пропускной способностью памяти.
10. Типовые ошибки и ограничения
Заявленная bandwidth вместо достижимой
Спецификация GPU показывает пиковую пропускную способность. Рантайм видит меньшую эффективную величину из-за доступа к памяти, конкуренции потоков, формата тензоров и служебных операций. Используйте коэффициент η и калибруйте его по одному реальному замеру.
Неправильный размер KV-cache
Ошибка в числе KV-heads или забытый множитель K/V искажает результат линейно. Сверяйте конфигурацию attention, а не подставляйте общее число голов по привычке.
Смешение prefill и decode
Prompt processing и генерация используют разные формы матриц и могут иметь разные узкие места. В отчёте храните их отдельно.
Игнорирование padding и разной длины запросов
В динамическом батчинге реальный KV-трафик определяется распределением длин. Среднее значение может скрыть хвост длинных запросов, который определяет latency и расход памяти.
Слепая вера в квантование
Уменьшение размера весов не гарантирует пропорционального ускорения: kernel может быть ограничен вычислениями, деквантизацией или пропускной способностью другого уровня памяти. Проверяйте фактический формат буферов и трассу рантайма.
Итоговая схема расчёта
Для предварительной оценки на конкретном GPU достаточно следующей последовательности:
- Получите фактический размер весов и параметров модели.
- Определите
L,Hkv,Dи формат KV-cache. - Посчитайте весовой traffic budget и KV-budget для каждого batch/context.
- Оцените decode как
η · BW / Qдиапазоном значенийη. - Найдите
BridgeиTcriticalдля нужной конфигурации. - Проверьте расчёт короткой серией реальных decode-замеров.
Главный практический вывод: для короткого контекста часто ограничителем остаются веса, а для большого batch или длинной истории — KV-cache. Поэтому оптимальный batch нельзя определить отдельно от длины контекста и формата cache. Сначала стройте traffic budget, затем измеряйте место, где модель отходит от этой оценки.
Дополнительные практические материалы: гайды Agent Lab Journal и глоссарий терминов.