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à.
# Formazione distribuita con Elastic Fabric Adapter
Un [Elastic Fabric Adapter](https://aws.amazon.com/hpc/efa/) (EFA) è un dispositivo di rete che è possibile collegare all'istanza DLAMI per accelerare le applicazioni HPC (High Performance Computing). EFA consente di ottenere le prestazioni applicative di un cluster HPC locale, con la scalabilità, la flessibilità e l'elasticità fornite dal cloud. AWS
I seguenti argomenti mostrano come iniziare a utilizzare EFA con DLAMI.
**Nota**
Scegliete il vostro DLAMI da questo elenco DLAMI di [GPU di base](appendix-ami-release-notes.md#appendix-ami-release-notes-base)
**Topics**
+ [
# Avvio di un'istanza con EFA AWS Deep Learning AMIs
](tutorial-efa-launching.md)
+ [
# Utilizzo di EFA su DLAMI
](tutorial-efa-using.md)
# Avvio di un'istanza con EFA AWS Deep Learning AMIs
[La versione più recente di Base DLAMI è pronta per l'uso con EFA e viene fornita con i driver necessari, i moduli kernel, libfabric, openmpi e il plug-in NCCL OFI per le istanze GPU.](https://github.com/aws/aws-ofi-nccl/tree/aws)
[È possibile trovare le versioni CUDA supportate di un DLAMI di base nelle note di rilascio.](appendix-ami-release-notes.md#appendix-ami-release-notes-base)
Nota:
+ Quando si esegue un'applicazione NCCL utilizzando `mpirun` EFA, è necessario specificare il percorso completo dell'installazione supportata da EFA come:
```
/opt/amazon/openmpi/bin/mpirun
```
+ Per consentire all'applicazione di utilizzare EFA, aggiungere `FI_PROVIDER="efa"` al comando `mpirun` come mostrato in [Utilizzo di EFA su DLAMI](tutorial-efa-using.md).
**Topics**
+ [
## Preparare un gruppo di sicurezza abilitato all'EFA
](#tutorial-efa-security-group)
+ [
## Avvio dell'istanza
](#tutorial-efa-launch)
+ [
## Verifica l'allegato EFA
](#tutorial-efa-verify-attachment)
## Preparare un gruppo di sicurezza abilitato all'EFA
L'EFA richiede un gruppo di sicurezza che consenta tutto il traffico in entrata e in uscita da e verso il gruppo di sicurezza stesso. [Per ulteriori informazioni, consulta la documentazione EFA.](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security)
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel riquadro di navigazione, scegliere **Security Groups (Gruppi di sicurezza)** e quindi **Create Security Group (Crea gruppo di sicurezza)**.
1. Nella finestra **Create Security Group (Crea gruppo di sicurezza)** effettuare le operazioni seguenti:
+ In **Nome gruppo di sicurezza**, immettere un nome descrittivo per il gruppo di sicurezza, ad esempio `EFA-enabled security group`.
+ (Facoltativo) In **Description (Descrizione)**, inserire una breve descrizione del gruppo di sicurezza.
+ In **VPC**, selezionare il VPC in cui avviare le istanze abilitate per EFA.
+ Scegli **Create** (Crea).
1. Selezionare il gruppo di sicurezza creato e, nella scheda **Description (Descrizione)**, copiare il valore **Group ID (ID gruppo)**.
1. Nelle schede **In entrata** e In **uscita**, effettuate le seguenti operazioni:
+ Seleziona **Edit** (Modifica).
+ In **Type (Tipo)**, selezionare **All traffic (Tutto il traffico)**.
+ In **Source (Origine)**, scegliere **Custom (Personalizzata)**.
+ Incollare nel campo l'ID del gruppo di sicurezza copiato in precedenza.
+ Scegli **Save** (Salva).
1. Abilitare il traffico in entrata facente riferimento a [Autorizzazione del traffico in entrata per le istanze Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html). Se salti questo passaggio, non sarai in grado di comunicare con l'istanza DLAMI.
## Avvio dell'istanza
EFA on the AWS Deep Learning AMIs è attualmente supportato con i seguenti tipi di istanze e sistemi operativi:
+ P3dn: Amazon Linux 2, Ubuntu 20.04
+ P4d, P4de: Amazon Linux 2, Amazon Linux 2023, Ubuntu 20.04, Ubuntu 22.04
+ P5, P5e, P5en: Amazon Linux 2, Amazon Linux 2023, Ubuntu 20.04, Ubuntu 22.04
La sezione seguente mostra come avviare un'istanza DLAMI abilitata per EFA. Per ulteriori informazioni sul lancio di un'istanza abilitata per EFA, consulta [Launch Enabled Instances into a Cluster Placement](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-instances) Group.
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Scegliere **Launch Instance (Avvia istanza)**.
1. Nella pagina **Scegli un AMI**, seleziona un DLAMI supportato che si trova nella pagina delle note di rilascio di [DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes)
1. Nella pagina **Scegli un tipo di istanza**, seleziona uno dei seguenti tipi di istanza supportati, quindi scegli **Avanti: Configura i dettagli dell'istanza**. Fai riferimento a questo link per l'elenco delle istanze supportate: Guida [introduttiva a EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html) e MPI
1. Nella pagina **Configure Instance Details (Configura i dettagli dell'istanza)**, procedere come segue:
+ In **Number of instances (Numero di istanze)**, immettere il numero di istanze abilitate per EFA che si desidera avviare.
+ In **Network (Rete)** e **Subnet (Sottorete)**, selezionare il VPC e la sottorete in cui avviare le istanze.
+ [Facoltativo] Per il **gruppo di collocamento**, selezionate **Aggiungi istanza al** gruppo di collocamento. Per ottenere prestazioni ottimali, avviare le istanze all'interno di un gruppo di collocazione.
+ [Facoltativo] Per **il nome del gruppo di collocamento**, selezionate **Aggiungi a un nuovo gruppo di collocamento**, inserite un nome descrittivo per il gruppo di collocamento, quindi per la **strategia del gruppo di collocamento**, selezionate **cluster**.
+ Assicurati di abilitare **«Elastic Fabric Adapter»** in questa pagina. Se questa opzione è disabilitata, modificare la subnet in una che supporta il tipo di istanza selezionato.
+ Nella sezione **Network Interfaces (Interfacce di rete)**, per il dispositivo **eth0** scegliere **New network interface (Nuova interfaccia di rete)**. Facoltativamente, puoi specificare un IPv4 indirizzo principale e uno o più IPv4 indirizzi secondari. Se stai avviando l'istanza in una sottorete a cui è associato un blocco IPv6 CIDR, puoi facoltativamente specificare un IPv6 indirizzo primario e uno o più indirizzi secondari. IPv6
+ Scegliere **Next: Add Storage (Successivo: aggiungi storage)**.
1. Nella pagina **Add archiviazione (Aggiungi archiviazione)**, specificare i volumi da collegare all'istanza, oltre a quelli specificati dall'AMI (ad esempio il volume dispositivo root), quindi selezionare **Next: Add Tags (Successivo: aggiungi tag)**.
1. Nella pagina **Add Tags (Aggiungi tag)** specificare i tag per l'istanza, ad esempio un nome intuitivo, quindi selezionare **Next: Configure Security Group (Successivo: configurazione del gruppo di sicurezza)**.
1. **Nella pagina **Configura gruppo di sicurezza**, per **Assegna un gruppo di sicurezza**, seleziona **Seleziona un gruppo di sicurezza esistente, quindi seleziona il gruppo** di sicurezza creato in precedenza.**
1. Scegliere **Review and Launch (Analizza e avvia)**.
1. Nella pagina **Review Instance Launch (Verifica avvio istanza)** controllare le impostazioni e selezionare **Launch (Avvia)** per scegliere una coppia di chiavi e avviare l'istanza.
## Verifica l'allegato EFA
### Dalla console
Dopo aver avviato l'istanza, controlla i dettagli dell'istanza nella AWS console. A tale scopo, seleziona l'istanza nella console EC2 ed esamina la scheda Descrizione nel riquadro inferiore della pagina. Trova il parametro 'Interfacce di rete: eth0' e fai clic su eth0 che apre un pop-up. Assicurati che «Elastic Fabric Adapter» sia abilitato.
Se EFA non è abilitato, puoi risolvere il problema in uno dei seguenti modi:
+ Terminando l'istanza EC2 e avviandone una nuova con le stesse fasi. Assicurati che l'EFA sia collegato.
+ Collega EFA a un'istanza esistente.
1. Nella console EC2, passa a Network Interfaces (Interfacce di rete).
1. Fai clic su Create a Network Interface (Crea un'interfaccia di rete).
1. Seleziona la stessa subnet in cui si trova l'istanza.
1. Assicurati di abilitare «Elastic Fabric Adapter» e fai clic su Crea.
1. Torna alla scheda EC2 Instances (Istanze EC2) e seleziona l'istanza.
1. Vai a Azioni: Stato dell'istanza e interrompi l'istanza prima di collegare EFA.
1. Da Actions (Operazioni), seleziona Networking: Attach Network Interface (Rete: Collega interfaccia di rete).
1. Seleziona l'interfaccia appena creata e clicca su attach (collega).
1. Riavviare l'istanza.
### Dall'istanza
Il seguente script di test è già presente sul DLAMI. Eseguilo per assicurarti che i moduli del kernel siano caricati correttamente.
```
$ fi_info -p efa
```
L'aspetto dell'output sarà simile al seguente.
```
provider: efa
fabric: EFA-fe80::e5:56ff:fe34:56a8
domain: efa_0-rdm
version: 2.0
type: FI_EP_RDM
protocol: FI_PROTO_EFA
provider: efa
fabric: EFA-fe80::e5:56ff:fe34:56a8
domain: efa_0-dgrm
version: 2.0
type: FI_EP_DGRAM
protocol: FI_PROTO_EFA
provider: efa;ofi_rxd
fabric: EFA-fe80::e5:56ff:fe34:56a8
domain: efa_0-dgrm
version: 1.0
type: FI_EP_RDM
protocol: FI_PROTO_RXD
```
### Verifica della configurazione del gruppo di sicurezza
Il seguente script di test è già presente sul DLAMI. Eseguilo per assicurarti che il gruppo di sicurezza creato sia configurato correttamente.
```
$ cd /opt/amazon/efa/test/
$ ./efa_test.sh
```
L'aspetto dell'output sarà simile al seguente.
```
Starting server...
Starting client...
bytes #sent #ack total time MB/sec usec/xfer Mxfers/sec
64 10 =10 1.2k 0.02s 0.06 1123.55 0.00
256 10 =10 5k 0.00s 17.66 14.50 0.07
1k 10 =10 20k 0.00s 67.81 15.10 0.07
4k 10 =10 80k 0.00s 237.45 17.25 0.06
64k 10 =10 1.2m 0.00s 921.10 71.15 0.01
1m 10 =10 20m 0.01s 2122.41 494.05 0.00
```
Se smette di rispondere o non viene completato, assicurati che il tuo gruppo di sicurezza abbia le regole corrette inbound/outbound .
# Utilizzo di EFA su DLAMI
La sezione seguente descrive come utilizzare EFA per eseguire applicazioni multinodo su. AWS Deep Learning AMIs
## Esecuzione di applicazioni multinodo con EFA
Per eseguire un'applicazione su un cluster di nodi è richiesta la seguente configurazione
**Topics**
+ [
### Abilitazione di SSH senza password
](#tutorial-efa-using-multi-node-ssh)
+ [
### Creazione di file hosts
](#tutorial-efa-using-multi-node-hosts)
+ [
### Test NCCL
](#tutorial-efa-using-2node)
### Abilitazione di SSH senza password
Seleziona un nodo nel cluster come il nodo principale. I nodi rimanenti sono indicati come nodi membro.
1. Nel nodo principale, genera la coppia di chiavi RSA.
```
ssh-keygen -t rsa -N "" -f ~/.ssh/id_rsa
```
1. Modifica le autorizzazioni della chiave privata sul nodo principale.
```
chmod 600 ~/.ssh/id_rsa
```
1. Copia la chiave `~/.ssh/id_rsa.pub` pubblica e aggiungila a uno `~/.ssh/authorized_keys` dei nodi membri del cluster.
1. Puoi ora accedere direttamente ai nodi membro dal nodo principale utilizzando l'IP privato.
```
ssh
```
1. Disabilita strictHostKey Checking e abilita l'inoltro degli agenti sul nodo leader aggiungendo quanto segue al file \$1/.ssh/config sul nodo leader:
```
Host *
ForwardAgent yes
Host *
StrictHostKeyChecking no
```
1. Nelle istanze Amazon Linux 2, esegui il seguente comando sul nodo leader per fornire le autorizzazioni corrette al file di configurazione:
```
chmod 600 ~/.ssh/config
```
### Creazione di file hosts
Nel nodo principale, creare un file hosts per identificare i nodi nel cluster. Il file hosts deve contenere una voce per ogni nodo del cluster. Crea un file \$1/hosts e aggiungi ogni nodo utilizzando l'IP privato come riportato di seguito:
```
localhost slots=8
slots=8
slots=8
```
### Test NCCL
**Nota**
Questi test sono stati eseguiti utilizzando la versione EFA 1.38.0 e il plugin OFI NCCL 1.13.2.
Di seguito sono elencati un sottoinsieme di test NCCL forniti da Nvidia per testare funzionalità e prestazioni su più nodi di elaborazione
**Istanze supportate: P3dn, P4, P5, P5e, P5en**
#### Test delle prestazioni
##### Test delle prestazioni NCCL multinodo su P4D.24XLarge
[Per verificare le prestazioni NCCL con EFA, esegui il test NCCL Performance standard disponibile sul Repo ufficiale di NCCL-Tests.](https://github.com/NVIDIA/nccl-tests.git) Il DLAMI viene fornito con questo test già creato per CUDA XX.X. Allo stesso modo è possibile eseguire il proprio script con EFA.
Quando costruisci il tuo script, fai riferimento alla seguente guida:
+ Utilizzate il percorso completo di mpirun come mostrato nell'esempio durante l'esecuzione di applicazioni NCCL con EFA.
+ Modifica i parametri np e N in base al numero di istanze e al tuo cluster. GPUs
+ Aggiungi il flag NCCL\$1DEBUG=INFO e assicurati che i log indichino l'utilizzo di EFA come «Il provider selezionato è EFA».
+ Imposta la posizione del registro di formazione da analizzare per la convalida
```
TRAINING_LOG="testEFA_$(date +"%N").log"
```
Utilizza il comando `watch nvidia-smi` su uno qualsiasi dei nodi membri per monitorare l'utilizzo di GPU. I `watch nvidia-smi` comandi seguenti si riferiscono a una versione generica di CUDA xx.x e dipendono dal sistema operativo dell'istanza. Puoi eseguire i comandi per qualsiasi versione CUDA disponibile nella tua istanza Amazon EC2 sostituendo la versione CUDA nello script.
+ Amazon Linux 2, Amazon Linux 2023:
```
$ /opt/amazon/openmpi/bin/mpirun -n 16 -N 8 \
-x NCCL_DEBUG=INFO --mca pml ^cm \
-x LD_LIBRARY_PATH=/usr/local/cuda-xx.x/efa/lib:/usr/local/cuda-xx.x/lib:/usr/local/cuda-xx.x/lib64:/usr/local/cuda-xx.x:/opt/amazon/efa/lib64:/opt/amazon/openmpi/lib64:$LD_LIBRARY_PATH \
--hostfile hosts --mca btl tcp,self --mca btl_tcp_if_exclude lo,docker0 --bind-to none \
/usr/local/cuda-xx.x/efa/test-cuda-xx.x/all_reduce_perf -b 8 -e 1G -f 2 -g 1 -c 1 -n 100 | tee ${TRAINING_LOG}
```
+ Ubuntu 20.04, Ubuntu 20.04:
```
$ /opt/amazon/openmpi/bin/mpirun -n 16 -N 8 \
-x NCCL_DEBUG=INFO --mca pml ^cm \
-x LD_LIBRARY_PATH=/usr/local/cuda-xx.x/efa/lib:/usr/local/cuda-xx.x/lib:/usr/local/cuda-xx.x/lib64:/usr/local/cuda-xx.x:/opt/amazon/efa/lib:/opt/amazon/openmpi/lib:$LD_LIBRARY_PATH \
--hostfile hosts --mca btl tcp,self --mca btl_tcp_if_exclude lo,docker0 --bind-to none \
/usr/local/cuda-xx.x/efa/test-cuda-xx.x/all_reduce_perf -b 8 -e 1G -f 2 -g 1 -c 1 -n 100 | tee ${TRAINING_LOG}
```
L'aspetto dell'output deve essere simile al seguente:
```
# nThread 1 nGpus 1 minBytes 8 maxBytes 1073741824 step: 2(factor) warmup iters: 5 iters: 100 agg iters: 1 validation: 1 graph: 0
#
# Using devices
# Rank 0 Group 0 Pid 33378 on ip-172-31-42-25 device 0 [0x10] NVIDIA A100-SXM4-40GB
# Rank 1 Group 0 Pid 33379 on ip-172-31-42-25 device 1 [0x10] NVIDIA A100-SXM4-40GB
# Rank 2 Group 0 Pid 33380 on ip-172-31-42-25 device 2 [0x20] NVIDIA A100-SXM4-40GB
# Rank 3 Group 0 Pid 33381 on ip-172-31-42-25 device 3 [0x20] NVIDIA A100-SXM4-40GB
# Rank 4 Group 0 Pid 33382 on ip-172-31-42-25 device 4 [0x90] NVIDIA A100-SXM4-40GB
# Rank 5 Group 0 Pid 33383 on ip-172-31-42-25 device 5 [0x90] NVIDIA A100-SXM4-40GB
# Rank 6 Group 0 Pid 33384 on ip-172-31-42-25 device 6 [0xa0] NVIDIA A100-SXM4-40GB
# Rank 7 Group 0 Pid 33385 on ip-172-31-42-25 device 7 [0xa0] NVIDIA A100-SXM4-40GB
# Rank 8 Group 0 Pid 30378 on ip-172-31-43-8 device 0 [0x10] NVIDIA A100-SXM4-40GB
# Rank 9 Group 0 Pid 30379 on ip-172-31-43-8 device 1 [0x10] NVIDIA A100-SXM4-40GB
# Rank 10 Group 0 Pid 30380 on ip-172-31-43-8 device 2 [0x20] NVIDIA A100-SXM4-40GB
# Rank 11 Group 0 Pid 30381 on ip-172-31-43-8 device 3 [0x20] NVIDIA A100-SXM4-40GB
# Rank 12 Group 0 Pid 30382 on ip-172-31-43-8 device 4 [0x90] NVIDIA A100-SXM4-40GB
# Rank 13 Group 0 Pid 30383 on ip-172-31-43-8 device 5 [0x90] NVIDIA A100-SXM4-40GB
# Rank 14 Group 0 Pid 30384 on ip-172-31-43-8 device 6 [0xa0] NVIDIA A100-SXM4-40GB
# Rank 15 Group 0 Pid 30385 on ip-172-31-43-8 device 7 [0xa0] NVIDIA A100-SXM4-40GB
ip-172-31-42-25:33385:33385 [7] NCCL INFO cudaDriverVersion 12060
ip-172-31-43-8:30383:30383 [5] NCCL INFO Bootstrap : Using ens32:172.31.43.8
ip-172-31-43-8:30383:30383 [5] NCCL INFO NCCL version 2.23.4+cuda12.5
...
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Initializing aws-ofi-nccl 1.13.2-aws
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Using Libfabric version 1.22
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Using CUDA driver version 12060 with runtime 12050
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Configuring AWS-specific options
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Setting provider_filter to efa
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Setting FI_EFA_FORK_SAFE environment variable to 1
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Setting NCCL_NVLSTREE_MAX_CHUNKSIZE to 512KiB
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Setting NCCL_NVLS_CHUNKSIZE to 512KiB
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Running on p4d.24xlarge platform, Setting NCCL_TOPO_FILE environment variable to /opt/amazon/ofi-nccl/share/aws-ofi-nccl/xml/p4d-24xl-topo.xml
...
-----------------------------some output truncated-----------------------------------
# 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)
8 2 float sum -1 180.3 0.00 0.00 0 179.3 0.00 0.00 0
16 4 float sum -1 178.1 0.00 0.00 0 177.6 0.00 0.00 0
32 8 float sum -1 178.5 0.00 0.00 0 177.9 0.00 0.00 0
64 16 float sum -1 178.8 0.00 0.00 0 178.7 0.00 0.00 0
128 32 float sum -1 178.2 0.00 0.00 0 177.8 0.00 0.00 0
256 64 float sum -1 178.6 0.00 0.00 0 178.8 0.00 0.00 0
512 128 float sum -1 177.2 0.00 0.01 0 177.1 0.00 0.01 0
1024 256 float sum -1 179.2 0.01 0.01 0 179.3 0.01 0.01 0
2048 512 float sum -1 181.3 0.01 0.02 0 181.2 0.01 0.02 0
4096 1024 float sum -1 184.2 0.02 0.04 0 183.9 0.02 0.04 0
8192 2048 float sum -1 191.2 0.04 0.08 0 190.6 0.04 0.08 0
16384 4096 float sum -1 202.5 0.08 0.15 0 202.3 0.08 0.15 0
32768 8192 float sum -1 233.0 0.14 0.26 0 232.1 0.14 0.26 0
65536 16384 float sum -1 238.6 0.27 0.51 0 235.1 0.28 0.52 0
131072 32768 float sum -1 237.2 0.55 1.04 0 236.8 0.55 1.04 0
262144 65536 float sum -1 248.3 1.06 1.98 0 247.0 1.06 1.99 0
524288 131072 float sum -1 309.2 1.70 3.18 0 307.7 1.70 3.20 0
1048576 262144 float sum -1 408.7 2.57 4.81 0 404.3 2.59 4.86 0
2097152 524288 float sum -1 613.5 3.42 6.41 0 607.9 3.45 6.47 0
4194304 1048576 float sum -1 924.5 4.54 8.51 0 914.8 4.58 8.60 0
8388608 2097152 float sum -1 1059.5 7.92 14.85 0 1054.3 7.96 14.92 0
16777216 4194304 float sum -1 1269.9 13.21 24.77 0 1272.0 13.19 24.73 0
33554432 8388608 float sum -1 1642.7 20.43 38.30 0 1636.7 20.50 38.44 0
67108864 16777216 float sum -1 2446.7 27.43 51.43 0 2445.8 27.44 51.45 0
134217728 33554432 float sum -1 4143.6 32.39 60.73 0 4142.4 32.40 60.75 0
268435456 67108864 float sum -1 7351.9 36.51 68.46 0 7346.7 36.54 68.51 0
536870912 134217728 float sum -1 13717 39.14 73.39 0 13703 39.18 73.46 0
1073741824 268435456 float sum -1 26416 40.65 76.21 0 26420 40.64 76.20 0
...
# Out of bounds values : 0 OK
# Avg bus bandwidth : 15.5514
```
#### Test di convalida
Per verificare che i test EFA abbiano restituito un risultato valido, utilizza i seguenti test per confermare:
+ Ottieni il tipo di istanza utilizzando EC2 Instance Metadata:
```
TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
INSTANCE_TYPE=$(curl -H "X-aws-ec2-metadata-token: $TOKEN" -v http://169.254.169.254/latest/meta-data/instance-type)
```
+ Eseguire [Test delle prestazioni](#tutorial-efa-using-multinode)
+ Imposta i seguenti parametri
```
CUDA_VERSION
CUDA_RUNTIME_VERSION
NCCL_VERSION
```
+ Convalida i risultati come mostrato:
```
RETURN_VAL=`echo $?`
if [ ${RETURN_VAL} -eq 0 ]; then
# [0] NCCL INFO NET/OFI Initializing aws-ofi-nccl 1.13.2-aws
# [0] NCCL INFO NET/OFI Using CUDA driver version 12060 with runtime 12010
# cudaDriverVersion 12060 --> This is max supported cuda version by nvidia driver
# NCCL version 2.23.4+cuda12.5 --> This is NCCL version compiled with cuda version
# Validation of logs
grep "NET/OFI Configuring AWS-specific options" ${TRAINING_LOG} || { echo "AWS-specific options text not found"; exit 1; }
grep "busbw" ${TRAINING_LOG} || { echo "busbw text not found"; exit 1; }
grep "Avg bus bandwidth " ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
grep "NCCL version $NCCL_VERSION" ${TRAINING_LOG} || { echo "Text not found: NCCL version $NCCL_VERSION"; exit 1; }
if [[ ${INSTANCE_TYPE} == "p4d.24xlarge" ]]; then
grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Text not found: NET/Libfabric/0/GDRDMA"; exit 1; }
grep "NET/OFI Selected Provider is efa (found 4 nics)" ${TRAINING_LOG} || { echo "Selected Provider is efa text not found"; exit 1; }
elif [[ ${INSTANCE_TYPE} == "p4de.24xlarge" ]]; then
grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
grep "NET/OFI Selected Provider is efa (found 4 nics)" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
elif [[ ${INSTANCE_TYPE} == "p5.48xlarge" ]]; then
grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
grep "NET/OFI Selected Provider is efa (found 32 nics)" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
elif [[ ${INSTANCE_TYPE} == "p5e.48xlarge" ]]; then
grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
grep "NET/OFI Selected Provider is efa (found 32 nics)" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
elif [[ ${INSTANCE_TYPE} == "p5en.48xlarge" ]]; then
grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
grep "NET/OFI Selected Provider is efa (found 16 nics)" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
elif [[ ${INSTANCE_TYPE} == "p3dn.24xlarge" ]]; then
grep "NET/OFI Selected Provider is efa (found 4 nics)" ${TRAINING_LOG} || { echo "Selected Provider is efa text not found"; exit 1; }
fi
echo "***************************** check_efa_nccl_all_reduce passed for cuda version ${CUDA_VERSION} *****************************"
else
echo "***************************** check_efa_nccl_all_reduce failed for cuda version ${CUDA_VERSION} *****************************"
fi
```
+ Per accedere ai dati del benchmark, possiamo analizzare l'ultima riga della tabella in uscita dal test Multi Node all\$1reduce:
```
benchmark=$(sudo cat ${TRAINING_LOG} | grep '1073741824' | tail -n1 | awk -F " " '{{print $12}}' | sed 's/ //' | sed 's/ 5e-07//')
if [[ -z "${benchmark}" ]]; then
echo "benchmark variable is empty"
exit 1
fi
echo "Benchmark throughput: ${benchmark}"
```