Maximiza el ancho de banda de red de la GPU en clústeres en modo Autopilot

En esta página, se muestra cómo maximizar el ancho de banda de la red y la capacidad de procesamiento para las cargas de trabajo de GPU de alto rendimiento en clústeres de Autopilot de Google Kubernetes Engine (GKE) con GPUDirect-TCPXO, GPUDirect-TCPX, gVNIC y varias redes. Si usas clústeres estándar, consulta Maximiza el ancho de banda de red de la GPU en clústeres en modo estándar.

Esta página está dirigida a ingenieros de aprendizaje automático (AA) y administradores de plataformas que facilitan las cargas de trabajo de AA. Para obtener más información sobre los roles comunes y las tareas de ejemplo a las que hacemos referencia en el contenido de Trusted Cloud by S3NS , consulta Tareas y roles comunes de los usuarios de GKE.

Las aplicaciones de inteligencia artificial (IA), AA y computación de alto rendimiento (HPC) requieren una aceleración potente para optimizar el rendimiento reduciendo los tiempos de finalización de los trabajos. Por ejemplo, los modelos de AA que se enfocan en la IA conversacional y en la generación de imágenes requieren alta escalabilidad y potencia de procesamiento.

Antes de leer esta página, asegúrate de estar familiarizado con las tecnologías de redes, como las tarjetas de interfaz de red (NIC) y TCP, y las tecnologías de aceleración como la Biblioteca de comunicaciones colectivas de NVIDIA (NCCL).

Acerca de las Trusted Cloud supercomputadoras de GPU

Trusted Cloud tiene supercomputadoras optimizadas para aceleradores que están diseñadas para modelos masivos y escalables. Estas máquinas tienen los siguientes beneficios:

  • Ocho GPU NVIDIA B200, H200 o H100 por máquina
  • Hasta 200 Gbps de ancho de banda en la NIC principal.
  • NIC secundarias (hasta ocho en los tipos de máquinas A3 Mega y hasta cuatro en los tipos de máquinas A3 High), cada una de las cuales admite hasta 200 Gbps de ancho de banda para la transferencia de datos de GPU.

Tu carga de trabajo de GKE debe usar todas las GPU disponibles y todas las NIC secundarias disponibles en un solo nodo y usar una parte significativa del ancho de banda disponible. La solución que se describe en este documento es ideal para cargas de trabajo que requieren alto rendimiento, alta capacidad de procesamiento y baja latencia.

Funciones y capacidades obligatorias para maximizar el ancho de banda

Para maximizar el ancho de banda de tu red en los nodos de GPU de supercomputadora, usa todas las siguientes características:

  • Pila de redes GPUDirect: La serie de máquinas A3 admite tres pilas de redes para el acceso directo a la memoria (RDMA) personalizado y remoto:
    • En los tipos de máquinas A3 High y las GPU NVIDIA H100, utiliza GPUDirect-TCPX para reducir la sobrecarga necesaria para transferir cargas útiles de paquetes desde y hacia las GPU, lo que mejora significativamente la capacidad de procesamiento a gran escala en comparación con las GPU que no usan GPUDirect.
    • En los tipos de máquinas A3 Mega y las GPU NVIDIA H100 Mega, se utiliza GPUDirect-TCPXO, lo que mejora aún más la comunicación entre la GPU y la VM.
    • En los tipos de máquinas A3 Ultra y las GPU NVIDIA H200, y en los tipos de máquinas A4 y las GPU NVIDIA B200, utiliza GPUDirect RDMA para ejecutar cargas de trabajo de IA distribuidas con mejoras adicionales en el rendimiento. Para comenzar, crea un clúster de GKE personalizado optimizado para IA.
  • gVNIC: Habilita las funciones de GPUDirect, como la división del encabezado del paquete, la dirección del flujo y la administración del búfer. Se requiere gVNIC para usar GPUDirect-TCPX o GPUDirect-TCPXO. Para obtener detalles sobre gVNIC, consulta Aumenta la velocidad del tráfico de red para los nodos de GPU.
  • Varias redes : Agrega NICs secundarias a la máquina optimizada para aceleradores. Cada NIC está asociada con una subred independiente en su propia VPC para evitar conflictos. Para obtener detalles sobre la compatibilidad con varias redes, consulta Configura la compatibilidad con varias redes para Pods.
  • Políticas de posición: Usa una política de posición de recursos para colocar todos los nodos de GPU de una carga de trabajo específica en servidores que se encuentran físicamente cerca para minimizar la latencia. Si deseas obtener más detalles, consulta Define la posición compacta para los nodos de GKE.

Esquema del procedimiento

Para usar todas estas funciones juntas, harás lo siguiente:

  1. Crea subredes y nubes privadas virtuales (VPC).
  2. Crea el entorno de GKE.
  3. Instala el objeto binario GPUDirect-y el complemento NCCL.
  4. Implementa el complemento de inserción de dispositivos de NRI
  5. Implementa una carga de trabajo de prueba para verificar la configuración de GPUDirect.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

  • Habilita la API de Google Kubernetes Engine.
    • Habilitar la API de Google Kubernetes Engine
  • Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.
  • Asegúrate de tener suficiente cuota para las GPU H100. Para solicitar más cuota, consulta Cuotas de GPU.

Requisitos

Los siguientes requisitos se aplican a GPUDirect-TCPX y GPUDirect-TCPXO, a menos que se indique lo contrario.

  • Tu clúster debe usar la versión 1.31.1-gke.1621000 de GKE o una posterior.
  • Tus nodos de GPU deben usar la versión 535 o posterior del controlador NVIDIA.
  • Debes usar GKE Dataplane V2.
  • Para las cargas de trabajo de GPUDirect-TCPX o GPUDirect-TCPXO que se ejecutan en varios grupos de nodos, todos los grupos de nodos deben estar en las mismas zonas de Compute Engine y deben usar los mismos conjuntos de redes, como VPCs y subredes.

Limitaciones

Se aplica la siguiente limitación:

  • GPUDirect-TCPX y GPUDirect-TCPXO no son compatibles con GPU de instancias múltiples, uso compartido de tiempo de GPU ni NVIDIA MPS.
  • No puedes usar NCCL FastSocket con GPUDirect-TCPX ni GPUDirect-TCPXO .
  • Tu carga de trabajo de GKE debe usar todas las GPUs disponibles y todas las NICs secundarias disponibles en un solo nodo. Varios Pods no pueden usar GPUDirect-TCPX ni GPUDirect-TCPXO en un solo nodo.
  • Solo puedes usar los tipos de máquinas a3-highgpu-8g y a3-megagpu-8g. No se admiten otros tipos de máquinas A3.

Crea VPC y subredes

Crea redes de VPC independientes en tu proyecto para cada NIC virtual que agregues a los nodos. Cada red de VPC debe tener una subred y una regla de firewall que permita el tráfico de red interno.

  1. Crea las redes de VPC para GPUDirect en tu proyecto, cada una con una subred y una regla de firewall: Elige la pestaña GPUDirect-TCPX para los tipos de máquinas A3 High o la pestaña GPUDirect-TCPXO para los tipos de máquinas A3 Mega y, luego, completa las siguientes instrucciones:

    GPUDirect-TCPXO

    Para maximizar el ancho de banda, te recomendamos que crees ocho redes nuevas.

    for N in $(seq 1 8); do
gcloud compute networks create PREFIX-net-$N \
    --subnet-mode=custom \
    --mtu=8244

gcloud compute networks subnets create PREFIX-sub-$N \
    --network=PREFIX-net-$N \
    --region=REGION \
    --range=SUBNET_RANGE

gcloud compute firewall-rules create PREFIX-internal-$N \
  --network=PREFIX-net-$N \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=SOURCE_RANGE
done

    Reemplaza lo siguiente:

    • PROJECT_ID: Es el ID de tu proyecto de Trusted Cloud .
    • REGION: Es la región de Compute Engine para cada subred.
    • SUBNET_RANGE: Es el rango de direcciones IP de cada subred en notación CIDR. En este comando de ejemplo, se itera para ocho subredes, por lo que debes usar una variable para cambiar la dirección IP para cada subred. Por ejemplo, especifica 192.168.$N.0/24 para que la primera subred use 192.168.1.0/24, la segunda subred use 192.168.2.0/24, etcétera.
    • SOURCE_RANGE: El rango de direcciones IP de origen para que la regla de firewall permita el tráfico de entrada, en notación CIDR. Por ejemplo, 192.168.0.0/16

    GPUDirect-TCPX

    Para maximizar el ancho de banda, te recomendamos que crees cuatro redes nuevas.

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

gcloud compute networks subnets create PREFIX-sub-$N \
    --network=PREFIX-net-$N \
    --region=REGION \
    --range=SUBNET_RANGE

gcloud compute firewall-rules create PREFIX-internal-$N \
  --network=PREFIX-net-$N \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=SOURCE_RANGE
done

    Reemplaza lo siguiente:

    • PROJECT_ID: Es el ID de tu proyecto de Trusted Cloud .
    • REGION: Es la región de Compute Engine para cada subred.
    • SUBNET_RANGE: Es el rango de direcciones IP de cada subred en notación CIDR. En este comando de ejemplo, se itera para cuatro subredes, por lo que debes usar una variable para cambiar la dirección IP para cada subred. Por ejemplo, especifica 192.168.$N.0/24 para que la primera subred use 192.168.1.0/24, la segunda subred use 192.168.2.0/24, etcétera.
    • SOURCE_RANGE: El rango de direcciones IP de origen para que la regla de firewall permita el tráfico de entrada, en notación CIDR. Por ejemplo, 192.168.0.0/16

  2. Verifica que se hayan creado las redes:

    gcloud compute networks list

Crea el entorno de GKE

Crea un clúster de GKE nuevo que use varias redes (vista previa). No puedes actualizar un clúster existente para usar redes múltiples.

GPUDirect-TCPXO

  1. Elige una versión de GKE disponible que admita GPUDirect-TCPXO. Para enumerar las versiones, ejecuta este comando:

    gcloud container get-server-config \
    --format="yaml(validMasterVersions)" \
    --region=REGION \
    --project=PROJECT_ID

    Reemplaza lo siguiente:

    • REGION: La región de procesamiento del plano de control del clúster.
    • PROJECT_ID: Es el ID de tu proyecto de Trusted Cloud .

  2. Crea un clúster:

    gcloud beta container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=LOCATION \
    --cluster-version=VERSION \
    --enable-multi-networking \
    --workload-policies=allow-net-admin

    Reemplaza lo siguiente:

    • CLUSTER_NAME: Es el nombre del clúster nuevo.
    • VERSION: Una versión de GKE que admite GPUDirect-TCPXO, como se describe en Requisitos.
    • LOCATION: La ubicación de Compute Engine para el clúster.

  3. Crea los recursos de red y GKENetworkParamSet en el clúster que corresponden a las redes de VPC y las subredes que creaste:

    kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc1
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc1
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc2
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc2
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc3
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc3
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc4
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc4
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc5
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc5
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc6
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc6
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc7
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc7
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc8
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc8
  type: Device
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc1
spec:
  vpc: PREFIX-net-1
  vpcSubnet: PREFIX-sub-1
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc2
spec:
  vpc: PREFIX-net-2
  vpcSubnet: PREFIX-sub-2
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc3
spec:
  vpc: PREFIX-net-3
  vpcSubnet: PREFIX-sub-3
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc4
spec:
  vpc: PREFIX-net-4
  vpcSubnet: PREFIX-sub-4
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc5
spec:
  vpc: PREFIX-net-5
  vpcSubnet: PREFIX-sub-5
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc6
spec:
  vpc: PREFIX-net-6
  vpcSubnet: PREFIX-sub-6
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc7
spec:
  vpc: PREFIX-net-7
  vpcSubnet: PREFIX-sub-7
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc8
spec:
  vpc: PREFIX-net-8
  vpcSubnet: PREFIX-sub-8
  deviceMode: NetDevice
EOF

    Estos recursos le indican a GKE que configure las NIC para el tráfico de GPU en modo de transferencia. GKE no aplica la programación de redes incorporadas que usan eBPF a este tráfico.

GPUDirect-TCPX

  1. Crea un clúster:

    gcloud beta container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=LOCATION \
    --cluster-version=VERSION \
    --enable-multi-networking \
    --workload-policies=allow-net-admin

    Reemplaza lo siguiente:

    • CLUSTER_NAME: Es el nombre del clúster nuevo.
    • VERSION: Una versión de GKE que admita GPUDirect-TCPX, como se describe en Requisitos.
    • LOCATION: La ubicación de Compute Engine para el clúster.

  2. Crea los recursos de red y GKENetworkParamSet en el clúster que corresponden a las redes de VPC y las subredes que creaste:

    kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc1
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc1
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc2
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc2
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc3
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc3
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc4
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc4
  type: Device
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc1
spec:
  vpc: PREFIX-net-1
  vpcSubnet: PREFIX-sub-1
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc2
spec:
  vpc: PREFIX-net-2
  vpcSubnet: PREFIX-sub-2
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc3
spec:
  vpc: PREFIX-net-3
  vpcSubnet: PREFIX-sub-3
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc4
spec:
  vpc: PREFIX-net-4
  vpcSubnet: PREFIX-sub-4
  deviceMode: NetDevice
EOF

    Estos recursos le indican a GKE que configure las NIC para el tráfico de GPU en modo de transferencia. GKE no aplica la programación de redes incorporadas que usan eBPF a este tráfico.

Instala el objeto binario de GPUDirect y configura NCCL

En esta sección, se muestra cómo instalar el objeto binario de GPUDirect, según tu tipo de máquina A3 (GPUDirect-TCPX para A3 High, GPUDirect-TCPXO para A3 Mega) y una versión específica de la biblioteca NCCL con un DaemonSet.

GPUDirect-TCPXO

Este DaemonSet hace lo siguiente:

  1. Configuración previa a la instalación para configurar los parámetros relacionados con GPUDirect-TCPXO.
  2. Instala la biblioteca NCCL y el objeto binario GPUDirect-TCPXO en el nodo.
  3. Almacena la biblioteca y el objeto binario en el directorio /home/kubernetes/bin/nvidia/lib64 en la VM. De forma predeterminada, GKE activa este directorio en la ruta /usr/local/nvidia/lib64 en los contenedores de GPU que necesitan usar NCCL y GPUDirect-TCPXO.

Para instalar el archivo binario y configurar NCCL, sigue estos pasos:

  1. Revisa el manifiesto de Daemonset nccl-tcpxo-installer-autopilot.yaml en GitHub.

  2. Crea un espacio de nombres dedicado:

    kubectl create ns gpudirect-system

  3. Implementa el DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpxo/nccl-tcpxo-installer-autopilot.yaml

    El complemento NCCL tarda alrededor de dos minutos en comenzar a ejecutarse.

GPUDirect-TCPX

Este DaemonSet hace lo siguiente:

  1. Instala la biblioteca NCCL y el objeto binario GPUDirect-TCPX en el nodo.
  2. Almacena la biblioteca y el objeto binario en el directorio /home/kubernetes/bin/nvidia/lib64 en la VM. De forma predeterminada, GKE activa este directorio en la ruta /usr/local/nvidia/lib64 en los contenedores de GPU que necesitan usar NCCL y GPUDirect-TCPX.

Para instalar el archivo binario y configurar NCCL, haz lo siguiente:

  1. Revisa el manifiesto de Daemonset nccl-tcpx-installer-autopilot.yaml en GitHub.

  2. Crea un espacio de nombres dedicado:

    kubectl create ns gpudirect-system

  3. Implementa el DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-tcpx-installer-autopilot.yaml

    El complemento NCCL tarda alrededor de dos minutos en comenzar a ejecutarse.

Implementa el complemento del inyector de dispositivos de NRI

En esta sección, se muestra cómo instalar el inyector de dispositivos NRI con un DaemonSet. Ambos tipos de máquinas con GPU H100 instalan el mismo complemento del inyector de dispositivos NRI. Este complemento hace lo siguiente:

  1. Habilita la interfaz de recursos del nodo (NRI) en el nodo que tiene GPU H100. La NRI está habilitada de forma predeterminada en la versión 1.29 de GKE y versiones posteriores.
  2. Implementa un contenedor de complemento del inyector de dispositivos de NRI que inserta dispositivos de GPU en los contenedores especificados por las anotaciones de Pod.

Para instalar el complemento, haz lo siguiente:

  1. Revisa el manifiesto de Deployment nri-device-injector-autopilot.yaml en GitHub.

  2. Implementa el DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nri_device_injector/nri-device-injector-autopilot.yaml

    El complemento NCCL tarda alrededor de dos minutos en comenzar a ejecutarse.

Implementa una carga de trabajo de prueba

En esta sección, implementarás una carga de trabajo de muestra para verificar que NCCL y GPUDirect-TCPX o GPUDirect-TCPXO funcionen como se espera. Esta carga de trabajo de ejemplo hace lo siguiente:

  1. Implementa dos Pods, cada uno de los cuales se ejecuta en un nodo que tiene GPU H100.
  2. Implementa un contenedor sidecar en cada Pod para permitir que esos Pods usen GPUDirect-TCPXO o GPUDirect-TCPX.

Para implementar esta carga de trabajo de ejemplo, haz lo siguiente:

GPUDirect-TCPXO

Esta carga de trabajo incluye un contenedor sidecar llamado tcpxo-daemon, que ejecuta un servicio que permite al Pod usar GPUDirect-TCPXO. Debes agregar este contenedor sidecar a cualquier Pod de tu propio entorno que necesite usar GPUDirect-TCPXO. Para obtener un fragmento de los campos obligatorios que debes agregar a tus manifiestos, consulta Agrega GPUDirect a tu manifiesto.

  1. Revisa el manifiesto nccl-test-latest-autopilot.yaml en GitHub.

  2. Implementa dos Pods con la carga de trabajo de prueba:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpxo/nccl-test-latest-autopilot.yaml

  3. Después de que se implementen los Pods, activa una prueba de recopilación completa:

    kubectl exec --stdin --tty --container=nccl-test nccl-test-host-1 -- /scripts/allgather.sh nccl-host-1 nccl-host-2

    El resultado es similar a este:

    #                                                              out-of-place                       in-place
#        size         count      type   redop    root     time   algbw   busbw #wrong     time   algbw   busbw #wrong
#         (B)    (elements)                               (us)  (GB/s)  (GB/s)            (us)  (GB/s)  (GB/s)
            0             0     float    none      -1     0.24    0.00    0.00      0     0.18    0.00    0.00      0
            0             0     float    none      -1     0.19    0.00    0.00      0     0.17    0.00    0.00      0
            0             0     float    none      -1     0.17    0.00    0.00      0     0.17    0.00    0.00      0
            0             0     float    none      -1     0.17    0.00    0.00      0     0.17    0.00    0.00      0
            0             0     float    none      -1     0.17    0.00    0.00      0     0.17    0.00    0.00      0
          256             4     float    none      -1    235.2    0.00    0.00      0    235.1    0.00    0.00      0
          512             8     float    none      -1    241.0    0.00    0.00      0    236.1    0.00    0.00      0
         1024            16     float    none      -1    236.3    0.00    0.00      0    233.3    0.00    0.00      0
         2048            32     float    none      -1    234.1    0.01    0.01      0    233.4    0.01    0.01      0
         4096            64     float    none      -1    237.1    0.02    0.02      0    235.3    0.02    0.02      0
         8192           128     float    none      -1    236.2    0.03    0.03      0    235.2    0.03    0.03      0
        16384           256     float    none      -1    236.6    0.07    0.06      0    238.5    0.07    0.06      0
        32768           512     float    none      -1    237.9    0.14    0.13      0    238.8    0.14    0.13      0
        65536          1024     float    none      -1    242.3    0.27    0.25      0    239.4    0.27    0.26      0
       131072          2048     float    none      -1    263.0    0.50    0.47      0    275.1    0.48    0.45      0
       262144          4096     float    none      -1    279.2    0.94    0.88      0    269.9    0.97    0.91      0
       524288          8192     float    none      -1    273.5    1.92    1.80      0    273.5    1.92    1.80      0
      1048576         16384     float    none      -1    315.1    3.33    3.12      0    314.1    3.34    3.13      0
      2097152         32768     float    none      -1    319.2    6.57    6.16      0    311.5    6.73    6.31      0
      4194304         65536     float    none      -1    331.8   12.64   11.85      0    331.3   12.66   11.87      0
      8388608        131072     float    none      -1    356.3   23.54   22.07      0    353.8   23.71   22.23      0
     16777216        262144     float    none      -1    409.1   41.01   38.45      0    405.2   41.40   38.81      0
     33554432        524288     float    none      -1    451.4   74.34   69.69      0    447.7   74.94   70.26      0
     67108864       1048576     float    none      -1    713.4   94.07   88.19      0    713.8   94.01   88.13      0
    134217728       2097152     float    none      -1   1122.1  119.62  112.14      0   1116.3  120.23  112.72      0
    268435456       4194304     float    none      -1   1785.8  150.32  140.92      0   1769.2  151.72  142.24      0
    536870912       8388608     float    none      -1   2859.7  187.74  176.00      0   2852.6  188.20  176.44      0
   1073741824      16777216     float    none      -1   5494.1  195.44  183.22      0   5568.2  192.83  180.78      0
   2147483648      33554432     float    none      -1    10841  198.09  185.71      0    10798  198.88  186.45      0
   4294967296      67108864     float    none      -1    21453  200.21  187.70      0    21490  199.86  187.37      0
   8589934592     134217728     float    none      -1    42603  201.63  189.03      0    42670  201.31  188.73      0
# Out of bounds values : 0 OK
# Avg bus bandwidth    : 45.7587
#

GPUDirect-TCPX

Esta carga de trabajo incluye un contenedor de sidecar llamado tcpx-daemon, que ejecuta un servicio que permite al Pod usar GPUDirect-TCPX. Debes agregar este contenedor de sidecar a cualquier Pod de tu propio entorno que necesite usar GPUDirect-TCPX. Para obtener un fragmento de los campos obligatorios que debes agregar a tus manifiestos, consulta Agrega GPUDirect a tu manifiesto.

  1. Revisa el manifiesto de ConfigMap nccl-config.yaml en GitHub. Este manifiesto implementa secuencias de comandos que inicializan una prueba NCCL all-gather y establecen parámetros de configuración específicos de NCCL.

  2. Revisa el manifiesto de Deployment nccl-test-latest-autopilot.yaml en GitHub.

  3. Implementa el ConfigMap y la carga de trabajo de prueba:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-config.yaml
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-test-latest-autopilot.yaml

  4. Ejecuta los siguientes comandos para activar una prueba de recopilación completa de NCCL para los nodos:

    kubectl exec \
  --stdin --tty --container=nccl-test nccl-test-host-1 \
  -- /configs/allgather.sh nccl-host-1 nccl-host-2

    El resultado es similar al siguiente:

    #                                                              out-of-place                       in-place
#       size         count      type   redop    root     time   algbw   busbw #wrong     time   algbw   busbw #wrong
#        (B)    (elements)                               (us)  (GB/s)  (GB/s)            (us)  (GB/s)  (GB/s)
    1048576         16384     float    none      -1    696.8    1.50    1.41      0    729.0    1.44    1.35      0
    2097152         32768     float    none      -1    776.4    2.70    2.53      0    726.7    2.89    2.71      0
    4194304         65536     float    none      -1    774.3    5.42    5.08      0    805.1    5.21    4.88      0
    8388608        131072     float    none      -1    812.1   10.33    9.68      0    817.6   10.26    9.62      0
   16777216        262144     float    none      -1   1035.2   16.21   15.19      0   1067.8   15.71   14.73      0
   33554432        524288     float    none      -1   1183.3   28.36   26.59      0   1211.8   27.69   25.96      0
   67108864       1048576     float    none      -1   1593.4   42.12   39.49      0   1510.5   44.43   41.65      0
  134217728       2097152     float    none      -1   2127.8   63.08   59.13      0   2312.7   58.03   54.41      0
  268435456       4194304     float    none      -1   3603.0   74.50   69.85      0   3586.2   74.85   70.17      0
  536870912       8388608     float    none      -1   7101.7   75.60   70.87      0   7060.9   76.03   71.28      0
# Out of bounds values : 0 OK
# Avg bus bandwidth    : 29.8293

Usa la configuración requerida de NCCL para mejorar el rendimiento

Los siguientes pares clave-valor son los parámetros de configuración de NCCL necesarios para GPUDirect-TCPX y GPUDirect-TCPXO. Cuando implementes tus cargas de trabajo que usan NCCL, configúralas como variables de entorno para optimizar el rendimiento.

GPUDirect-TCPXO


"NCCL_FASTRAK_CTRL_DEV=eth0",
"NCCL_FASTRAK_IFNAME=eth1,eth2,eth3,eth4,eth5,eth6,eth7,eth8",
"NCCL_SOCKET_IFNAME=eth0",
"NCCL_CROSS_NIC=0",
"NCCL_ALGO=Ring,Tree",
"NCCL_PROTO=Simple,LL128",
"NCCL_MIN_NCHANNELS=4",
"NCCL_TUNER_PLUGIN=libnccl-tuner.so",
"NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config.textproto",
"NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_guest_config.textproto",
"NCCL_DYNAMIC_CHUNK_SIZE=524288",
"NCCL_P2P_NET_CHUNKSIZE=524288",
"NCCL_P2P_PCI_CHUNKSIZE=524288",
"NCCL_P2P_NVL_CHUNKSIZE=1048576",
"NCCL_FASTRAK_NUM_FLOWS=2",
"NCCL_FASTRAK_USE_SNAP=1",
"NCCL_FASTRAK_PLUGIN_ACCEPT_TIMEOUT_MS=600000",
"NCCL_FASTRAK_ENABLE_CONTROL_CHANNEL=0",
"NCCL_BUFFSIZE=8388608",
"CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7",
"NCCL_NET_GDR_LEVEL=PIX",
"NCCL_FASTRAK_ENABLE_HOTPATH_LOGGING=0",
"NCCL_FASTRAK_USE_LLCM=1",
"NCCL_NVLS_ENABLE=0"

De manera opcional, puedes establecer todos los parámetros de configuración a la vez siguiendo estos pasos:

  1. En el manifiesto del contenedor de carga de trabajo, agrega el siguiente par clave-valor como una variable de entorno:

    NCCL_LIB_DIR="/usr/local/nvidia/lib64"

  2. Asegúrate de que la secuencia de comandos nccl-env-profile.sh se ejecute cuando se inicie el contenedor de la carga de trabajo. Por ejemplo, puedes hacerlo en la especificación de tu Pod a través de la anulación del comando del contenedor para incluir lo siguiente:

    source ${NCCL_LIB_DIR}/nccl-env-profile.sh

Compatibilidad con LL128

El protocolo de comunicación NCCL LL128 (baja latencia 128) de NVIDIA puede mejorar significativamente el rendimiento de las operaciones colectivas de tamaño pequeño a mediano. GPUDirect-TCPX admite el protocolo LL128.

Para usar LL128, asegúrate de que el archivo nccl-tcpxo-installer.yaml de la sección Instala el binario de GPUDirect y configura NCCL use la siguiente versión de imagen del contenedor o una posterior:

us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx-
dev:v1.0.8-1

Para configurar LL128, haz lo siguiente:

  • Para la versión del complemento us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx- dev:v1.0.8-1NCCL, sigue estos pasos:

    1. En el manifiesto de carga de trabajo, configura la siguiente variable de entorno:

      NCCL_LIB_DIR="/usr/local/nvidia/lib64

    2. Configura tu carga de trabajo para que ejecute la secuencia de comandos nccl-env-profile-ll128.sh cuando se inicie el contenedor. En el manifiesto de carga de trabajo, configura el siguiente comando:

      source ${NCCL_LIB_DIR}/nccl-env-profile-ll128.sh

      La secuencia de comandos nccl-env-profile-ll128.sh tiene las siguientes variables de entorno:

      NCCL_PROTO=Simple,LL128
NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config_ll128.textproto
NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_guest_config_ll128.textproto

  • Para el complemento de NCCL de us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx-dev:v1.0.9-1 y versiones posteriores, LL128 se convierte en un parámetro predeterminado, por lo que usar la secuencia de comandos nccl-env-profile.sh o la secuencia de comandos nccl-env-profile-ll128.sh habilita LL128. Para inhabilitar LL128, haz lo siguiente:

    1. En el manifiesto de carga de trabajo, configura la siguiente variable de entorno:

      NCCL_LIB_DIR="/usr/local/nvidia/lib64

    2. Configura tu carga de trabajo para que ejecute la secuencia de comandos nccl-env-profile-ll128.sh cuando se inicie el contenedor. En el manifiesto de carga de trabajo, configura el siguiente comando:

      source ${NCCL_LIB_DIR}/nccl-env-profile-simple.sh

      La secuencia de comandos nccl-env-profile-simple.sh tiene las siguientes variables de entorno:

      NCCL_PROTO=Simple
NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config_simple.textproto
NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_tuner_config_simple.textproto

GPUDirect-TCPX


"NCCL_SOCKET_IFNAME=\"eth0\"",
"NCCL_ALGO=Ring",
"NCCL_PROTO=Simple",
"NCCL_CROSS_NIC=0",
"NCCL_NET_GDR_LEVEL=PIX",
"NCCL_P2P_PXN_LEVEL=0",
"NCCL_GPUDIRECTTCPX_SOCKET_IFNAME=eth1,eth2,eth3,eth4",
"NCCL_GPUDIRECTTCPX_CTRL_DEV=eth0",
"NCCL_DYNAMIC_CHUNK_SIZE=524288",
"NCCL_P2P_NET_CHUNKSIZE=524288",
"NCCL_P2P_PCI_CHUNKSIZE=524288",
"NCCL_P2P_NVL_CHUNKSIZE=1048576",
"NCCL_BUFFSIZE=4194304",
"NCCL_NSOCKS_PERTHREAD=4",
"NCCL_SOCKET_NTHREADS=1",
"NCCL_GPUDIRECTTCPX_TX_BINDINGS=\"eth1:8-21,112-125;eth2:8-21,112-125;eth3:60-73,164-177;eth4:60-73,164-177\"",
"NCCL_GPUDIRECTTCPX_RX_BINDINGS=\"eth1:22-35,126-139;eth2:22-35,126-139;eth3:74-87,178-191;eth4:74-87,178-191\"",
"NCCL_GPUDIRECTTCPX_PROGRAM_FLOW_STEERING_WAIT_MICROS=500000"

Recopila registros de depuración de NCCL

Para registrar errores de NCCL, te recomendamos que agregues la siguiente configuración de NCCL:

NCCL_DEBUG=INFO
NCCL_DEBUG_SUBSYS=INIT,NET,ENV,COLL,GRAPH
NCCL_DEBUG_FILE=/DIRECTORY/FILE_NAME.%h.%p
  • NCCL_DEBUG=INFO: Imprime información de depuración.
    • Para cargas de trabajo a gran escala (64 nodos o más), se puede producir un registro extenso. Para evitar esta situación, y a menos que hayas especificado NCCL_DEBUG_FILE, te recomendamos que configures NCCL_DEBUG=WARN para limitar los registros solo a los errores.

  • NCCL_DEBUG_SUBSYS: Filtra los subsistemas para los que NCCL recopila información de depuración. Te recomendamos que recopiles registros de los siguientes subsistemas:

    • INIT: Es la fase de inicialización de NCCL.
    • NET: Es la red de NCCL.
    • ENV: Son las variables de entorno que usa NCCL.
    • COLL: Operaciones colectivas.
    • GRAPH: Detección de topología y búsqueda de grafos.

    Si deseas recopilar registros para diferentes subsistemas, consulta NCCL_DEBUG_SUBSYS en la documentación de NCCL para obtener una lista de los valores aceptados.

  • NCCL_DEBUG_FILE (opcional): Dirige el registro de depuración de NCCL a un archivo que especifiques. Esta variable escribe los registros de NCCL en archivos estándar, lo que evita que la salida de registro se mezcle con la salida de la aplicación. Esta variable también escribe registros de diferentes rangos de NCCL en archivos diferentes, lo que evita que se mezclen los registros.

    Usa el siguiente formato de nombre de archivo:

    /DIRECTORY/FILE_NAME.%h.%p

    Reemplaza lo siguiente:

    • DIRECTORY: Es el directorio en el que deseas almacenar los archivos de registro.
    • FILE_NAME: Es el nombre de los archivos de registro.

    El marcador de posición %h se resuelve como el nombre de host del nodo, mientras que %p se resuelve como el ID de proceso (PID) del proceso que genera el registro.

Para obtener más información sobre la depuración de registros de NCCL, consulta Soluciona problemas de GPU en GKE.

Agrega GPUDirect a tus manifiestos

En esta sección, se muestra los campos obligatorios que debes agregar a los manifiestos de Kubernetes para que los Pods usen GPUDirect.

En el modo Autopilot, también debes seleccionar las GPUs adecuadas en los manifiestos de Pod para que GKE aprovisione el hardware. Para las GPUs H100 Mega, usa GPUDirect-TCPXO. Para las GPU H100, usa GPUDirect-TCPX.

Agrega los siguientes selectores de nodos a tu Pod:

nodeSelector:
  cloud.google.com/gke-accelerator: GPU_NAME
  cloud.google.com/gke-gpu-driver-version: latest

Reemplaza GPU_NAME por el nombre de la GPU. Los valores admitidos son los siguientes:

  • nvidia-h100-mega-80gb
  • nvidia-h100-80gb

Según el tipo de GPUDirect, haz lo siguiente:

GPUDirect-TCPXO

  1. Agrega las siguientes anotaciones a los metadatos del Pod. 

    metadata:
  annotations:
    devices.gke.io/container.tcpxo-daemon: |+
      - path: /dev/nvidia0
      - path: /dev/nvidia1
      - path: /dev/nvidia2
      - path: /dev/nvidia3
      - path: /dev/nvidia4
      - path: /dev/nvidia5
      - path: /dev/nvidia6
      - path: /dev/nvidia7
      - path: /dev/nvidiactl
      - path: /dev/nvidia-uvm
      - path: /dev/dmabuf_import_helper
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"vpc1"},
        {"interfaceName":"eth2","network":"vpc2"},
        {"interfaceName":"eth3","network":"vpc3"},
        {"interfaceName":"eth4","network":"vpc4"},
        {"interfaceName":"eth5","network":"vpc5"},
        {"interfaceName":"eth6","network":"vpc6"},
        {"interfaceName":"eth7","network":"vpc7"},
        {"interfaceName":"eth8","network":"vpc8"}
      ]

  2. Agrega los siguientes campos a la especificación del Pod:

    spec:
  volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia/lib64
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys
  - name: aperture-devices
    hostPath:
      path: /dev/aperture_devices

  3. Agrega el siguiente contenedor al manifiesto para ejecutar el servicio tcpxo-daemon. Reemplaza (TCPXO_DAEMON_IMAGE) por la imagen más reciente, us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/tcpgpudmarxd-dev:v1.0.17:

    - name: tcpxo-daemon
  image: TCPXO_DAEMON_IMAGE
  imagePullPolicy: Always
  command: ["/bin/sh", "-c"]
  args:
    - |
      set -ex
      chmod 755 /fts/entrypoint_rxdm_container.sh
      /fts/entrypoint_rxdm_container.sh --num_hops=2 --num_nics=8 --uid= --alsologtostderr
  securityContext:
    capabilities:
      add:
        - NET_ADMIN
        - NET_BIND_SERVICE
  volumeMounts:
    - name: libraries
      mountPath: /usr/local/nvidia
    - name: sys
      mountPath: /hostsysfs
    - name: proc-sys
      mountPath: /hostprocsysfs

  4. Agrega la siguiente variable de entorno a cada contenedor de GPU:

    env:

- name: NCCL_FASTRAK_LLCM_DEVICE_DIRECTORY
  value: /dev/aperture_devices

  5. Agrega los siguientes volumeMounts a cada contenedor de GPU. Sin configuraciones de aperture_devices, se requiere privileged:true para los contenedores de GPU:

    volumeMounts:
  - name: aperture-devices
    mountPath: /dev/aperture_devices

  6. Agrega variables de entorno para configurar las opciones de NCCL. Para obtener más información, consulta Usa la configuración recomendada de NCCL para mejorar el rendimiento.

Una especificación de Pod completa se ve de la siguiente manera:

apiVersion: v1
kind: Pod
metadata:
name: a3plus-workloads
annotations:
  devices.gke.io/container.tcpxo-daemon: |+
    - path: /dev/nvidia0
    - path: /dev/nvidia1
    - path: /dev/nvidia2
    - path: /dev/nvidia3
    - path: /dev/nvidia4
    - path: /dev/nvidia5
    - path: /dev/nvidia6
    - path: /dev/nvidia7
    - path: /dev/nvidiactl
    - path: /dev/nvidia-uvm
    - path: /dev/dmabuf_import_helper
  networking.gke.io/default-interface: 'eth0'
  networking.gke.io/interfaces: |
    [
      {"interfaceName":"eth0","network":"default"},
      {"interfaceName":"eth1","network":"vpc1"},
      {"interfaceName":"eth2","network":"vpc2"},
      {"interfaceName":"eth3","network":"vpc3"},
      {"interfaceName":"eth4","network":"vpc4"},
      {"interfaceName":"eth5","network":"vpc5"},
      {"interfaceName":"eth6","network":"vpc6"},
      {"interfaceName":"eth7","network":"vpc7"},
      {"interfaceName":"eth8","network":"vpc8"}
    ]
...
containers:
  - name: tcpxo-daemon
    image: TCPXO_DAEMON_IMAGE
    imagePullPolicy: Always
    command: ["/bin/sh", "-c"]
    args:
      - |
        set -ex
        chmod 755 /fts/entrypoint_rxdm_container.sh
        /fts/entrypoint_rxdm_container.sh --num_hops=2 --num_nics=8 --uid= --alsologtostderr
    securityContext:
      capabilities:
        add:
          - NET_ADMIN
          - NET_BIND_SERVICE
    volumeMounts:
      - name: libraries
        mountPath: /usr/local/nvidia
      - name: sys
        mountPath: /hostsysfs
      - name: proc-sys
        mountPath: /hostprocsysfs
    
  - name: main-application-container
...
   
      - name: NCCL_FASTRAK_LLCM_DEVICE_DIRECTORY
        value: /dev/aperture_devices
    securityContext:
    volumeMounts:
      - name: aperture-devices
        mountPath: /dev/aperture_devices
    resources:
      limits:
        nvidia.com/gpu: 8
volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys
  - name: aperture-devices
    hostPath:
      path: /dev/aperture_devices

GPUDirect-TCPX

  1. Agrega las siguientes anotaciones a los metadatos del Pod. 

    metadata:
  annotations:
    devices.gke.io/container.tcpx-daemon: |+
      - path: /dev/nvidia0
      - path: /dev/nvidia1
      - path: /dev/nvidia2
      - path: /dev/nvidia3
      - path: /dev/nvidia4
      - path: /dev/nvidia5
      - path: /dev/nvidia6
      - path: /dev/nvidia7
      - path: /dev/nvidiactl
      - path: /dev/nvidia-uvm
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"vpc1"},
        {"interfaceName":"eth2","network":"vpc2"},
        {"interfaceName":"eth3","network":"vpc3"},
        {"interfaceName":"eth4","network":"vpc4"},
      ]

  2. Agrega los siguientes campos a la especificación del Pod:

    spec:
  volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia/lib64
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys

  3. Agrega el siguiente contenedor al manifiesto para ejecutar el servicio tcpx-daemon:

    - name: tcpx-daemon
  image: us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/tcpgpudmarxd-dev:v2.0.9
  command:
    - /tcpgpudmarxd/build/app/tcpgpudmarxd
    - --gpu_nic_preset
    - a3vm
    - --gpu_shmem_type
    - fd
    - --uds_path
    - /run/tcpx
    - --setup_param
    - \"--verbose 128 2 0 \"
  securityContext:
    capabilities:
        add:
          - NET_ADMIN
  volumeMounts:
    - name: libraries
      mountPath: /usr/local/nvidia/lib64
    - name: tcpx-socket
      mountPath: /run/tcpx
    - name: sys
      mountPath: /hostsysfs
    - name: proc-sys
      mountPath: /hostprocsysfs

  4. Agrega las siguientes activaciones de volumen a cualquier contenedor que solicite GPU:

    volumeMounts:
- name: tcpx-socket
  mountPath: /tmp
- name: libraries
  mountPath: /usr/local/nvidia/lib64

  5. Agrega variables de entorno para configurar las opciones de NCCL. Para obtener más información, consulta la sección Usa la configuración recomendada de NCCL para mejorar el rendimiento de este documento.

Una especificación de Pod completa se ve de la siguiente manera:

apiVersion: v1
kind: Pod
metadata:
name: a3-gpu-workloads-example
labels:
  name: a3-gpu-workloads-example
annotations:
  devices.gke.io/container.tcpx-daemon: |+
        - path: /dev/nvidia0
        - path: /dev/nvidia1
        - path: /dev/nvidia2
        - path: /dev/nvidia3
        - path: /dev/nvidia4
        - path: /dev/nvidia5
        - path: /dev/nvidia6
        - path: /dev/nvidia7
        - path: /dev/nvidiactl
        - path: /dev/nvidia-uvm
  networking.gke.io/default-interface: 'eth0'
  networking.gke.io/interfaces: |
    [
      {"interfaceName":"eth0","network":"default"},
      {"interfaceName":"eth1","network":"vpc1"},
      {"interfaceName":"eth2","network":"vpc2"},
      {"interfaceName":"eth3","network":"vpc3"},
      {"interfaceName":"eth4","network":"vpc4"}
    ]
spec:
containers:
  - name: tcpx-daemon
    image: us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/tcpgpudmarxd-dev:v2.0.11
    imagePullPolicy: Always
    command:
      - /tcpgpudmarxd/build/app/tcpgpudmarxd
      - --gpu_nic_preset
      - a3vm
      - --gpu_shmem_type
      - fd
      - --uds_path
      - /run/tcpx
      - --setup_param
      - \"--verbose 128 2 0 \"
    securityContext:
capabilities:
        add:
          - NET_ADMIN
    volumeMounts:
      - name: libraries
        mountPath: /usr/local/nvidia/lib64
        readOnly: true
      - name: tcpx-socket
        mountPath: /run/tcpx
      - name: sys
        mountPath: /hostsysfs
      - name: proc-sys
        mountPath: /hostprocsysfs
    
  - name: a3-gpu-workloads-example
    ...
    volumeMounts:
      - name: tcpx-socket
        mountPath: /tmp
      - name: libraries
        mountPath: /usr/local/nvidia/lib64
        readOnly: true
    resources:
      limits:
        nvidia.com/gpu: 8
    
...
volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia/lib64
  - name: tcpx-socket
    emptyDir:
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys

¿Qué sigue?