ibisco HPC Wiki

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)

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)

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

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

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>
  

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

Inizio