FUNDAMENTELE SISTEMELOR DISTRIBUITE

REFERAT

STUDENT: MOSOI STEFAN

 Cuprins

1. Exclude Mutuala - MCS Lock ….............................................................................3

1.1 Prezentare Algoritm …................................................................................................…....................3
1.2 Pseudocod...........................................................................................................................................4
1.3 Cod OpenMP ….................................................................................................................................5
1.4 Bibliografie........................................................................................................................................7

2. Comunicare All-To-All In sistemele ierarhice...............................................................8

2.1 Prezentare Algoritm.....................................................................................................8
2.2 Pseudocod....................................................................................................................9
2.3 Bibilografie..................................................................................................................9

3. Echilibrarea incarcari – Dimension Exchange …........................................................10

2.1 Prezenatarea algoritmului..................................................................................................................10
2.2 Pseudocod..........................................................................................................................................11
2.3 Bibliografie........................................................................................................................................12
 1.Exclude Mutuala - MCS Lock

1.1Prezentare Algoritm

Mellor-Crummey si Scott au inventat inchidrerea MCS care are urmatoarele caracteristici:

 garanteaza ordonarea FIFO a achizitionarilor de blocari. FIFO garanteaza non-lockout care implica
fara deadlock.
 Se foloseste doar de variabile de flag locale. Acest lucru va imbunatatii performanta fata de
algoritmii care se folosesc de variabile acesibile global
 are nevoie doar de un spatiu mic si constant pentru blocare
 e rapid, necesitand doar O(1) transactii in retea pe blocare.

Definim o data de pastrare qnode astfel:

qnode {
next: * qnode;
locked: Boolean
}
De asemenea definim tipul lock = * qnode;

In sistemele bazate pe asteptare, este de dorit ca procesorul pi sa se foloseasca de memorie partajata

locala.
Algoritmul este bazat pe doua operatii atomice:
1. PreiaSiPastreasa - functia inlocuieste valoare pointerului global cu qnode-ul local si intoarce
valoarea veche a lock-ului
2. ComparaSiInterschimba - il compara pe primul cu al doilea si daca sunt la fel inlocuieste prima
cu a treia si intoarce true altfel intoarce false

Un procesor pi cand incearca sa intre in sectiunea critica , se foloseste de Preia_Si_Pastreaza pentru a

face ca lock-ul L (global) sa arate catre qnode-ul lui (l), si salveaza qnode-ul pointat anterior de L in variabila
locala predecesor. Daca un predecesor chiar exista, dupa ce se blocheaza pe el insusi si facand ca next-ul
predecesorului sa arate catre qnode-ul sau, incepe sa se astepte pana cand predecesorul semnaleaza iesirea din
zona critica. Daca nu exista predecesor sau primeste semnal intra in sectiunea critica.
Din moment ce numai predecesorul direct poate semnala un proces de blocare, este clar ca algoritmul
asigura proprietatea FIFO. Este de asemenea clar ca algoritmul este rapid deorece achizitionarea lock-ului este
un numar constant de tranzactii.
In partea de iesire, procesorul care iese din sectiunea critica, mai intai verifica existenta urmatorului
qnode. Daca exista unu, ii este semnalat sa se opreasca din asteptare. Altfel, procesorul care iese din lock,
verifica daca a fost apelata Preia_SI_Pastreaza de alt procesor. Daca da, in care caz ComparaSiInterschimba
intoarce vechea valoare al lui L, procesorul va astepta ca alt procesor sa il aiba setat ca urmator care este folosit
ca sa deblocheze urmatorul procesor.
1.2 PseudoCod
1. PreiaSiPastreasa:
 are 2 argumente
 primul este pointer la lock in memoria partajata globala
 al doilea este qnode-ul local

Pseudocod:
PreiaSiPastreaza(A: adresa memorie, B: adresa memorie)
temp:=A
A:=B
return (temp)

2.ComparaSiInterschimba:

Pseudocod:
ComparaSiInterschimba(A: adresa memore,B: adresa memorie,C:adresa memorie)
temp:=A;
daca Temp=B atunci
A:=C
return true
return false
3. Algoritm

<Intrare>
I->next:=nil
predecesor:=preiaSiPastreaza(L,I);
daca predecesor!=nil
I->locked=true
predecesor->next=I;
wait until I->locked=false;
<Sectiunea Critica>
<Exit>
if I->next=nil
then
if ComparaSiInterschimba(L,i,nil)
goto <Remainder>
wait until I->next!=nil
I->next->locked=false;
<Remainder>
 1.3 Progam OpenMP

#include <stdio.h>
#include <omp.h>
#include <unistd.h>
#include <stdlib.h>

typedef struct qnode{

struct qnode *next;
int locked;
}qnode;

struct qnode *preia_Si_Pastreaza(struct qnode* A,struct qnode* B){

struct qnode *temp;

temp=A;
A=B;

return temp;
}

int ComparaSiInterschimba(struct qnode *A,struct qnode *B,struct qnode *C){

struct qnode *temp=A;
if (&temp==&B){
A=C;
return 1;
}
return 0;
}

int main(void) {
struct qnode *L=NULL;
int procs=0;
#pragma omp parallel num_threads(4) shared(L,procs)
{
struct qnode *I=(struct qnode*)malloc(sizeof(struct qnode*));
I->next=NULL;
struct qnode *predecesor=NULL;
//preia si pastreaza
predecesor=L;
L=I;
//verificare lock
if (predecesor!=NULL){
I->locked=1;
predecesor->next=I;
int i=0;
while (I->locked==1){sleep(1);i++;}
}
 //intrare in sectiunea critica
int i;
for (i=0;i<5;i++){
sleep(1);
}
if (I->next==NULL){
//compara si Interschimba
int result=0;
if (L==I){
L=NULL;
result=0;
} else {
result=1;
}
if (result==1){
while (I->next==NULL){
sleep(1);
}
}
}
if (I->next!=NULL){
I->next->locked=0;
}
}
return 0;
}
 1.4 Bibliografie

[1]http://www.comp.nus.edu.sg/~andrews/
[2]John M. Mellor-Crummey and Michael L. Scott. Algorithms for scalable
synchronization on shared-memory multiprocessors. ACM Transactions on
Computer Systems, 9(1):21–65, February 1991.
 2. Comunicare All-To-All Clusterizat In Sistemele Ierarhice

2.1 Prezentare Algoritm

Fie:
 N numarul de noduri de procesoare
 G graful complet de N noduri
 GA subgraful indus de un subset de noduri A
 GiA al i-lea 1-factor al lui GA
 U si V pentru noduri de procesoare
 u si v pentru procesoare individuale
 size(U) numarul de procesoare in nodul U
 l(u) indexul local al procesorului u, cu 0< l(u) < size(U)

Pentru a specifica ar trebui schimbate cand doua noduri U si V sunt grupate impunem o
ordonare cum urmeaza:
U ← V daca size(U)<size(V), sau size(U)=size(V) & U≤V
unde U ≤ V se refera la o ordine arbitrara a nodurilor.

Prima recursie parcurge numarul de faze, fiecare considerand 1-factorizare a setului de noduri
active A care nu schimbat inca mesajele. A doua recursie parcurge toti 1-factorii G iA al lui GA . Recursia
paralela considera toate perechile (U,V) care sunt vecini in 1-factorul dat. Ordonare U ← V este
folosita pentru descrie convenabil schimbul intre procesoarele de pe nodul U si procesoarele de pe
nodul V necesare pentru a stabili invariatia de pe cea prima recursie dupa ce 'done' a fost marit la
'current'. Cand U=V, schimbul bidirectional este inlocuit de o trimitere unidirectionala, deoarece alfel
mesajele intre noduri ar fi trimise de doua ori. Trimiterea unui mesaj m uv de la u la v inseamna copierea
muv din bufferul sursa in bufferul destinatie al lui u.
Algoritmul All-To-All clusterizat afectueaza un schimb All-To-All personalizat intr-un numar
de pasi egal cu numarul maxim de mesaje pe care procesoarele dintr-un nod trebuie sa le trimita.
Fie 0 = S0 < S1 < … < Sk o secventa de dimensiuni diferite de noduri. Algoritmul fa executa k
faze. In faza i nodurile U cu dimensiunea size(U)≥Si sunt active. In particular, prima recursie se
termina. Si mai mult, la sfarsitul algoritmului done = max UЄ {0,..,N-1}size(U) . Recursia invarianta implica
ca toate mesajele au fost transmise. Limita in numarul de pasi este implicita deoarece toate nodurile cu
numarul maxim de procesoare participa in comunicatie in fiecare pas si deoarece nici un mesaj nu e
trimis de doua ori.
Motivul pentru care algoritmul nu este optimal in anumite cazuri este ca un nod grupat cu el
insusi comunica unidirectional cu el insusi in fiecare pas. Daca la acelasi pas alte doua noduri cu numar
maxim de procesoare sunt grupate , ele comunica bidirectional si atunci ia mai mult timp sa completeze
runda. Aceasta nu este optimala cel putin in cateva cazuri sunt planuri care evita aceste situati. Totusi
sunt putini pasi ineficienti: Consideram un nod U cu un numar maxim n=size(U) de
procesoare.Algoritmul face pn pasi. Cel mult n 2 din acesti pasi – o fractiune din p/n – pot fi ineficienti
pentru nodul U. Deci un numar mic de pasi sunt ineficienti pentru nodul N deoarece p >> n.
 2.2 Pseudocod

A ← {0,...,N-1}
done ← 0
while A ≠ Ø do
loop invariant: oricare ar fi (U,V) Є G : oricare ar fi u Є U, v Є V:
(U ← V & 0 ≤ l(u) < done) => muv si mvu au fost transmise
current ← min{size(U)| U Є A}
for i= 0,...,|A|-1 do
for all (U,V) Є GiA where U ← V pardo
for each u Є U , done ≤ l(u) <current do
for each v Є V do
if U=V then send muv de la u la v
else exchange muv si mvu intre u si v
done ← current
A ← A\{U| size(U)=done}

2.3 Bibilografie

[1]http://algo2.iti.kit.edu/sanders/papers/europar2.ps.gz
 2. Echilibrarea incarcari – Generalised Dimension Exchange

2.1Prezentare Algoritm

Aceasta metode de echilibrare a incarcarii a fost initial studiata pentru hipercuburi unde vecinii
procesorului sunt inspectati prin urmarea fiecarii dimensiuni ale hipercubului. De aici numele de
“dimension exchange”. O generalizare a acestui algoritm pentru topologii oarecare numita Generalised
Dimension Exchange a fost introdusa mai tarziu. Aceasta se bazeaza pe tehnica colorarii marginilor
pentru a afla numarul de dimensiuni si dimensiunea asociata fiecarei legaturi. Legaturile intre noduri
invecinate sunt minimal colorate astfel incat nici un nod nu are doua legaturi de aceeasi culoare. De aici
rezulta ca o dimensiune este definita ca toate legaturile de aceeasi culoare. La fiecare iteratie , o
anumita colorare este aleasa , si numai procesoarele cu legaturi de acea culoare executa procedura de
schimb. Acest lucru este repetat pana cand echilibrarea este atinsa.

Un algoritm de colorare a grafului este necesar pentru definira subpasilor. Setul de margini E
este impartit in c seturi disjuncte Ei astfel incat E=E1U....UEC si pentru orice pereche de muchii incidente
la un nod comun ele sunt in seturi diferite Ei si Ej .
Colorarea marginilor lui G induce subrafuri Gi= (V,Ei). Matricile de difuzie si Laplace ale
acestor subgrafuri sunt notate cu Mi si Li . Inainte sa definim algoritmi de schimb de dimensiune
treubuie mai intai sa introducem niste notaii:
MDE=Mc...M1
LDE=1/α(I - MDE)
Aici DE indica schimb de dimensiune. Multiplicarea lui MDE cu un vector de incarcari w
inseamna precis ca subpasii c sunt aplicati lui w si cea mai recenta informatie este folosita pentru
fiecare sub pas. In plus vom avea nevoie de valorile proprii μDE si λDE ale matricilor MDE si LDE.
De asemena vom avea nevoie si de matricele de incidenta A={-1,0,1}nxN ale lui Gi . In contrasc
cu definitia usuala a matricii de incidenta nu stergem coloanele care nu sunt colorate cu culoarea I din
A, dar inlocuim -1 si 1 din aceste coloane cu 0.
3.2 Pseudocod

for k = 1 ,... , m – 1 do
ŵ 0 = wk-1
for j=1, … , c do { loop over the colours}
ŵj = Mjŵ j-1
x=x + (1/ λDEk+1)*ATj ŵj-1
end for
wk = (1 - 1/ α λDEk+1)*wk-1+ (1/ α λDEk+1)* ŵc
end for

ŵ0 =w0 , x'j = 0
for j=1,...,c do {loop peste culort}
ŵj = Mjŵ j-1 ; x'j = x'j +α ATj ŵ j-1 ;
end for
w1= 1/γ1*[α1w0-ŵc];x1= -1/γ1*x'c
for k=2,...m-1 do
ŵ0 = w k-1; x'0=xk-1;
for j=1, … , c do
ŵj = Mjŵ j-1 ; x'j = x'j +α ATj ŵ j-1 ;
end for
wk=1/γ1*[αkwk-i-ŵc -βkwk-2]
xk=1/γ1*[αkxk-i-x'c -βkwk-2]
end for
 3.3Bibliografie

[1]http://www.tesisenxarxa.net/TESIS_UAB/AVAILABLE/TDX-0331108-105123//acf1de2.pdf
[2]Holger Arndt Load Balancing: Dimension Exchange on Product Graphs, November 2003