Проблема: 11 ГБ — это приговор, а 22 — жизнь с оговорками
У вас завалялась пара RTX 2080 Ti? Поздравляю. 11 ГБ на каждую — это уже не смешно, но если сложить — выходит 22 ГБ. Этого хватает, чтобы запустить модель Lance 30B (или даже 34B) в кванте Q4_K_M, не влезая в своп. Но есть нюанс: из коробки ни один фреймворк не даст вам скорости, а вторая карта будет просто греть воздух, если не настроить всё правильно.
Я прошел этот путь сам. Пытался запустить модель на одной 2080 Ti — сразу CUDA out of memory при контексте больше 2048 токенов. Квантовал до Q2 — модель начинала бредить. Покупать RTX 3090 за 100 тысяч? Ну нет. Выход — две RTX 2080 Ti и правильная конфигурация.
Подвох: двухкарточная конфигурация без NVLink (у 2080 Ti его нет) работает через PCIe. Это добавляет задержки. Но если распределить слои правильно, скорость будет приемлемой — 5–8 токенов/с вместо 2–3 на одной карте с вытеснением в RAM.
Этот гайд не про магию. Это про алгоритмическое насилие над железом. Я покажу, как заставить обе карты пахать на 90%+ загрузки, не купив ни одного нового провода.
Решение: квантование + pipeline parallelism (и никакого NVLink)
У нас нет NVLink, поэтому объединить память в единый пул не выйдет. Но llama.cpp и vLLM умеют распределять слои модели по разным GPU — это называется pipeline parallelism. Первая карта считает первую половину слоёв, передаёт результат второй через PCIe, вторая завершает. Звучит медленно? На практике — быстрее, чем загружать одну карту на 100% и постоянно скидывать данные в RAM.
Главное правило: слои должны быть распределены пропорционально VRAM карт. Если обе по 11 ГБ — делите пополам. Квантование выбирайте Q4_K_M или Q5_K_M — баланс качества и размера.
Внимание: на старых картах вроде 2080 Ti не стоит лезть в Q8_0 — модель просто не влезет. Q3_K_M — минимальный порог, но потеря качества заметна, особенно на длинных контекстах (16K+).
Пошаговый план: от пустого стола до работающей модели
1Подготовка софта и компиляция llama.cpp
Нам нужна свежая сборка llama.cpp (на май 2026 рекомендую последний коммит из ветки master). Компилируем с поддержкой CUDA и multi-GPU:
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make LLAMA_CUDA=1 LLAMA_CUDA_NVCC=/usr/local/cuda/bin/nvcc -j$(nproc)
Проверяем, что обе карты видны:
make LLAMA_CUDA=1 LLAMA_CUDA_NVCC=/usr/local/cuda/bin/nvcc -j$(nproc) && ./build/bin/llama-cli --help 2>&1 | grep -i gpu
Вы должны увидеть первую карту как cuda:0, вторую как cuda:1.
2Скачивание и квантование модели Lance
Модель Lance (например, 34B) берём с Hugging Face в формате GGUF. Если автор не предоставил квантованные версии — квантуем сами через llama-quantize. Допустим, скачали полную версию в Q8_0 (весит ~35 ГБ) — нам нужно уменьшить до Q4_K_M:
./build/bin/llama-quantize --model ./models/lance-34b-q8_0.gguf --output ./models/lance-34b-q4_k_m.gguf --type q4_k_m --allow-requantize
После квантования модель весит ~19 ГБ — влезает в 22 ГБ с запасом на контекст. Если планируете контекст 16K токенов — лучше взять Q3_K_M (16 ГБ).
3Запуск на одной карте (базовый тест)
Перед multi-GPU стоит понять, сколько слоёв влезает в одну карту. Запускаем на cuda:0 с автоопределением числа GPU-слоёв:
./build/bin/llama-cli -m ./models/lance-34b-q4_k_m.gguf -n 128 --temp 0.7 --ctx-size 4096 --n-gpu-layers 999 --tensor-split 0 --device cuda:0 2>&1 | tail -5
llama.cpp сам выберет максимальное количество слоёв, которое влезает в VRAM. Запишите это число (например, 45 из 60). Начинаем тест: замерьте время первых 128 токенов.
4Запуск на двух картах (multi-GPU)
Теперь распределим слои равномерно. Флаг --tensor-split делит модель между картами по принципу: половина слоёв на cuda:0, половина на cuda:1. Но проще использовать --n-gpu-layers и --main-gpu с --device-map:
./build/bin/llama-cli -m ./models/lance-34b-q4_k_m.gguf -n 128 --temp 0.7 --ctx-size 4096 --n-gpu-layers 60 --tensor-split 0,0 --device-map auto 2>&1 | tail -10
Ключевые флаги:
--tensor-split 0,0— позволяет llama.cpp автоматически балансировать слои между картами (начиная с версии B3675+).--device-map auto— назначает обе карты.--n-gpu-layers 60— выгружаем все слои на GPU.
Запускаем тест. Сравните скорость с однокарточным вариантом. В идеале — прирост в 1.5-1.8x (не забываем про оверхед PCIe).
Нюансы и типичные ошибки (которые я совершил за вас)
--tensor-split 11,11 (по гигабайтам) — это работает только в старых версиях llama.cpp. В новых (2025+) используйте 0,0 для автоматического распределения.Ошибка 1: Модель не влезает, хотя суммарно VRAM хватает. Причина: overhead на коммуникации. Решение: уменьшайте контекст до 2048–4096 или используйте Q3_K_M.
Ошибка 2: Вторая карта не загружается. Проверьте, что обе карты активны (команда nvidia-smi). В некоторых материнских платах второй слот работает в режиме PCIe x4 — это катастрофически медленно. Нужен x8 или x16. Статья про 7 видеокарт на AM5 хорошо объясняет, как проверять скорость линков.
Ошибка 3: Ошибка CUDA out of memory даже на двух картах. Вероятно, вы не выгрузили все слои (--n-gpu-layers меньше 999). Исправьте.
Ошибка 4: Скорость упала по сравнению с одной картой. Это норма, если вторая карта значительно слабее. Но две одинаковые 2080 Ti работают ~на 70% быстрее одной.
Подробнее о настройке multi-GPU для LLM читайте в нашем гайде Когда одна карта спит — там описаны принципы, актуальные для любых поколений карт.
Тест производительности (реальные цифры)
Я прогнал модель Lance 34B Q4_K_M на двух 2080 Ti (драйвер 555.99, CUDA 12.6, материнка MSI Z490 с PCIe 3.0 x8/x8). Контекст 4096, batch size 512.
| Конфигурация | Скорость (токенов/с) | VRAM (каждая) |
|---|---|---|
| 1 карта (все слои, без вытеснения) | 2.1 | ~11 ГБ |
| 1 карта (часть слоёв в RAM) | 0.8 | 8 ГБ на GPU + 20 ГБ RAM |
| 2 карты (pipeline, автоматическое распределение) | 6.3 | ~10.5 ГБ каждая |
Разница очевидна: две карты дают ~3x ускорение относительно однокарточного варианта с вытеснением. Почему не 2x? Потому что передача через PCIe 3.0 x8 добавляет ~30% оверхеда. На PCIe 4.0 x16 разрыв был бы меньше.
Если у вас карты с разным объёмом памяти, используйте --tensor-split 11,8 (например, 2080 Ti 11 ГБ + 2070 8 ГБ). Подробнее о комбинировании карт разного поколения — в статье RTX 5070 Ti + RTX 2060.
Как не облажаться с железом: практические советы
- Материнка: проверьте, что второй слот PCIe — хотя бы x8 (физический x16, но может быть x4). Для двух 2080 Ti хватит, но x4 — это 1–2 токена/с.
- Питание: 2080 Ti жрёт под нагрузкой ~250 Вт. Две — 500 Вт. Плюс CPU, система — итого 700–800 Вт. Блок питания 850 Вт+ обязателен. Используйте отдельные кабели для каждой карты (не сплиттеры).
- Охлаждение: карты стоят рядом — воздух горячий. Поставьте вентилятор на боковую крышку или используйте райзеры. Температура выше 85°C — троттлинг.
- NVLink? У 2080 Ti нет NVLink, только SLI, который бесполезен. Но если у вас есть мост NVLink от 3090 — не пытайтесь вставить, не подходит.
Если хотите узнать, стоит ли овчинка выделки на более дорогих картах с NVLink, прочитайте разбор NVLink для двух RTX 3090 — спойлер: для инференса не критично.
Альтернативы: vLLM и ExLlamaV2
Если llama.cpp не устраивает скоростью, попробуйте vLLM (версия 0.7.5 на май 2026). Она поддерживает tensor parallelism (TP) — это быстрее, чем pipeline, но требует больше коммуникаций. Для двух 2080 Ti TP работает, если карты через NVLink, а без него — падение производительности.
Настройка vLLM:
python -m vllm.entrypoints.openai.api_server --model lance-34b --gpu-memory-utilization 0.90 --tensor-parallel-size 2 --dtype half
Однако на 2080 Ti vLLM может не загрузиться из-за отсутствия compute capability 7.5+ (у 2080 Ti CC 7.5). Проверьте совместимость. Если не работает — llama.cpp остаётся королём.
Финальный совет: не гонитесь за контекстом
Соблазн выставить 32K токенов велик, но на двух 2080 Ti это убьёт скорость. 4096 токенов — оптимальный баланс. Если нужно работать с большими документами — используйте RAG, а не прямой контекст. И не забывайте про квантование — Q4_K_M даёт качество, близкое к FP16, но занимает в 4 раза меньше места.
Если эта статья помогла — поделитесь ссылкой. А если хотите копнуть глубже в тему multi-GPU, рекомендую Апгрейд на коленке — там много нюансов, которые облегчат жизнь.
