Sei sulla pagina 1di 30

MICC-Cluster Quick HOWTO

Tiberio Uricchio < uricchio@gmail.com >


24/02/2012

Architettura attuale

Il cluster composto da:

4 compute node

4 Core (2 reali, 4 logici) 8 GB di RAM 320 Gb di HDD 7.2k rpm

1 master node

4 Core (2 reali, 4 logici) 16 GB di RAM 320 Gb di HDD 10k rpm

1 dispositivo SAS

4 TB di HDD in RAID0 connessione in bra ottica

Architettura attuale

Il sistema operativo installato Linux con distribuzione Rocks Cluster. Rocks Cluster un derivato da CentOS 5, update 5 che a sua volta derivato da Red Hat Enterprise Linux 5.

Quasi tutto ci che supportato da Red Hat, supportato da Rocks.

Lunico punto di accesso al cluster il nodo master, il frontend dellintera struttura. E sufciente utilizzare questa macchina per tutte le esigenze. Lindirizzo attuale markone.localdomain (IP 192.168.0.210), non visibile direttamente allesterno. E necessario un indirizzo di rete locale. E possibile accedere dallesterno passando attraverso una macchina pass-through, dotata sia di indirizzo IP esterno e interno (morpheus, shrek, trinity, ...) e del servizio SSH. E anche possibile utilizzare servizi avanzati attraverso un SSH tunnel proxy.

Accesso
Laccesso effettuato utilizzando un semplice collegamento SSH sul frontend.

Per gli utenti Windows necessario scaricare un client SSH. E consigliato Putty[1] o Penguinet[2].

Phoenix:~ urix$ ssh urix@192.168.0.210 urix@192.168.0.210's password: Last login: Wed Feb 22 18:13:47 2012 from 192.168.0.101 Rocks 5.4.3 (Viper) Profile built 15:46 13-Jan-2012 Kickstarted 17:13 13-Jan-2012 [urix@markone ~]$

Filesystem

La disposizione degli applicativi di sistema tipica Linux. Ogni compute node possiede una copia (ridotta) del sistema operativo, dove sono stati rimossi i pacchetti di sviluppo. 3 percorsi svolgono funzioni particolari:

/home/utente

la home dellutente condivisa su tutte le macchine. E situata sicamente sul dispositivo SAS collegato al nodo master.

/share/apps

contiene applicazioni aggiuntive rispetto alla distribuzione base. Sono presenti pacchetti quali OpenCV, Python+Numpy+Scipy,TBB, etc.

/share/datasets

contiene alcuni dataset precaricati. Si trovano sicamente sul disco locale della macchina master. Hanno una velocit di trasferimento superiore rispetto ai dati delle home.

A questo punto utilizzando soltanto i percorsi condivisi possibile rendere unapplicazione indipendente dal nodo su cui in esecuzione.

Jobs

Il cluster possiede una coda di lavori da eseguire e gestisce automaticamente lallocazione dei jobs sulla base delle esigenze espresse e dalle disponibilit di risorse.

I jobs vengono gestiti dal software Sun Grid Engine.

Il software di management permette di allocare risorse come processori, memoria, spazio su disco, a programmi funzionanti in modalit batch.

Ogni utente pu sottomettere un job specicando uno script bash/sh/csh. Opzionalmente pu richiedere anche una quantit di memoria e di tempo di cpu.

E utile indicare sempre una quantit di tempo di cpu, per evitare che in caso di problemi il job occupi un tempo indenito in esecuzione.

Jobs

qsub

Ogni programma lanciato da console viene eseguito SOLTANTO sul nodo master! E necessario sottomettere un lavoro per poter sfruttare le potenzialit del cluster. Il comando per inviare un job in coda qsub. qsub [options] script

E necessario specicare uno script per eseguire il lavoro. Nel caso in cui vogliamo direttamente eseguire un programma utente, uno script di esempio : #!/bin/env bash #$ -cwd /path/to/executable

E possibile indicare direttamente nello script le opzioni di qsub, in modo da legarle al lavoro specico. La seconda riga nellesempio imposta lopzione cwd.

Jobs

qsub

qsub [-cwd] [-o path] [-e path] [-l res] [-p priority] script Le opzioni comuni sono:

[-cwd] esegue il job dalla cartella in cui presente lo script. [-o path] redirige lo standard output del programma sul path specicato. E possibile usare /dev/null per non salvare loutput. Se non specicato invia loutput in un le nella propria home, denominato nomejob.oJobId [-e path] redirige lo standard error del programma sul path specicato. E possibile usare /dev/null per non salvare loutput. Se non specicato invia loutput in un le nella propria home, denominato nomejob.eJobId [-l res] specica le risorse richieste dal job per essere eseguito.

h_data=1024M imposta 1GB di RAM h_rt=24:00:00 imposta massimo 1gg di esecuzione per core (hard runtime).

[-p priority] imposta la priorit del lavoro. Accetta valori interi tra -1023 a 1024. La priorit predenita 0. Come utenti possibile soltanto diminuire la priorit.

Jobs

qsub

Esempio: vogliamo eseguire un hello world sul cluster. Il le hello.cpp contiene: #include <iostream> int main() { std::cout << Hello world! << std::endl; return 0; }

Compilo leseguibile: [urix@markone ~]$ g++ hello.cpp -o hello

Provo rapidamente in locale sul nodo master se funziona: [urix@markone ~]$ ./hello Hello world! [urix@markone ~]$

Jobs

qsub

Creo uno script per eseguire il job hello.sh #!/bin/env bash #$ -cwd #$ -o /home/urix/hello.out #$ -e /home/urix/hello.err #$ -l h_rt=00:01:00 /home/urix/hello

Invio il lavoro in coda: [urix@markone ~]$ qsub hello.sh

Il risultato: [urix@markone ~]$ cat hello.out Warning: no access to tty (Bad file descriptor). Thus no job control in this shell. Hello world! [urix@markone ~]$

Jobs

qstat

Per vericare i jobs in esecuzione si usa il comando qstat qstat [-f] [-j job_number]

Eseguito senza opzioni, mostra i propri jobs in coda:


[urix@markone ~]$ qstat job-ID prior name user state submit/start at queue slots ja-task-ID ---------------------------------------------------------------------------------------------------166 0.00000 hello.sh urix qw 02/23/2012 16:52:38 1 [urix@markone ~]$

lopzione [-f] mostra un riassunto sulle risorse disponibili al momento.

lopzione [-j job_number] mostra i dettagli di un job. E utile in caso per conoscere lo stato esaustivo del job e i motivi di un eventuale blocco o errore.

Jobs

qstat

Lavoro in attesa:
[urix@markone ~]$ qstat job-ID prior name user state submit/start at queue slots ja-task-ID ---------------------------------------------------------------------------------------------------166 0.00000 hello.sh urix qw 02/23/2012 16:52:38 1 [urix@markone ~]$

Lavoro in esecuzione:
[root@markone ~]# qstat -u "*" job-ID prior name user state submit/start at queue slots ja-task-ID -------------------------------------------------------------------------------------------------165 0.55500 Job10 melis r 02/23/2012 15:57:00 all.q@markone.local 10 [root@markone ~]#

Jobs

qstat

Stati di un job: d(eletion), t(ransfering), r(unning), R(estarted), s(uspended), S(uspended), T(hreshold), w(aiting) o h(old). E(rror). Lo stato error implica un errore nelle propriet del job inviato.

Stato generale:
[urix@markone ~]$ qstat -f queuename qtype resv/used/tot. load_avg arch states --------------------------------------------------------------------------------all.q@compute-0-0.local BIP 0/2/4 1.55 lx26-amd64 --------------------------------------------------------------------------------all.q@compute-0-1.local BIP 0/2/4 0.00 lx26-amd64 --------------------------------------------------------------------------------all.q@compute-0-2.local BIP 0/2/4 0.00 lx26-amd64 --------------------------------------------------------------------------------all.q@compute-0-3.local BIP 0/2/4 0.00 lx26-amd64 --------------------------------------------------------------------------------all.q@markone.local BIP 0/2/2 4.46 lx26-amd64 [urix@markone ~]$

Jobs

altri comandi

Altri comandi utili: qhost visualizza informazioni sullo stato delle risorse sui nodi (load, ram, swap). qdel job_number elimina un job dalla coda. qhold job_number ferma un job mettendolo in attesa. qrls job_number rilascia un lavoro interrotto da qhold. qresub job_number sottomette un nuovo job identico a quello specicato.

[urix@markone ~]$ qhost HOSTNAME ARCH NCPU LOAD MEMTOT MEMUSE SWAPTO SWAPUS ------------------------------------------------------------------------------global compute-0-0 lx26-amd64 4 1.57 7.7G 3.5G 996.2M 161.3M compute-0-1 lx26-amd64 4 0.00 7.7G 1.1G 996.2M 17.6M compute-0-2 lx26-amd64 4 0.00 7.7G 3.9G 996.2M 17.0M compute-0-3 lx26-amd64 4 0.01 7.7G 352.7M 996.2M 16.2M markone lx26-amd64 4 4.52 15.6G 5.4G 996.2M 88.6M [urix@markone ~]$

Jobs

dipendenti

Molto spesso capita di poter eseguire un job soltanto al termine di altri (es. map/reduce) Conviene utilizzare lopzione [-N name] del comando qsub per specicare il nome del job per farvi riferimento successivamente. Per sottomettere un job che dipende da altri jobs, si utilizza lopzione [-hold_jid job_name1,job_name2,...] indicando i jobs da cui dipende. Esempio:
[urix@markone ~]$ qsub -N hello1 hello1.sh Your job 172 ("hello1") has been submitted [urix@markone ~]$ qsub -N hello2 -hold_jid hello1 hello2.sh Your job 173 ("hello2") has been submitted [urix@markone ~]$ qsub -N hello3 -hold_jid hello1,hello2 hello3.sh Your job 174 ("hello3") has been submitted [urix@markone ~]$ qstat job-ID prior name user state submit/start at queue slots ja-task-ID -------------------------------------------------------------------------------------------172 0.00000 hello1 urix r 02/23/2012 18:26:34 all.q@markone.local 1 173 0.00000 hello2 urix hqw 02/23/2012 18:26:40 1 174 0.00000 hello3 urix hqw 02/23/2012 18:26:48 1

Jobs

array job

Un problema comune lesecuzione di tanti jobs molto simili tra di loro, ad esempio un job per classe o un job per dataset. E sufciente un solo le script che differenzia i lavori in base ad un indice numerico. Lintero array di lavori visto come un unico job id.

Si utilizza lopzione [-t n-m:step] nel comando qsub che specica un range da n a m con passi di step. Lo script deve utilizzare la variabile ambiente $SGE_TASK_ID per selezionare i dati da elaborare.

Esempio: vogliamo processare 1000 video numerati da 1 a 1000. Un possibile script :


#!/bin/sh #$ -t 1-1000 /home/urix/processavideo -i ~/video/${SGE_TASK_ID}.avi -o ~/risultati/output.$SGE_TASK_ID

Jobs

paralleli

Un job parallelo un lavoro svolto da pi nodi interconnessi attraverso un sistema di comunicazione e gestione, quali ad esempio MPI (Message Passing Interface) o Hadoop. Sge supporta nativamente i principali pacchetti MPI come openMPI e mpich2. Al momento Hadoop non ancora installato.

Sge supporta il concetto di ambiente, ovvero la predisposizione delle risorse necessarie per lavvio di lavori particolari (tipo lavvio di servizi server su richiesta).

Esempio: vogliamo eseguire un applicativo MPI usando da 5 a 10 slot. Lo script diventa:


#!/bin/sh #$ -pe mpi 5-10 /opt/openmpi/bin/mpirun -n $NSLOTS mpi-processavideo

Matlab
Matlab installato su tutti i nodi e pu essere utilizzato secondo differenti scenari.

Esecuzione di jobs indipendenti Utilizzo del Parallel Computing Toolbox

Matlab si trova installato in /opt/MATLAB/R2011a/

Matlab

jobs indipendenti

Lesecuzione di Matlab pu essere fatta come un semplice applicativo che procede ad eseguire codice seriale. Questo permette di riutilizzare in parte gli script visti nora. Sfrutta correttamente le risorse del cluster. E applicabile a problemi largamente parallelizzabili. E sufciente la conoscenza di Matlab standard. Necessita di programmare esplicitamente la divisione e lassemblaggio dei dati.

Si crea unistanza di Matlab per ogni slot che occupiamo. Ogni slot un core e quindi importante evitare qualsiasi comando di parallelizzazione esplicito da Matlab (matlabpool etc). Ogni istanza deve usare solo un core.

Matlab

jobs indipendenti

Esempio: vogliamo calcolare 1024 punti della funzione seno in [0 : 2*pi] Scrivo uno script Matlab che esegue la funzione e salva i dati su disco. File sin.m:
for i=1:1024 ! A(i) = sin(i*2*pi/1024); end save(A.mat); exit

Scrivo uno script bash per avviare il lavoro. File matlab_job.sh:


#!/bin/sh #$ -cwd /opt/MATLAB/R2011a/bin/matlab -nojvm -nodisplay -r sin

Inne sottometto il lavoro con qsub:


[urix@markone ~]$ qsub -o /dev/null -e /dev/null matlab_job.sh

Matlab

jobs indipendenti

Esempio: vogliamo calcolare 1024 punti della funzione seno in [0 : 2*pi] in parallelo. E conveniente sfruttare il meccanismo degli array job. Scrivo uno script Matlab che verr eseguita su ogni nodo che calcola una parte del range in base allindice del lavoro e salva i dati su disco. Assumo di usare 10 nodi. File sin.m:
job_id_string = getenv('SGE_TASK_ID'); job_id = str2double(job_id_string) - 1; range = (1024 / 10 * job_id - 1) : (1024 / 10 * job_id) for i = range ! A(i) = sin(i*2*pi/1024); end save(sprintf(A%d.mat, uint16(job_id)));

Scrivo uno script bash per avviare il lavoro. File matlab_job.sh:


#!/bin/sh #$ -cwd /opt/MATLAB/R2011a/bin/matlab -nojvm -nodisplay -r sin

Inne sottometto il lavoro con qsub:


[urix@markone ~]$ qsub -t 1-10:1 -o /dev/null -e /dev/null matlab_job.sh

Matlab

Parallel Computing Toolbox

Matlab supporta in modo nativo la sottomissione dei jobs e la ricezione dei risultati. Lutilizzo di Matlab in questa modalit si scontra con lutilizzo del job manager SGE. Ogni volta che viene richiesto un lavoro, Matlab deve richiedere lutilizzo di alcuni slot per tutta la durata della computazione.

E semplice da usare. C un overhead maggiore nel trasferimento dati. E necessaria la conoscenza del toolkit Parallel Computing. Si integra pi facilmente con lambiente Matlab. A volte nasconde insidie. (argh!)

Tutte le modalit che richiedono lutilizzo di matlabpool presentano forti svantaggi per la gestione dei jobs. Richiedono lutilizzo delle risorse richieste in maniera esclusiva, non permettendo il riutilizzo dei nodi liberi.

Matlab

Parallel Computing Toolbox

Listanza di Matlab principale sar il client dellinfrastruttura. Generalmente si esegue direttamente sul nodo master in modalit testuale ma nulla impedisce di utilizzare la modalit graca o addirittura di eseguirla sulla propria macchina locale.

Il client deve essere congurato con un prolo contenente i dati di collegamento.

La preparazione richiede linterfacciamento con SGE. Nel caso di utilizzo del nodo master, la procedura si limita ad importare il proprio prolo e a renderlo default. Nel caso di utilizzo della propria macchina, la procedura coinvolge uninstallazione pi lunga e una serie di accortezze per la copia dei dati e labilitazione della comunicazione via rete.

Si consiglia vivamente di utilizzare il nodo master come client.

Matlab

Parallel Computing Toolbox

La procedura pi adatta alla condivisione delle risorse la modalit batch. In maniera simile allutilizzo del cluster via script, si sottomette direttamente uno script da eseguire. Dietro la procedura semplicata, SGE carica unistanza di Matlab sulla prima macchina disponibile, esegue il lavoro ed inne avverte il client alla ne del lavoro.

Matlab

Parallel Computing Toolbox

Esempio: vogliamo calcolare 1024 punti della funzione seno in [0 : 2*pi] Scrivo uno script Matlab che esegue la funzione. File sin.m:
for i=1:1024 ! A(i) = sin(i*2*pi/1024); end

Assumendo di avere il prolo del cluster impostato, richiedo lesecuzione batch:


job = batch('sin')

Il comando batch non blocca la sessione del client, posso continuare ad eseguire altri comandi mentre aspetto il risultato. Posso anche aspettare con il comando:
wait(job)

Matlab
load(job, 'A'); plot(A);

Parallel Computing Toolbox

Al termine dellesecuzione del lavoro, posso caricare i risultati:

Ricordarsi di eliminare i dati del job:


destroy(job)

Matlab

Parallel Computing Toolbox

Esiste la possibilit di eseguire codice parallelo su pi nodi utilizzando listruzione parfor. Si richiede lutilizzo di matlabpool e quindi la riserva di un numero di istanze.

Matlab

Parallel Computing Toolbox

Esempio: vogliamo calcolare 1024 punti della funzione seno in [0 : 2*pi] in parallelo. Scrivo uno script Matlab che esegue la funzione. File sin.m:
parfor i=1:1024 ! A(i) = sin(i*2*pi/1024); end

Richiedo lesecuzione batch specicando il numero di istanze in pool richieste:


job = batch('sin', 'matlabpool', 3)

Esattamente come prima, aspetto lesecuzione del lavoro, plotto i risultati ed inne distruggo i dati del job.

wait(job); load(job, 'A'); plot(A); destroy(job);

Matlab

Parallel Computing Toolbox

La guida del Parallel Computing Toolbox include altre funzioni per la parallellizazione dellesecuzione quali le procedure SIMD. Unaltra funzione interessante la possibilit di allocare matrici distribuite. Anche queste funzionalit utilizzano il matlabpool e sono soggetti allallocazione esclusiva di risorse per tutto il tempo dellesecuzione del job.

La semplicit di Matlab rappresenta unastrazione di alto livello. E utile conoscere i dettagli del livello inferiore (SGE) in quanto capita di ritrovarsi con errori di allocazione di risorse.

In tal caso importante vericare i propri jobs e ripulire la coda da eventuali problemi.

Riferimenti

[1] PuTTY download page. http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html

[2] Penguinet http://www.siliconcircus.com/

[3] Parallel Computing Toolbox Users Guide http://www.mathworks.com/help/pdf_doc/distcomp/distcomp.pdf