Massimizza le prestazioni della rete GPU con GPUDirect-TCPX

Nota: questo documento descrive la configurazione per un cluster che utilizza un tipo di macchina a3-highgpu-8g. Per eseguire il deployment di un cluster a3-megagpu-8g che utilizza GPUDirect-TCPXO, vedi Esegui il deployment di un cluster A3 Mega Slurm per l'addestramento ML.

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

La serie di macchine ottimizzate per l'acceleratore A3 ha 208 vCPU e fino 1872 GB di memoria. Ogni tipo di macchina a3-highgpu-8g ha otto GPU NVIDIA H100 collegate, che offrono 80 GB di memoria GPU per GPU. Queste VM possono fino a 1000 Gbit/s di larghezza di banda di rete, il che li rende ideali per applicazioni modelli linguistici basati su trasformatore, database e computing ad alte prestazioni (HPC).

Quando lavori con VM a3-highgpu-8g, puoi utilizzare GPUDirect-TCPX per ottenere la latenza più bassa possibile tra le applicazioni e la rete. GPUDirect-TCPX è un accesso diretto remoto alla memoria (RDMA) personalizzato che aumenta le prestazioni di rete delle VM A3 consentendo il trasferimento diretto dai payload dei pacchetti di dati dalla memoria GPU senza dover passare per la CPU e la memoria di sistema. Le VM A3 possono utilizzare GPUDirect-TCPX combinato con il NIC virtuale Google (gVNIC) per offrire la velocità effettiva massima tra le VM in un cluster rispetto alla Tipi di macchine ottimizzate per l'acceleratore A2 o G2.

Questo documento mostra come utilizzare la configurazione e il test della rete GPU migliorata le prestazioni disponibili con GPUDirect-TCPX su a3-highgpu-8g VM che utilizzano Container-Optimized OS.

Panoramica

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

1. Configura una o più reti Virtual Private Cloud (VPC) e imposta MTU (noti anche come frame jumbo) su 8244.
2. Crea le tue VM GPU utilizzando cos-105-lts Container-Optimized OS dell'immagine.
3. Installa i driver per GPU su ogni VM.
4. Su ogni VM, concedi alle schede di interfaccia di rete (NIC) l'accesso alla GPU.
5. Esegui un test NCCL.

Configurare reti MTU con frame jumbo

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

Crea una regola firewall, subnet e rete di gestione

Completa i seguenti passaggi per configurare la rete di gestione:

1. Crea la rete di gestione utilizzando 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 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 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 l'IP di origine possono connettersi alla VM mediante 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 a causa 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 Reti e subnet del virtual private cloud.
• PROJECT_ID : il tuo ID progetto.
• REGION: la regione in cui vuoi creare reti.
• SSH_SOURCE_IP_RANGE: intervallo IP in formato CIDR. Questo specifica gli indirizzi IP di origine che possono connettersi alla VM tramite SSH.

Crea reti di dati, subnet e una 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 Crea e verifica una rete MTU con frame jumbo.

Crea le tue VM GPU

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

1. Crea ogni VM utilizzando cos-105-lts Container-Optimized OS e specifica la MTU virtuale create nel passaggio precedente.

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

   Il primo NIC virtuale viene utilizzato come NIC principale per informazioni generali networking e spazio di archiviazione, le altre quattro NIC virtuali sono allineate NUMA con 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 del virtual private cloud.

Installa i driver per GPU

Su ogni VM A3, completa i seguenti passaggi.

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
   

Concedi alle NIC l'accesso alle GPU

Su ogni VM A3, concedi alle NIC l'accesso alle GPU completando quanto segue 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 del percorso dei dati di ricezione. Un servizio di gestione GPUDirect-TCPX Ricevi il gestore del percorso dei dati, deve essere eseguito insieme alle applicazioni che usano GPUDirect-TCPX. Per avviare su ogni VM di 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 la NVIDIA Collective Communications Library (NCCL) e GPUDirect-TCPX.

   Una specifica versione della libreria NCCL e una combinazione binaria del plug-in GPUDirect-TCPX per utilizzare NCCL con il supporto GPUDirect-TCPX. Google Cloud ha forniti 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 si trovano nella directory /var/lib/tcpx/lib64.

Esegui test

Su ogni VM A3, esegui un test NCCL svolgendo i seguenti 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 su 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 NCCL e GPUDirect-TCPX NCCL nel il container e aggiungi il percorso montato a LD_LIBRARY_PATH

2. Dopo aver avviato il container, le applicazioni che utilizzano NCCL possono essere eseguite all'interno del container. Ad esempio, per eseguire il test run-allgather, completa i seguenti 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. Alle ore alla fine dei log, vedrai i risultati di all-gather.

         Se nei log NCCL è presente la seguente riga, questa verifica GPUDirect-TCPX è stato inizializzato correttamente.

         NCCL INFO NET/GPUDirectTCPX ver. 3.1.1.