Узнайте, как взаимодействуют центральный и графический процессоры в парадигме «хост-устройство».
Делиться
Эта статья является частью серии материалов о распределенном искусственном интеллекте на нескольких графических процессорах:
- Часть 1: Понимание парадигмы «Хост и устройство» (эта статья)
- Часть 2: Перевозки между двумя точками и коллективные перевозки (скоро будет опубликовано)
- Часть 3: Как взаимодействуют графические процессоры (скоро будет опубликовано)
- Часть 4: Накопление градиента и распределенный параллелизм данных (DDP) (скоро будет опубликовано)
- Часть 5: ZeRO (скоро будет доступна)
- Часть 6: Тензорный параллелизм (скоро будет опубликована)
Введение
В этом руководстве объясняются основные принципы взаимодействия центрального процессора (ЦП) и дискретной видеокарты (ГК). Это вводное руководство высокого уровня, призванное помочь вам сформировать представление о парадигме «хост-устройство». Мы сосредоточимся на видеокартах NVIDIA, которые наиболее часто используются для задач искусственного интеллекта.
В случае интегрированных графических процессоров, таких как те, что используются в чипах Apple Silicon, архитектура несколько отличается, и в этой статье она рассматриваться не будет.
Общая картина: хост и устройство
Наиболее важная концепция, которую необходимо усвоить, — это взаимосвязь между хостом и устройством .
- Хост: Это ваш центральный процессор . Он запускает операционную систему и построчно выполняет ваш скрипт на Python. Хост — это управляющий; он отвечает за общую логику и указывает устройству, что делать.
- Устройство: Это ваш графический процессор (GPU) . Это мощный, но специализированный сопроцессор, предназначенный для массовых параллельных вычислений. Устройство является ускорителем; оно ничего не делает, пока хост не даст ему задание.
Ваша программа всегда запускается на центральном процессоре (ЦП). Когда вам нужно, чтобы графический процессор (ГП) выполнил задачу, например, умножение двух больших матриц, ЦП отправляет инструкции и данные на ГП.
Взаимодействие ЦП и ГП
Хост взаимодействует с устройством через систему очередей.
- Команды инициируются ЦП: Ваш скрипт, работающий на ЦП, встречает строку кода, предназначенную для графического процессора (например, tensor.to('cuda')).
- Команды ставятся в очередь: ЦП не ждет. Он просто помещает эту команду в специальный список задач для графического процессора, называемый потоком CUDA — подробнее об этом в следующем разделе.
- Асинхронное выполнение: Центральный процессор не ждет завершения фактической операции графическим процессором, хост переходит к следующей строке вашего скрипта. Это называется асинхронным выполнением , и это ключ к достижению высокой производительности. Пока графический процессор занят вычислениями, центральный процессор может работать над другими задачами, например, подготовкой следующего пакета данных.
CUDA-потоки
CUDA Stream — это упорядоченная очередь операций графического процессора. Операции, отправленные в один поток, выполняются последовательно , одна за другой. Однако операции из разных потоков могут выполняться одновременно — графический процессор может одновременно обрабатывать несколько независимых рабочих нагрузок.
По умолчанию каждая операция PyTorch на графическом процессоре ставится в очередь в текущем активном потоке (обычно это поток по умолчанию, который создается автоматически). Это просто и предсказуемо: каждая операция ожидает завершения предыдущей, прежде чем начать новую. В большинстве случаев это незаметно. Но это снижает производительность, когда есть задачи, которые могут перекрываться.
Множественные потоки: Параллелизм
Классический пример использования нескольких потоков — это совмещение вычислений и передачи данных . Пока графический процессор обрабатывает пакет N, можно одновременно скопировать пакет N+1 из оперативной памяти центрального процессора в видеопамять графического процессора:
Поток 0 (вычисления): [обработка пакета 0]────[обработка пакета 1]─── Поток 1 (данные): ────[копирование пакета 1]────[копирование пакета 2]───
Такая конвейерная обработка данных возможна благодаря тому, что вычисления и передача данных происходят на отдельных аппаратных блоках внутри графического процессора, что обеспечивает истинный параллелизм. В PyTorch вы создаете потоки и планируете работу над ними с помощью менеджеров контекста:
compute_stream = torch.cuda.Stream() transfer_stream = torch.cuda.Stream() with torch.cuda.stream(transfer_stream): # Добавляем передачу в очередь transfer_stream next_batch = next_batch_cpu.to('cuda', non_blocking=True) with torch.cuda.stream(compute_stream): # Эта передача выполняется параллельно с предыдущей output = model(current_batch)
Обратите внимание на флаг non_blocking=True в методе .to(). Без него передача данных все равно будет блокировать поток ЦП, даже если вы планируете выполнять ее асинхронно.
Синхронизация между потоками
Поскольку потоки независимы, необходимо явно указывать, когда один зависит от другого. Простой и понятный инструмент:
torch.cuda.synchronize() # ожидает завершения ВСЕХ потоков на устройстве
Более точечный подход использует события CUDA . Событие отмечает определенную точку в потоке, и другой поток может ожидать ее, не останавливая основной поток ЦП:
event = torch.cuda.Event() with torch.cuda.stream(transfer_stream): next_batch = next_batch_cpu.to('cuda', non_blocking=True) event.record() # отметка: передача завершена with torch.cuda.stream(compute_stream): compute_stream.wait_event(event) # не начинать, пока передача не завершится output = model(next_batch)
Это эффективнее, чем stream.synchronize(), потому что приостанавливает работу зависимого потока только на стороне графического процессора — поток ЦП остается свободным для дальнейшей обработки задач.
Для повседневной работы с кодом обучения PyTorch вам не потребуется вручную управлять потоками. Однако такие функции, как DataLoader(pin_memory=True) и предварительная выборка, в значительной степени зависят от этого механизма. Понимание потоков помогает распознать, зачем нужны эти настройки, и предоставляет инструменты для диагностики скрытых проблем с производительностью, когда они возникают.
Тензоры PyTorch
PyTorch — это мощный фреймворк, который абстрагирует многие детали, но эта абстракция иногда может скрывать то, что происходит «под капотом».
При создании тензора PyTorch он состоит из двух частей: метаданных (таких как его форма и тип данных) и собственно числовых данных. Поэтому, когда вы запускаете что-то вроде `t = torch.randn(100, 100, device=device)`, метаданные тензора сохраняются в оперативной памяти хоста, а его данные — в видеопамяти графического процессора.
Это различие важно. Когда вы запускаете print(t.shape), процессор может немедленно получить доступ к этой информации, поскольку метаданные уже находятся в его собственной оперативной памяти. Но что произойдет, если вы запустите print(t), для чего требуются фактические данные, находящиеся в видеопамяти?
Синхронизация хост-устройства
Доступ к данным графического процессора через центральный процессор может вызвать синхронизацию «хост-устройство» , что является распространенным узким местом в производительности. Это происходит всякий раз, когда центральному процессору требуется результат от графического процессора, который еще недоступен в оперативной памяти центрального процессора.
Например, рассмотрим строку `print(gpu_tensor)`, которая выводит тензор, вычисление которого еще не завершено графическим процессором. Центральный процессор не может вывести значения тензора, пока графический процессор не завершит все вычисления для получения окончательного результата. Когда скрипт доходит до этой строки, центральный процессор вынужден блокироваться , то есть останавливаться и ждать завершения работы графического процессора. Только после того, как графический процессор завершит свою работу и скопирует данные из своей видеопамяти в оперативную память центрального процессора, центральный процессор сможет продолжить выполнение.
В качестве другого примера, в чем разница между torch.randn(100, 100).to(device) и torch.randn(100, 100, device=device)? Первый метод менее эффективен, поскольку он создает данные на ЦП, а затем передает их на ГП. Второй метод более эффективен, поскольку он создает тензор непосредственно на ГП; ЦП только отправляет команду создания.
Эти точки синхронизации могут существенно повлиять на производительность. Эффективное программирование графического процессора предполагает их минимизацию, чтобы обеспечить максимальную загрузку как хоста, так и устройства. В конце концов, вы хотите, чтобы ваши графические процессоры работали максимально быстро.
Масштабирование: распределенные вычисления и ранги
Обучение больших моделей, таких как большие языковые модели (LLM), часто требует большей вычислительной мощности, чем может предложить один графический процессор (GPU). Координация работы на нескольких графических процессорах открывает мир распределенных вычислений.
В этом контексте возникает новое и важное понятие: ранг .
- Каждый ранг представляет собой процесс ЦП, которому назначается одно устройство (ГП) и уникальный идентификатор. Если вы запустите обучающий скрипт на двух ГП, вы создадите два процесса: один с рангом = 0, а другой с рангом = 1.
Это означает, что вы запускаете два отдельных экземпляра своего скрипта Python. На одной машине с несколькими графическими процессорами (на одном узле) эти процессы работают на одном и том же центральном процессоре, но остаются независимыми, не разделяя память или состояние. Процесс 0 управляет назначенным ему графическим процессором (cuda:0), а процесс 1 — другим графическим процессором (cuda:1). Хотя оба процесса выполняют один и тот же код, вы можете использовать переменную, содержащую идентификатор процесса, чтобы назначать разные задачи каждому графическому процессору, например, заставлять каждый обрабатывать разную часть данных (примеры этого мы увидим в следующей статье этой серии).
Заключение
Поздравляем, что дочитали до конца! В этом посте вы узнали о:
- Взаимоотношения хоста и устройства
- Асинхронное выполнение
- CUDA Streams и как они обеспечивают одновременную работу графического процессора.
- Синхронизация хост-устройства
В следующем посте мы подробнее рассмотрим операции «точка-точка» и «коллективные операции», которые позволяют нескольким графическим процессорам координировать сложные рабочие процессы, такие как распределенное обучение нейронных сетей.
Источник: towardsdatascience.com
