Massimizza le prestazioni della rete della GPU con GPUDirect-TCPX

La famiglia di macchine ottimizzate per l'acceleratore è progettata da Google Cloud per offrire le prestazioni e l'efficienza necessarie per carichi di lavoro con accelerazione GPU come l'intelligenza artificiale (AI), il machine learning (ML) e il computing ad alte prestazioni (HPC).

La serie di macchine ottimizzate per l'acceleratore A3 ha 208 vCPU e fino a 1872 GB di memoria. A ogni VM A3 sono collegate otto GPU NVIDIA H100, che offrono 80 GB di memoria GPU per GPU. Queste VM possono ricevere fino a 1000 Gbps di larghezza di banda di rete, il che le rende ideali per grandi modelli linguistici, database e computing ad alte prestazioni (HPC) basati su trasformatore.

Quando lavori con VM A3, puoi utilizzare GPUDirect-TCPX per ottenere la latenza più bassa possibile tra le applicazioni e la rete. GPUDirect-TCPX è uno stack di rete personalizzato con accesso diretto alla memoria (RDMA) che aumenta le prestazioni di rete delle VM A3 consentendo ai payload dei pacchetti di dati di trasferire direttamente dalla memoria GPU all'interfaccia di rete senza dover passare attraverso la CPU e la memoria di sistema. Le VM A3 possono utilizzare GPUDirect-TCPX in combinazione con Google Virtual NIC (gVNIC) per offrire la massima velocità effettiva tra le VM in un cluster rispetto ai tipi di macchine ottimizzate per l'acceleratore A2 o G2.

Questo documento mostra come utilizzare la configurazione e il test delle prestazioni di rete GPU migliorate disponibili con GPUDirect-TCPX sulle VM A3 che utilizzano Container-Optimized OS.

Panoramica

Per testare le prestazioni della rete con GPUDirect-TCPX, completa i seguenti passaggi:

  1. Configura le reti jumbo frame MTU Virtual Private Cloud (VPC).
  2. Crea le tue VM GPU utilizzando l'immagine di Container-Optimized OS cos-105-lts.
  3. Installa i driver GPU su ogni VM.
  4. Su ogni VM, consenti alle schede di interfaccia di rete (NIC) di accedere alla GPU.
  5. Esegui un test NCCL.

Configurazione delle reti MTU jumbo frame

Le VM a3-highgpu-8g hanno cinque NIC fisiche. Per ottenere le migliori prestazioni per le NIC fisiche, devi creare cinque reti Virtual Private Cloud e impostare la MTU su 8244.

Crea una regola di gestione per rete, subnet e firewall

Per configurare la rete di gestione:

  1. Crea la rete di gestione utilizzando il comando networks create:

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

  2. Crea la subnet di gestione utilizzando il comando 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

  3. Crea le regole firewall utilizzando il comando firewall-rules create.

    1. Crea una regola firewall per la rete di gestione.

      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

    2. Crea la regola firewall tcp:22 per limitare gli indirizzi IP di origine che possono connettersi alla tua VM utilizzando SSH.

      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

    3. Crea la regola firewall icmp che può essere utilizzata per verificare la presenza di problemi di trasmissione dati nella rete.

      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

Sostituisci quanto segue:

  • NETWORK_NAME_PREFIX: il prefisso del nome da utilizzare per le reti e le subnet Virtual Private Cloud.
  • PROJECT_ID : il tuo ID progetto.
  • REGION: la regione in cui vuoi creare le reti.
  • SSH_SOURCE_IP_RANGE: intervallo IP in formato CIDR. Consente di specificare gli indirizzi IP di origine che possono connettersi alla VM tramite SSH.

crea reti di dati, subnet e regola firewall

Utilizza il comando seguente per creare quattro reti di dati, ciascuna con subnet e regole firewall.

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

Per saperne di più su come creare reti Virtual Private Cloud, consulta Creare e verificare una rete MTU con frame jumbo.

Crea le VM GPU

Per testare le prestazioni della rete con GPUDirect-TCPX, devi creare almeno due VM A3.

  1. Crea ogni VM utilizzando l'immagine di Container-Optimized OS cos-105-lts e specificando le reti MTU virtuali create nel passaggio precedente.

    Le VM devono utilizzare anche l'interfaccia di rete Google Virtual NIC (gVNIC). Per le VM A3, è richiesta la versione gVNIC 1.4.0rc3 o successiva. Questa versione del driver è disponibile in Container-Optimized OS.

    Il primo NIC virtuale viene utilizzato come NIC primario per il networking e l'archiviazione generali, le altre quattro NIC virtuali sono allineate con NUMA a due delle otto GPU sullo stesso switch PCIe.

    gcloud compute instances create VM_NAME \
  --project=PROJECT_ID \
  --zone=ZONE \
  --machine-type=a3-highgpu-8g \
  --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

    Sostituisci quanto segue:

    • VM_NAME: il nome della VM.
    • PROJECT_ID : il tuo ID progetto.
    • ZONE: la zona per la VM.
    • NETWORK_NAME_PREFIX: il prefisso del nome da utilizzare per le reti e le subnet Virtual Private Cloud.

Installa i driver GPU

Su ogni VM A3, completa i passaggi seguenti.

  1. Installa i driver GPU NVIDIA eseguendo questo comando:

    sudo cos-extensions install gpu -- --version=latest

  2. Rimonta il percorso eseguendo questo comando:

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

Consenti alle NIC di accedere alle GPU

Su ogni VM A3, concedi alle NIC l'accesso alle GPU svolgendo i seguenti passaggi:

  1. Configura il Registro di sistema.

    • Se utilizzi Container Registry, esegui questo comando:

      docker-credential-gcr configure-docker

    • Se utilizzi Artifact Registry, esegui questo comando:

      docker-credential-gcr configure-docker --registries us-docker.pkg.dev

  2. Configura il gestore dei percorsi dei dati di ricezione. Un servizio di gestione, GPUDirect-TCPX receive Data Path Manager, deve essere eseguito insieme alle applicazioni che utilizzano GPUDirect-TCPX. Per avviare il servizio su ogni VM Container-Optimized OS, esegui questo comando:

    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"

  3. Verifica che il container receive-datapath-manager sia stato avviato.

    docker container logs --follow receive-datapath-manager

    L'output dovrebbe essere simile al seguente:

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

  4. Per interrompere la visualizzazione dei log, premi ctrl-c.

  5. Installa le regole della tabella IP.

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

  6. Configura il plug-in NVIDIA Collective Communications Library (NCCL) e GPUDirect-TCPX.

    Per utilizzare NCCL con supporto GPUDirect-TCPX, sono necessarie una versione specifica della libreria NCCL e una combinazione binaria di plug-in GPUDirect-TCPX. Google Cloud ha fornito pacchetti che soddisfano questo requisito.

    Per installare il pacchetto Google Cloud, esegui questo comando:

    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

    Se questo comando ha esito positivo, i file libnccl-net.so e libnccl.so vengono inseriti nella directory /var/lib/tcpx/lib64.

Esegui test

Su ogni VM A3, esegui un test NCCL completando questi passaggi:

  1. Avvia il 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 \
  "$@"
}

    Il comando precedente completa quanto segue:

    • Monta i dispositivi NVIDIA da /dev nel container
    • Imposta lo spazio dei nomi di rete del container sull'host
    • Imposta lo spazio dei nomi utente del container per l'host
    • Aggiunge CAP_IPC_LOCK alle funzionalità del container
    • Monta /tmp dell'host in /tmp del container
    • Monta il percorso di installazione del plug-in NCCL e GPUDirect-TCPX NCCL nel container e aggiunge il percorso montato a LD_LIBRARY_PATH

  2. Dopo aver avviato il container, le applicazioni che utilizzano NCCL possono essere eseguite dall'interno del container. Ad esempio, per eseguire il test run-allgather, completa questi passaggi:

    1. Su ogni VM A3, esegui questo comando:

      $ run_tcpx_container -it --rm us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/nccl-plugin-gpudirecttcpx shell

    2. Su una VM, esegui questi comandi:

      1. Configura la connessione tra le VM. Sostituisci VM-0 e VM-1 con i nomi di ogni VM.

        /scripts/init_ssh.sh VM-0 VM-1
pushd /scripts && /scripts/gen_hostfiles.sh VM-0 VM-1; popd

        Viene creata una directory /scripts/hostfiles2 su ogni VM.

      2. Esegui lo script.

        /scripts/run-allgather.sh 8 eth1,eth2,eth3,eth4 1M 512M 2

        L'esecuzione dello script run-allgather richiede circa due minuti. Alla fine dei log, vedrai i risultati all-gather.

        La riga seguente nei log di NCCL indica che GPUDirect-TCPX è stato inizializzato correttamente.

        NCCL INFO NET/GPUDirectTCPX ver. 3.1.1.