Diese Seite wurde von der Cloud Translation API übersetzt.

A3-VM mit aktiviertem GPUDirect-TCPX erstellen

Linux

Die Beschleunigeroptimierte Maschinenfamilie wurde von Google Cloud entwickelt, um die erforderliche Leistung und Effizienz für GPU-beschleunigte Arbeitslasten wie künstliche Intelligenz (KI), maschinelles Lernen (ML) und Hochleistungs-Computing zu bieten.

Die accelerator-optimierte A3-Maschinenserie hat 208 vCPUs und bis zu 1.872 GB Arbeitsspeicher. Jeder A3-Maschinentyp hat acht NVIDIA H100-GPUs, die 80 GB GPU-Speicher pro GPU bieten. Diese VMs können eine Netzwerkbandbreite von bis zu 1.000 Gbit/s nutzen. Sie eignen sich daher ideal für große transformerbasierte Sprachmodelle, Datenbanken und Hochleistungs-Computing (HPC).

Wenn Sie mit a3-highgpu-8g- oder a3-edgegpu-8g-VMs arbeiten, können Sie GPUDirect-TCPX verwenden, um die niedrigste mögliche Latenz zwischen Anwendungen und dem Netzwerk zu erreichen. GPUDirect-TCPX ist ein benutzerdefinierter RFM-Netzwerkstack (Remote Direct Memory Access), der die Netzwerkleistung Ihrer A3-VMs erhöht, indem er Datennutzlasten direkt vom GPU-Speicher an die Netzwerkschnittstelle übertragen kann, ohne die CPU und den Systemspeicher zu durchlaufen. A3-VMs können GPUDirect-TCPX in Kombination mit Google Virtual NIC (gVNIC) verwenden, um im Vergleich zu den beschleunigungsoptimierten A2- oder G2-Maschinentypen den höchsten Durchsatz zwischen VMs in einem Cluster zu erzielen.

In diesem Dokument erfahren Sie, wie Sie eine a3-highgpu-8g- oder a3-edgegpu-8g-VM erstellen, die auf Container-Optimized OS ausgeführt wird. Außerdem erfahren Sie, wie Sie GPUDirect-TCPX auf der VM aktivieren und die verbesserte GPU-Netzwerkleistung einrichten und testen.

Übersicht

So testen Sie die Netzwerkleistung mit GPUDirect-TCPX:

Richten Sie ein oder mehrere Virtual Private Cloud-Netzwerke (VPC) ein und legen Sie die MTU-Einstellung (auch als Jumbo-Frames bezeichnet) auf 8244 fest.
Erstellen Sie Ihre GPU-VMs mit dem Container-Optimized OS-Image cos-105-lts oder höher.
Installieren Sie die GPU-Treiber auf jeder VM.
Gewähren Sie auf jeder VM den Netzwerkschnittstellenkarten (NICs) Zugriff auf die GPU.
Führen Sie einen NCCL-Test aus.

MTU-Netzwerke im Jumbo Frame einrichten

a3-highgpu-8g- und a3-edgegpu-8g-VMs haben fünf physische NICs. Sie müssen fünf Virtual Private Cloud-Netzwerke erstellen und die MTU auf 8244 festlegen, um die beste Leistung für die physischen NICs zu erzielen.

Verwaltungsnetzwerk, Subnetz und Firewallregel erstellen

Führen Sie die folgenden Schritte aus, um das Verwaltungsnetzwerk einzurichten:

Erstellen Sie das Verwaltungsnetzwerk mit dem Befehl networks create:

gcloud compute networks create NETWORK_NAME_PREFIX-mgmt-net \
  --project=PROJECT_ID \
  --subnet-mode=custom \
  --mtu=8244

Erstellen Sie das Verwaltungssubnetz mit dem Befehl networks subnets create:

gcloud compute networks subnets create NETWORK_NAME_PREFIX-mgmt-sub \
  --project=PROJECT_ID \
  --network=NETWORK_NAME_PREFIX-mgmt-net \
  --region=REGION \
  --range=192.168.0.0/24

Erstellen Sie Firewallregeln mit dem Befehl firewall-rules create.

Erstellen Sie eine Firewallregel für das Verwaltungsnetzwerk.

gcloud compute firewall-rules create NETWORK_NAME_PREFIX-mgmt-internal \
 --project=PROJECT_ID \
 --network=NETWORK_NAME_PREFIX-mgmt-net \
 --action=ALLOW \
 --rules=tcp:0-65535,udp:0-65535,icmp \
 --source-ranges=192.168.0.0/16

Erstellen Sie die Firewallregel tcp:22, um einzuschränken, welche Quell-IP-Adressen eine SSH-Verbindung zu Ihrer VM herstellen können.

gcloud compute firewall-rules create NETWORK_NAME_PREFIX-mgmt-external-ssh \
 --project=PROJECT_ID \
 --network=NETWORK_NAME_PREFIX-mgmt-net \
 --action=ALLOW \
 --rules=tcp:22 \
 --source-ranges=SSH_SOURCE_IP_RANGE

Erstellen Sie die Firewallregel icmp, mit der Sie nach Problemen mit der Datenübertragung im Netzwerk suchen können.

gcloud compute firewall-rules create NETWORK_NAME_PREFIX-mgmt-external-ping \
 --project=PROJECT_ID \
 --network=NETWORK_NAME_PREFIX-mgmt-net \
 --action=ALLOW \
 --rules=icmp \
 --source-ranges=0.0.0.0/0

Ersetzen Sie Folgendes:

NETWORK_NAME_PREFIX: Das Namenspräfix, das für die Virtual Private Cloud-Netzwerke und -Subnetze verwendet werden soll.
PROJECT_ID: Ihre Projekt-ID
REGION: Die Region, in der Sie die Netzwerke erstellen möchten.
SSH_SOURCE_IP_RANGE: IP-Bereich im CIDR-Format. Hier wird angegeben, welche Quell-IP-Adressen über SSH eine Verbindung zu Ihrer VM herstellen können.

Datennetzwerke, Subnetze und Firewallregeln erstellen

Verwenden Sie den folgenden Befehl, um vier Datennetzwerke jeweils mit Subnetzen und Firewallregeln zu erstellen.

for N in $(seq 1 4); do
  gcloud compute networks create NETWORK_NAME_PREFIX-data-net-$N \
      --project=PROJECT_ID \
      --subnet-mode=custom \
      --mtu=8244

  gcloud compute networks subnets create NETWORK_NAME_PREFIX-data-sub-$N \
      --project=PROJECT_ID \
      --network=NETWORK_NAME_PREFIX-data-net-$N \
      --region=REGION \
      --range=192.168.$N.0/24

  gcloud compute firewall-rules create NETWORK_NAME_PREFIX-data-internal-$N \
      --project=PROJECT_ID \
      --network=NETWORK_NAME_PREFIX-data-net-$N \
      --action=ALLOW \
      --rules=tcp:0-65535,udp:0-65535,icmp \
      --source-ranges=192.168.0.0/16
done

Weitere Informationen zum Erstellen von Virtual Private Cloud-Netzwerken finden Sie unter MTU-Netzwerk im Jumbo Frame erstellen und prüfen.

GPU-VMs erstellen

Wenn Sie die Netzwerkleistung mit GPUDirect-TCPX testen möchten, müssen Sie mindestens zwei A3-VMs erstellen.

Erstellen Sie jede VM mit dem Container-Optimized OS-Image der Version cos-105-lts oder höher und geben Sie die virtuellen MTU-Netzwerke an, die Sie im vorherigen Schritt erstellt haben.

Außerdem müssen die VMs die Netzwerkschnittstelle „Google Virtual NIC“ (gVNIC) verwenden. Für A3-VMs ist gVNIC-Version 1.4.0rc3 oder höher erforderlich. Diese Treiberversion ist auf Container-Optimized OS verfügbar.

Die erste virtuelle NIC wird als primäre NIC für die allgemeine Netzwerk- und Speichernutzung verwendet. Die anderen vier virtuellen NICs sind NUMA-ausgerichtet und mit zwei der acht GPUs auf demselben PCIe-Switch verbunden.

gcloud compute instances create VM_NAME \
  --project=PROJECT_ID \
  --zone=ZONE \
  --machine-type=MACHINE_TYPE \
  --maintenance-policy=TERMINATE --restart-on-failure \
  --image-family=cos-105-lts \
  --image-project=cos-cloud \
  --boot-disk-size=${BOOT_DISK_SZ:-50} \
  --metadata=cos-update-strategy=update_disabled \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --network-interface=nic-type=GVNIC,network=NETWORK_NAME_PREFIX-mgmt-net,subnet=NETWORK_NAME_PREFIX-mgmt-sub \
  --network-interface=nic-type=GVNIC,network=NETWORK_NAME_PREFIX-data-net-1,subnet=NETWORK_NAME_PREFIX-data-sub-1,no-address \
  --network-interface=nic-type=GVNIC,network=NETWORK_NAME_PREFIX-data-net-2,subnet=NETWORK_NAME_PREFIX-data-sub-2,no-address \
  --network-interface=nic-type=GVNIC,network=NETWORK_NAME_PREFIX-data-net-3,subnet=NETWORK_NAME_PREFIX-data-sub-3,no-address \
  --network-interface=nic-type=GVNIC,network=NETWORK_NAME_PREFIX-data-net-4,subnet=NETWORK_NAME_PREFIX-data-sub-4,no-address

Ersetzen Sie Folgendes:

VM_NAME ist der Name Ihrer VM.
PROJECT_ID: Ihre Projekt-ID
ZONE: eine Zone, die Ihren Maschinentyp unterstützt.
MACHINE_TYPE: Maschinentyp für die VM. Geben Sie entweder a3-highgpu-8g oder a3-edgegpu-8g an.
NETWORK_NAME_PREFIX: Das Namenspräfix für die Virtual Private Cloud-Netzwerke und -Subnetze.

GPU-Treiber installieren

Führen Sie auf jeder A3-VM die folgenden Schritte aus.

Führen Sie den folgenden Befehl aus, um die NVIDIA-GPU-Treiber zu installieren:
```
sudo cos-extensions install gpu -- --version=latest
```

Mit dem folgenden Befehl können Sie den Pfad neu bereitstellen:

sudo mount --bind /var/lib/nvidia /var/lib/nvidia
sudo mount -o remount,exec /var/lib/nvidia

NICs Zugriff auf die GPUs gewähren

Gewähren Sie auf jeder A3-VM den NICs Zugriff auf die GPUs. Gehen Sie dazu so vor:

Konfigurieren Sie die Registry.
- Wenn Sie Container Registry verwenden, führen Sie den folgenden Befehl aus:
```
docker-credential-gcr configure-docker
```
- Wenn Sie Artifact Registry verwenden, führen Sie den folgenden Befehl aus:
```
docker-credential-gcr configure-docker --registries us-docker.pkg.dev
```

Konfigurieren Sie den Manager für den Empfangsdatenpfad. Der Verwaltungsdienst „GPUDirect-TCPX Receive Data Path Manager“ muss neben den Anwendungen ausgeführt werden, die GPUDirect-TCPX verwenden. Führen Sie den folgenden Befehl aus, um den Dienst auf jeder VM mit Container-Optimized OS zu starten:

docker run --pull=always --rm \
  --name receive-datapath-manager \
  --detach \
  --privileged \
  --cap-add=NET_ADMIN --network=host \
  --volume /var/lib/nvidia/lib64:/usr/local/nvidia/lib64 \
  --device /dev/nvidia0:/dev/nvidia0 \
  --device /dev/nvidia1:/dev/nvidia1 \
  --device /dev/nvidia2:/dev/nvidia2 \
  --device /dev/nvidia3:/dev/nvidia3 \
  --device /dev/nvidia4:/dev/nvidia4 \
  --device /dev/nvidia5:/dev/nvidia5 \
  --device /dev/nvidia6:/dev/nvidia6 \
  --device /dev/nvidia7:/dev/nvidia7 \
  --device /dev/nvidia-uvm:/dev/nvidia-uvm \
  --device /dev/nvidiactl:/dev/nvidiactl \
  --env LD_LIBRARY_PATH=/usr/local/nvidia/lib64 \
  --volume /run/tcpx:/run/tcpx \
  --entrypoint /tcpgpudmarxd/build/app/tcpgpudmarxd \
us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/tcpgpudmarxd \
  --gpu_nic_preset a3vm --gpu_shmem_type fd --uds_path "/run/tcpx" --setup_param "--verbose 128 2 0"

Prüfen Sie, ob der receive-datapath-manager-Container gestartet wurde.

docker container logs --follow receive-datapath-manager

Die Ausgabe sollte in etwa so aussehen:

I0000 00:00:1687813309.406064       1 rx_rule_manager.cc:174] Rx Rule Manager server(s) started...

Wenn Sie die Protokolle nicht mehr ansehen möchten, drücken Sie ctrl-c.

Installieren Sie IP-Tabellenregeln.

sudo iptables -I INPUT -p tcp -m tcp -j ACCEPT

Konfigurieren Sie die NVIDIA Collective Communications Library (NCCL) und das GPUDirect-TCPX-Plug-in.

Für die Verwendung von NCCL mit GPUDirect-TCPX-Unterstützung sind eine bestimmte NCCL-Bibliotheksversion und eine bestimmte Kombination aus GPUDirect-TCPX-Plug-in-Binärprogrammen erforderlich. Google Cloud bietet Pakete an, die diese Anforderung erfüllen.

Führen Sie den folgenden Befehl aus, um das Google Cloud-Paket zu installieren:
```
docker run --rm -v /var/lib:/var/lib us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/nccl-plugin-gpudirecttcpx install --install-nccl
sudo mount --bind /var/lib/tcpx /var/lib/tcpx
sudo mount -o remount,exec /var/lib/tcpx
```
Wenn dieser Befehl erfolgreich ist, werden die Dateien libnccl-net.so und libnccl.so im Verzeichnis /var/lib/tcpx/lib64 abgelegt.

Tests ausführen

Führen Sie auf jeder A3-VM einen NCCL-Test aus. Gehen Sie dazu so vor:

Starten Sie den Container.

#!/bin/bash

function run_tcpx_container() {
docker run \
  -u 0 --network=host \
  --cap-add=IPC_LOCK \
  --userns=host \
  --volume /run/tcpx:/tmp \
  --volume /var/lib/nvidia/lib64:/usr/local/nvidia/lib64 \
  --volume /var/lib/tcpx/lib64:/usr/local/tcpx/lib64 \
  --shm-size=1g --ulimit memlock=-1 --ulimit stack=67108864 \
  --device /dev/nvidia0:/dev/nvidia0 \
  --device /dev/nvidia1:/dev/nvidia1 \
  --device /dev/nvidia2:/dev/nvidia2 \
  --device /dev/nvidia3:/dev/nvidia3 \
  --device /dev/nvidia4:/dev/nvidia4 \
  --device /dev/nvidia5:/dev/nvidia5 \
  --device /dev/nvidia6:/dev/nvidia6 \
  --device /dev/nvidia7:/dev/nvidia7 \
  --device /dev/nvidia-uvm:/dev/nvidia-uvm \
  --device /dev/nvidiactl:/dev/nvidiactl \
  --env LD_LIBRARY_PATH=/usr/local/nvidia/lib64:/usr/local/tcpx/lib64 \
  "$@"
}

Mit dem vorherigen Befehl werden die folgenden Aufgaben ausgeführt:

NVIDIA-Geräte von /dev im Container bereitstellen
Legt den Netzwerk-Namespace des Containers auf den Host fest
Der Nutzer-Namespace des Containers wird auf „host“ festgelegt
fügt dem Container die Funktion CAP_IPC_LOCK hinzu
/tmp des Hosts wird auf /tmp des Containers bereitgestellt
Der Installationspfad von NCCL und das GPUDirect-TCPX-NCCL-Plug-in werden im Container bereitgestellt und der bereitgestellte Pfad wird LD_LIBRARY_PATH hinzugefügt

Nachdem Sie den Container gestartet haben, können Anwendungen, die NCCL verwenden, innerhalb des Containers ausgeführt werden. So führen Sie beispielsweise den Test run-allgather aus:
1. Führen Sie auf jeder A3-VM Folgendes aus:
```
$ run_tcpx_container -it --rm us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/nccl-plugin-gpudirecttcpx shell
```
2. Führen Sie auf jeder VM die folgenden Befehle aus:
  1. Richten Sie eine Verbindung zwischen den VMs ein. Ersetzen Sie VM-0 und VM-1 durch die Namen der einzelnen VMs.
```
/scripts/init_ssh.sh VM-0 VM-1
pushd /scripts && /scripts/gen_hostfiles.sh VM-0 VM-1; popd
```
    Dadurch wird auf jeder VM ein /scripts/hostfiles2-Verzeichnis erstellt.
  2. Führen Sie das Skript aus.
```
/scripts/run-allgather.sh 8 eth1,eth2,eth3,eth4 1M 512M 2
```
    Die Ausführung des run-allgather-Scripts dauert etwa zwei Minuten. Am Ende der Protokolle sehen Sie die all-gather-Ergebnisse.
    
    Wenn Sie die folgende Zeile in Ihren NCCL-Protokollen sehen, wurde GPUDirect-TCPX erfolgreich initialisiert.
```
NCCL INFO NET/GPUDirectTCPX ver. 3.1.1.
```