Capitolul 3

Modele si metrici pentru

evaluarea performantelor

Overhead in programe paralele
Utilizand de N ori mai multe resurse in paralel,
va rula un algoritm de N ori mai repede ? NU !
Cauze: paralelizarea introduce o regie
suplimentara (overhead):
Interactiunea interprocese: comunicare
(transmitere rezultate intermediare sau partiale),
sincronizare
Inactivitate temporara (idling): exista procesoare
care sunt inactive pe anumite perioade de timp;
Cauze: incarcare inegala, asteptare sincronizare.
Calcule suplimentare: calcule care nu apar in
formularea seriala a algoritmului.
Din: [Grama,Gupta,Kumar&Karypis]
Evaluarea performantelor
sistemelor paralele
Modele analitice si metrici
Costuri ale comunicarii
In sisteme cu transmitere de mesaje
In sisteme cu memorie partajata
Metrici de performanta
Timp de Executie, Suprasarcina, Accelerare,
Eficienta, Cost
Scalabilitatea
Legea lui Amdahl
Izoeficienta
Costurile comunicarii prin
transmitere de mesaje
Timpul de transmitere a unui mesaj intre 2
procese cuprinde:
Timpul de initializare (Startup time t
s
):
pregatirea mesajului pentru transmisie
(header, coduri corectoare de erori), rutare.
Timpul per-hop (t
h
): Timpul necesar header-
ului mesajului sa ajunga la urmatorul nod, de
care este direct conectat. Latenta nodului.
Timpul de transfer al unui cuvant (t
w
): Timpul
necesar transferarii unui cuvant intre 2 noduri
direct conectate. Depinde de latimea de
banda a conexiunii.
Calculul timpului de comunicare
Datele problemei: mesaj de dimensiune m,
trebuie sa traverseze l legaturi de la nodul sursa
la nodul destinatie
Timpul de comunicare depinde si de
mecanismul de rutare
Pentru cut-through routing (mecanism fara
buffer-ari la nodurile intermediare):
T
comm
=t
s
+l*t
h
+m*t
w
Valorile pentru t
s
, t
h
, t
w
:
sunt constante determinate de caracteristicile
hardware-ului si a protocoalelor de comunicatie
De obicei: t
s
>> t
w ,
si t
h
neglijabil


Optimizarea timpului de comunicare
T
comm
=t
s
+l*t
h
+m*t
w

Comunicare de tip en-gros: este mai eficient a
transmite un singur mesaj mare decat multe mesaje
mici, datorita ponderii importante a lui t
s
Minimizarea distantei de comunicare: reducerea
nr de link-uri l de parcurs; se poate face prin optimizarea
asignarii proceselor pe procesoare. In practica, utilizand
biblioteci de transmitere de mesaje, programatorul are
un control redus asupra modului in care procesele sunt
mapate pe procesoare.
Minimizarea volumului datelor transmise
Modelul liniar al costului
comunicarii
T
comm
=t
s
+l*t
h
+m*t
w
t
s
>> t
w ,
si t
h
neglijabil

T
comm
=t
s
+m*t
w




Tcomm
m
ts
tw
Modelul liniar al costului
comunicarii
Din: [Foster]
Costurile comunicarii prin
memorie partajata
Dificil de estimat:
Utilizarea memoriilor cache
Programatorul de obicei nu poate controla in ce
adrese fizice se face stocarea anumitor date
Costul pentru acces read-only poate fi aproximat
grosier prin aceeasi formula ca si in cazul
transmiterii de mesaje:
T
mem
=t
s
+m*t
w
Particularitate : t
s
<< t
w


Metrici de performanta
Timpul de Executie Ts siTp
Suprasarcina (Total parallel Overhead) To
Accelerare (Speedup) S
Eficienta E
Cost

Timpul de executie
Ts = Timpul de executie serial: timpul
masurat de la inceputul si pana la sfarsitul
executiei algoritmului pe un calculator
secvential.
TP= Timpul de executie paralel: timpul
masurat de la inceputul executiei si pana
la terminarea ultimului subtask paralel.
Total parallel Overhead
Suprasarcina (Total paralell overhead) To=
diferenta dintre timpul total de lucru insumat al
tuturor procesoarelor si timpul necesar celui mai
rapid algoritm secvential



Timpul total de lucru insumat al tuturor
procesoarelor = p*TP = timpul de calcul + timpul
de comunicare + timpul de inactivitate temporara
cumulat pentru toate procesoarele

S P O
T T p T =
De cate ori mai repede se rezolva o problema in paralel
fata de cazul secvential ?
Accelerarea (Speedup) = raportul dintre timpul necesar
rezolvarii unei probleme pe un procesor si timpul necesar
rezolvarii in paralel pe p procesoare identice



S este o metrica a performantei algoritmului si nu a
calculatorului paralel
Ts se refera la timpul de executie al celui mai bun
algoritm secvential pentru respectiva problema
De exemplu, pentru un algoritm paralel de sortare, se va raporta
timpul acestuia la timpul de executia al algoritmului Quicksort
secvential, nu Bubblesort secvential !

Accelerarea
P
T
S
T
S =
Valoarea accelerarii
Teoretic (ideal):
accelerare liniara S=p
De obicei in practica:
Accelerare subliniara S < p (datorita
overhead)
Posibile anomalii:
accelerare supraliniara S>p.
Cauze: imbunatatirea accesului la memorie prin partitionarea
datelor de volum mare intre mai multe noduri; comportarea
unor algoritmi pe cazuri particulare.

Exemplu - Efect de supralinearitate
Din: [Grama,Gupta,Kumar&Karypis]
Estimarea accelerarii




Ts(n) = complexitatea de timp secventiala pentru
o problema data
Este functie de n=dimensiunea datelor
TP(n,p)= complexitatea de timp paralela
Estimeaza timpul de rulare a algoritmului concurent
pe p procesoare; depinde si de modelul arhitecturii
paralele
Ts(n) <=TP(n,1)

) , (
) (
) , (
p n
P
T
n
S
T
p n S =
Exemplu: Adunarea a n numere
Varianta 1 n procesoare
Initial, fiecare procesor detine in memoria sa
locala una din valorile care trebuie insumate
Fiecare procesor de ordin impar transmite
valoarea pe care o detine procesorului din stanga
sa care realizeaza suma partiala
Dupa primul pas -> raman n/2 valori (sume
partiale) de insumat pe n/2 procesoare
Se repeta procedura, dupa al doilea pas ->
raman n/4 sume partiale de insumat
Dupa un numar de log(n) pasi, suma finala se
gaseste la primul procesor

Din: [Grama,Gupta,Kumar&Karypis]
Estimarea accelerarii
Pentru algoritmul de adunare a n valori utilizand
n procesoare
Numarul de pasi = log(n)
Fiecare pas consta dintr-o operatie de comunicare si
o operatie de adunare, de timp constant tcomm+tadd.
TP=O(log n)
Adunarea a n numere cazul secvential:
TS= O(n)
S=O(n/log n)

Eficienta
Eficienta utilizarii calculatorului paralel:




E <=1, este 1 in cazul ideal S=p
Exemplu: adunarea a n numere pe n procesoare:
E=S/n=O(1/log n)

p
S
E =
Exemplu: procesarea imaginilor
Imagine de n*n pixeli
Pt fiecare pixel trebuie calculata o valoare
functie de valorile pixelilor vecini (9 valori
inclusiv pixelul)
Imaginea este partitionata in p subimagini,
fiecare subimagine fiind procesata in paralel
Problema: pixelii care se afla pe frontiera
subimaginilor. Necesita operatii de comunicare
cu alte procesoare pentru a afla valorile vecinilor

Din: [Grama,Gupta,Kumar&Karypis]
Exemplu calcul metrici
2
2
2
2
2
9
) ( 2
1
1

) ( 2 9
9

) ( 2 9
dreapta respectiv stanga frontiera pe aflate valori de
coloanele comunice sa trebuie fasie Fiecare
n/p latime de fasii" " p in ta partitiona este Imaginea
: Paralel
9
: Serial
n c
n t t p
p
S
E
n t t
p
n
c
n c
T
T
S
n t t
p
n
c T
n c T
w S
w S
P
S
w S P
S

+
+
= =
+ +

= =
+ + =
=
Cost
Cost = TP * p
Costul reflecta timpul total de lucru insumat al
tuturor procesoarelor
E= Ts/Cost
Algoritm paralel optimal in cost (cost-optimal):
costul rezolvarii problemei cu ajutorul
algoritmului paralel este egal cu timpul de
executie al celui mai rapid algoritm secvential
Cost=O(Ts(n))
Eficienta unui sistem cost-optimal este O(1)
Exemplu de determinare a costului
Adunarea a n numere pe n procesoare
Ts=O(n)
TP=O(log n)
Cost= TP * n =O(n log n) > O(Ts)
Algoritmul nu este cost-optimal, utilizeaza
prea multe procesoare
Granularitatea
Granularitate = dimensiunea taskurilor in
care e descompusa problema
paralelizabila
Granularitate fina (fine-grained): numar mare
de taskuri mici
Granularitate mare (coarse-grained): numar
redus de taskuri mari
Cresterea granularitatii (scaderea
numarului de procesoare) poate ajuta la
imbunatatirea metricii de cost
Exemplu: Adunarea a n numere
Varianta 2 p procesoare
Se utilizeaza p<n procesoare
Fiecare procesor detine in memoria locala n/p valori
In primul pas, fiecare procesor calculeaza secvential
suma celor n/p valori proprii
Dupa primul pas -> raman p sume partiale de insumat
Acestea vor fi insumate dupa algoritmul de la varianta 1
-> dupa un numar de log(p) pasi se obtine suma finala
TP=n/p *tadd+ log p*(tadd+tcomm)
TP=O(n/p+log p)
Cost=TP * p= O(n+p log p)
Daca n=O(p log p), Cost = O(n) = O(Ts) -> algoritmul
este cost-optimal
Din: [Grama,Gupta,Kumar&Karypis]
Timpul de executie minim pentru o
anumita dimensiune a problemei
Cat de repede poate fi rezolvata o
problema de o dimensiune data, in
conditiile in care nu se pun restrictii
privitoare la numarul procesoarelor
utilizate ?
p=? pentru a obtine Tpmin
Fie p0 o solutie a ecuatiei dTp/dp=0
Tpmin=Tp(p0)

Exemplu de determinare a timpului
de executie minim
Adunarea a n numere pe p procesoare









! optimala - cost este nu Solutia
log
log 2 ) (
2
0 2
0
2
log 2 ) , (
0
min
0
min
0
2
n n p T Cost
n p T T
n
p
p n
p p
n
dp
dT
p
p
n
p n T
P
P P
P
P
= =
= =
=
= +
= + =
+ =
Metrici ale performantei - rezumat
Metrica Notatie/formula Semnificatie
Timp executie
secventiala
Ts Executia celui mai performant
algoritm secvential
Timp executie
paralela
Tp
Accelerare S=Ts/Tp In general S<p
Eficienta E=S/p In general E<1
Cost Cost=p*Tp Cost-optimal daca p*Tp=Ts
Suprasarcina To=pTp-Ts
Scalabilitate
Performanta unui sistem paralel depinde de
dimensiunea problemei si de numarul de
procesoare
Ce se intampla daca:
Creste dimensiunea problemei
Creste numarul de procesoare
Cum si cu cat se modifica performantele ?
Tipuri de scalabilitate:
Arhitecturala: cresterea debitului prin cresterea
resurselor
Algoritmica: abilitatea de utilizare a resurselor mai
mari

Legea lui Amdahl valoarea limita
a accelerarii
Coeficient de secventialitate f: procentul din calculele
unui algoritm care sunt inerent secventiale


p
f
f
T
T
S
p
T f
T f T
P
S
S
S P

+
= =

+ =
1
1
) 1 (
f
S
p
1
lim =

Legea lui Amdahl - Accelerarea
functie de numarul de procesoare
Numar procesoare
Accelerarea S
ideal
real
S=p
S<p
p
1/f
Exemplu
Problema: adunarea a n numere pe p procesoare


n
p p
p
S
E
p
p
n
n
T
T
S
p
p
n
T
t t
p t t
p
n
t T
P
S
P
comm add
comm add add P
log 2
1
1
log 2
log 2
1 : timp de e cu valoril masina o presupunem
log ) (

+
= =
+
= =
+ =
= =
+ + =
Din: [Grama,Gupta,Kumar&Karypis]
Din: [Grama,Gupta,Kumar&Karypis]
Relatia: Eficienta Numar
procesoare - Dimensiunea problemei
Pentru o dimensiune fixa a problemei, Eficienta
E scade odata cu cresterea numarului de
procesoare p
Pentru un numar fix de procesoare, eficienta E
poate sa creasca daca creste dimensiunea
problemei
Scalabilitate: pastrarea eficientei E constante
prin cresterea simultana a dimensiunii
problemei si numarului de procesoare
p creste la p
Cat trebuie sa creasca n asffel incat
E(n,p)=E(n,p)
Izoeficienta
Functia de izoeficienta: specifica rata de
crestere a dimensiunii problemei necesara
pentru a mentine constanta eficienta, odata
cu cresterea numarului de procesoare
Sisteme nescalabile: nu se poate determina functia de
izoeficienta (nu exista): eficienta nu poate fi mentinuta
constanta la cresterea numarului de procesoare
Sistem eficient scalabil: functie de izoeficienta mica: ex
O(p): dimensiunea problemei trebuie sa creasca liniar cu
numarul de procesoare
Sistem greu scalabil: functie de izoeficienta mare: ex
O(2^p): dimensiunea problemei trebuie sa creasca
exponential cu numarul de procesoare
Cum se defineste dimensiunea
problemei ?
Definitia trebuie aleasa astfel incat dimensiunea
sa fie direct proportionala cu volumul calculelor
Dimensiunea problemei = W= numarul total de
operatii necesare rezolvarii problemei
Exemplu: pentru inmultirea a 2 matrici cu n*n
elemente, dimensiunea problemei este W=O(n^3)
Dimensiunea problemei = W = Ts = timpul de
executie al celui mai performant algoritm
secvential

Calculul functiei de izoeficienta
) , (
1
) (
0
0
0
p W T
E
E
p W
E
W T
W
p
S
E
W T
p W
T
T
S
p
W T
T
W T p T T p T
O
O
O P
S
O
P
P S P O

=
=
+
= =
+

= =
+
=
= =
Exemplu calcul functie izoeficienta
Problema: adunarea a n numere pe p procesoare



log
log
la creasca sa trebuie ) curent, exemplului cazul (in
datelor a dimensiune atunci la la de creste procesoare
de numarul daca constanta, eficienta pastra a pentru
scalabil alg valoare orice pentru exista ) (
log 2
1
log 2
log 2
, ,
,
,
0
0
0
p p
p p
n n
n
p p
E p W
p p K T
E
E
W
p p T T p T
n T
p
p
n
T
O
S P O
S
P

=
=>
=

=
= =
=
+ =
Problema: procesarea imaginilor n*n pe p procesoare
) ( ) (
1
unde ), ( 2

) ( 2
) ( 2
) ( 2 9
9
2
0
0
2
2
2
p O p W
E
E
K W t t p K W
n W
n t t p K T K W
n t t p T T p T
n t t
p
n
c T
n c T
w S
w S O
w S S P O
w S P
S
=

= + =
=
+ = =
+ = =
+ + =
=
Exemplu calcul functie izoeficienta
Problema: procesarea imaginilor n*n pe p procesoare
16 , 256
2 2
4 4
64
4
64 , 8
2
) ( ) (


2
2
1
2
2
1 2
2
1 1
1
2
2
= =

= =
=
= =
=
=
=
n
p
p
W W
p
W n
p
p O p W
n W
Exemplu calcul functie izoeficienta
Exemplu calcul functie izoeficienta
Problema: procesarea imaginilor n*n pe p procesoare

0 1
0 1 2 3
0 1 2 3
p1=2
n1=8, W1=64
p2=4
n2=16, W2=256
E2=E1
p3=4
n3=8, W3=64
E3<E1
Calcul intuitiv functie izoeficienta
e temporar ti inactivita si i comunicati de cauzata na suprasarci si
ca crestere de rata aceeasi aiba sa trebuie efectiv calcul de timpul
insumat paralel executie de timpul si ca
crestere de rata aceeasi aiba sa r trebuie uniproceso executie de timpul
: ate scalabilit Conditie
procesoare p celor al insumat executie de timpul
procesor 1 pe executie de timpul

=
+ +
=
=

=
calcul S
idle i comunicati calcul
S
P
S
T T
ct E
T T T
T
E
T p
T
E
Exemplu calcul intuitiv functie
izoeficienta
Problema: procesarea imaginilor n*n pe p procesoare

0 1
0
1 2 3
0 1 2 3
p1=2
n1=8
p2=4
n2=16
p3=4
n3=8
Tcalcul2=4*Tcalcul1
Tcomunic2=4*Tcomunic1
E2=E1
Tcalcul3=1*Tcalcul1
Tcomunic3=2*Tcomunic1
E3<E1
Tcalcul1=Ts=8*8
Tcomunic1=2*2*8