Lucrare de Laborator NR 1.

Aplicaţia midlleware CONDOR

1 Obiectivele lucrări

1. Cunoaşterea suitei de aplicaţii CONDOR şi modul de folosire

2. Cunoaşterea modurilor de rulare a diverselor tipuri de aplicaţi în condor

2 Breviar teoretic

Condor este un sistem de management al încărcări. Condor seamănă cu sistemele de

tip consolă.
Condor asigură:
- mecanisme pentru cozii de joburi,
- politici de programare,
- scheme de prioritate,
- monitorizarea resurselor,
- managementul resurselor.

Avantaje:
1. La fel ca la sistemele consolă, utilizatorii trimit jobul lor (serial sau paralel) către
Condor, Condor îl va pune în coadă, va alege unde şi când să fie executat pe baza
politicilor stabilite, monitorizează progresul şi în final informează utilizatorul
despre terminarea procesului.
2. Un alt avantaj major al lui Condor este că oferă posibilitatea de a folosi cicli de
procesor nefolosiţi de la calculatoare. Condor poate fi configurat să folosească un
calculator când nu se înregistrează activitate de la tastară şi mouse o perioadă
configurabilă. În plus Condor are un mecanism care detectează reîncepere
activităţi pe un computer şi în cele mai multe cazuri reuşeşte să transfere jobul pe
alt calculator nefolosit. Pentru transferul de fişiere Condor nu necesită sistem de
partajare între calculatoare şi componenţă. Condor transmite de la calculator
înapoi la cel care a transmis jobul şi astfel Condor reuşeşte să combine toate
resursele de calcul într-o singură resursă.
3. Mecanismul ClassAd folosit de Condor asigură posibilitatea de a folosi
mecanisme care să specifice cerinţele jobului referitoare la resurse şi mecanisme
pentru oferirea resurselor. Descrierea unui job poate să conţină atât informaţii
despre necesarul resurselor cât şi despre preferinţe ale jobului. De asemenea sunt
mecanisme care să definească preferinţă şi disponibilităţi despre joburile care sunt
 rulate. Această opţiune face ca meta-schedulerul Condor să fie unul dorit în
sisteme Grid. Totuşi în colaborarea cu alte sisteme Grid, este posibilă doar prin
modificări ale codului Condor[ CITATION Col08 \l 1048 ].
Condor este produs de Condor Research Project din cadrul University of Wisconsin-
Madison (UW-Madison) şi prima sa instalare a fost în cadrul departamentului UW-Madison
Department of Computer Sciences. Actualmente în cadrul aceluiaşi departament gestionează
peste 1000 de calculatore cu o medie de 650 de zile de procesare pe zi şi a devenit un sisteme
folosit de mai multe instituţii guvernamentale şi academice.
În timp a apărut nevoia pentru o putere mare de calcul pentru o perioadă lungă de
timp. Un mediu care oferă acest lucru se numeşte High-Throughput Computing (HTC).
Condor este un astfel de mediu. Vechile sisteme aveau un cost ridicat şi achiziţionarea lor se
făcea în comuni de mai mulţi indivizi sau chiar grupuri de indivizi, dar acest fapt crea
neajunsuri. Cei care îl achiziţionase trebuie să îl folosească cu rândul pentru o perioadă de
timp limitată. Condor rezolvă această nemulţumire deoarece fiecare îşi achiziţionează
propriile sisteme pe care le foloseşte când doreşte şi toate celelalte sisteme libere.
Un alt avantaj este acela de a nu fi nevoit să rescrii codul de aplicaţii vechi pentru a
putea folosi această tehnologie.
Relincarea vechilor aplicaţii cu librăriile Condor capătă două proprietăţi noi:
- puncte de control,
- posibilitatea de a efectua apeluri de sistem la distanţă.
Punctul de control este un set complet de informaţii despre starea unui program. Un
program poate să fie reluat cu ajutorul unui punct de control. În cazul joburilor de durată
poate salva o perioadă de timp considerabilă. Condor salvează puncte de control periodic sau
în momentul în care maşina devine indisponibilă pentru continuarea execuţiei jobul. Jobul
poate fi continuat pe o altă maşină dar care trebuie să aibă aceeaşi arhitectură în cadrul
procesului denumit migrare.

Figura 1 Numărul de calculatoare Condor[ CITATION Con1 \l 1048 ]

 Securitatea maşinilor pe care se rulează la distanţă este foarte puţin afectată datorită
apelurilor de sistem la distanţă. Atunci când un job face un apel de sistem (funcţii I/O) sunt
transmise sistemului care a iniţiat jobul.
Condor poate fi instalat pe o mare varietate de platforme ca:
- Linux i386/IA64,
- Windows 2k/XP,
- MacOS,
- Solaris, IRIX,
- HP-UX,
- Compaq Tru64
- şi altele.
Condor poate fi folosit împreună cu alte tehnologii Grid cum ar fi:
- Globus: GT2,
- GT4,
- NorduGrid,
- UNICORE,
- Condor,
- PBS,
- LSF,
- EC2,
- NQS.
Se estimează că un sistem condor poate să crească până la aproximativ 1 milion de
noduri. Se doreşte creşterea la aproximativ 10 milioane.
Condor poate fi preferat faţă de alte tehnologi:
- datorită maturităţi,
- este printre puţinele tehnologi care oferă suport pentru Windows,
- simplu de folosit,
- scalabil şi flexibil,
- este gratis şi are o comunitate activă.
În Figura 1 este prezentată prezenţa Condor pe mapamond.

3 Desfăşurarea lucrări

Pe toate stațiile de lucru din laborator este instalat Condor. Pe fiecare calculator este
configurat să ruleze și sa accepte joburi, și joburile vor fi rulate instant. Atenție cu joburile
netestat pot bloca comunicația sau chiar calculatoarele.
Regăsiți condor în memoria calculatorului printr-o serie de executabile:
- condor_master: rulează continuu cu scopul de a supraveghea componentele
condor, dacă una din ele se blochează sau eșuează va fi restartată;
- condor_collector: este componentă a Condor central manager și se ocupă cu
colectarea informațiilor despre calculatoare, utilizatori și joburi rulate;
 - condor_negotiator: face parte din Condor central manger și decide unde sunt
rulate joburile;
- condor_startd: este prezent doar pe stațiile unde se pot rula joburi, și are ca rol
startarea joburilor și raportarea calculatorului către Condor central manager;
- condor_schedd: este prezent doar pe stațiile care au dreptul care adaugă joburi în
cluster;
- condor_shadow: câte o instanță a acestui program va fi generată pentru fiecare
job adăugat de pe acea stație.

3.1 Comenzi condor

3.2 condor_q
Comanda „condor_q” va afișa joburile adăugate de la stația curentă. Rezultatul va
conține următoarele câmpuri:
- id o perche de numere separate prin „.” Primul număr semnifică numărul clusterului
și al doilea numărul jobului;
- owner utilizatorul care a adăugat jobul;
- submitted data la care a fost adugăt;
- run_time timpul de rulare al jobului;
- st starea jobului care poate fi I sau R de la Idle sau Run;
- pri memoria consumată de job;
- cmd programul care se execută.

-- Submitter: Statia5 : <10.0.0.5:1032> : Statia5

ID OWNER SUBMITTED RUN_TIME ST PRI SIZE CMD

0 jobs; 0 idle, 0 running, 0 held

3.3 condor_status
Comanda „condor_status” va afișa toate stațiile din cluster. Rezultatul va conține
următoarele câmpuri:

- name numele stației, care poate fi limitat ca lungime;

- OpSys sistemul de operare, Ex Linux;
- Arch arhitectură staţie, Ex Intel;
- State starea stației, Ex Unclaimed=liber, Claimed=rulează un joc;
- Activity poate fi Idle sau Busy;
- LoadAv încărcarea medie a stației;
- Mem memoria calculatorului în megabiţi;
- ActvityTime de cât timp stația face activitatea curentă.
 Name OpSys Arch State Activity LoadAv Mem ActvtyTime

slot1@Statia2 WINNT51 INTEL Unclaimed Idle 0.000 507 0+05:05:07

slot2@Statia2 WINNT51 INTEL Unclaimed Idle 0.000 507 0+01:05:05
slot1@Statia4 WINNT51 INTEL Unclaimed Idle 0.000 507 0+01:00:04
slot2@Statia4 WINNT51 INTEL Unclaimed Idle 0.000 507 0+01:00:05
slot1@Statia5 WINNT51 INTEL Unclaimed Idle 0.010 507 0+01:45:05
slot2@Statia5 WINNT51 INTEL Unclaimed Idle 0.000 507 0+01:45:06
slot1@Statia7 WINNT51 INTEL Unclaimed Idle 0.000 507 3+05:05:56
slot2@Statia7 WINNT51 INTEL Unclaimed Idle 0.000 507 0+01:00:05
slot1@Statia8 WINNT51 INTEL Unclaimed Idle 0.000 507 0+06:05:09
slot2@Statia8 WINNT51 INTEL Unclaimed Idle 0.000 507 0+02:05:06
slot1@Statia9 WINNT51 INTEL Unclaimed Idle 0.000 507 0+06:00:12
slot2@Statia9 WINNT51 INTEL Unclaimed Idle 0.000 507 0+02:00:06
slot1@t209-statia3 WINNT51 INTEL Unclaimed Idle 0.000 507 0+02:00:04
slot2@t209-statia3 WINNT51 INTEL Unclaimed Idle 0.010 507 0+02:00:05

Total Owner Claimed Unclaimed Matched Preempting Backfill

INTEL/WINNT51 14 0 0 14 0 0 0

Total 14 0 0 14 0 0 0

3.4 Adăugarea unui job

Înainte de a adăuga un job avem nevoie de job. Să presupunem următorul program:

#include <stdio.h>
main(int argc, char **argv)
{
int sleep_time;
int input;
int failure;

if (argc != 3) {
printf("Usage: simple <sleep-time> <integer>\n");
failure = 1;
} else {
sleep_time = atoi(argv[1]);
input = atoi(argv[2]);

printf("Thinking really hard for %d seconds...\n", sleep_time);

sleep(sleep_time);
printf("We calculated: %d\n", input * 2);
failure = 0;
}
return failure;
}

Denumiți programul „simple.c” și compilați programul.

Pentru a adăuga jobul trebuie creat un fișier cu descrierea jobului în felul următor:
Universe = vanilla
Executable = simple.exe
Arguments = 4 10
Log = simple.log
Output = simple.out
Error = simple.error
should_transfer_files = YES
when_to_transfer_output = ON_EXIT
Queue

- Universe specifică universul de rulare, „vanilla” este cel standard mai târziu vom
întâlni și altele;
- Executable numele programului rulat;
- Arguments argumentele pentru programul dat anterior;
- Log nu este câmp obligatoriu, el specifică fișierul în Condor va scrie un log
despre actuala execuție
- Output specifică numele fișierului în care Condor va depune rezultatul;
- Error fișierul în care vor fi scrie eventualele erori;
- Should_transfer_files specifică dacă sunt sau nu transferate fișiere, necesar în cazul
în care nu se folosesc locații partajate în rețea;
- When_to_transffer_output când trebuie transferat conținutul ieșiri.

Adăugarea jobului se face cu comnada:

condor_submit submit
Submitting job(s).
Logging submit event(s).
1 job(s) submitted to cluster 4.

Vizualizarea stări jobului:

condor_q

-- Submitter: Statia5 : <10.0.0.5:1032> : Statia5

ID OWNER SUBMITTED RUN_TIME ST PRI SIZE CMD
4.0 Administrator 2/8 15:46 0+00:00:17 I 0 0.0 simple.exe 4 10

1 jobs; 1 idle, 0 running, 0 held

Fișier de log

Fișierul out

3.5 Adăugarea unui job parametrizat

Dacă folosim Condor pentru a adăuga câte un job cel mai probabil nu avem nevoie de
Condor.
Următorul exemplu prezintă un fișier care definește 3 joburi:
Universe = vanilla
Executable = simple
Arguments = 4 10
Log = simple.log
Output = simple.$(Process).out
Error = simple.$(Process).error
should_transfer_files = YES
when_to_transfer_output = ON_EXIT
Queue

Arguments = 4 11
Queue

Arguments = 4 12
Queue
Se poate observa prezența “$(Process)” care la momentul rulări va fi înlocuit „id-
ul„ jobului.
Fișierele de ieșire vor arăta de forma:
„simple.1.out, simple.2.out, ect…. „

3.6 Adăugare unui job Java

Folosirea programelor în Java este utilă în momentul în care avem un cluster format
din mai multe arhitecturi.
Paşii:
1. Se editează programul Java:

public class simple

{
public static void main(String[] args)
{
if (args.length != 2) {
System.out.println("Usage: simple.java <sleep-time>
<integer>");
}
Integer arg_sleep_time;
Integer arg_input;

arg_sleep_time = new Integer(args[0]);

arg_input = new Integer(args[1]);

int sleep_time;
int input;

sleep_time = arg_sleep_time.intValue();
input = arg_input.intValue();

try {
System.out.println("Thinking really hard for " + sleep_time + "
seconds...");
Thread.sleep(sleep_time * 1000);
System.out.println("We calculated: " + input * 2);
} catch (InterruptedException exception) {
;
}
return;
}
}

2. Se compilează programul:

javac simple.java

3. Fișierul de adăugare al jobului

Universe = java
Executable = simple.class
Arguments = simple 4 10
Log = simple.log
Output = simple.out
Error = simple.error
java_vm_args = -Xmx500m
should_transfer_files = YES
when_to_transfer_output = ON_EXIT
Queue

3.7 Adugarea unui job DAG

DAG este utilizat pentru a defini secvențe de joburi. Să considerăm exemplul din
figura 1.2:

Figura 1.2 Graf secvențe de joburi

În acest caz avem o serie de joburi în paralel dar avem și un job care pregătește date
pentru rulare și la sfârșit unul care le centralizează.
Pentru a putea alcătui un graf de rulare ca cel de mai sus mai întâi trebuie să avem
fișiere submit pentru fiecare job în parte.

job.setup.submit
job.work1.submit
job.work2.submit
job.finalize.submit
 Copiați fișierul de mai sus cu numele indicate. Fiecare fișier trebuie editat pentru a
schimba fișiere de ieșire și de eroare nu dorim ca el să își suprascrie rezultatul. Fișierul de log
va rămâne același.

Se poate crea fișierul Dag:

Job Setup job.setup.submit

Job Work1 job.work1.submit
Job Work2 job.work2.submit
Job Final job.finalize.submit

PARENT Setup CHILD Work1 Work2

PARENT Work1 Work2 CHILD Final

Denumiți fișierul “simple.dag”. Adăugați fișierul în Condor cu următoarea comandă:

condor_submit_dag simple.dag

Verificații periodic coada de joburi Condor pentru a observa ordinea de execuție.

Analizații cele 4 fișiere de ieșire și fișierul log.
Adițional veți mai găsi și fișierul de log DAG

simple.dag.dagman.out

4 Cerinţe

1. Testaţi toate programele şi toate tipurile de adăugare a joburilor în Condor;

2. Analizaţii fişiere de log şi cele cu rezultate;
3. Ştergeţi un job din listă;
4. Observaţi starea staţiilor în momente de timp când execută şi colegi voiştri
programe.