Complexitatea algoritmilor paraleli

intrare

ieire

Mai simplu de calculat pentru arhitecturi sincrone (SIMD)

Exemplu: Sortarea pe un vector de procesoare

Functionare: are doua faze

In fiecare pas al primei faze, fiecare procesor realizeaz
urmtoarele operaii:
1) accept o valoare de la vecinul din stnga;
2) compar valoarea cu cea memorata local;
3) transmite valoarea mai mare vecinului din dreapta;
4) memoreaz local valoarea mai mic.
 Pasii algoritmului de sortare
30512 iniial

3051 dup pasul 1

2

305 2 dup pasul 2

1

30 5
dup pasul 3
1 2

0 1 2 3 5 dup pasul 9

Pentru N valori, faza 1 dureaza 2N-1 pasi

 Faza a doua
variante:
1. fiecare procesor ncepe s transmit spre stnga, imediat ce
numerele sunt sortate;
2. cunoscnd poziia sa din vector i numrnd valorile inspectate,
fiecare procesor calculeaz momentul cnd ncepe s transmit spre
stnga;
3. procesorul din dreapta ncepe s transmit spre stnga imediat ce
primete o valoare; toate celelalte ncep s transmit spre stnga
imediat ce primesc o valoare dinspre dreapta;
4. fiecare procesor ncepe s transmit spre stnga imediat ce nu mai
primete o valoare dinspre stnga.
complexitate ambele faze
metoda 3 => 4N-3 pasi
metoda 4 => 3N-1 pasi
 Metoda 4 faza 2

0 1 2 3 5 sfarsit faza 1

0 un pas - procesoarele observa

1 2 3 5 ca nu mai primesc din stanga
si transmit in stanga

1 2 3 5 un pas valoarea din dreapta

trece la iesirea din stanga

2 3 5

3 5

5
 Msuri de performana
T timpul total necesar execuiei algoritmului paralel
P numarul de procesoare utilizate
In algoritmul prezentat, P = N i T = O(N).
G timpul de execuie al celui mai rapid algoritm secvenial
Pentru algoritmul secvential de ordonare,
G= O(N log N)
accelerarea S (speedup)
S = G/T
In algoritmul precedent,
S= O(N log N)/ O(N) = O(log N).
Ideal = accelerarea liniara S = O(P)
Exemplu cautarea unei valori intr-un sir de numere
 se poate mereu?
sectiuni secventiale Legea lui Amdahl
procentajul f din totalul calculelor trebuie s se desfoare
secvenial
T = f * G + (1-f) * G / P
rezulta
S = G/T = 1 / (f + (1-f) / P)
costul C = T*P
in exemplu - C = O(N2).

eficiena E = G/C
este costul secvential / costul paralel
E = G/C = G/(TP) = S/P
in exemplu - E = O((log N)/N).
 Modelul work-depth - al grafurilor orientate aciclice
Model de graf
fiecare intrare este reprezentata ca un nod fr arce de intrare
fiecare operatie este reprezentat ca un nod ale crui arce de intrare
provin de la nodurile care reprezint operanzii
o ieire este reprezentat ca un nod fr arce de ieire.
a[1]

a[2] +

a[3]
+ +
a[4]

a[5] +
+
a[6] +

a[7]
+
In figura: modelul de
a[8]
insumare a 8 numere
 Modelul este independent de orice arhitectur i orice numr
concret de procesoare.
Pune n eviden:
lucrul efectuat de algoritm (numrul total de operaii)
adncimea (lungimea celui mai lung lan de dependene secveniale
din algoritm).
grad paralelism = lucru / adncime

a[1]

a[2] +
Exemplu: a[3]
+
schema de insumarea a n numere a[4]
+

lucrul = n a[5] +
+
adancimea = log n a[6] +
grad paralelism = n / log n a[7]
+
a[8]
 Suma elementelor unui tablou
runda h=1 h=2 h=3
a[1] b[1] b[1] b[1] b[1] s

a[2] b[2] b[2] b[2]

a[3] b[3] b[3]

a[4] b[4] b[4]

a[5] b[5]
Schema de executie
a[6] b[6] - copiaza datele in variabila de lucru b
- in fiecare pas h, lucreaza primele n/2h
a[7] b[7] procese
- procesul i aduna in b[i] valorile din
a[8] b[8] b[2*i-1] si b[2*i]
 Calculul complexitii pe descrierea pseudocod

real a[1:n], b[1:n]; /* presupunem n = 2k */

real s;
process suma [i = 1 to n]{
b[i] = a[i]; /* n operatii paralele, in 1 pas */
for [h = 1 to log n] /* sunt log n pasi */
if (i <= n/2h) /* in pas h se fac in paralel n/2h ops. */
b[i] = b[2*i-1] + b[2*i];
if (i==1) s = b[1]; /* o operatie in 1 pas */
}

T(n) = 1 + log n + 1 = O(log n)

W(n) = n + h = 1, log n n/2h + 1 = n + (n/2 +n/4 +...+1) +1 = O(n).
 Principiul de planificare pentru PRAM
Calculul timpului de executie al algoritmului paralel reflecta
natura paralela a solutiei
presupune ca sunt disponibile oricate procesoare sunt necesare
Cum se calculeaza timpul de executie daca sunt disponibile mai
putine procesoare decat ar avea nevoie algoritmul?

Teorema lui Brent ne da limita superioara

Pentru un algoritm paralel care ruleaza n T(n) uniti de timp, executnd
W(n) operaii, se poate obine o adaptare a algoritmului care s ruleze
pe p procesoare PRAM n cel mult inf(W(n)/p) + T(n) uniti de timp
Justificare
Fie Wi(n) numrul de operaii executate n unitatea i de timp.
Deoarece sunt p procesoare, Wi(n) operaii se execut n Wi(n)/p pai.
Numarul total de pasi (pentru p procesoare)

i=1,T(n) sup(Wi(n)/p) <= i=1,T(n) (inf(Wi(n)/p) + 1) <= inf(W(n)/p) + T(n)

 Exemplu demonstrativ teorema lui Brent
Algoritmul de insumare executat de p procesoare
presupunem p = 2q si n = 2k si p <= n

Copierea tabloului A in B, daca oricate procesoare sunt disponibile

for [i = 1 to n] B[i] = A[i];

Pentru p procesoare:
fiecare procesor s executa secvential l = n/p operatii de copiere,
a valorilor incepand cu pozitia l*(s-1)+1
primele s-1 procesoare copiaza l*(s-1) valori

procesorul s executa (secvential):

for [j = l*(s-1)+1 to l*(s-1)+l] B[j] = A[j];
 Executia operatiilor pe p procesoare (2)
Insumarea valorilor, daca oricate procesoare sunt disponibile
La fiecare iteratie h, se fac in paralel n/2h operatii (una per procesor)
for [h = 1 to log n]
if (i <= n/2h) b[i] = b[2*i-1] + b[2*i];
Pentru p procesoare:
Daca nr operatii >= nr procesoare
adica n/2h >= p
sau 2k-h >= 2q
sau k-h >= q
atunci cele n/2h operatii se impart egal la p = 2q procesoare,
fiecare executand
n/2h/p = 2k-h-q operatii
procesorul s actualizeaza elementele
de la 2k-h-q(s-1) + 1 la 2k-h-q s
Altfel, doar o parte a procesoarelor executa cate o operatie
real A[1:n], B[1:n]; /* n = 2k si p = 2q */
real S; int l = n/p; O(n/p)
process suma [s = 1 to p]{
for [j = l*(s-1)+1 to l*(s-1)+l] B[j] = A[j];
for [h = 1 to log n]{
if (k-h >= q) /*nr op >= nr proc */ In iteraia h, un
for [j = 2 k-h-q*(s-1) + 1 to 2 k-h-q *s] proces ia sup(n/2h/p)
B[j] = B[2*j-1] + B[2*j]; = sup(n/(2hp))
else
o unitate de timp
if (s <= 2 ) B[s] = B[2*s-1] + B[2*s];
k-h

}
if (s = =1) S = B[1];
}
n/p + h=1, log n sup(n/(2hp)) + 1
<= n/p + h=1, log n (inf(n/(2hp)) + 1) + 1
<= n/p + n/ph=1, log n inf(1/(2h)) + log n + 1
<= n/p + n/p + log n + 1
rezulta: Tp(n) = O(n/p + log n) = W(n)/p + T(n)