Attualmente bisogna rivolgersi ai referenti di ente o istituto ai quali fornire alcune informazioni di identificazione che saranno rigirate agli amministratori di sistema. Gli amministratori inviano al richiedente poi le credenziali (nome utente e password provvisoria).

ATTENZIONE: la password è PROVVISORIA, va cambiata al primo accesso.

Per cambiarla usare da linea di comando il comando yppasswd, adatto a creare (o cambiare) una password valida non sul solo sistema di ingresso, ma su tutte le risorse del sistema HPC (Network password in un Network Information Service - NIS)

La procedura di login cambierà leggermente tra pochi mesi, v. avanti Modalità di accesso

Per accedere al sistema (in particolare al suo front-end o UI - User Interface) bisogna collegarsi tramite protocollo SSH all'host ibiscohpc-ui.scope.unina.it. L'accesso per ora è solo in modalità emulazione di terminale non grafico. L'account dell'UI comunque è valido per tutte le risorse del cluster.

Esempio di accesso da sistemi unix-like:

$ ssh ibiscohpc-ui.scope.unina.it -l <USERNAME>

Per accedere da sistemi windows si può usare il software putty, reperibile gratuitamente al sito https://www.putty.org/, oppure, da Windows 10 in poi, usando da finestra di comandi (CMD.exe o Powershell.exe) il software Openssh già installato in Windows (eventualmente non attivo, va semplicemente attivato nelle optional features)

Tra alcuni mesi l'accesso al cluster avverrà esclusivamente tramite il metodo “utente - SSH Key” (altri metodi di accesso sicuro sono allo studio).
Gli utenti attuali sono invitati a generare la coppia di chiavi e caricare la chiave pubblica sul server nella loro home.
I nuovi utenti, quando chiederanno un account, seguiranno una procedura leggermente differente: essi genereranno la coppia di chiavi, ma non caricheranno la chiave pubblica sul server (non avranno ancora accesso): essi la manderanno all'admin Ibisco. L'admin la copierà, con i corretti permessi, nella home del nuovo utente. Dopodiché l'utente avrà l'abitlià di entrare nel sistema senza inserire una password del server (ma avrà ancora da inserire una passphrase, v. avanti).
Una volta entrato, l'utente creerà una password per il server con yppasswd per l'accesso a tutti i nodi del cluster.

Ovviamente, è importante tenere in un posto segreto e sicuro la chiave privata e la passphrase, altrimenti, come in tutti i problemi di sicurezza, tutti i vantaggi portati da algoritmi di accesso più sicuri sarnno vanificati.

Qui mostriamo un possibile modo di generare la coppia di chiavi in linux e in windows. In ogni caso c'è molta documentazione in internet su come fare.

su un sistema linux

dalla vostra home directory eseguite
$ ssh-keygen -t rsa
Premete enter alla prima domanda (filename)
In risposta alla richiesta “Enter passphrase”, inserite una psspphrase della chiave per proteggere l'accesso alla chiave privata. L'uso della passphrase rafforza la sicurezza e quindi si raccomanda di usarla. La coppia di chiavi viene generata dal sistema.

• Se ancora avete accesso con password al sistema (vecchi utenti), potete eseguire il seguente comando che copia la vostra chiave pubblica sul server e la aggiunge al file ./ssh/authorized_keys con i corretti permessi:

$ ssh-copy-id -i ~/.ssh/id_rsa.pub <username>@ibiscohpc-wiki.scope.unina.it

• Se siete nuovi utenti, semplicemente mandate per e-mail il file ~/.ssh/id_rsa.pub agli admin Ibisco: essi provederanno a copiarla nella vostra directory .ssh nel cluster con i corretti permessi.

su un sistema Windows

Noi suggeriamo PuTTY, un pachetto software per Windows che semplifica l'uso di Windows come client SSH a la gestione delle connessioni a host remoti
Per creare la coppia di chiavi (https://the.earth.li/~sgtatham/putty/0.77/htmldoc/) potete seguire la seguente procedura.

1. Eseguite PUTTYGEN.EXE
2. Lasciate le scelte standard (Key → SSH-2 RSA Key,Use probable primes, show fingerprint as SHA256; Parameters → RSA, 2048 bit)
3. Premete il bottone “Generate” e seguite le indicazioni
4. quando viene chiesta un passphrase, inseritene una buona e salvatela in un luogo sicuro
5. salvate in qualche directory sicura o in un dispositivo usb esterno la chiave privata (ricordatevi il percorso, necessario ad eseguire una sessione con PuTTY)
6. copiate tutto il contentuto del riquadro sotto “Public key for pasting …” (copia-incolla) in un file id_rsa.pub. Esso avrà il formato giusto per essere accettato da OpenSSH (il software SSH disponibile su linux e perciò anche su IBiSco)
7. mandate per e-mail la chiave pubblica agli admin: come scritto prima essi provederanno a copiarla nella vostra directory .ssh nel cluster con i corretti permessi.

Gli utenti della risorsa hanno attualmente a loro disposizione la possibilità di usare i seguenti file systems

/lustre/home/ file system condiviso fra nodi e UI realizzato mediante tecnologia Lustre dove risiedono le home degli utenti

/lustre/scratch file system condiviso fra nodi realizzato mediante tecnologia Lustre da usare come area scratch

/home/scratch file system locale a ciascun nodo da usare come area scratch

ATTENZIONE: /lustre/scratch e /home/scratch sono accessibili SOLO dai nodi (vale a dire, quando si accede ad uno di essi), non dalla UI

Documentazione approfondita su Lustre è reperibile in rete, al link: https://www.lustre.org/.

/ibiscostorage nuova area scratch condivisa tra UI e nodi di calcolo (disponibile dal 07/10/2022), non basata su Lustre

Per migliorare l'uso delle risorse sono state cambiate le regole di gestione dei job.

* Sono state implementate nuove politiche di utilizzo basate su meccanismi di fairshare
* Sono state definite nuove code per la sottomissione dei job

1. Coda sequential:
   • accetta solo job sequenziali con numero di task non superiore ad 1,
   • che non usano le GP-GPU,
   • per un numero totale di job su di essa in esecuzione non superiore a 128
   • e limite massimo del tempo di esecuzione pari a 1 settimana
2. Coda parallel:
   • accetta solo job paralleli con numero di task superiore ad 1 e minore di 1580,
   • che facciano uso di non più 64 GP-GPU
   • e limite massimo del tempo di esecuzione pari a 1 settimana
3. Coda gpus:
   • accetta solo job che facciano uso di non più di 64 GP-GPU,
   • con numero di task minore di 1580
   • e limite massimo del tempo di esecuzione pari a 1 settimana
4. Coda hparallel:
   • accetta solo job paralleli con numero di task superiore a 1580 e minore di 3160,
   • che facciano uso di almeno 64 GP-GPU
   • e limite massimo del tempo di esecuzione pari a 1 giorno

Dal 9 ottobre sarà disabilitata la coda corrente e saranno attive solo quelle definite qui, da selezionare in modo esplicito. Ad esempio, per sottomottere un job nella coda parallel eseguire

$ srun -p parallel <ALTRE OPZIONI> <NOME COMANDO>

Se il job non è conforme alle regole della coda usata, sarà terminato.

Per usare le risorse del cluster è installato nel sistema il gestore di risorse SLURM. Documentazione approfondita su esso è disponibile al link https://slurm.schedmd.com/.

SLURM è un sistema software open source per la gestione di cluster; è altamente scalabile, offre meccanismi di fault-tolerance e di scheduling di jobs.

Le componenti principali di SLURM sono:

• nodi - nodi di calcolo;
• partizioni - raggruppamenti logici di nodi;
• jobs - allocazione di risorse assegnate ad un utente per un determinato ammontare di tempo;
• job steps - insieme di attività (solitamente parallele) all'interno di un job.

Le partizioni possono essere considerate come job queues ognuna delle quali definisce vincoli sulla dimensione dei job, limiti temporali, permessi di utilizzo di risorse da parte degli utenti, ecc.

Gestione centralizzata attraverso un demone, slurmctld, per il monitoraggio di risorse e jobs. Ogni nodo è gestito da un demone slurmd che si occupa di gestire richieste di attività.

Alcuni strumenti a disposizione dell'utente sono:

• srun - avviare job;
• sbatch - sottomettere script batch;
• salloc - richiedere l’allocazione di risorse (nodi), con eventuali vincoli (ad es, numero di processori per nodo);
• scancel - terminare job in coda o in esecuzione;
• sinfo - conoscere informazioni sullo stato del sistema;
• squeue - conoscere lo stato dei jobs;
• sacct - ottenere informazioni sui jobs.
• …

Un elenco completo dei comandi disponibili si trova nel man (disponibile anche online all’indirizzo https://slurm.schedmd.com/man_index.html): man <cmd>

sinfo - Conoscere e verificare lo stato delle risorse (partizioni esistenti, relativi nodi, …) e stato generale del sistema:

Esempio: $ sinfo

Output:

  PARTITION AVAIL  TIMELIMIT  NODES  STATE NODELIST
  hpc*      up     infinite   32     idle  ibiscohpc-wn[01-32]

L'output riporta le informazioni sulle partizioni, nell'esempio:

• una partizione denominata “hpc” (* indica che è la partizione di default);
• la partizione è disponibile (stato up);
• non sono impostati limiti di tempo sulla partizione;
• la partizione è composta da 32 nodi;
• lo stato è idle;
• i nodi disponibili sono denominati ibiscohpc-wn01, ibiscohpc-wn02, …, ibiscohpc-wn32.

squeue - Conoscere lo stato della coda di jobs:

Esempio: $ squeue

Output:

  JOBID PARTITION     NAME     USER         ST      TIME  NODES NODELIST(REASON)
  4815  hpc           sleep    cnr-isas     R       0:04 

L'output mostra, per ogni job:

• identificativo del job;
• nome della partizione su cui è stato lanciato il job;
• nome del job;
• nome utente che ha lanciato il job;
• stato del job (running);
• tempo di esecuzione del job.

scontrol - informazioni più dettagliate su job e risorse

Esempio (info dettagliate sul nodo ibiscohpc-wn02): $ scontrol show node ibiscohpc-wn02

Output:

  NodeName=ibiscohpc-wn02 Arch=x86_64 CoresPerSocket=24
     CPUAlloc=0 CPUTot=96 CPULoad=0.01
     AvailableFeatures=HyperThread
     ActiveFeatures=HyperThread
     Gres=gpu:tesla:4(S:0)
     NodeAddr=ibiscohpc-wn02 NodeHostName=ibiscohpc-wn02 Version=20.11.5
     OS=Linux 3.10.0-957.1.3.el7.x86_64 #1 SMP Mon Nov 26 12:36:06 CST 2018
     RealMemory=1546503 AllocMem=0 FreeMem=1528903 Sockets=2 Boards=1
     State=IDLE ThreadsPerCore=2 TmpDisk=0 Weight=1 Owner=N/A MCS_label=N/A
     Partitions=hpc
     BootTime=2022-02-01T16:24:43 SlurmdStartTime=2022-02-01T16:25:25
     CfgTRES=cpu=96,mem=1546503M,billing=96
     AllocTRES=
     CapWatts=n/a
     CurrentWatts=0 AveWatts=0
     ExtSensorsJoules=n/s ExtSensorsWatts=0 ExtSensorsTemp=n/s
     Comment=(null)

srun - controllo dell’esecuzione di un job parallelo sul cluster gestito da Slurm. Se necessario, srun alloca le risorse per l’esecuzione del job.

Alcuni parametri utili di srun sono:

-c, –cpus-per-task=<ncpus>

• numero di CPUs allocate per processo. Di default viene utilizzata una CPU per processo.

-l, –label

• mostra in testa alle righe, sullo stdout, il numero del task cui l’output si riferisce.

-N, –nodes=<minnodes>[-maxnodes]

• numero minimo (minnodes) da allocare per il job ed eventuale numero massimo (maxnodes) di nodi.
• Se il parametro non viene specificato, vengono allocati i nodi necessari a soddisfare i requisiti specificati dai parametri -n e -c.
• Se i valori sono al di fuori dal range consentito per la partizione associata, il job viene posto in uno stato PENDING. Ciò consente una possibile esecuzione in un secondo momento, quando viene eventualmente modificato il limite della partizione.

-n, –ntasks=<number>

• numero di task da eseguire. srun alloca le risorse necessarie in base al numero di task richiesti (di default, viene richiesto un nodo per ogni task ma, tramite l’opzione –cpus-per-task, questo comportamento può essere modificato).

Esempio, accedere in maniera interattiva ad un nodo, dalla UI:

  $ salloc  srun --pty /bin/bash

Esempio, per sottomettere un job batch, dalla UI:

  $ echo -e '#!/bin/sh\nhostname' | sbatch

Esempio, per sottomettere un job interattivo MPI con <N> tasks, dalla UI:

  $ srun -n <N> <EXEFILE>
  

Comando importante quando si usa OpenMP

Aggiungere il seguente comando nello script usato per sottomettere un job OpenMP:

  $ export OMP_NUM_THREADS = <nthreads>

• Esso specifica il numero di threads da usare quando si eswegue codice che usa OpenMP per eseguire un programma parallelo (C/C++/Fortran). Il massimo valore dovrebbe essere pari al numero diprocessori disponibili. Per maggiori informazioni su OpenMP, potete consultare openMP.

Per utilizzare la suite Intel di compilatori e librerie, bisogna utilizzare (interattivamente o all'interno di qualunque script in cui essi siano necessari) il comando

. /nfsexports/intel/oneapi/setvars.sh 

Per dettagli su “Red Hat Developer Toolset” si veda https://access.redhat.com/documentation/en-us/red_hat_developer_toolset/7/html/user_guide/chap-red_hat_developer_toolset

Di seguito alcuni esempi di come invocare i vari ambienti di sviluppo:

* Creare una subshell bash in cui sono operativi i tool (in questo caso gcc/g++/gfortran/… v.10):

 $ scl enable devtoolset-10 bash 

# Rendere operativi i tool (in questo caso gcc/g++/gfortran/… v.10, nella shell corrente):

 $ source scl_source enable devtoolset-10 

Il seguente script è un esempio di uso di Singularity

#!/bin/bash
singularity run library://godlovedc/funny/lolcow 

Per usare python, è necessario avviare l'ambiente conda usando il seguente comando:

source /nfsexports/SOFTWARE/anaconda3.OK/setupconda.sh
<commands execution> [Example: python example.py]
conda deactivate 

Il sotto-ambiente tensorflow va attivato dopo aver avviato l'ambiente conda:

source /nfsexports/SOFTWARE/anaconda3.OK/setupconda.sh
conda activate tensorflowgpu
<commands execution> [Example: python example.py]
conda deactivate
conda deactivate

Per usare l'ambiente bioconda, bisogna eseguire il seguente comando:

source /nfsexports/SOFTWARE/anaconda3.OK/setupconda.sh
conda activate bioconda
<commands execution> [Example: python example.py]
conda deactivate
conda deactivate

Per usare l'ambiente Pytorch, bisogna eseguire i seguenti comandi:

source /nfsexports/SOFTWARE/anaconda3.OK/setupconda.sh
conda activate pytorchenv
<commands execution> [Example: python example.py]
conda deactivate
conda deactivate

Per elencare i packages disponibiliin del dato ambiente, eseguire il comando:

conda list

• La parallelizzazione dei processi è un modo efficace di sfruttare il sistema HPC. Il codice può essere parallelizzato distribuendo i task tra i nodi disponibili e le loro rispettive CPU e GPU. L'informazione di distribuzione può essere specificata in un semplice script bash, sub.sh, come segue:

#!/bin/bash
#SBATCH --nodes=[nnodes]           #number of nodes
#SBATCH --ntasks-per-node=[ntasks per node] #number of cores per node
#SBATCH --gres=gpu:[ngpu]        #number of GPUs per node

Supponiamo che un dato programma in python debba essere eseguito per differenti valori di una variable “rep”. E' possibile produrre l'esecuzione in parallelo del codice python durante la sottomissione del job, creando file temporanei, ciascun file con la variabile rep=a1, a2, … Ad esempio il programma example.py potrebbe contenere la linea:

 rep=REP 

Lo script di sottomissione job sub.sh puòò essere usato per parallelizzare il processo nel seguente modo:

#!/bin/bash
#SBATCH --nodes=[nnodes]            #number of nodes
#SBATCH --ntasks-per-node=[ntasks per node]  #number of cores per node
#SBATCH --gres=gpu:[ngpu]         #number of GPUs per node
NPROC=[nprocesses]                     #number of processing units to be accessed

tmpstring=tmp               #temporary files generated 

count=0                     #begin counting the temporary files
for rep in {1..10};         #The value of rep should run from 1 to 10
do
    tmpprogram=${tmpstring}_${rep}.py         #temporary file names for each of the values of rep
    sed -e "s/REP/$rep/g"   #replace the variable REP in the .py with rep specified in the sub.sh file.
    $program > $tmpprogram  #create the temporary files in parallel
    python $tmpprogram &    #run the temporary files
    (( count++ ))           #increase the count number
    [[ $(( count % NPROC )) -eq 0 ]] && wait  #wait for the parallel programs to finish.
done
rm ${tmpstring}*            #optionally remove the temporary files after the execution of all the temporary files

• La sottomissone di job paralleli può essere anche ottenuta tramite sottomissionre di array di job. Informazione appofondita può essere trovata in https://slurm.schedmd.com/job_array.html.

• La parallelizzazione può essere implementata nello stesso programma python. Per esempio, la valutazione di una funzione per differenti valori di una può essere fatta in parallelo. Python offre molti package per parallelizzare il dato processo. Il package basilare tra questi è multiprocessing.

• I moduli keras e Pytorch in tensorflow, che sono principalmente usati per machine learning, individuano le GPU automaticamente.

Per utilizzare gmsh è necessario configurare l'ambiente di esecuzione (shell) in modo da garantire la disponibilità delle necessarie librerie eseguendo il seguente comando:

 $ scl enable devtoolset-10 bash 

All'interno della shell così configurata è quindi possibile eseguire il comando gmsh disponibile nella directory

  /nfsexports/SOFTWARE/gmsh-4.10.1-source/install/bin

Quando non sarà più necessaria la shell configurata ad-hoc, si può terminare mediante il comando

 $ exit  

per usare questa versione, disponibile nella directory

/nfsexports/SOFTWARE/OpenFOAM-9.0/

è necessario configurare l'ambiente come segue:

 $ source /nfsexports/SOFTWARE/OpenFOAM-9.0/etc/bashrc 

 $ source /nfsexports/SOFTWARE/intel/oneapi/compiler/latest/env/vars.sh 

• Per usare la finestra comandi di Matlab, usare ssh ibiscohpc-ui.scope.unina.it -l [username] -Y quando si entra nel cluster IBISCO.
• Configurare l'ambiente Matlab usando il comando /nfsexports/SOFTWARE/MATLAB/R2020b/bin/matlab . Questo apre la finestra comandi mathworksdove si potrà aggiungere il file di configurazione (v. avanti).
  
• Si può accedere a Matlab versione R2022a usando il comando /nfsexports/SOFTWARE/MATLAB/R2022a/bin/matlab .

Qui allegato si può trovare un esempio di un *Profile File* che può essere usato per configurare la macchina parallela multi-nodo per l'esecuzione di job paralleli Matlab sul cluster HPC IBiSco.

Esempio di file di configurazione for esecuizione parallela

Il file deve essere decompresso prima dell'uso

Affinché al cluster acceda un programma Matlab, l'utente deve *prima importare* quel file avviando il *Cluster Profile Manager* sul desktop Matlab (Sul tab *Home* tab, nell'area *Environment*, selezionare *Parallel* > *Create and Manage Clusters*).\\)

Figure 2: Finestra di importazione delle configurazione

Una volta che il profilo è stato importato, ad esso può far irferimento un programma parallelo Matlab usando il nome profilo 'SlurmIBISCOHPC': ovvero

mypool=parpool('SlurmIBISCOHPC', ___, ___, ___, ___) 
...
delete(mypool); 

Per modificare il profilo 'SlurmIBISCOHPC' l'utente può usare

1. la finestra *Create and Manage Clusters*
2. i comandi di profilo Martlab tipo saveProfile (https://it.mathworks.com/help/parallel-computing/saveprofile.html)

Questo è un esempio di utilizzo di parfor per parallelizzare il ciclo for (dimostrato in MathWorks). In questo esempio viene calcolato il raggio spettrale di una matrice e viene convertito un for-loop in un parfor-loop. Aprire un file denominato test.m con il codice seguente

mypool=parpool('SlurmIBISCOHPC', 5) % 5 è il numero di lavoratori
n = 100;
A = 200;
a = zeros(n);
parfor i = 1:n
    a(i) = max(abs(eig(rand(A))));
end
delete(mypool); 
quit

Per eseguire questo codice, è possibile utilizzare il seguente comando sulla UI:

/nfsexports/SOFTWARE/MATLAB/R2020b/bin/matlab -nodisplay -nosplash -nodesktop -r test

Inizio