Cluster di calcolo 'Blade'

Concetti fondamentali

Il server 'blade' installato presso il nostro Dipartimento è configurato per soddisfare le richieste di risorse di calcolo da parte degli utenti in modalita' non interattiva o 'batch'.

E' possibile eseguire sul cluster qualsisasi applicazione a 32 o 64 bit che eseguireste abitualmente da uno dei PC Linux della rete DEI (ad esempio Matlab) o qualsiasi programma abbiate ricompilato da voi.

Le varie richieste vengono prese in carico dal programma di gestione del server, accodate in base ad un sistema di priorità ed eseguite dalla risorsa di calcolo più adeguata in quel momento.

I risultati della computazione che normalmente comparirebbero a video vengono salvati in un file di output.

Il programma di gestione adottato è Sun Grid Engine. Come altri sistemi di gestione simili il meccanismo di interazione principale consiste nel creare un file di testo (job file) contenente le richieste di risorse di calcolo ed il precorso (almeno) del programma da eseguire, del file da usare come input e di quello da scrivere come output. Una volta creato il job file un apposito comando (qsub) viene usato per accodare la richiesta.

Caratteristiche tecniche

Il cluster e' composto da 14 'lame' di calcolo modello DELL PowerEdge M600 ciascuna equipaggiata con:

  • 2 Processori quad core Intel Xeon E5450 (12MB Cache, 3.00 GHz)
  • 16 GB RAM
  • 2 Hard disk da 72GB in configurazione RAID-1 (mirroring)

Le lame sono alloggiate in uno chassis modello M1000e e sono connesse da uno switch di classe gigabit.

Per poter usare il cluster di calcolo è OBBLIGATORIO connettersi sia SSH al server login.dei.unipd.it


ESEMPIO 1:
sottomettere come semplice 'job' al sistema la stampa della lista dei files nella cartella corrente.

Lanciando semplicemente il comando 'ls' questo verrebbe eseguito sulla macchina dove siamo collegati in quel momento: vogliamo invece che l'esecuzione avvenga su uno dei nodi di calcolo. Per far ciò usiamo il comando 'qsub'.

I comandi indicati dopo il carattere '>'sono quelli che dovete scrivere da tastiera.

> qsub -cwd -m ea
ls

( premete ora CTRL + d )

Your job 1598 ('STDIN') has been submitted

Il job viene accodato (preso in carico) dal sistema:

> qstat

job-ID  prior   name       user         state submit/start at     queue                          slots ja-task-ID 
-----------------------------------------------------------------------------------------------------------------
1598    0.00000 STDIN      mazzon       qw    03/03/2009 11:50:51                                    1

Ad un certo punto il job passerà dallo stato 'qw' allo stato 'r' (running):

> qstat

job-ID  prior   name       user         state submit/start at     queue                          slots ja-task-ID
-----------------------------------------------------------------------------------------------------------------
1598   0.75000  STDIN      mazzon       r     03/03/2009 12:32:22 LOW@runner-11.dei.unipd.it     1

Al termine della computazione l'output del programma si trova nel file STDIN.o1598 (dove 1598 è il JOBID: si veda il comando precedente).
In questa modalità di interazione:

  • dovete riscrivere ogni volta gli stessi comandi
  • i job vengono sottomessi con la minima priorità

 

ESEMPIO 2: avvio di uno script Matlab

1) Create un JOB file contenente:

#!/bin/bash
#
# Specifico il progetto associato
#
#$ -P 30_Ricerca
#
# Genera output ed errori nella cartella corrente.
# Il file di output sara' test.job.oJOBID
# quello degli errori sara' invece test.job.eJOBID
#
#$ -cwd -m ea
#
# Non redirigo l'output: ogni esecuzione generera'
# un file di output diverso
#
# Voglio ricevere una mail quando il job termina
# o in caso venga abortito
#
#$ -m ea

matlab -r ScriptDaEseguire

 

2) Dal terminale del proprio pc copiare la cartella contenente il JOB file appena creato e tutti i file necessari a MATLAB ( file dati, script, funzioni ecc.)  sul server login con il comando:

scp -r  percorso/nelTuoPc/Cartella LoginDEI@login.dei.unipd.it:Percorso_Su_login/


Dove il -r copia tutti i file della cartella, poi si trova l'indirizzo di partenza ed il nome della cartella seguito dall'indirizzo di destinazione.

3) Loggarsi sul server login per far partire un nuovo lavoro con il comando:

ssh  LoginDEI@login.dei.unipd.it



La password che viene chiesta è quella relativa alla vostra login del DEI.

4) Dal server login è ora sufficiente far partire il job file (punto 5), in caso servisse con i comandi: cd NomeCartella (per entrare nella cartella) e: ls (per mostrare il contenuto della cartella) posizionarsi nella cartella copiata al punto precedente. Per modificare i file usare il comando:

nano NomeFile.m



5) Per avviare il lavoro è sufficiente lanciare il comando:

qsub NomeJOBFile.job



Per vedere l'avanzamento del lavoro è sufficiente digitare il comando qstat. Da quello che appare si vede lo stato del lavoro, e soprattutto il jobid assegnato.

6) Eventuali file di output si salvano nella cartella contenente tutti i file MATLAB ed il JOBfile, per visualizzare velocemente il contenuto dei file test.job.oJOBID usare il comando:

cat test.job.oJOBID

Per altre particolari opzioni e istruzioni piu' dettagliate leggete quel che segue.

Allo stato attuale sono state definite delle code di esecuzione alle quali si accede sulla base di appartenenza o meno ad un determinato gruppo unix.

La cosa e' importante: qualora si appartenga a piu' di un gruppo ed il gruppo primario non sia tra quelli ammessi sara' OBBLIGATORIO usare il comando newgrp nuovo_gruppo prima di lanciare qsub.

Esempio: l'utente 'mazzon' appartiene a piu' di un gruppo UNIX: lo si vede utilizzando il comando id (senza parametri mostra uid e gid dell'utente corrente):

> id mazzon

uid=6912(mazzon) gid=14(sysadmin) groups=100(users),14(sysadmin),318(meladmin),325(wifi)

Il gruppo primario (quello che verra' utilizzato da SGE) e' quello indicato dopo la voce 'gid=', gli altri sono ovviamente indicati dalla lista 'groups='. Qualora il gruppo primario fosse impostato, ad esempio, a 'meladmin' si avrebbe il seguente risultato:

> newgrp meladmin
> qsub mmfast.job

Unable to run job: warning: mazzon your job is not allowed to run in any queue
job rejected: no access to project '30_Ricerca' for user 'mazzon'.
Exiting.

La lista dei gruppi che possono sottomettere un job al sistema SGE e' indicata nelle tabelle sottostanti.


Code
Il sistema SGE e' stato configurato sulla base dei concetti di 'code' (queue) e 'progetti' (projects). Ogni utente che abbia accesso ad una coda ha anche accesso anche a tutte le altre code che stanno "al di sotto" nella seguente tabella:

NOMEgruppi ammessilimitazioni
FULLbio
signet
Max Istanze: 16 per il progetto 10_Bio + 16 per il progetto 10_Signet
HIGHtelecom, tc-dott, tc-main, tc-studMax Istanze: 8 per il progetto 20_Telecom
MEDIUM{gruppi della coda FULL}
{gruppi della coda HIGH}
assegni
collab
docenti
dottor
personale
tesi
 
LOW{tutti i gruppi della coda MEDIUM}
studenti
 
NOTE:
  • Dove non specificato il numero di istanze ammissibili per ogni coda e' pari al numero di 'core' dei processori del cluster, cioe' 112;
  • Il massimo numero di job che un singolo utente puo' avere in esecuzione contemporaneamente e' 20.

 

Progetti
Se da un lato le code differenziano i job presi in carico da SGE sulla base del gruppo di appartenenza, un controllo piu' fine del processo di schedulazione si puo' fare a livello di scelta del progetto (project). Questo puo' essere visto come una specificazione a livello 'semantico' del compito da eseguire sul server di calcolo.

Ogni utente cioe' puo' scegliere, in base ai progetti a cui ha accesso, se richiedere (anche all'interno della stessa coda di priorita') delle risorse di calcolo sulla base del progetto_A o del progetto_B. Il concetto di progetto consente inoltre allo scheduler di differenziare gli utenti che hanno accesso ad una stessa coda.

I progetti attualmente definiti, gli utenti che vi possono accedere e le code su cui possono essere eseguiti sono, al momento:

NOMEgruppi ammessicode ammesse
10_BiobioFULL, MEDIUM, LOW
10_SignetsignetFULL, MEDIUM, LOW
20_Telecomtelecom, tc-dott, tc-main, tc-studHIGH, MEDIUM, LOW
30_Ricerca{gruppi progetto 10_Bio}
{gruppi progetto 10_Signet}
{gruppi progetto 20_Telecom}
assegni
collab
docenti
dottor
personale
tesi
MEDIUM, LOW
40_Studenti{tutti i gruppi precedenti}
studenti
LOW
NOTE: qualora non venga specificato il progetto di default e' 40_Studenti. Non specificare un progetto al momento della sottomissione del job comportera' di conseguenza l'accesso alla sola coda LOW.

La fonte principale di documentazione per tutto il sistema di gestione Sun Grid Engine sono le pagine di manuale accessibili dalla linea di comando (ad esempio: man qstat). Un veloce riassunto delle principali opzioni di ciascun comando si puo' ottenere usando lo switch '-help'.

qstat
mostra lo stato dei job e delle code

parametrofunzione
nessun parametromostra i job in coda
-flista completa di tutte le code
-j [num]lista dettagliata [del job numero num]

qhost
mostra lo stato degli host per l'esecuzione

parametrofunzione
nessun parametromostra una tabella degli host per l'esecuzione e della loro configurazione
-qlista delle code disponibili sui vari host
-jmostra i job in esecuzione sui vari host

qsub
lancia un job

parametrofunzione
-cwdlancia il job (e genera output ed errori) dalla directory corrente
-P progetto(p MAIUSCOLO) specifica il progetto associato al job
-o outputredireziona lo standard output nel file output. Se non specificato vengono generati file con suffisso .oXYZ, dove XYZ e' il numero di accodamento del job
-e errorredireziona lo standard error nel file error. Se non specificato vengono generati file con suffisso .eXYZ, dove XYZ e' il numero di accodamento del job
-m b|e|a|s|nseleziona in che occasioni notificare via mail l'utente. DEFAULT: nessuna notifica. Le possibili opzioni (se ne possono specificare piu' di una) sono:
  • b (beginning): notifica all'avvio del job;
  • e (end): notifica alla fine del job;
  • a (abort): notifica se il job viene abortito o rischedulato;
  • s (suspend): notifica se il job viene sospeso;
  • n (none): non notificare mai (default).

N.B.: Tutti i parametri della linea di comando possono essere messi in un job file anteponendo all'opzione (una o piu' per riga) i due caratteri '#$'.

qdel
elimina un job in coda

parametrofunzione
-u MIALOGINcancella TUTTI i miei job in coda
lista_di_jobcancella tutti i job specificati nella lista

Supponiamo di voler eseguire con matlab lo script ScriptMatlab.m nella cartella devel/jobs della propria homedir. I parametri per la sottomissione al sistema che voglio impostare sono:

  • Il progetto associato al job e' 30_Ricerca;
  • Decido di non sovrascrivere l'output (ed eventuali errori) ad ogni esecuzione utilizzando la direttiva -o (-e) ma di lasciare che il sistema crei automaticamente un file di output diverso ad ogni esecuzione, in modo da poter poi processare i vari files per fini statistici.

Creero' allora un 'job file' (mmfast.job) contenente i seguenti comandi: (notare che le righe che iniziano col solo carattere '#' introducono dei commenti, quelle che iniziano con '#$' introducono le direttive per lo scheduler) Il job file da sottomettere allo scheduler

#!/bin/bash
#
# Specifico il progetto associato
#
#$ -P 30_Ricerca
#
# Genera output ed errori nella cartella corrente.
# Se non specificato diversamente output ed errori
# vengono rediretti rispettivamente nei 2 file 
# mmfast.job.oJOBID e mmfast.job.eJOBID
#
#$ -cwd
#
# Voglio ricevere una mail quando il job termina
# o in caso venga abortito
#
#$ -m ea
#
cd ~/devel/jobs
matlab -r ScriptMatlab

Il file e' pronto per la sottomissione che avviene semplicemente con il comando:

> qsub mmfast.job
Your job 1571 ('mmfast.job') has been submitted

Posso controllare lo stato di avanzamento dei miei jobs: inizialmente saranno nello stato queued + waiting indicato dalle lettere 'qw' alla voce 'state':

> qstat
job-ID  prior   name       user         state submit/start at     queue                          slots ja-task-ID 
-----------------------------------------------------------------------------------------------------------------
   1571 0.00000 mmfast.job mazzon       qw    02/27/2009 11:35:43

Appena il sistema trovera' delle risorse libere su cui eseguire il programma, il suo stato passera' a running (lettera 'r' dello 'state'):

> qstat
job-ID  prior   name       user         state submit/start at     queue                          slots ja-task-ID 
-----------------------------------------------------------------------------------------------------------------
   1571 0.75000 mmfast.job mazzon       r     02/27/2009 11:35:53 MEDIUM@runner-06.dei.unipd.it      1

Un output piu' dettagliato si ottiene specificando l'opzione '-j' ed il numero di sequenza del job nel comando qstat:

> qstat -j 1571
==============================================================
job_number:                 1571
exec_file:                  job_scripts/1571
submission_time:            Fri Feb 27 11:35:43 2009
owner:                      mazzon
uid:                        6912
group:                      sysadmin
gid:                        14
sge_o_home:                 /home/mazzon
sge_o_log_name:             mazzon
sge_o_path:                 /usr/share/gridengine/bin/lx26-x86:...:/home/mazzon/bin
sge_o_shell:                /bin/bash
sge_o_workdir:              /home/mazzon/devel/jobs
sge_o_host:                 pcmazzon
account:                    sge
cwd:                        /home/mazzon/devel/jobs
stderr_path_list:           NONE:NONE:/dev/null
mail_list:                  mazzon@pcmazzon.dei.unipd.it
notify:                     FALSE
job_name:                   mmfast.job
jobshare:                   0
env_list:                   
script_file:                mmfast.job
project:                    30_Ricerca
scheduling info:            There are no messages available

Quando l'esecuzione terminera' trovero' il file di output (se ho specificato la direttiva '-cwd') nella cartella dell'eseguibile:

> ls
ScriptMatlab.m	mmfast.job  mmfast.job.o1569  mmfast.job.o1570	mmfast.job.o1571

Con l'intento di razionalizzare l'utilizzo del Parallel Computing Toolbox di Matlab si e' provveduto a restringere l'accesso al toolbox, per i job in esecuzione sul cluster Blade, ai soli runner-13 e runner-14 che sono stati di recente sostituiti con macchine piu' performanti (64 CPU e 256 GB RAM).

A tale scopo sono state riservate 4 licenze ad uso esclusivo di questi 2 host ed e' stata creata una coda di esecuzione che esiste solo in queste 2 lame.

Operativamente, per eseguire quindi un job matlab che utilizzasse il parallel toolbox sara' necessario specificare nel job file:

  • la coda 'parallel' con la direttiva
    -q parallel
  • il numero di CPU richieste (fino a 32 per job) con la direttiva
    -l par_cpu=N

A chi è rivolto: tutti
Descrizione: in questa scheda vengono riportate le modalità per utilizzare il nuovo server di calcolo dipartimentale tramite il proprio account informatico.
Referente: Servizi Informatici