View a markdown version of this page

Utilizzo P6e-GB200 UltraServers con Amazon EKS - Amazon EKS
ConsiderazioniComponentiProceduraInstalla l'operatore GPU NVIDIAInstalla il driver NVIDIA DRAInstalla EFA per le comunicazioni incrociate UltraServerMulti-Node Convalida IMEX tramite NVLink

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 su che si trova 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 P6e-GB200 UltraServers EC2.

Considerazioni

  • Amazon EKS supporta le versioni P6e-GB200 UltraServers di Kubernetes 1.33 e successive. Questa versione di Kubernetes fornisce il supporto per Dynamic Resource Allocation (DRA), abilitato di default in EKS e nelle AMI accelerate AL2023. EKS-optimized DRA è un requisito per l'utilizzo con EKS. P6e-GB200 UltraServers DRA è supportato con il provisioning della capacità statica di Karpenter, i gruppi di nodi gestiti da EKS e i nodi autogestiti, ma non è supportato con EKS Auto Mode o Karpenter dynamic capacity provisioning.

  • P6e-GB200 UltraServers sono resi disponibili tramite EC2 Capacity Blocks for ML. https://aws.amazon.com/ec2/capacityblocks/ Gestisci l'elaborazione accelerata per i AI/ML carichi di lavoro su Amazon EKSPer informazioni su come avviare i nodi EKS con Capacity Blocks, consulta.

  • Quando si utilizzano gruppi di nodi gestiti da 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 su 0 prima dell'aggiornamento.

  • Si consiglia di utilizzare la variante ARM NVIDIA AL2023 delle AMI accelerate. EKS-optimized Questa AMI include i componenti e la configurazione del nodo richiesti 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 le AMI EKS-optimized accelerate per le istanze GPU.

  • Si consiglia di utilizzare la versione EKS-optimized AMI v20251103 o successiva, che include la versione del driver NVIDIA 580. Questa versione del driver NVIDIA consente a Coherent Driver-Based Memory (CDMM) di risolvere la potenziale segnalazione di un eccesso di memoria. Quando CDMM è abilitato, le seguenti funzionalità non sono supportate: NVIDIA GPU Multi-Instance (MIG) e vGPU. Per ulteriori informazioni su CDMM, vedere NVIDIA Coherent Memory Management (CDMM). Driver-based

  • 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. Le AMI NVIDIA EKS-optimized AL2023 non includono il plug-in del dispositivo NVIDIA Kubernetes o il driver NVIDIA DRA e devono essere installati separatamente.

  • Ogni p6e-gb200.36xlarge istanza può essere configurata con un massimo di 17 schede di rete e può sfruttare l'EFA per la comunicazione tra. UltraServers Il traffico di rete del carico di lavoro può incrociarsi UltraServers, ma per ottenere le massime prestazioni si consiglia di pianificare i carichi di lavoro nello stesso modo UltraServer sfruttando IMEX per le comunicazioni intra-GPU. UltraServer Per ulteriori informazioni, consulta Configurazione EFA per le istanze. P6e-GB200

  • Ogni p6e-gb200.36xlarge istanza dispone di 3 storage nell'archivio di istanze da 7,5 TB. Per impostazione predefinita, l' EKS-optimized AMI non formatta e non monta gli archivi di istanze. L'archiviazione temporanea del nodo può essere condivisa tra i pod che richiedono l'archiviazione temporanea e le immagini dei contenitori che vengono scaricate sul nodo. Se si utilizza l' EKS-optimized AMI AL2023, questa può essere configurata come parte del bootstrap del nodo nei dati utente impostando la politica di archiviazione locale dell'istanza su RAID0. NodeConfig L'impostazione su RAID0 comporta lo striping dell'istanza, memorizza 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, è possibile utilizzare l'operatore GPU NVIDIA 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.

Pila Componente

EKS-optimized AMI accelerata

Kernel 6.12 o 6.18

Driver GPU NVIDIA

Driver in modalità utente NVIDIA CUDA

Toolkit per contenitori NVIDIA

NVIDIA fabric manager

Driver NVIDIA IMEX

NVIDIA NVLink Subnet Manager

driver EFA

Componenti in esecuzione sul nodo

VPC CNI

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: assegna gli IP VPC come interfaccia di rete principale per i pod in esecuzione su EKS

  • Driver EFA DRA o plug-in per dispositivi EFA: assegna i dispositivi EFA come reti secondarie per i pod in esecuzione su EKS. Responsabile del traffico di rete trasversale. P6e-GB200 UltraServers Per i carichi di lavoro multinodo, il GPU-to-GPU traffico all'interno di un nodo UltraServer può fluire su NVLink multinodo. Il driver EFA DRA è consigliato per Kubernetes 1.34 e versioni successive e fornisce l'allocazione e la condivisione dei dispositivi basate sulla topologia. Il plug-in del dispositivo EFA è supportato per tutte le versioni di Kubernetes. Per ulteriori informazioni, consulta Gestisci i dispositivi EFA su Amazon EKS.

  • Plugin per dispositivi NVIDIA Kubernetes: assegna 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à diventata sperimentale. Per informazioni aggiornate, consulta le versioni dei driver NVIDIA DRA. 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 sui 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.

    • Il driver NVIDIA DRA utilizza un'etichetta Clique ID (nvidia.com/gpu.clique) applicata da NVIDIA GFD che trasmette la conoscenza della topologia di rete e del dominio NVLink.

    • È consigliabile creare un processo per carico di lavoro. ComputeDomain

  • NVIDIA Node Feature Discovery (NFD): dipendenza necessaria affinché GFD applichi le etichette dei nodi in base agli attributi a livello di nodo scoperti.

  • 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 su cui è in esecuzione l'AMI accelerata ARM NVIDIA AL2023. P6e-GB200 UltraServers EKS-optimized Consulta i collegamenti per i passaggi preliminari Gestisci l'elaborazione accelerata per i AI/ML carichi di lavoro su Amazon EKS per i nodi autogestiti EKS e i gruppi di nodi gestiti.

La procedura seguente utilizza i componenti seguenti.

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 dei ComputeDomain domini CRD e IMEX.

Driver EFA DRA (DRANET)

Più recente

Per UltraServer comunicazioni incrociate 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 del contenitore sono installati come parte dell'AMI EKS-optimized accelerata, devono essere impostati nella configurazione dei valori Helm. false

  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

  2. 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 con operatore GPU NVIDIAv25.3.4, il driver NVIDIA DRA deve essere installato separatamente. Si consiglia di tenere traccia delle note di rilascio dell'operatore 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 il comando nodeAffinity tolerations che configura il 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

  2. 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

  3. 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 i carichi di lavoro distribuiti su GPU. P6e-GB200 UltraServers

    Verificare 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 le comunicazioni incrociate UltraServer

Per utilizzare la comunicazione EFA tra 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 e l'NCI primario (indice 0) deve essere del tipo interface e supportare fino a 100 Gbps di larghezza di banda ENA. Configura le interfacce EFA ed ENA secondo i tuoi requisiti durante il provisioning dei nodi. Consulta la AWS documentazione sulla configurazione EFA per P6e-GB200 le istanze 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

  2. Aggiungere il repository grafico EKS Helm e installare 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

  3. Verificate che il 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           <none>          60s

  4. Verificate che gli ResourceSlice oggetti DeviceClass and 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

Opzione 2: installare 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

  2. Aggiungi il repository grafico 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

  3. 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           <none>          60s

  4. Verifica che i tuoi nodi dispongano di dispositivi EFA allocabili. Ad esempio, se hai configurato le tue istanze con 1 interfaccia solo efa in ogni gruppo NCI, è previsto 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

Per un test NCCL NVLINK multi-nodo e altri micro-benchmark, 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 del dominio NVL72, installate innanzitutto l'operatore MPI:

    kubectl create -f https://github.com/kubeflow/mpi-operator/releases/download/v0.7.0/mpi-operator.yaml

  2. Create un file denominato nvbandwidth-test-job.yaml che definisca il manifesto del test. Nota l'affinità del nvidia.com/gpu.clique pod per programmare i lavoratori nello stesso dominio NVLink con raggiungibilità NVLink. Multi-Node L'esempio seguente esegue un test memcpy CE Read multi-nodo da dispositivo a dispositivo utilizzando cu e stampa i risultati nei log. MemcpyAsync

    A partire da NVIDIA, le versioni dei driver DRA sono elastiche e possono essere v25.8.0 ComputeDomains impostate nella definizione. .spec.numNodes 0 ComputeDomain Consulta le ultime note sulla versione dei driver NVIDIA DRA per gli aggiornamenti.

    Può essercene solo uno ComputeDomain (canale IMEX) per nodo. Non allocationMode modificare All il valore della ComputeDomain risorsa, in quanto ciò può impedire l'allocazione ComputeDomain e la pianificazione corretta dei Pods che ComputeDomain vi accedono. Per ulteriori informazioni, consulta il problema #353 del driver NVIDIA DRA. 

    ---
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

  3. Crea ComputeDomain e avvia il lavoro con il seguente comando.

    kubectl apply -f nvbandwidth-test-job.yaml

  4. Dopo ComputeDomain la creazione, puoi vedere che il carico di lavoro ComputeDomain ha due nodi:

    kubectl get computedomains.resource.nvidia.com -o yaml
    status:
  nodes:
  - cliqueID: <ClusterUUID>.<Clique ID>
    ipAddress: <node-ip>
    name: <node-hostname>
  - cliqueID: <ClusterUUID>.<Clique ID>
    ipAddress: <node-ip>
    name: <node-hostname>
  status: Ready

  5. Rivedi i risultati del lavoro con il comando seguente.

    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 risultato del 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.

  6. Quando il test è completo, cancellalo con il seguente comando.

    kubectl delete -f nvbandwidth-test-job.yaml