**Contribuisci a migliorare questa pagina**
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
Per contribuire a questa guida per l'utente, scegli il GitHub link **Modifica questa pagina** nel riquadro destro di ogni pagina.
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo P6e-GB200 UltraServers con Amazon EKS
Questo argomento descrive come configurare e utilizzare Amazon EKS con P6e-GB200 UltraServers. Il tipo di `p6e-gb200.36xlarge` istanza con 4 GPU NVIDIA Blackwell è disponibile solo come. P6e-GB200 UltraServers Esistono due tipi di. P6e-GB200 UltraServers `u-p6e-gb200x36` UltraServer Ha 9 `p6e-gb200.36xlarge` istanze e `u-p6e-gb200x72` UltraServer ha 18 `p6e-gb200.36xlarge` istanze.
Per ulteriori informazioni, consulta la pagina Web di [Amazon EC2 P6e-GB200 UltraServers ](https://aws.amazon.com/ec2/instance-types/p6/).
## Considerazioni
+ Amazon EKS supporta P6e-GB200 UltraServers le versioni 1.33 e successive di Kubernetes. [Questa versione di Kubernetes fornisce il supporto per [Dynamic Resource Allocation](https://kubernetes.io/docs/concepts/scheduling-eviction/dynamic-resource-allocation/) (DRA), abilitato di default in EKS e nelle AMI accelerate AL2023. EKS-optimized ](https://docs.aws.amazon.com/eks/latest/userguide/ml-eks-optimized-ami.html) Il DRA è un requisito per l'utilizzo di con EKS. P6e-GB200 UltraServers Il DRA non è supportato in Karpenter o EKS Auto Mode e si consiglia di utilizzare i gruppi di nodi autogestiti EKS o i gruppi di nodi gestiti da EKS quando si utilizza con EKS. P6e-GB200 UltraServers
+ P6e-GB200 UltraServers sono disponibili tramite [EC2](https://aws.amazon.com/ec2/capacityblocks/) Capacity Blocks for ML. [Gestisci le risorse di calcolo per i AI/ML carichi di lavoro su Amazon EKS](ml-compute-management.md)Per informazioni su come avviare nodi EKS con Capacity Blocks, consulta la pagina.
+ Quando si utilizzano gruppi di nodi gestiti EKS con Capacity Blocks, è necessario utilizzare modelli di avvio personalizzati. Quando si aggiornano i gruppi di nodi gestiti da EKS con P6e-GB200 UltraServers, è necessario impostare la dimensione desiderata del gruppo di nodi `0` prima dell'aggiornamento.
+ Si consiglia di utilizzare la variante ARM NVIDIA AL2023 delle EKS-optimized AMI accelerate. Questa AMI include i componenti del nodo e la configurazione necessari con cui lavorare P6e-GB200 UltraServers. Se decidi di creare la tua AMI, sei responsabile dell'installazione e della convalida della compatibilità del nodo e del software di sistema, inclusi i driver. Per ulteriori informazioni, consulta [Usa l'accelerazione ottimizzata per EKS per le istanze AMIs GPU](ml-eks-optimized-ami.md).
+ Si consiglia di utilizzare la versione EKS-optimized AMI `v20251103` o successiva, che include il driver NVIDIA versione 580. Questa versione del driver NVIDIA consente a Coherent Driver-Based Memory (CDMM) di risolvere il problema della potenziale segnalazione di un eccesso di memoria. Quando CDMM è abilitato, le seguenti funzionalità non sono supportate: GPU NVIDIA (MIG) e Multi-Instance vGPU. Per ulteriori informazioni su CDMM, consulta [NVIDIA](https://nvdam.widen.net/s/gpqp6wmz7s/cuda-whitepaper—cdmm-pdf) Coherent Memory Management (CDMM). Driver-based
+ Quando si utilizza l'[operatore GPU NVIDIA con l'](https://docs.nvidia.com/datacenter/cloud-native/gpu-operator/latest/overview.html)AMI NVIDIA EKS-optimized AL2023, è necessario disabilitare l'installazione da parte dell'operatore del driver e del toolkit, poiché questi sono già inclusi nell'AMI. Le AMI NVIDIA EKS-optimized AL2023 non includono il plug-in per dispositivi NVIDIA Kubernetes o il driver NVIDIA DRA e devono essere installate separatamente.
+ Ogni `p6e-gb200.36xlarge` istanza può essere configurata con un massimo di 17 schede di rete e può sfruttare EFA per la comunicazione tra. UltraServers Il traffico di rete dei carichi di lavoro può UltraServers intersecarsi, ma per ottenere prestazioni ottimali si consiglia di pianificare i carichi di lavoro nello stesso ambiente UltraServer sfruttando IMEX per la comunicazione intra-GPU. UltraServer [Per ulteriori informazioni, consulta Configurazione EFA per le istanze. P6e-GB200 ](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html#efa-for-p6e)
+ [Ogni `p6e-gb200.36xlarge` istanza dispone di 3 istanze di storage da 7,5 TB.](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html) Per impostazione predefinita, l' EKS-optimized AMI non formatta e non monta gli instance store. Lo storage temporaneo del nodo può essere condiviso tra i pod che richiedono lo storage temporaneo e le immagini dei contenitori che vengono scaricate nel nodo. Se si utilizza l' EKS-optimized AMI AL2023, questa può essere configurata come parte del bootstrap dei nodi nei dati utente impostando la politica di archiviazione locale dell'istanza su RAID0. [NodeConfig](https://docs.aws.amazon.com/eks/latest/eksctl/node-bootstrapping.html#configuring-the-bootstrapping-process) Se impostata su RAID0, l'istanza archivia e configura il runtime del contenitore e il kubelet per utilizzare questo storage temporaneo.
## Componenti
I seguenti componenti sono consigliati per eseguire carichi di lavoro su EKS con. P6e-GB200 UltraServers Facoltativamente, puoi utilizzare l'[operatore GPU NVIDIA](https://docs.nvidia.com/datacenter/cloud-native/gpu-operator/latest/overview.html) per installare i componenti del nodo NVIDIA. Quando si utilizza l'operatore GPU NVIDIA con l'AMI NVIDIA EKS-optimized AL2023, è necessario disabilitare l'installazione da parte dell'operatore del driver e del toolkit, poiché questi sono già inclusi nell'AMI.
- ** EKS-optimized AMI accelerata **
- kernel 6.12
- Driver per GPU NVIDIA
- Driver in modalità utente NVIDIA CUDA
- Toolkit per container NVIDIA
- NVIDIA Fabric Manager
- Driver NVIDIA IMEX
- Gestore di sottorete NVIDIA NVLink
- Driver EFA
- ** Componenti in esecuzione sul nodo **
- PATTUMIERA IN PVC
- Driver EFA DRA o plug-in per dispositivi EFA
- Plugin per dispositivi NVIDIA K8s
- Driver NVIDIA DRA
- NVIDIA Node Feature Discovery (NFD)
- NVIDIA GPU Feature Discovery (GFD)
I componenti del nodo nella tabella precedente svolgono le seguenti funzioni:
+ **VPC CNI**: alloca gli IP VPC come interfaccia di rete principale per i pod in esecuzione su EKS
+ **Driver EFA DRA o plug-in per dispositivi EFA: alloca i dispositivi EFA come reti secondarie** per i pod in esecuzione su EKS. Responsabile del traffico di rete attraverso. P6e-GB200 UltraServers Per i carichi di lavoro multinodo, il GPU-to-GPU traffico all'interno di un UltraServer può fluire su NVLink multinodo. Il driver EFA DRA è consigliato per Kubernetes 1.34 e versioni successive e consente l'allocazione basata sulla topologia e la condivisione dei dispositivi. Il plug-in del dispositivo EFA è supportato per tutte le versioni di Kubernetes. Per ulteriori informazioni, consulta [Gestisci i dispositivi EFA su Amazon EKS](device-management-efa.md).
+ **Plugin per dispositivi NVIDIA Kubernetes: alloca le GPU come dispositivi** per i pod in esecuzione su EKS. Si consiglia di utilizzare il plug-in per dispositivi NVIDIA Kubernetes fino a quando la funzionalità di allocazione GPU del driver NVIDIA DRA non sarà più sperimentale. [Consulta le versioni dei driver NVIDIA DRA per informazioni aggiornate.](https://github.com/kubernetes-sigs/nvidia-dra-driver-gpu/releases)
+ **Driver NVIDIA DRA**: abilita risorse ComputeDomain personalizzate che facilitano la creazione di domini IMEX che seguono i carichi di lavoro in esecuzione. P6e-GB200 UltraServers
+ La ComputeDomain risorsa descrive un dominio Internode Memory Exchange (IMEX). Quando i carichi di lavoro con un ResourceClaim for a ComputeDomain vengono distribuiti nel cluster, il driver NVIDIA DRA crea automaticamente un IMEX DaemonSet che viene eseguito su nodi corrispondenti e stabilisce i canali IMEX tra i nodi prima dell'avvio del carico di lavoro. [Per saperne di più su IMEX, consulta la panoramica di NVIDIA IMEX per sistemi NVLink multinodo.](https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/overview.html)
+ Il driver NVIDIA DRA utilizza un'etichetta ID clique (`nvidia.com/gpu.clique`) applicata da NVIDIA GFD che trasmette la conoscenza della topologia di rete e del dominio NVLink.
+ È consigliabile creare un lavoro per carico di lavoro. ComputeDomain
+ **NVIDIA Node Feature Discovery (NFD)**: dipendenza richiesta per GFD per applicare le etichette dei nodi in base agli attributi a livello di nodo rilevati.
+ **NVIDIA GPU Feature Discovery (GFD)**: applica un'etichetta topologica standard NVIDIA chiamata ai nodi. `nvidia.com/gpu.clique` I nodi all'interno dello stesso `nvidia.com/gpu.clique` hanno più nodi NVLink-reachability ed è possibile utilizzare le affinità dei pod nell'applicazione per pianificare i pod sullo stesso dominio NVLink.
## Procedura
La sezione seguente presuppone che tu abbia un cluster EKS che esegue Kubernetes versione 1.33 o successiva con uno o più gruppi di nodi con esecuzione P6e-GB200 UltraServers dell'AMI accelerata NVIDIA ARM AL2023. EKS-optimized Consulta i collegamenti per i passaggi preliminari [Gestisci le risorse di calcolo per i AI/ML carichi di lavoro su Amazon EKS](ml-compute-management.md) per i nodi autogestiti e i gruppi di nodi gestiti da EKS.
La procedura seguente utilizza i componenti riportati di seguito.
| Nome | Versione | Description |
| --- | --- | --- |
| Operatore GPU NVIDIA | 25.3.4 \+ | Per la gestione del ciclo di vita dei plug-in richiesti come il plug-in per dispositivi NVIDIA Kubernetes e. NFD/GFD |
| Driver NVIDIA DRA | 25.8.0\+ | Per la gestione di ComputeDomain CRD e domini IMEX. |
| Driver EFA DRA (DRANET) | Più recente | Per la UltraServer comunicazione incrociata con allocazione basata sulla topologia. Consigliato per Kubernetes 1.34\+. |
| Plugin per dispositivi EFA | 0.5.14\+ | Per comunicazioni incrociate. UltraServer Supportato per tutte le versioni di Kubernetes. |
## Installa l'operatore GPU NVIDIA
L'operatore GPU NVIDIA semplifica la gestione dei componenti necessari per utilizzare le GPU nei cluster Kubernetes. Poiché il driver della GPU NVIDIA e il toolkit contenitore sono installati come parte dell' EKS-optimized AMI accelerata, questi devono essere impostati `false` nella configurazione dei valori Helm.
1. Crea un file di valori Helm denominato con la seguente configurazione. `gpu-operator-values.yaml`
```
devicePlugin:
enabled: true
nfd:
enabled: true
gfd:
enabled: true
driver:
enabled: false
toolkit:
enabled: false
migManager:
enabled: false
```
1. Installa l'operatore GPU NVIDIA per il tuo cluster utilizzando il `gpu-operator-values.yaml` file creato nel passaggio precedente.
```
helm repo add nvidia https://helm.ngc.nvidia.com/nvidia
helm repo update
```
```
helm install gpu-operator nvidia/gpu-operator \
--namespace gpu-operator \
--create-namespace \
--version v25.3.4 \
--values gpu-operator-values.yaml
```
## Installa il driver NVIDIA DRA
A partire dalla versione NVIDIA GPU Operator`v25.3.4`, il driver NVIDIA DRA deve essere installato separatamente. Si consiglia di tenere traccia delle [note di rilascio](https://github.com/NVIDIA/gpu-operator/releases) dell'operatore della GPU NVIDIA poiché potrebbero cambiare in una versione futura.
1. Crea un file di valori Helm denominato `dra-values.yaml` con la seguente configurazione. Nota `tolerations` che configura il `nodeAffinity` driver DRA in modo che venga distribuito solo su nodi con una GPU NVIDIA.
```
resources:
gpus:
enabled: false # set to false to disable experimental gpu support
computeDomains:
enabled: true
controller:
nodeSelector: null
affinity: null
tolerations: []
kubeletPlugin:
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: "nvidia.com/gpu.present"
operator: In
values:
- "true"
tolerations:
- key: "nvidia.com/gpu"
operator: Exists
effect: NoSchedule
```
1. Installa il driver NVIDIA DRA per il tuo cluster utilizzando il `dra-values.yaml` file creato nel passaggio precedente.
```
helm repo add nvidia https://helm.ngc.nvidia.com/nvidia
helm repo update
```
```
helm install nvidia-dra-driver-gpu nvidia/nvidia-dra-driver-gpu \
--version="25.8.0" \
--namespace nvidia-dra-driver-gpu \
--create-namespace \
-f dra-values.yaml
```
1. Dopo l'installazione, il driver DRA crea `DeviceClass` risorse che consentono a Kubernetes di comprendere e allocare le `ComputeDomain` risorse, rendendo possibile la gestione IMEX per carichi di lavoro GPU distribuiti su. P6e-GB200 UltraServers
Verifica che le risorse DRA siano disponibili con i seguenti comandi.
```
kubectl api-resources | grep resource.k8s.io
```
```
deviceclasses resource.k8s.io/v1 false DeviceClass
resourceclaims resource.k8s.io/v1 true ResourceClaim
resourceclaimtemplates resource.k8s.io/v1 true ResourceClaimTemplate
resourceslices resource.k8s.io/v1 false ResourceSlice
```
```
kubectl get deviceclasses
```
```
NAME
compute-domain-daemon.nvidia.com
compute-domain-default-channel.nvidia.com
```
## Installa EFA per la comunicazione incrociata UltraServer
Per utilizzare la comunicazione EFA tra di loro UltraServers, installa il driver EFA DRA (DRANET) o il plug-in del dispositivo EFA. P6e-GB200 le istanze possono essere configurate con un massimo di [17 schede di rete](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html#efa-for-p6e) e l'NCI primario (indice 0) deve essere di tipo `interface` e supporta fino a 100 Gbps di larghezza di banda ENA. Configura le interfacce EFA ed ENA in base alle tue esigenze durante il provisioning dei nodi. Consulta la [AWS documentazione sulla configurazione EFA per P6e-GB200 le istanze](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html#efa-for-p6e) per maggiori dettagli sulla configurazione EFA.
**Importante**
Non installate il driver EFA DRA e il plug-in del dispositivo EFA sullo stesso nodo. I due meccanismi non possono coesistere sullo stesso nodo.
### Opzione 1: installare il driver EFA DRA (DRANET)
1. Create un file di valori Helm denominato `efa-values.yaml` con la seguente configurazione.
```
tolerations:
- key: nvidia.com/gpu
operator: Exists
effect: NoSchedule
```
1. Aggiungi l'archivio cartografico EKS Helm e installa il driver EFA DRA.
```
helm repo add eks https://aws.github.io/eks-charts
helm repo update
```
```
helm install aws-dranet eks/aws-dranet --namespace kube-system -f efa-values.yaml
```
1. Verificare che DRANET sia in esecuzione. DaemonSet
```
kubectl get daemonset -n kube-system aws-dranet
```
```
NAME DESIRED CURRENT READY UP-TO-DATE AVAILABLE NODE SELECTOR AGE
aws-dranet 2 2 2 2 2 60s
```
1. Verificate che gli `ResourceSlice` oggetti `DeviceClass` e siano disponibili.
```
kubectl get deviceclass efa.networking.k8s.aws
```
```
NAME AGE
efa.networking.k8s.aws 60s
```
```
kubectl get resourceslices -l resource.k8s.io/driver=dra.net
```
Per ulteriori informazioni sull'utilizzo del driver EFA DRA, inclusa l'allocazione basata sulla topologia e la condivisione dei dispositivi, vedere. [Gestisci i dispositivi EFA su Amazon EKS](device-management-efa.md)
### Opzione 2: installa il plug-in del dispositivo EFA
1. Create un file di valori Helm denominato `efa-values.yaml` con la seguente configurazione.
```
tolerations:
- key: nvidia.com/gpu
operator: Exists
effect: NoSchedule
```
1. Aggiungi l'archivio cartografico EKS Helm e installa il plug-in del dispositivo EFA.
```
helm repo add eks https://aws.github.io/eks-charts
helm repo update
```
```
helm install efa eks/aws-efa-k8s-device-plugin -n kube-system -f efa-values.yaml
```
1. Verifica che il plug-in del dispositivo EFA sia in esecuzione. DaemonSet
```
kubectl get daemonset -n kube-system aws-efa-k8s-device-plugin-daemonset
```
```
NAME DESIRED CURRENT READY UP-TO-DATE AVAILABLE NODE SELECTOR AGE
aws-efa-k8s-device-plugin-daemonset 2 2 2 2 2 60s
```
1. Verifica che i tuoi nodi abbiano dispositivi EFA allocabili. Ad esempio, se hai configurato le istanze con 1 interfaccia solo efa in ogni [gruppo NCI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html#efa-for-p6e), si prevede che vengano visualizzati 4 dispositivi EFA allocabili per nodo.
```
kubectl get nodes "-o=custom-columns=NAME:.metadata.name,EFA:.status.allocatable.vpc\.amazonaws\.com/efa"
```
```
NAME EFA
ip-192-168-11-225.us-west-2.compute.internal 4
ip-192-168-24-96.us-west-2.compute.internal 4
```
## Multi-Node Convalida IMEX su NVLink
[Per un test NVLINK NCCL multinodo e altri microbenchmark, consulta il fantastico repository di formazione distribuito.](https://github.com/aws-samples/awsome-distributed-training/tree/main/micro-benchmarks/nccl-tests) GitHub I passaggi seguenti mostrano come eseguire un test NVLink multinodo con nvbandwidth.
1. Per eseguire un test della larghezza di banda multinodo su due nodi nel dominio NVL72, installa prima l'operatore MPI:
```
kubectl create -f https://github.com/kubeflow/mpi-operator/releases/download/v0.7.0/mpi-operator.yaml
```
1. Create un file denominato `nvbandwidth-test-job.yaml` che definisca il manifesto del test. Nota l'affinità del `nvidia.com/gpu.clique` pod per pianificare i lavoratori nello stesso dominio NVLink che ha Multi-Node la raggiungibilità di NVLink. L'esempio seguente esegue un test memcpy CE Read da dispositivo a dispositivo multinodo utilizzando cu e stampa i risultati nei log. MemcpyAsync
A partire da NVIDIA, la versione `v25.8.0` ComputeDomains del driver DRA è elastica e può essere impostata nella definizione. `.spec.numNodes` `0` ComputeDomain Consulta le ultime note di [rilascio del driver NVIDIA DRA](https://github.com/kubernetes-sigs/nvidia-dra-driver-gpu/releases) per gli aggiornamenti.
Può essercene solo uno ComputeDomain (canale IMEX) per nodo. Non modificate l'indirizzo della `allocationMode` ComputeDomain risorsa, in quanto ciò può impedire che i Pod ComputeDomain e i Pod che vi accedono ComputeDomain vengano allocati e programmati correttamente. `All` Per ulteriori informazioni, consulta il numero \#353 del [driver NVIDIA DRA](https://github.com/kubernetes-sigs/dra-driver-nvidia-gpu/issues/353).
```
---
apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
name: nvbandwidth-test-compute-domain
spec:
numNodes: 0 # This can be set to 0 from NVIDIA DRA Driver version v25.8.0+
channel:
resourceClaimTemplate:
name: nvbandwidth-test-compute-domain-channel
---
apiVersion: kubeflow.org/v2beta1
kind: MPIJob
metadata:
name: nvbandwidth-test
spec:
slotsPerWorker: 4 # 4 GPUs per worker node
launcherCreationPolicy: WaitForWorkersReady
runPolicy:
cleanPodPolicy: Running
sshAuthMountPath: /home/mpiuser/.ssh
mpiReplicaSpecs:
Launcher:
replicas: 1
template:
metadata:
labels:
nvbandwidth-test-replica: mpi-launcher
spec:
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
# Only schedule on NVIDIA GB200/GB300 nodes
- key: node.kubernetes.io/instance-type
operator: In
values:
- p6e-gb200.36xlarge
- p6e-gb300.36xlarge
containers:
- image: ghcr.io/nvidia/k8s-samples:nvbandwidth-v0.7-8d103163
name: mpi-launcher
securityContext:
runAsUser: 1000
command:
- mpirun
args:
- --bind-to
- core
- --map-by
- ppr:4:node
- -np
- "8"
- --report-bindings
- -q
- nvbandwidth
- -t
- multinode_device_to_device_memcpy_read_ce
Worker:
replicas: 2 # 2 worker nodes
template:
metadata:
labels:
nvbandwidth-test-replica: mpi-worker
spec:
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
# Only schedule on NVIDIA GB200/GB300 nodes
- key: node.kubernetes.io/instance-type
operator: In
values:
- p6e-gb200.36xlarge
- p6e-gb300.36xlarge
podAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
- labelSelector:
matchExpressions:
- key: nvbandwidth-test-replica
operator: In
values:
- mpi-worker
topologyKey: nvidia.com/gpu.clique
containers:
- image: ghcr.io/nvidia/k8s-samples:nvbandwidth-v0.7-8d103163
name: mpi-worker
securityContext:
runAsUser: 1000
env:
command:
- /usr/sbin/sshd
args:
- -De
- -f
- /home/mpiuser/.sshd_config
resources:
limits:
nvidia.com/gpu: 4 # Request 4 GPUs per worker
claims:
- name: compute-domain-channel # Link to IMEX channel
resourceClaims:
- name: compute-domain-channel
resourceClaimTemplateName: nvbandwidth-test-compute-domain-channel
```
\+. Crea ComputeDomain e avvia il processo con il seguente comando.
\+
```
kubectl apply -f nvbandwidth-test-job.yaml
```
\+. ComputeDomain creazione, puoi vedere che il carico di lavoro ComputeDomain ha due nodi:
\+
```
kubectl get computedomains.resource.nvidia.com -o yaml
```
\+
```
status:
nodes:
- cliqueID: .
ipAddress:
name:
- cliqueID: .
ipAddress:
name:
status: Ready
```
\+. Esaminate i risultati del lavoro con il seguente comando.
\+
```
kubectl logs --tail=-1 -l job-name=nvbandwidth-test-launcher
```
\+ Un test riuscito mostra le statistiche sulla larghezza di banda GB/s per il test memcpy multinodo. Di seguito è riportato un esempio di output di test riuscito.
\+
```
...
nvbandwidth Version: ...
Built from Git version: ...
MPI version: ...
CUDA Runtime Version: ...
CUDA Driver Version: ...
Driver Version: ...
Process 0 (nvbandwidth-test-worker-0): device 0: NVIDIA GB200 (...)
Process 1 (nvbandwidth-test-worker-0): device 1: NVIDIA GB200 (...)
Process 2 (nvbandwidth-test-worker-0): device 2: NVIDIA GB200 (...)
Process 3 (nvbandwidth-test-worker-0): device 3: NVIDIA GB200 (...)
Process 4 (nvbandwidth-test-worker-1): device 0: NVIDIA GB200 (...)
Process 5 (nvbandwidth-test-worker-1): device 1: NVIDIA GB200 (...)
Process 6 (nvbandwidth-test-worker-1): device 2: NVIDIA GB200 (...)
Process 7 (nvbandwidth-test-worker-1): device 3: NVIDIA GB200 (...)
Running multinode_device_to_device_memcpy_read_ce.
memcpy CE GPU(row) -> GPU(column) bandwidth (GB/s)
0 1 2 3 4 5 6 7
0 N/A 821.45 822.18 821.73 822.05 821.38 822.61 821.89
1 822.34 N/A 821.67 822.12 821.94 820.87 821.53 822.08
2 821.76 822.29 N/A 821.58 822.43 821.15 821.82 822.31
3 822.19 821.84 822.05 N/A 821.67 821.23 820.95 822.47
4 821.63 822.38 821.49 822.17 N/A 821.06 821.78 822.22
5 822.08 821.52 821.89 822.35 821.27 N/A 821.64 822.13
6 821.94 822.15 821.68 822.04 821.39 820.92 N/A 822.56
7 822.27 821.73 822.11 821.86 822.38 821.04 821.49 N/A
SUM multinode_device_to_device_memcpy_read_ce ...
NOTE: The reported results may not reflect the full capabilities of the platform.
Performance can vary with software drivers, hardware clocks, and system topology.
```
\+. Quando il test è completo, eliminalo con il seguente comando.
\+
```
kubectl delete -f nvbandwidth-test-job.yaml
```