Esta página foi traduzida pela API Cloud Translation.

Maximizar a largura de banda da rede da GPU em clusters no modo Autopilot

Autopilot

Nesta página, mostramos como maximizar a largura de banda e a capacidade de processamento para cargas de trabalho de GPU de alto desempenho em clusters do Autopilot do Google Kubernetes Engine (GKE) usando GPUDirect-TCPXO, GPUDirect-TCPX, gVNIC e várias redes. Se você usa clusters padrão, consulte Maximizar a largura de banda da rede da GPU em clusters no modo padrão.

Esta página é destinada a engenheiros de machine learning (ML) e administradores de plataforma que facilitam cargas de trabalho de ML. Antes de ler esta página, confira se você conhece as tecnologias de rede, como placas de rede (NICs) e TCP, e as tecnologias de aceleração, como a Biblioteca de Comunicação Coletiva da NVIDIA (NCCL).

Aplicativos de inteligência artificial (IA), ML e computação de alto desempenho (HPC) exigem aceleração poderosa para otimizar o desempenho, reduzindo os tempos de conclusão de jobs. Por exemplo, os modelos de ML que se concentram em IA de conversação e geração de imagens exigem alta escalonabilidade e poder de computação.

Sobre Google Cloud Supercomputadores de GPU

OGoogle Cloud tem supercomputadores otimizados para aceleradores que são desenvolvidos para modelos grandes e escalonáveis. Essas máquinas têm os seguintes benefícios:

Oito GPUs NVIDIA H100 por máquina.
Até 200 Gbps de largura de banda na placa de rede (NIC) principal.
NICs secundárias (até oito em tipos de máquina A3 Mega e até quatro em tipos de máquina A3 High), cada uma com suporte de largura de banda de até 200 Gbps para transferência de dados de GPU.

Para uma lista completa de benefícios, consulte a série de máquinas A3 na documentação do Compute Engine.

Sua carga de trabalho do GKE precisa usar todas as GPUs e NICs secundárias disponíveis em um único nó e usar uma parte significativa da largura de banda disponível. A solução descrita neste documento é ideal para cargas de trabalho que exigem alto desempenho, alta capacidade de processamento e baixa latência.

Recursos e funcionalidades necessários para maximizar a largura de banda

Para maximizar a largura de banda da rede nos nós de supercomputadores da GPU, use todos os recursos a seguir:

Pilha de rede GPUDirect: a série de máquinas A3 oferece suporte a duas pilhas de rede para acesso direto à memória (RDMA, na sigla em inglês) personalizado e remoto:
- Em tipos de máquina A3 High e GPUs NVIDIA H100, use o GPUDirect-TCPX para reduzir a sobrecarga necessária para transferir payloads de pacotes de e para GPUs, o que melhora significativamente a capacidade de processamento em escala em comparação com as GPUs que não usam o GPUDirect.
- Em tipos de máquina A3 Mega e GPUs Mega NVIDIA H100, use o GPUDirect-TCPXO, que melhora ainda mais a comunicação da GPU com a VM.
gVNIC: ativa os recursos do GPUDirect, como divisão de cabeçalho de pacote, direcionamento de fluxo e gerenciamento de buffer. A gVNIC é necessária para usar o GPUDirect-TCPX ou o GPUDirect-TCPXO. Para detalhes sobre a gVNIC, consulte Aumentar a velocidade do tráfego de rede para nós da GPU.
Várias redes: adicione NICs secundárias à máquina otimizada para aceleradores. Cada placa de rede é associada a uma sub-rede separada na própria VPC para evitar conflitos. Para detalhes sobre o suporte a várias redes, consulte Configurar o suporte a várias redes para pods.
Políticas de posicionamento: use uma política de posicionamento de recursos para colocar todos os nós da GPU em uma carga de trabalho específica em servidores fisicamente próximos a fim de minimizar a latência. Para mais detalhes, consulte Definir um posicionamento compacto para nós do GKE.

Descrição do procedimento

Para usar todos esses recursos juntos, faça o seguinte:

Crie nuvens privadas virtuais (VPC) e sub-redes
Crie o ambiente do GKE.
Instalar o binário GPUDirect e o plug-in NCCL
Implantar o plug-in de injeção de dispositivo NRI
Implante uma carga de trabalho de teste para verificar a configuração do GPUDirect

Antes de começar

Antes de começar, veja se você realizou as seguintes tarefas:

Ative a API Google Kubernetes Engine.

Ativar a API Google Kubernetes Engine

Se você quiser usar a CLI do Google Cloud para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a gcloud CLI anteriormente, instale a versão mais recente executando gcloud components update.
Observação: para instalações atuais da gcloud CLI, defina as propriedades compute/region e compute/zone. Quando você define os locais padrão, você evita erros como este na gcloud CLI: One of [--zone, --region] must be supplied: Please specify location.

Verifique se você tem cota suficiente para GPUs H100. Para solicitar mais cotas, consulte as cotas de GPU.

Requisitos

Os requisitos a seguir se aplicam a GPUDirect-TCPX e GPUDirect-TCPXO, a menos que indicado de outra forma.

Seu cluster precisa usar o GKE versão 1.31.1-gke.1621000 ou mais recente.

Os nós da GPU precisam usar o driver da NVIDIA versão 535 ou mais recente.
É preciso usar o GKE Dataplane V2.

Limitações

Considere as seguintes limitações:

O GPUDirect-TCPX e o GPUDirect-TCPXO não são compatíveis com GPUs de várias instâncias, compartilhamento de tempo de GPU ou NVIDIA MPS.
Não é possível usar o NCCL FastSocket.
Sua carga de trabalho do GKE precisa usar todas as GPUs e NICs secundárias disponíveis em um único nó. Vários pods não podem usar GPUDirect-TCPX ou GPUDirect-TCPXO em um único nó.
Só é possível usar os tipos de máquina a3-highgpu-8g e a3-megagpu-8g. Outros tipos de máquina A3 não são compatíveis.

Criar VPCs e sub-redes

Crie redes VPC separadas no seu projeto para cada placa de rede virtual que você adicionar aos nós. Cada rede VPC precisa ter uma sub-rede e uma regra de firewall que permita o tráfego de rede interno.

Crie as redes VPC para GPUDirect no projeto, cada uma com uma sub-rede e uma regra de firewall: Escolha a guia "GPUDirect-TCPX" para tipos de máquina A3 High ou a guia "GPUDirect-TCPXO" para tipos de máquina A3 Mega e siga estas instruções:
GPUDirect-TCPXO
Para maximizar a largura de banda, recomendamos que você crie oito novas redes.
```
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
```
Substitua:
- PROJECT_ID: o ID do projeto do Google Cloud .
- REGION: a região do Compute Engine para cada sub-rede.
- SUBNET_RANGE: o intervalo de endereços IP de cada sub-rede na notação CIDR. Este comando de exemplo itera para oito sub-redes. Portanto, use uma variável para alterar o endereço IP de cada sub-rede. Por exemplo, especifique 192.168.$N.0/24 para que a primeira sub-rede use 192.168.1.0/24, a segunda use 192.168.2.0/24 e assim por diante.
- SOURCE_RANGE: o intervalo de endereços IP de origem para que a regra de firewall permita o tráfego de entrada, na notação CIDR. Por exemplo, 192.168.0.0/16.
GPUDirect-TCPX
Para maximizar a largura de banda, recomendamos que você crie quatro novas redes.
```
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
```
Substitua:
- PROJECT_ID: o ID do projeto do Google Cloud .
- REGION: a região do Compute Engine para cada sub-rede.
- SUBNET_RANGE: o intervalo de endereços IP de cada sub-rede na notação CIDR. Este comando de exemplo faz a iteração de quatro sub-redes. Portanto, use uma variável para alterar o endereço IP de cada sub-rede. Por exemplo, especifique 192.168.$N.0/24 para que a primeira sub-rede use 192.168.1.0/24, a segunda use 192.168.2.0/24 etc.
- SOURCE_RANGE: o intervalo de endereços IP de origem para que a regra de firewall permita o tráfego de entrada, na notação CIDR. Por exemplo, 192.168.0.0/16.
Verifique se as redes foram criadas:
```
gcloud compute networks list
```

Crie o ambiente do GKE

Crie um novo cluster do GKE que use várias redes (pré-lançamento). Não é possível atualizar um cluster atual para usar várias redes.

GPUDirect-TCPXO

Escolha uma versão disponível do GKE compatível com o GPUDirect-TCPXO. Para listar as versões, execute este comando:
```
gcloud container get-server-config \
    --format="yaml(validMasterVersions)" \
    --region=REGION \
    --project=PROJECT_ID
```
Substitua:
- REGION: a região de computação do plano de controle do cluster.
- PROJECT_ID: o ID do projeto do Google Cloud .

Crie um cluster:

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

Substitua:

CLUSTER_NAME: o nome do novo cluster;
VERSION: uma versão do GKE que oferece suporte ao GPUDirect-TCPXO, conforme descrito em Requisitos.
LOCATION: a região do Compute Engine para o cluster.

Crie recursos de rede e GKENetworkParamSet no cluster que correspondem às redes e sub-redes VPC que você criou:

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

Esses recursos orientam o GKE a configurar as placas de rede (NICs) para o tráfego da GPU no modo de passagem. O GKE não aplica a programação de rede integrada usando eBPF a esse tráfego.

GPUDirect-TCPX

Crie um cluster:

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

Substitua:

CLUSTER_NAME: o nome do novo cluster;
VERSION: uma versão do GKE que oferece suporte ao GPUDirect-TCPX, conforme descrito em Requisitos.
LOCATION: a região do Compute Engine para o cluster.

Crie recursos de rede e GKENetworkParamSet no cluster que correspondem às redes e sub-redes VPC que você criou:

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

Esses recursos orientam o GKE a configurar as placas de rede (NICs) para o tráfego da GPU no modo de passagem. O GKE não aplica a programação de rede integrada usando eBPF a esse tráfego.

Instalar o binário GPUDirect e configurar o NCCL

Esta seção mostra como instalar o binário GPUDirect com base no tipo de máquina A3 (GPUDirect-TCPX para A3 High, GPUDirect-TCPXO para A3 Mega) e uma versão específica da biblioteca NCCL usando um DaemonSet.

GPUDirect-TCPXO

Esse DaemonSet faz o seguinte:

Pré-instalação para configurar configurações relacionadas ao GPUDirect-TCPXO.
Instala a biblioteca NCCL e o binário GPUDirect-TCPXO no nó.
Armazena a biblioteca e o binário no diretório /home/kubernetes/bin/nvidia/lib64 na VM. Por padrão, o GKE monta esse diretório no caminho /usr/local/nvidia/lib64 nos contêineres de GPU que precisam usar o NCCL e o GPUDirect-TCPXO.

Para instalar o binário e configurar o NCCL, siga estas etapas:

Revise o manifesto do Daemonset nccl-tcpxo-installer-autopilot.yaml no GitHub.
Crie um namespace dedicado:
```
kubectl create ns gpudirect-system
```

Implante o DaemonSet:

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

O plug-in do NCCL leva aproximadamente dois minutos para começar a ser executado.

GPUDirect-TCPX

Esse DaemonSet faz o seguinte:

Instala a biblioteca NCCL e o binário GPUDirect-TCPX no nó.
Armazena a biblioteca e o binário no diretório /home/kubernetes/bin/nvidia/lib64 na VM. Por padrão, o GKE monta esse diretório no caminho /usr/local/nvidia/lib64 nos contêineres de GPU que precisam usar o NCCL e o GPUDirect-TCPX.

Para instalar o binário e configurar o NCCL, faça o seguinte:

Revise o manifesto do Daemonset nccl-tcpx-installer-autopilot.yaml no GitHub.
Crie um namespace dedicado:
```
kubectl create ns gpudirect-system
```

Implante o DaemonSet:

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

O plug-in do NCCL leva aproximadamente dois minutos para começar a ser executado.

Implantar o plug-in de injeção de dispositivo NRI

Esta seção mostra como instalar o injetor de dispositivo NRI usando um DaemonSet. Os dois tipos de máquina de GPU H100 instalam o mesmo plug-in de injeção de dispositivo NRI. Esse plug-in faz o seguinte:

Ativa a interface de recursos do nó (NRI) no nó que tem GPUs H100. A NRI é ativada por padrão no GKE versão 1.29 e mais recente.
Implanta um contêiner de plug-in de injeção de dispositivo NRI que injeta dispositivos de GPU em contêineres especificados por anotações de pod.

Para instalar o plug-in, proceda da seguinte maneira:

Revise o manifesto de implantação nri-device-injector-autopilot.yaml no GitHub.

Implante o DaemonSet:

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

O plug-in do NCCL leva aproximadamente dois minutos para começar a ser executado.

Implantar uma carga de trabalho de teste

Nesta seção, você vai implantar uma carga de trabalho de amostra para verificar se o NCCL e o GPUDirect-TCPX ou o GPUDirect-TCPXO funcionam conforme o esperado. Esta carga de trabalho de exemplo faz o seguinte:

Implanta dois pods, cada um executado em um nó que tem GPUs H100.
Implanta um contêiner de arquivo secundário em cada pod para permitir que esses pods usem o GPUDirect-TCPXO ou o GPUDirect-TCPX.

Para implantar essa carga de trabalho de exemplo, faça o seguinte:

GPUDirect-TCPXO

Essa carga de trabalho inclui um contêiner de arquivo secundário chamado tcpxo-daemon, que executa um serviço que permite ao pod usar o GPUDirect-TCPXO. Você precisa adicionar esse contêiner de arquivo secundário a qualquer pod no seu próprio ambiente que precise usar GPUDirect-TCPXO. Para conferir um snippet dos campos obrigatórios a serem adicionados aos manifestos, consulte Adicionar GPUDirect ao manifesto.

Revise o manifesto nccl-test-latest-autopilot.yaml no GitHub.

Implante dois pods com a carga de trabalho de teste:

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

Após a implantação dos pods, acione um teste de todos os pods:

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

O resultado será assim:

#                                                              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

Essa carga de trabalho inclui um contêiner de arquivo secundário chamado tcpx-daemon, que executa um serviço que permite ao pod usar o GPUDirect-TCPX. Você precisa adicionar esse contêiner de arquivo secundário a qualquer pod no seu próprio ambiente que precise usar GPUDirect-TCPX. Para conferir um snippet dos campos obrigatórios a serem adicionados aos manifestos, consulte Adicionar GPUDirect ao manifesto.

Revise o manifesto ConfigMap nccl-config.yaml no GitHub. Esse manifesto implanta scripts que inicializam um teste all-gather do NCCL e define configurações específicas do NCCL.
Revise o manifesto de implantação nccl-test-latest-autopilot.yaml no GitHub.

Implante o ConfigMap e a carga de trabalho de teste:

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

Execute os seguintes comandos para acionar um teste de todos os nós do NCCL:

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

O resultado será assim:

#                                                              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

Usar as configurações necessárias do NCCL para melhorar o desempenho

Os pares de chave-valor a seguir são as configurações de configuração do NCCL necessárias para GPUDirect-TCPX e GPUDirect-TCPXO Ao implantar cargas de trabalho que usam o NCCL, defina-as como variáveis de ambiente para otimizar o desempenho.

GPUDirect-TCPXO

## required

"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",
"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"
## recommended, to log NCCL errors
"NCCL_DEBUG=WARN",
"NCCL_DEBUG_SUBSYS=INIT,NET,ENV,COLL,GRAPH"

Também é possível definir todas as configurações de uma vez seguindo estas etapas:

Adicione o seguinte par de chave-valor como uma variável de ambiente no manifesto do contêiner da carga de trabalho:
```
NCCL_LIB_DIR="/usr/local/nvidia/lib64"
```
Confira se o script nccl-env-profile.sh é executado quando o contêiner de carga de trabalho é iniciado. Por exemplo, você pode fazer isso na especificação do pod, substituindo o comando do contêiner para incluir o seguinte:
```
source ${NCCL_LIB_DIR}/nccl-env-profile.sh
```

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"

Adicionar GPUDirect aos manifestos

Esta seção mostra os campos obrigatórios que você precisa adicionar aos manifestos do Kubernetes para que seus pods usem o GPUDirect.

No modo Autopilot, você também precisa selecionar as GPUs adequadas nos manifestos de pods para que o GKE provisione o hardware. Para GPUs Mega H100, use o GPUDirect-TCPXO. Para GPUs H100, use o GPUDirect-TCPX.

Adicione os seguintes seletores de nó ao pod:

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

Substitua GPU_NAME pelo nome da GPU. Os valores compatíveis são os seguintes:

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

Dependendo do tipo de GPUDirect, faça o seguinte:

GPUDirect-TCPXO

Adicione as seguintes anotações aos metadados do 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"}
      ]

Adicione os seguintes campos à especificação do 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

Adicione o contêiner a seguir ao manifesto para executar o serviço tcpxo-daemon. Substitua (TCPXO_DAEMON_IMAGE) pela imagem mais recente us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/tcpgpudmarxd-dev:v1.0.12:

- 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

Adicione a seguinte variável de ambiente a cada contêiner de GPU:

env:

- name: NCCL_FASTRAK_LLCM_DEVICE_DIRECTORY
  value: /dev/aperture_devices

Adicione as seguintes volumeMounts a cada contêiner de GPU. Sem as configurações de aperture_devices, o privileged:true é necessário para contêineres de GPU:
```
volumeMounts:
  - name: aperture-devices
    mountPath: /dev/aperture_devices
```
Adicione variáveis de ambiente para configurar as opções da NCCL. Para mais detalhes, consulte Usar as configurações recomendadas do NCCL para melhorar o desempenho.

Uma especificação de pod completa tem esta aparência:

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

Adicione as seguintes anotações aos metadados do 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"},
      ]

Adicione os seguintes campos à especificação do pod:

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

Adicione o seguinte contêiner ao manifesto para executar o serviço 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

Adicione as seguintes montagens de volume a todos os contêineres que solicitarem GPUs:
```
volumeMounts:
- name: tcpx-socket
  mountPath: /tmp
- name: libraries
  mountPath: /usr/local/nvidia/lib64
```
Observação: o caminho do soquete tcpx padrão é /tmp para contêineres que solicitam GPUs. Se você definir a variável de ambiente NCCL_GPUDIRECTTCPX_UNIX_CLIENT_PREFIX como um valor diferente de /tmp, o GKE montará o volume tcpx-socket no mountPath.
Adicione variáveis de ambiente para configurar as opções da NCCL. Para mais detalhes, consulte a seção Usar as configurações recomendadas do NCCL para melhorar o desempenho neste documento.

Uma especificação de pod completa tem esta aparência:

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

A seguir

Saiba mais sobre as práticas recomendadas para redes do GKE.
Saiba mais sobre a família de tecnologias Nvidia GPUDirect para movimentação e acesso de dados em GPUs Nvidia.
Saiba mais sobre a disponibilidade atual da versão da GPU e como solicitar GPUs no GKE.