Заклинание драконов: как заставить NVIDIA и Intel ARC работать вместе для LLM

Почему эта статья нужна прямо сейчас

У вас есть RTX 4090 на 24 ГБ и Intel Arc Pro B60 на 24 ГБ. По отдельности - ни одна не тянет Llama 3.2 70B. Вместе - 48 ГБ VRAM, теоретически хватает. Вы запускаете модель через llama.cpp с флагом --gpu-layers, надеясь на чудо. А получаете скорость 0.5 токена в секунду и ошибки CUDA.

Знакомо? Это не баг, это feature. Смешанные GPU конфигурации - самый болезненный, но и самый эффективный способ получить много VRAM за небольшие деньги. Особенно после того, как я показал, что Intel Arc Pro B60 стоит в три раза дешевле RTX 3090 при тех же 24 ГБ.

Три подхода к параллелизации: от простого к сложному

Прежде чем лезть в код, нужно понять, какую проблему мы решаем. Есть три принципиально разных способа заставить несколько GPU работать вместе:

1 Layer splitting (разделение по слоям)

Самый простой метод, который поддерживает почти все инструменты. Модель разрезается горизонтально: первые 20 слоев на GPU 0, следующие 20 на GPU 1. Работает в llama.cpp, Ollama, некоторых версиях Hugging Face.

Проблема: каждый токен должен пройти через все GPU последовательно. Если у вас 40 слоев на двух картах, токен прыгает туда-сюда 40 раз. Задержки на передачу убивают производительность.

2 Tensor parallelism (тензорный параллелизм)

Сложнее, но эффективнее. Каждый слой модели разделяется вертикально: матричные умножения распределяются между GPU. Нужно в 10 раз больше синхронизации, но данные передаются реже.

Поддерживается в vLLM с версии 0.4.0 (2025), NVIDIA TensorRT-LLM, и некоторых кастомных сборках PyTorch.

3 Pipeline parallelism (конвейерный параллелизм)

Промышленный уровень. Разные батчи обрабатываются на разных GPU одновременно. Пока GPU 0 обрабатывает слой 1 для токена A, GPU 1 обрабатывает слой 1 для токена B.

Требует DeepSpeed или Megatron-LM. Для инференса - overkill в 99% случаев.

Практика: запускаем Llama 3.2 70B на RTX 4090 + Intel Arc Pro B60

Давайте смотреть правде в глаза: документация llama.cpp про --ngl (n-gpu-layers) врет. Или, точнее, недоговаривает. Вот что происходит на самом деле.

Как НЕ надо делать (вы это уже пробовали)

# Это почти гарантированно сломается или будет работать медленно
./llama-cli -m llama-3.2-70b.Q4_K_M.gguf \
  --n-gpu-layers 999 \
  --gpu-layers-draft 999 \
  --main-gpu 0 \
  --tensor-split 24,24

Почему это плохо? Потому что --tensor-split 24,24 пытается разделить тензоры поровну между GPU. Но у вас разные архитектуры, разные драйверы, разная скорость памяти. Система не знает, что Intel ARC в 1.7 раза медленнее.

Правильный способ: ручное распределение нагрузки

Сначала установите самую новую версию llama.cpp на январь 2026. Проверьте, что у вас llama.cpp версии 0.15.0 или выше - там улучшили поддержку Intel GPU через SYCL.

# Клонируем и собираем с поддержкой CUDA и SYCL
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build && cd build
cmake .. -DLLAMA_CUDA=ON -DLLAMA_SYCL=ON -DLLAMA_SYCL_TARGET=INTEL
make -j$(nproc)

Теперь ключевой момент: нужно определить, сколько слоев отправить на каждую карту. Не поровну, а пропорционально производительности.

# Запускаем бенчмарк на каждой карте отдельно
# На NVIDIA:
./llama-cli -m llama-3.2-70b.Q4_K_M.gguf --n-gpu-layers 40 -ngl 40 --no-mmap
# Записываем скорость в токенах/сек

# На Intel ARC (через SYCL):
./llama-cli -m llama-3.2-70b.Q4_K_M.gguf --n-gpu-layers 40 -ngl 40 --no-mmap -s 1000
# SYCL флаг может отличаться, проверяйте документацию

Допустим, получилось: NVIDIA - 15 токенов/сек, Intel ARC - 9 токенов/сек. Соотношение 5:3. Значит, из 80 слоев модели, 50 должны быть на NVIDIA, 30 на Intel ARC.

# Финальная команда:
./llama-cli -m llama-3.2-70b.Q4_K_M.gguf \
  --n-gpu-layers 80 \
  --gpu-layers-draft 80 \
  --tensor-split 50,30 \
  --main-gpu 0 \
  --no-mmap \
  -c 4096 \
  -b 512 \
  -t 12

Флаг --no-mmap критически важен для смешанных конфигураций. Без него система пытается маппить одну и ту же память на разные драйверы - гарантированный краш.

vLLM с mixed GPU: новая фича, которая работает (иногда)

vLLM 0.5.0 (релиз декабрь 2025) добавил экспериментальную поддержку heterogeneous GPU. Это значит, можно использовать разные модели карт в одном инстансе. Но с оговорками.

# Установите vLLM 0.5.0 или новее
pip install vLLM>=0.5.0

# В коде:
from vllm import LLM, SamplingParams

# Это сработает только если у вас CUDA 12.4+ и драйверы поддерживают
# unified memory между разными GPU (чаще всего - нет)
llm = LLM(
    model="meta-llama/Llama-3.2-70B",
    tensor_parallel_size=2,
    gpu_memory_utilization=0.9,
    max_model_len=8192,
    # Ключевой параметр:
    enforce_eager=True,  # Отключает graph capture, который ломается на mixed GPU
)

Проблема в том, что vLLM ожидает одинаковую производительность от всех GPU. Если один медленнее - вся система ждет его. Решение - использовать separate_weights для распределения слоев:

# Экспериментальная фича, может сломаться
llm = LLM(
    model="meta-llama/Llama-3.2-70B",
    tensor_parallel_size=2,
    separate_weights=["cuda:0", "cuda:1"],  # На самом деле для Intel нужно "sycl:0"
    # Но vLLM пока плохо дружит с SYCL
)

Оценка производительности: какие цифры реальны

Давайте убьем главный миф: "48 ГБ VRAM = можно запустить любую модель". На деле, производительность определяется тремя факторами:

Реальная математика для RTX 4090 + Intel Arc Pro B60:

• RTX 4090 один: 18 токенов/сек на Llama 3.2 70B Q4_K_M
• Intel ARC один: 10 токенов/сек (из-за медленной памяти)
• Теоретический максимум: 10 токенов/сек (ограничено медленным)
• Реальный результат с overhead: 7-8 токенов/сек

Да, вместе они работают медленнее, чем RTX 4090 одна. Но! Они позволяют запустить модель, которая вообще не влезает в одну карту. Это trade-off: доступность vs скорость.

Частые ошибки и как их избежать

Ошибка 1: Несовместимые драйверы

NVIDIA драйвер 550.xx + Intel oneAPI 2025.3 = гарантированный краш. Нужно либо обновить Intel до 2026.1, либо откатить NVIDIA до 545.xx.

Ошибка 2: Неправильное распределение памяти

# Плохо: пытается зарезервировать всю память заранее
--tensor-split 24,24 --gpu-layers 999

# Хорошо: резервирует по мере необходимости
--tensor-split 20,28 --gpu-layers 60 --no-mmap

Ошибка 3: Игнорирование теплового троттлинга

Intel ARC Pro B60 греется меньше, чем RTX 4090 (225W vs 450W). Но если поставить их рядом в корпусе без хорошего обдува - NVIDIA будет троттлить. Решение: мониторить температуру и настраивать power limits.

Ошибка 4: Одинаковые настройки для разных GPU

Flash Attention 2 работает на NVIDIA, но не на Intel ARC. Нужно отключать:

# В transformers:
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.2-70B",
    torch_dtype=torch.float16,
    device_map="auto",
    # Отключаем оптимизации для Intel:
    use_flash_attention_2=False,
)

Когда это вообще стоит делать?

Смешанные GPU конфигурации - не для всех. Вот четкие критерии:

1. У вас уже есть одна мощная карта (RTX 4090/5090) и нужно больше VRAM
2. Бюджет не позволяет купить вторую такую же
3. Вы готовы потратить 2-3 дня на настройку и отладку
4. Ваша задача - инференс, а не обучение (обучение на mixed GPU - ад)
5. Вы не боитесь читать исходный код llama.cpp, когда что-то ломается

Если все пять пунктов про вас - дерзайте. Если нет - рассмотрите альтернативы:

• Аренда облачного GPU с большей памятью (дорого в долгосрочной перспективе)
• Сборка фермы из одинаковых б/у карт (дешевле, чем кажется)
• Использование меньшей модели с квантованием (Llama 3.2 13B вместо 70B)

Что изменится в 2026-2027

Глядя на roadmap основных проектов:

• llama.cpp: Полная поддержка SYCL 2026, автоматическое определение оптимального распределения слоев
• vLLM: Нативная поддержка Intel/AMD GPU через PLATFORM API (ожидается в 0.6.0)
• PyTorch: torch.compile для mixed GPU (экспериментально уже сейчас)
• Intel: Карты следующего поколения с PCIe 6.0 и памятью HBM3e (конкуренция NVIDIA)

Мой прогноз: к концу 2026 mixed GPU конфигурации станут на 50% менее болезненными. Автоматические оптимизаторы научатся учитывать разницу в производительности. Но ручная настройка все равно будет нужна для maximum performance.

А пока - сохраните эту статью в закладки. Когда в следующий раз попробуете запустить модель на двух разных картах и получите ошибку "CUDA error: invalid device ordinal", вернитесь к разделу "Правильный способ: ручное распределение нагрузки".

И да, не забудьте сделать бэкап системы перед экспериментами. Trust me.