Crear una VM A3 con GPUDirect-TCPX habilitado

La familia de máquinas optimizadas para aceleradores se ha diseñado paraGoogle Cloud proporcionar el rendimiento y la eficiencia necesarios para las cargas de trabajo aceleradas por GPU, como la inteligencia artificial (IA), el aprendizaje automático (ML) y la computación de alto rendimiento (HPC).

La serie de máquinas optimizadas para aceleradores A3 tiene 208 vCPUs y hasta 1872 GB de memoria. Cada tipo de máquina A3 tiene ocho GPUs NVIDIA H100 conectadas, lo que ofrece 80 GB de memoria de GPU por GPU. Estas VMs pueden alcanzar hasta 1000 Gbps de ancho de banda de red, lo que las hace ideales para modelos de lenguaje grandes basados en transformadores, bases de datos y computación de alto rendimiento (HPC).

Cuando trabajes con máquinas virtuales a3-highgpu-8g o a3-edgegpu-8g, puedes usar GPUDirect-TCPX para conseguir la latencia más baja posible entre las aplicaciones y la red. GPUDirect-TCPX es una pila de redes de acceso directo a memoria remota (RDMA) personalizada que aumenta el rendimiento de la red de tus VMs A3 al permitir que las cargas útiles de los paquetes de datos se transfieran directamente de la memoria de la GPU a la interfaz de red sin tener que pasar por la CPU y la memoria del sistema. Las VMs A3 pueden usar GPUDirect-TCPX combinado con la NIC virtual de Google (gVNIC) para ofrecer el mayor rendimiento entre las VMs de un clúster en comparación con los tipos de máquinas A2 o G2 optimizados para aceleradores.

En este documento se explica cómo crear una máquina virtual a3-highgpu-8g o a3-edgegpu-8g que se ejecute en un sistema operativo Container-Optimized OS. También se muestra cómo habilitar GPUDirect-TCPX en la VM y cómo configurar y probar el rendimiento de la red de la GPU mejorado.

Información general

Para probar el rendimiento de la red con GPUDirect-TCPX, sigue estos pasos:

  1. Configura una o varias redes de nube privada virtual (VPC) que tengan un MTU grande.
  2. Crea tus VMs con GPU mediante la imagen de cos-105-lts de Container-Optimized OS o una posterior.
  3. En cada VM, instala los controladores de GPU.
  4. En cada VM, da acceso a la GPU a las tarjetas de interfaz de red (NICs).
  5. Ejecuta una prueba de NCCL.

Configurar redes de VPC

En estas redes de VPC, te recomendamos que asignes un valor más alto a la unidad de transmisión máxima (MTU). Los valores de MTU más altos aumentan el tamaño de los paquetes y reducen la sobrecarga del encabezado de los paquetes, lo que incrementa el rendimiento de los datos de la carga útil.

Para maximizar el ancho de banda de red de los tipos de máquinas A3 High, define el MTU en 8244 bytes. Para consultar los ajustes de MTU recomendados para otros tipos de máquinas con GPU, consulta Ajustes de MTU para tipos de máquinas con GPU.

Crear una red de gestión, una subred y una regla de cortafuegos

Sigue estos pasos para configurar la red de gestión:

  1. Crea la red de gestión con el comando networks create:

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

  2. Crea la subred de gestión con el 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 reglas de cortafuegos con el comando firewall-rules create.

    1. Crea una regla de cortafuegos para la red de gestión.

      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 regla de cortafuegos tcp:22 para limitar las direcciones IP de origen que pueden conectarse a tu 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 regla de cortafuegos icmp que se puede usar para comprobar si hay problemas de transmisión de datos en la red.

      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

Haz los cambios siguientes:

  • NETWORK_NAME_PREFIX: el prefijo de nombre que se usará para las redes y subredes de nube privada virtual.
  • PROJECT_ID : tu ID de proyecto.
  • REGION: la región en la que quieras crear las redes.
  • SSH_SOURCE_IP_RANGE: intervalo de IPs en formato CIDR. Especifica qué direcciones IP de origen pueden conectarse a tu VM mediante SSH.

Crear redes de datos, subredes y reglas de cortafuegos

Usa el siguiente comando para crear cuatro redes de datos, cada una con subredes y reglas de cortafuegos.

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

Para obtener más información sobre cómo crear redes de nube privada virtual, consulta el artículo Crear y verificar una red con MTU de jumbo frame.

Crear tus máquinas virtuales con GPU

Para probar el rendimiento de la red con GPUDirect-TCPX, debes crear al menos dos VMs A3.

  1. Crea cada VM con la imagen de cos-105-lts o una versión posterior de Container-Optimized OS y especifica las redes de MTU virtual que se crearon en el paso anterior.

    Las VMs también deben usar la interfaz de red de NIC virtual de Google (gVNIC). En las VMs A3, se requiere la versión 1.4.0rc3 o una posterior de gVNIC. Esta versión del controlador está disponible en Container-Optimized OS.

    La primera NIC virtual se usa como NIC principal para las redes y el almacenamiento generales. Las otras cuatro NICs virtuales están alineadas con NUMA con dos de las ocho GPUs en el mismo conmutador 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

    Haz los cambios siguientes:

    • VM_NAME: el nombre de tu VM.
    • PROJECT_ID : tu ID de proyecto.
    • ZONE: una zona que admita tu tipo de máquina.
    • MACHINE_TYPE: el tipo de máquina de la VM. Especifica a3-highgpu-8g o a3-edgegpu-8g.
    • NETWORK_NAME_PREFIX: el prefijo de nombre que se va a usar para las redes y subredes de nube privada virtual.

Instalar controladores de GPU

En cada máquina virtual A3, sigue estos pasos.

  1. Instala los controladores de la GPU NVIDIA ejecutando el siguiente comando:

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

  2. Vuelve a montar la ruta ejecutando el siguiente comando:

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

Dar acceso a las NICs a las GPUs

En cada VM A3, da acceso a las GPUs a las NICs siguiendo estos pasos:

  1. Configura el registro.

    • Si usas Container Registry, ejecuta el siguiente comando:

      docker-credential-gcr configure-docker

    • Si usas Artifact Registry, ejecuta el siguiente comando:

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

  2. Configura el gestor de rutas de datos de recepción. Un servicio de gestión, GPUDirect - TCPX Receive Data Path Manager, debe ejecutarse junto con las aplicaciones que usan GPUDirect - TCPX. Para iniciar el servicio en cada VM de Container-Optimized OS, ejecuta el siguiente 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 que el contenedor receive-datapath-manager se haya iniciado.

    docker container logs --follow receive-datapath-manager

    La salida debería ser similar a la siguiente:

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

  4. Para dejar de ver los registros, pulsa ctrl-c.

  5. Instala reglas de tabla de IP.

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

  6. Configura la biblioteca de comunicaciones colectivas de NVIDIA (NCCL) y el complemento GPUDirect-TCPX.

    Para usar NCCL con compatibilidad con GPUDirect-TCPX, se necesita una versión específica de la biblioteca NCCL y una combinación binaria del complemento GPUDirect-TCPX. Google Cloud ha proporcionado paquetes que cumplen este requisito.

    Para instalar el paquete Google Cloud , ejecuta el siguiente 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

    Si este comando se ejecuta correctamente, los archivos libnccl-net.so y libnccl.so se colocarán en el directorio /var/lib/tcpx/lib64.

Ejecutar pruebas

En cada máquina virtual A3, ejecuta una prueba de NCCL siguiendo estos pasos:

  1. Inicia el contenedor.

    #!/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 \
  "$@"
}

    El comando anterior hace lo siguiente:

    • Monta dispositivos NVIDIA de /dev en el contenedor.
    • Define el espacio de nombres de red del contenedor en el host.
    • Define el espacio de nombres de usuario del contenedor en el host.
    • Añade CAP_IPC_LOCK a las funciones del contenedor.
    • Monta /tmp del host en /tmp del contenedor.
    • Monta la ruta de instalación del complemento NCCL y GPUDirect-TCPX NCCL en el contenedor y añade la ruta montada a LD_LIBRARY_PATH.

  2. Una vez que hayas iniciado el contenedor, las aplicaciones que usen NCCL podrán ejecutarse desde dentro del contenedor. Por ejemplo, para realizar la prueba run-allgather, sigue estos pasos:

    1. En cada máquina virtual A3, ejecuta lo siguiente:

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

    2. En una de las VMs, ejecuta los siguientes comandos:

      1. Configura la conexión entre las VMs. Sustituye VM-0 y VM-1 por los nombres de cada VM.

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

        De esta forma, se crea un directorio /scripts/hostfiles2 en cada máquina virtual.

      2. Ejecuta la secuencia de comandos.

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

        El script run-allgather tarda unos dos minutos en ejecutarse. Al final de los registros, verá los all-gather resultados.

        Si ves la siguiente línea en los registros de NCCL, significa que GPUDirect-TCPX se ha inicializado correctamente.

        NCCL INFO NET/GPUDirectTCPX ver. 3.1.1.