Differenze tra le versioni di "AIE:Guida Utenti"

Versione delle 18:50, 11 gen 2023

DRAFT: Questa pagina è una bozza.

Guida per gli utenti del Cluster di calcolo e NVIDIA DGX in AI@Edge.

Architettura Cluster

AI@Edge mette a disposizione:

Cluster di Calcolo

E' costituito da:

Un nodo frontend;
Quattro nodi di calcolo identici;
Un nodo di storage.

Il nodo frontend ha le seguenti caratteristiche:

CPU: 1 x AMD EPYC 7352 (24 cores, 48 threads)

System memory: 128GB

Storage: 4HDD in RAID 5

/ 200GB

/home 500GB (contiene le home degli utenti ed e' esportata via NFS sul frontend e sui nodi di calcolo)

/opt/share 9.8TB (contiene software condiviso ed e' esportata via NFS sul frontend e sui nodi di calcolo)

Ciascun nodo di calcolo ha le seguenti caratteristiche:

CPU: 2 x AMD EPYC 7413 (48 cores, no HT)

System memory: 512GB

GPU: 1 x NVIDIA A100 GPU

Storage: 440GB

Il nodo di storage dispone di

2 SSD in RAID1 per il sistema operativo;

4 SSD in RAID5 5.2TB dedicati al folder /datafast (esportata via NFS sul frontend e sui nodi di calcolo)

8 HDD in RAID5 63.7TB dedicati al folder /data (esportata via NFS sul frontend e sui nodi di calcolo)

TODO: 4 nodi con XX caratteristiche, frontend che con SLURM comanda sotto nodi, lista mountpoints/paths di interesse (dati e software)

NVIDIA DGX A100

TODO caratteristiche DGX, lista mountpoints e path di interesse

Richiesta Creazione Utente sul Cluster

TODO Chi può accedere al momento.

TODO elenco amministratori per laboratiorio. Contattare tizio, caio e fornire le seguenti info...

Accesso e Utilizzo Cluster di calcolo

Una volta ottenuto l'utente

TODO Si accede al frontend

ssh <username>@edge-mst1.isti.cnr.it

E' obbligatorio l'utilizzo di slurm per lanciare jobs sul cluster. La documentazione ufficiale e' disponibile ai seguenti link:
https://slurm.schedmd.com/documentation.html
https://slurm.schedmd.com/tutorials.html

TODO Si richiede risorse con SLURM

srun/sbatch ...

Per un tutorial e alcuni esempi di utilizzo si può vedere la wiki: https://gitlab.com/w895/centro_calcolo_isti/-/wikis/home

Accesso e Utilizzo NVIDIA DGX A100

Si accede alla DGX via ssh con certificato preinstallato (nessuna password viene richiesta):

ssh <username>@edge-nd1.isti.cnr.it

È fortemente consigliato l'utilizzo di Docker (quiun tutorial) per creare l'ambiente con il software necessario e lanciare processi.

Si richiede:

di taggare le proprie immagini docker con nomi nel formato <username>/<nome_immagine> (es: fabiocarrara/my-project:latest). Le immagini che non seguono questo standard possono essere cancellate periodicamente per recuperare spazio.
di NON lanciare e tenere attivi job e/o servizi interattivi (es. jupyter notebooks, server http/flask, etc.). I processi che non seguono questo standard possono essere killati in qualsiasi momento.
di aggiungere ad ogni invocazione di docker run le opzioni --user e --cpus come segue:
```
docker run \
    ...
    --user $(id -u):$(id -g) \
    --cpus <X> \  # sostituire <X> con un numero di CPU consono al numero di GPU utilizzate
    ...
```
L'opzione --user è necessaria per evitare che i processi girino come utente root. I processi che non seguono questo standard e girano come root possono essere killati in qualsiasi momento. L'opzione --cpus è fortemente consigliata per evitare di occupare erroneamente l'interezza delle CPU. Una euristica per specificare <X> è scegliere un valore compreso tra 8*nGPUs e 24*nGPUs dove nGPUs indica il numero di GPU richieste.

Esempio di workflow

Creo una workdir per un nuovo progetto sui dischi non-SSD (dentro ~/raid/):
```
mkdir ~/raid/my-project
cd ~/raid/my-project
```
Creo un file Dockerfile scegliendo un'immagine di partenza (FROM) e installando i miei requisiti software (RUN).
```
cat << EOF > Dockerfile
FROM nvcr.io/nvidia/pytorch:22.09-py3
RUN pip install transformers
EOF
```

Costruisco la mia immagine:

# sostituire <username> con il proprio nome utente
docker build -t <username>/my-project:latest -f - < Dockerfile

Creo uno script bash drun.sh per lanciare comandi dentro dei container nati dalla mia immagine. Questo è il contenuto di drun.sh:
```
#!/bin/bash
TODO
```

Preparo del codice da lanciare. Ad esempio, due script python:

# due script di esempio da lanciare
cat << EOF > count_gpus.py
import torch
num_of_gpus = torch.cuda.device_count()
print(num_of_gpus)
EOF

cat << EOF > test.py
import transformers
print(transformers.__version__)
EOF

Lancio dei job nei containers. TODO

@@ Riga 82: / Riga 82: @@
 Per un tutorial e alcuni esempi di utilizzo si può vedere la wiki: https://gitlab.com/w895/centro_calcolo_isti/-/wikis/home
-== Accesso e Utilizzo  NVIDIA DGX A100==
+== Accesso e Utilizzo NVIDIA DGX A100==
-'''TODO''' Si accede alla DGX via ssh con certificato preinstallato<syntaxhighlight lang="bash">
+Si accede alla DGX via ssh con certificato preinstallato (nessuna password viene richiesta):<syntaxhighlight lang="bash">
-ssh ...
+ssh <username>@edge-nd1.isti.cnr.it
-</syntaxhighlight>'''TODO''' Usare docker per creare immagini con il software necessario e per lanciare:<syntaxhighlight lang="bash">
+</syntaxhighlight>'''È fortemente consigliato''' l'utilizzo di [https://www.docker.com/ Docker]  ([https://training.play-with-docker.com/ops-stage1/ qui]un tutorial) per creare l'ambiente con il software necessario e lanciare processi.
-docker build ...
-docker run --gpus ...
+'''Si richiede:'''
+# di taggare le proprie immagini docker con nomi nel formato <code><username>/<nome_immagine></code> (es: <code>fabiocarrara/my-project:latest</code>). '''<u>Le immagini che non seguono questo standard possono essere cancellate periodicamente per recuperare spazio.</u>'''
+# di '''<u>NON</u>''' lanciare e tenere attivi job e/o servizi interattivi (es. jupyter notebooks, server http/flask, etc.). '''<u>I processi che non seguono questo standard possono essere killati in qualsiasi momento.</u>'''
+# di aggiungere ad ogni invocazione di <code>docker run</code> le opzioni <code>--user</code> e <code>--cpus</code> come segue:<syntaxhighlight lang="bash">
+docker run \
+    ...
+    --user $(id -u):$(id -g) \
+    --cpus <X> \  # sostituire <X> con un numero di CPU consono al numero di GPU utilizzate
+    ...
+</syntaxhighlight>L'opzione <code>--user</code> è necessaria per evitare che i processi girino come utente <code>root</code>. '''<u>I processi che non seguono questo standard e girano come <code>root</code> possono essere killati in qualsiasi momento.</u>'''  L'opzione <code>--cpus</code> è fortemente consigliata per evitare di occupare erroneamente l'interezza delle CPU. Una euristica per specificare <code><X></code> è scegliere un valore compreso tra <code>8*nGPUs</code> e <code>24*nGPUs</code> dove <code>nGPUs</code> indica il numero di GPU richieste.
+=== Esempio di workflow ===
+# Creo una workdir per un nuovo progetto sui dischi non-SSD (dentro <code>~/raid/</code>):<syntaxhighlight lang="bash">
+mkdir ~/raid/my-project
+cd ~/raid/my-project
+</syntaxhighlight>
+# Creo un file <code>Dockerfile</code> scegliendo un'immagine di partenza (<code>FROM</code>) e installando i miei requisiti software (<code>RUN</code>).<syntaxhighlight lang="bash">
+cat << EOF > Dockerfile
+FROM nvcr.io/nvidia/pytorch:22.09-py3
+RUN pip install transformers
+EOF
+</syntaxhighlight>
+# Costruisco la mia immagine:<syntaxhighlight lang="bash">
+# sostituire <username> con il proprio nome utente
+docker build -t <username>/my-project:latest -f - < Dockerfile
+</syntaxhighlight>
+# Creo uno script bash <code>drun.sh</code> per lanciare comandi dentro dei container nati dalla mia immagine. Questo è il contenuto di <code>drun.sh</code>:<syntaxhighlight lang="bash">
+#!/bin/bash
+TODO
+</syntaxhighlight>
+# Preparo del codice da lanciare. Ad esempio, due script python:<syntaxhighlight lang="bash">
+# due script di esempio da lanciare
+cat << EOF > count_gpus.py
+import torch
+num_of_gpus = torch.cuda.device_count()
+print(num_of_gpus)
+EOF
+cat << EOF > test.py
+import transformers
+print(transformers.__version__)
+EOF
 </syntaxhighlight>
+# Lancio dei job nei containers. '''TODO'''