Complexitatea algoritmilor

p
paraleli
Ciprian Dobre
ciprian dobre@cs pub ro
ciprian.dobre@cs.pub.ro

Complexitatea algoritmilor paraleli

Ct de mult paralelism exist ntr-o aplicaie?

Depinde
Performana
P f
funcie
f
i d
de:

Timp de execuie
Memorie ocupat
N d
Nr.
de procesoare
Scalabilitate
Eficien
Fiabilitate
Toleran la defecte
Portabilitate
Costuri

Exemplu: sortarea pe un vector de procesoare

Sortarea pe un vector de procesoare

intrare
ieire
Fi
Fiecare procesor are o memorie
i llocal
l ii propriul
i l su

program
Funcionare sistolic
Un ceas global comand execuia simultan a operaiilor
Fiecare procesor realizeaz la fiecare pas:
Recepia
R
i unor date
d t de
d la
l vecini
i i
Inspecia memoriei locale
Execuia
calculelor specificate
p
de program
p g
Modificarea memoriei locale
Transmiterea unor date ctre vecini

Sortarea pe un vector de procesoare

intrare
ieire
Vector de N procesoare
2 faze
n
fiecare pas al primei faze, fiecare procesor realizeaz
urmtoarele operaii:
1) accept o valoare de la vecinul din stnga;
2) compar valoarea cu cea memorat local;
p ;
3)) transmite valoarea mai mare vecinului din dreapta;
4) memoreaz local valoarea mai mic.

Paii algoritmului de sortare

30512

iniial

3 0 5 12
3 0 51

pasul 1
pasul 2

2
comparatie

305

pasul 3

comparatie

30

1
comparatie

2
comparatie

pasul 4

Paii algoritmului de sortare

Dup pasul 9:
0

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

Faza a doua

Valorile ordonate sunt scoase p

prin celula din stnga
g

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 procesorull di
3.
din d
dreapta
t ncepe s
ttransmit
it spre stnga
t
imediat
i di t ce
primete o valoare; toate celelalte ncep s transmit spre stnga
imediat ce primesc o valoare din dreapta;
4. fiecare procesor ncepe s transmit spre stnga imediat ce nu mai
primete o valoare dinspre stnga.

Complexitate:
e oda 3 => 4N-3
3 pas
pasi
metoda
metoda 4 => 3N-1 pasi

Variantele 1 i 2 impun cunoaterea:

-Pozitiei
P iti i procesoarelor
l in
i vector
t !!!
-Contorizarea valorilor !!!

Msuri de performan

Timpul total T necesar execuiei

Numrul de procesoare utilizate P
n algoritmul prezentat
prezentat, P = N i T = O(N).
O(N)
Acceleraia S (speedup)
S = G/T
unde
G este timpul de execuie al celui mai rapid algoritm
secvenial
n algoritmul precedent,
S= O(N log N)/ O(N) = O(log N).

Msuri de performan

Acceleraia liniar
Exemplu ???

S = O(P)

Ideal ar fi ca algoritmul paralel

s se execute de P ori mai rapid dect
cel mai bun algoritm secvenial

Cea mai bun valoare a acceleraiei ce se poate

ob e
obine
Justificare:
program
g
se p
poate executa n T p
pai
pe
p P
Dac un p
procesoare, putem oricnd s rulm respectivul
algoritm n mod secvenial n TP pai
G <= TP

S <= P

Msuri de performan (2)

Se poate obine mereu acceleraie liniar ?

Topologia sistemului impune uneori restricii de timp (ex: liniar O(N),
arbore O(logN))
Seciuni secveniale Legea lui Amdahl
Presupunnd c procentul f din totalul calculelor trebuie s se
desfoare secvenial
T = f * G + (1
(1-f)
f) * G / P
=>
S = 1 / (f + (1-f) / P)
=>
>
S <= 1/f
=> Un program paralel nu va rula mai repede dect suma poriunilor
sale secveniale,
secveniale indiferent de nr.
nr de procesoare pe care se execut

T >= f * G

Msuri de performana (3)

the effort expended on achieving high parallel

processing rates is wasted unless it is accompanied by
achievements
hi
in
i sequential
i l processing
i rates off very
nearly the same magnitude. Amdhal, 1967
speedup should be measured by scaling the
problem to the number of processors,
processors not by fixing the
problem size. Gustafson, 1988

Msuri de performan (4)

Costul C = T*P
n exemplu - C = O(N2)
Caracterizeaz ineficiena datorat nefolosirii complete a
procesoarelor
Eficiena E = G/C
E = G/C = G/(TP) = S/P
n exemplu - E = O((log N)/N)
Scalabilitatea
msur a accelerrii date de adugarea mai multor
procesoare

Calculul detaliat al complexitii

P
Paralelizarea
l li
se fface pentru
t atingerea
ti
unuii
timp de execuie ct mai redus
Cum putem ti dac un algoritm paralel este
optim sau nu?
Rspunsul depinde de modelul de
evaluare adoptat
n algoritmul anterior pasul algoritmului
reprezenta o operaie asupra unor cuvinte

Calculul detaliat al complexitii

Trecere la modelul "bit"

Fiecare procesor opereaz pe 1 bit
Operaia principal compararea a dou numere "s" i "d"
Topologie arborescent

msb 0 0

pas 1
=

0 0

1 0

lsb 0 1
s d

pas 2

pas 3

=
s
s

Calculul detaliat al complexitii

pas 1
msb 0 0
0 0

pas 2

pas 3

s
s

s
s

1 0

lsb 0 1
s d

comparaia
i tterminat
i t iin 2*l
2*log k paii
2k-1 procesoare

Calculul detaliat al complexitii

Algoritmul de sortare devine:

Intrare

I i
Ieire
Reea de (2k-1)*N
(2k 1) N procesoare
Test: Ci pai sunt necesari n aceast abordare pentru
faza 1?
(2N-1)*2*logK pai pt. faza 1

Abordare pipeline
Algoritm mai bun de comparare
Tablou liniar de k procesoare pe bit
n timp ce un procesor compar o pereche de bii a dou numere
succesive, procesorul de sub el lucreaz cu biii mai puin
semnificativi ai perechii de numere anterioare
La fiecare p
pas,, un procesor
p
p
primete
la intrare un bit,, iar de la
procesorul de deasupra o informaie
f
asupra comparaiei fcute
f
de
el la pasul anterior:
s dac numrul de la intrare este mai mare
d dac numrul memorat este mai mare
= - dac cele dou numere sunt egale
Dac primete s, procesorul transmite bitul de la intrare la ieire
i transmite s n jos
Dac primete d, procesorul transmite bitul memorat la ieire i
transmite d n jos
Dac primete =, transmite bitul mai mare la ieire, memoreaz
bitul mai mic i transmite n jos s, d, sau = n mod corespunztor

Abordare pipeline
3 0 5 1 2

<- iniial

-------------------------------------------------------------------------------------------------------------------------

0 0 1 0 0 [ ]
/ / / / /
1 0 0 0 1
[ ]
/ / / / /
1 0 1 1 0
[ ]
iniial

<-msb

0 [0] -> 0 1 0
=
/
1 0 [0] -> 0 1
/
s
/
1 0 1 [1] -> 0
dup pasul 4
/

<-lsb

--------------------------------------------------------------------------------------------------------------------------

0 0 1 0 [0]
/ / / /
1 0 0 0 1 [ ]
/ / / /
1 0 1 1 0
[ ]
dup pasul 1

[0] -> 0 0 1 0
=
/ /
1 [0] -> 0 0 1
=
/ /
1 0 [1] -> 1 0
dup pasul 5

Complexitate:
(k-1)+(2N-1) pai faza 1

-------------------------------------------------------------------------------------------------------------------------

0 0 1 [0] -> 0
/ / /
=
1 0 0 0 [1]
/ / /
1 0 1 1 0 [ ]
dup pasul 2

[0] ->

0 0 1 0
/ / /
[0] -> 1 0 0 1
s
/ / /
1 [0] -> 1 1 0
dup pasul 6

-------------------------------------------------------------------------------------------------------------------------

0 0 [0] -> 1 0
/ /
s
1 0 0 [0] -> 1
/ /
d
1 0 1 1 [0]
dup pasul 3

[0] ->

0 0 1 0
/ / / /
[0] ->
1 0 0 1
/ / / /
[0] -> 1 1 1 0
dup pasul 7

-------------------------------------------------------------------------------------------------------------------------

rezultat ->

3 1 5 2

Limite inferioare

Lrgimea benzii pentru introducerea datelor

ex: N numere se introduc n N pai
Diametrul reelei distana maxim ntre oricare dou
noduri
ex: pentru un grid de k*N
k N noduri, diametrul este N
N+k-2
k2
Lrgimea biseciei reelei numrul minim de legturi care
t b i ndeprtate
trebuie
d t t pentru
t a mpri
i reeaua

n dou
d
subreele separate, avnd acelai numr de noduri
interschimbarea datelor
ex: k*N/2 bii "trec" prin bisecia de lrgime k n minim N/2
pai

Limite inferioare (2)

procesorul rdcin are log N
celule
procesoare
intermediare

0
0
0
1
1

0
1
0
1
5

1
0
0
1
9

1
1
1
0
14

Diametrul reelei este 2*log N + 2*K - 2

Lrgimea benzii de intrare a datelor este K*N
Lrgimea biseciei este 1,
1 dac log N = 1 i 2 n celelalte cazuri
Sortare in O(KN) pai
dar, pentru K =1 exist algoritmi in O(log N)

procesoare
frunza cu
cte K
celule

Modele generale

Analiza complexitii algoritmilor presupune folosirea unui

model formal:
particulare ((ex: SIMD cu memorie locala))
p
abstracte:
Modele orientate spre categorii de maini paralele:
Maini cu memorie locala
Maini cu memorie modulara
Maini PRAM

Modele orientate spre algoritmi:

Modelul grafurilor orientate aciclice (work depth)

Modelul grafurilor orientate aciclice

M d ld
Model
de graff ((work
kd
depth)
th)
fiecare intrare este reprezentat ca un nod fr arce de intrare
fiecare operaie
p este reprezentat
p
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]
a[8]

+
+
+
+

+
+
+

Modelul grafurilor orientate aciclice (2)

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).
paralelismul algoritmului
=> lucru / adncime
nsumarea a n numere
lucrul = n
n-1
1
adncimea = log n

Calculul complexitii
var a, b: array [1:n] of real;/* pp n = 2k */
var
ar s: real;
l
fa i := 1 to n do in parallel b[i] := a[i] af;
fa h :=
: 1 to log n do
fa i := 1 to n/2h do in parallel
b[i] := b[2*i-1] + b[2*i]
af
af;
s := b[1];
T(n)) = 1 + log
T(
l n + 1 = O(l
O(log n))
W(n) = n + h = 1, log n n/2h + 1 = O(n)

Principiul de planificare pentru PRAM

Teorema lui Brent
Pentru un algoritm care ruleaz n T(n) uniti de timp
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
p

Justificare
Fie Wi(n) numrul de operaii executate n unitatea i de timp.
Pentru
P t fiecare
fi
i 1 <= i <= T(
i,
T(n),
) Wi(n)
( ) operaii
ii se execut
t n Wi(n)/p
( )/
pai paraleli, pe cele p procesoare.
numrul de pai paraleli:
i sup(Wi(n)/p) <= i (inf(Wi(n)/p) + 1) <= inf(W(n)/p) + T(n)

Exemplu
algoritm de nsumare executat de p procesoare PRAM
p = 2q <= n = 2k

Principiul de planificare pentru PRAM (2)

var A, B: array [1:n] of real;
/* n = 2k si p = 2q */
var S: real; l: int := n/p;
fa s := 1 to p do in parallel
fa j := 1 to l -> B[l*(s-1)+j] := A[l*(s-1)+j] af;
fa h := 1 to log n ->
if k-h-q >= 0 ->
fa j := 2k-h-q(s-1) + 1 to 2k-h-q s ->
B[j] := B[2*j-1] + B[2*j]
af
[] k-h-q < 0 ->
if s <= 2k-h -> B[s] := B[2*s-1] + B[2*s]
fi
fi
af
if s = 1 -> S := B[1] fi
af;

Cerine pentru algoritmi PRAM eficieni

P < n (dimensiunea
(di
i
problemei),
bl
i) P adaptiv
d ti
(dependent de dimensiunea problemei)
Ex: P(n) funcie subliniar de n rdcina
ptrat de n
Tp(n) mic, adaptiv, invers proporional cu P
C minim

Implementare pentru reele de procesoare

Topologie hipercub:
p = 2d procesoare,
procesoare
indexate de la 0 la p-1
p
binar a
reprezentarea
lui i, 0 <= i <= p-1, de
forma id-1id-2i0
dou procesoare sunt
conectate dac indicii
lor
o d
difer
e doa
doar ntr-o
t o
singur pozitie a
reprezentrilor lor
binare
structur recursiv

Implementare pentru reele de procesoare

P110

P111
P010

P100

P000 P001 P010 P011 P100 P101 P110 P111

P011

P110

P000

P001

Implementare pentru reele de procesoare (2)

Algoritmul de nsumare:
fiecare element A[i] al tabloului cu n elemente este memorat ntr-un
nod P[i] al hipercubului cu n noduri (n=2d)
rezultatul acumulat in A[0]
Paii:
A[0] := A[0] + A[4]
A[1] := A[1] + A[5]
A[2] := A[2] + A[6]
A[3] := A[3] + A[7]
A[0] := A[0] + A[4] + A[2] + A[6]
A[1] := A[1] + A[5] + A[3] + A[7]
A[0] := A[0] + A[4] + A[2] + A[6] + A[1] + A[5] + A[3] + A[7]

Implementare pentru reele de procesoare (2)

var A: array [0:n-1]

[0:n 1] of real;
fa i := 0 to n-1 do in parallel
fa l := d-1 to 0 ->
if i <= 2l - 1 ->
A[i] := A[i] + A[i(l)]
fi
af
af

/* n = 2d */

Obs: i(l) denot indexul obinut din i prin complementarea

bitului l
Complexitatea: O(log n)

Sumar
Complexitatea
C
l it t algoritmilor
l it il paraleli
l li
Msuri de performan
Calculul detaliat al complexitii
Limite inferioare

Sortarea pe un vector de procesoare

Modele generice
Modelul grafurilor orientate aciclice
Principiul de planificare pentru PRAM

ntrebri?