Инференс · Производительность GPU

Измеряем скорость decode LLM через пропускную способность памяти

Измеряем скорость decode LLM через пропускную способность памяти
Temporary fallback cover; replace in editorial pass.
Продвинутый уровень До 12 минут Практический расчёт
Самое важное из мира AI — в канале MAX AgentLabОтдельные разборы, инструменты и практические схемы Читайте Agent Lab в Telegram Разборы, кейсы и новости о практических AI-агентах без лишней воды.

Скорость генерации токенов у большой языковой модели часто упирается не в количество CUDA-ядер, а в то, как быстро GPU успевает прочитать веса и KV-cache. Поэтому до запуска длинного benchmark можно оценить порядок величины через traffic budget — бюджет трафика памяти на один decode-шаг.

Метод не заменяет измерение в реальном рантайме: kernel fusion, квантование, форма батча и служебные операции меняют результат. Но он помогает заранее ответить на два инженерных вопроса: сколько токенов в секунду разумно ожидать от конкретной карты и при каком batch дальнейшее увеличение параллелизма перестанет помогать.

1. Что именно мы оцениваем

В режиме decode модель получает по одному новому токену на каждую последовательность в батче. Для каждой последовательности она выполняет примерно один проход по весам модели и обращается к уже накопленному KV-cache. Если обозначить:

то минимальный 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 отдельной последовательности может ухудшаться.

Разделите два показателя:

Формула η · 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. Воспроизводимые шаги измерения

  1. Зафиксируйте версии драйвера, CUDA, рантайма, модели и параметры квантования.
  2. Убедитесь, что модель и KV-cache помещаются в VRAM с запасом. Не запускайте benchmark на production-сервисе.
  3. Прогрейте рантайм несколькими короткими запросами, исключив время загрузки модели.
  4. Измерьте decode отдельно от prefill: задайте достаточно длинный prompt, дождитесь заполнения cache, затем считайте только генерацию.
  5. Повторите замер для batch 1, 2, 4, 8 и последующих значений до безопасного лимита.
  6. Повторите серию для нескольких длин контекста и одинакового числа генерируемых токенов.
  7. Запишите 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 различаются, а «токены в секунду» иногда означает скорость одной последовательности, а не всего батча.

Затем проверьте монотонность:

Если кривая 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 достаточно следующей последовательности:

  1. Получите фактический размер весов и параметров модели.
  2. Определите L, Hkv, D и формат KV-cache.
  3. Посчитайте весовой traffic budget и KV-budget для каждого batch/context.
  4. Оцените decode как η · BW / Q диапазоном значений η.
  5. Найдите Bridge и Tcritical для нужной конфигурации.
  6. Проверьте расчёт короткой серией реальных decode-замеров.

Главный практический вывод: для короткого контекста часто ограничителем остаются веса, а для большого batch или длинной истории — KV-cache. Поэтому оптимальный batch нельзя определить отдельно от длины контекста и формата cache. Сначала стройте traffic budget, затем измеряйте место, где модель отходит от этой оценки.

Дополнительные практические материалы: гайды Agent Lab Journal и глоссарий терминов.