Crea una VM A3 con GPUDirect-TCPX abilitato

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

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

Quando utilizzi VM a3-highgpu-8g o a3-edgegpu-8g, puoi usare 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 remota (RDMA) che aumenta le prestazioni di rete delle VM A3 consentendo il trasferimento dei payload dei pacchetti di dati 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 combinato con Google Virtual NIC (gVNIC) per offrire il throughput più elevato tra le VM in un cluster rispetto ai tipi di macchine ottimizzati per l'acceleratore A2 o G2.

Questo documento spiega come creare una VM a3-highgpu-8g o a3-edgegpu-8g che funzioni su un sistema operativo Container-Optimized OS. Inoltre, spiega come attivare GPUDirect-TCPX sulla VM e configurare e testare le prestazioni di rete migliorate della GPU.

Panoramica

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

  1. Configura una o più reti Virtual Private Cloud (VPC) con un valore MTU elevato.
  2. Crea le VM GPU utilizzando l'immagine Container-Optimized OS cos-105-lts o successiva.
  3. Installa i driver della GPU su ogni VM.
  4. In ogni VM, concedi alle schede di interfaccia di rete (NIC) l'accesso alla GPU.
  5. Esegui un test NCCL.

Configura le reti VPC

Per queste reti VPC, ti consigliamo di impostare l'unità massima di trasmissione (MTU) su un valore più grande. Valori MTU più elevati aumentano le dimensioni dei pacchetti e riducono l'overhead dell'intestazione del pacchetto, il che aumenta la velocità effettiva dei dati utili.

Per massimizzare la larghezza di banda della rete per i tipi di macchina A3 High, imposta l'MTU su 8244 byte. Per esaminare le impostazioni MTU consigliate per altri tipi di macchine GPU, consulta Impostazioni MTU per i tipi di macchine GPU.

Crea una rete di gestione, una subnet e una regola firewall

Per configurare la rete di gestione, completa i seguenti passaggi:

  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 dei 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 Virtual Private Cloud e le subnet.
  • PROJECT_ID: il tuo ID progetto.
  • REGION: la regione in cui vuoi creare le reti.
  • SSH_SOURCE_IP_RANGE: l'intervallo IP in formato CIDR. Questo specifica quali indirizzi IP di origine possono connettersi alla VM utilizzando SSH.

Crea reti dati, subnet e regole firewall

Utilizza il seguente comando per creare quattro reti 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 ulteriori informazioni su come creare reti Virtual Private Cloud, consulta Crea e verifica una rete MTU con frame jumbo.

Crea le VM GPU

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

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

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

    La prima NIC virtuale viene utilizzata come NIC principale per la rete e l'archiviazione generiche, mentre le altre quattro NIC virtuali sono allineate con NUMA con due delle otto GPU sullo stesso switch PCIe.

    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

    Sostituisci quanto segue:

    • VM_NAME: il nome della VM.
    • PROJECT_ID: il tuo ID progetto.
    • ZONE: una zona che supporta il tuo tipo di macchina.
    • MACHINE_TYPE: il tipo di macchina per la VM. Specifica a3-highgpu-8g o a3-edgegpu-8g.
    • NETWORK_NAME_PREFIX: il prefisso del nome da utilizzare per le reti Virtual Private Cloud e le subnet.

Installa i driver della GPU

Su ogni VM A3, completa i seguenti passaggi.

  1. Installa i driver GPU NVIDIA eseguendo il seguente comando:

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

  2. Monta di nuovo il percorso eseguendo il seguente 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 i seguenti passaggi:

  1. Configura il registry.

    • Se utilizzi Container Registry, esegui il seguente comando:

      docker-credential-gcr configure-docker

    • Se utilizzi Artifact Registry, esegui il seguente comando:

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

  2. Configura il gestore del percorso dati in arrivo. Deve essere eseguito un servizio di gestione, GPUDirect-TCPX Receive Data Path Manager, insieme alle applicazioni che utilizzano GPUDirect-TCPX. Per avviare il servizio su ogni VM Container-Optimized OS, esegui il seguente 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 il plug-in GPUDirect-TCPX.

    Per utilizzare NCCL con il supporto di GPUDirect-TCPX è necessaria una versione specifica della libreria NCCL e una combinazione di file binari del plug-in GPUDirect-TCPX. Google Cloud offre pacchetti che soddisfano questo requisito.

    Per installare il pacchetto Google Cloud , esegui il seguente 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 il 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 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 dell'utente del container sull'host
    • Aggiunge CAP_IPC_LOCK alle funzionalità del container
    • Monta /tmp dell'host su /tmp del container
    • Monta il percorso di installazione della NCCL e del plug-in GPUDirect-TCPX NCCL nel container e aggiungi il percorso montato a LD_LIBRARY_PATH

  2. Dopo aver avviato il container, le applicazioni che utilizzano NCCL possono essere eseguite al suo interno. Ad esempio, per eseguire il test run-allgather, completa i seguenti passaggi:

    1. In ogni VM A3, esegui quanto segue:

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

    2. Su una VM, esegui i seguenti comandi:

      1. Configura la connessione tra le VM. Sostituisci VM-0 e VM-1 con i nomi di ciascuna 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 di all-gather.

        Se nei log NCCL viene visualizzata la riga seguente, significa che GPUDirect-TCPX è stato inizializzato correttamente.

        NCCL INFO NET/GPUDirectTCPX ver. 3.1.1.