Calcolo Parallelo e Distribuito

a.a. 2019-2020

I parametri di valutazione del software parallelo

Docente: Prof. L. Marcellino

Tutor: Dott. P. De Luca
AVVISO:
Mercoledì 22 aprile non facciamo lezione,
quindi la settimana prossima ci sarà lezione
solo il giovedì 23!

2
Speed-up
Si definisce il rapporto T(1) su T(p)
T(1)
S(p) 
T(p)
Lo speed up misura la riduzione del
tempo di esecuzione rispetto
all’algoritmo su 1 processore

S(p)  p
SPEEDUP IDEALE

Sideale (p)  p

3
Overhead totale Oh

T (1)
Sideale
( p)  p
T ( p)
Oh = pT(p) – T(1)
T(p) = (Oh + T(1)) /p
OVERHEAD totale

T(1) T(1) pT(1) p

S(p)    
T(p) (O h  T(1))/p O h  T(1) Oh
1
T(1)

L’OVERHEAD totale misura

quanto lo speed up differisce da quello ideale

4
Efficienza
Si definisce il rapporto…
S(p)
E(p) 
p

misura quanto l’algoritmo sfrutta il parallelismo del

calcolatore

EFFICIENZA IDEALE
Sideale ( p)
Eideale ( p)  1
p

5
 Domanda
T(1)
Lo speed-up S( p)  misura la riduzione del tempo di
T( p)
esecuzione dell’algoritmo sequenziale rispetto al tempo di esecuzione
dell’ algoritmo parallelo

Quale algoritmo scegliere per

misurare T(1)?

6
PRIMA SCELTA

T(1) = tempo di esecuzione dell’algoritmo

parallelo su 1 processore

S(p) dà informazioni su quanto l’algoritmo si presta

all’implementazione su un’architettura parallela
Svantaggio:

l’algoritmo parallelo su 1 processore potrebbe eseguire più

operazioni del necessario

7
SECONDA SCELTA
T(1) = tempo di esecuzione del migliore
algoritmo sequenziale

S(p) dà informazioni sulla

riduzione effettiva del tempo
nella risoluzione di un problema con p processori

Difficoltà:
• individuazione del “miglior” algoritmo sequenziale
• disponibilità di software che implementa tale algoritmo

8
Convenzione: prima scelta con efficienza

T(1) = tempo di esecuzione dell’algoritmo parallelo

su 1 processore

S(p) e E(p) danno informazioni su quanto l’algoritmo si

presta all’implementazione su un’architettura parallela

9
Domanda

Quando è possibile
ottenere
speed-up prossimi allo
speed-up ideale ?

10
 Il tempo di esecuzione sequenziale T(1)
si può decomporre in 2 parti:

una parte relativa alle operazioni che

devono essere eseguite esclusivamente in sequenziale

una parte relativa alle operazioni che potrebbero

essere eseguite concorrentemente

Ts Tc

T(1) = Ts + Tc
11
Esempio: Somma di n =4, T(1)= (n -1)tcalc =3tcalc

In fase di 2 addizioni potrebbero essere eseguite concorrentemente (Tc)

progettazione da 2 processori (p) al passo 1

dell’algoritmo
parallelo su 2 1 addizione eseguita in sequenziale (Ts) da 1 processore al passo 2
processori

Ts = 1 tcalc
Operazione che deve essere
T(1) = Ts + Tc eseguita in sequenziale

Tc = 2 tcalc
T (1)  (1  2 ) t  3t Operazioni che possono
calc calc
essere eseguite in parallelo
12
 T (1 )  T s  T c
0
Tempo
Ts Tc T(1)
Operazioni che Operazioni
devono essere eseguite eventualmente
da 1 processore parallelizzabili con
Calcoliamo il tempo impiegato
P processori
dall’algoritmo parallelo
con P processori, tenendo
presente che
Ts Tc / P T(P)
le operazioni relative alla parte
parallela
T sono ora seguite
c
T ( p) T  concorrentemente
s p
dai P processori
13
Esempio: Somma di n =4 su p=2, T(1)= (n -1)tcalc =3tcalc

P0 P1 2 addizioni eseguite concorrentemente (Tc) da 2 processori (p) al passo 1

1
 
2
 1 addizione eseguita in sequenziale (Ts) da 1 processore al passo 2

Ts = 1 tcalc
Operazione che viene
T(p) = Ts +Tc / p eseguita in sequenziale

Tc/p = 2/2 =1 tcalc

T ( p )  (1  1) t  2t Operazioni eseguite in
calc calc
parallelo
14
Calcoliamo lo speed-up:
Non è possibile v isualizzare l'immagine.

Somma di n =4 su p=2,
T(1) =3 tcalc
T(2)= 2 tcalc

T (1) 3tcalc
S(2)    1,5  2  S ideale( p)
T ( p) 2tcalc

15
In generale MIMD-SM

Il tempo di esecuzione di un algoritmo parallelo, distribuito su p

processori, comprende 2 componenti:
- Ts tempo per eseguire la parte seriale
- Tc/p tempo per eseguire la parte parallela

16
In generale MIMD-DM
Il tempo di esecuzione di un algoritmo parallelo, distribuito su p
processori, comprende 3 componenti:
- Ts tempo per eseguire la parte seriale
- Tc/p tempo per eseguire la parte parallela
- Tcom costo di comunicazione con Tcom(p)≥0, p>1

17
Senza considerare le comunicazioni

posto T(1)=1 , Ts= , allora Tc=1-

T
T ( p) T  c
T ( p )    (1   ) / p
s p

T (1) 1
S( p)  
T ( p)   1
p
Legge di Ware (Amdahl)
18
Lo Speed–up
Analizziamo l’andamento dello speed-up (W-A)
all’aumentare del numero p di processori, ovvero per
p∞

1 1
S(p) 
(1   ) p ∞ 

p
Il valore asintotico di
1
S(p) è


19
Esempio 1 (n fissato e p variabile)
Applichiamo la legge di Amdahl con n =32 e p =2, 4, 8, 16

Al crescere del numero p di processori…

p α (1-α)/p S(p) E(p)
La parte
2 0,032 0,968 1,9 0,95 sequenziale
4 0,032 0,903 3,4 0,85 è costante!
8 0,032 0,775 5,1 0,6

16 0,032 0,516 6,2 0,3

20
Esempio 1 (n fissato e p variabile)
Applichiamo la legge di Amdahl con n =32 e p =2, 4, 8, 16

Al crescere del numero p di processori…

p α (1-α)/p S(p) E(p)
Speed up ed
2 0,032 0,968 1,9 0,95 efficienza
4 0,032 0,903 3,4 0,85
degradano
perché la parte
8 0,032 0,775 5,1 0,6
parallela diminuisce!
16 0,032 0,516 6,2 0,3

21
In sintesi

Se la dimensione n del problema è fissata,

al crescere del numero p di processori,
non solo non si riescono ad ottenere
speed up vicini a quello ideale

MA

Le prestazioni peggiorano!

(non conviene utilizzare un maggior numero di processori!!)

22
Esempio 2 (n aumenta e p è fissato)
Applichiamo alla somma di n numeri
la legge di Amdahl con p =2 e n = 8, 16, 32, 64

Al crescere della dimensione n…

n α 1-α S(2,n) E(2,n) La parte
8 0,14 0,86 1,75 0,875
sequenziale
tende a zero!
16 0,06 0,94 1,8 0,9

32 0,03 0,97 1,9 0,96

64 0,01 0,99 1,96 0,99

23
Esempio 2 (n aumenta e p è fissato)
Applichiamo alla somma di n numeri
la legge di Amdahl con p =2 e n = 8, 16, 32, 64

Al crescere della dimensione n…

n α 1-α S(2,n) E(2,n) La parte parallela
8 0,14 0,86 1,75 0,875
è costante
16 0,06 0,94 1,8 0,9

32 0,03 0,97 1,9 0,96

64 0,01 0,99 1,96 0,99

24
Esempio 2 (n aumenta e p è fissato)
Applichiamo alla somma di n numeri
la legge di Amdahl con p =2 e n = 8, 16, 32, 64

Al crescere della dimensione n…

n α 1-α S(2,n) E(2,n)

8 0,14 0,86 1,75 0,875

Speed up ed
16 0,06 0,94 1,8 0,9 efficienza sono
32 0,03 0,97 1,9 0,96
“costanti”!
64 0,01 0,99 1,96 0,99
E soprattutto
l’efficienza tende
all’efficienza
IDEALE!
25
 Infatti…

Se p è fissato, al crescere della dimensione n del problema,

la parte sequenziale α 0, da cui…

1
S(p)  p
(1   ) α 0

p Il valore asintotico di

0 0 S(p) è p
(Sideale ( p)  p)

26
In sintesi
Fissando il numero p di processori e
aumentando la dimensione del
problema si possono ottenere
speed up prossimi a quello ideale

MA
non è possibile aumentare in
maniera indefinita la dimensione n
del problema:
le risorse (hardware) sono limitate!

27
Secondo la legge di Ware…

Aumentando il numero p di processori e mantenendo fissata la

dimensione n del problema si riesce ad utilizzare in maniera
efficiente l’ambiente di calcolo parallelo, se p ≤ pmax

…
superato questo valore le prestazioni peggiorano!!!

Aumentando la dimensione n del problema e mantenendo

fisso il numero p di processori le prestazioni
dell’algoritmo parallelo non degradano se n ≤ nmax
…
superato questo valore potrei avere problemi con la
memoria hardware!!!
28
Legge di Ware (Amdhal)

BASE • α frazione sequenziale

1
S( p) 
1  • (1- α) frazione parallelizzabile

p • (1- α)/p frazione parallela

GENERALIZZATA
1
S ( p)  p 1
 
 1  
k  2 k
k

p
p

α1 frazione di operazioni eseguite da un solo processore (sequenziale)

αk frazione di operazioni eseguite con parallelismo medio k<p
αp frazione di operazioni eseguite con parallelismo totale p
Domanda

Cosa succede se aumentiamo

il numero p di processori e
la dimensione n del problema ?

30
Esempio: somma di n numeri in parallelo (Ist)

Applichiamo la legge di Amdhal con p= 2, 4, 8, 16

Consideriamo quindi n= 8 , 16, 32, 64

n
4 è costante
p
n p α (1-α)/p S(p,n) E(p,n) La frazione di
8 2 0,14 0,86 1,75 0,875 operazioni
16 4 0,06 0,8 3 0,75 eseguite in
sequenziale
32 8 0,03 0,77 5,1 0,64
tende a zero!
64 16 0,01 0,76 9 0,56

31
Esempio: somma di n numeri in parallelo
Applichiamo la legge di Amdhal con p= 2, 4, 8, 16
Consideriamo quindi n= 8 , 16, 32, 64

n
4 è costante
p
n p α (1-α)/p S(p,n) E(p,n)

8 2 0,14 0,86 1,75 0,875

La frazione di
operazioni eseguite
16 4 0,06 0,8 3 0,75
in parallelo
32 8 0,03 0,77 5,1 0,64
è ‘’costante’’ !
64 16 0,01 0,76 9 0,56

32
Esempio: somma di n numeri in parallelo
Applichiamo la legge di Amdhal con p= 2, 4, 8, 16
Consideriamo quindi n= 8 , 16, 32, 64

n
4 è costante
p
Lo speed up
n p α (1-α)/p S(p,n) E(p,n)
aumenta!
8 2 0,14 0,86 1,75 0,875

16 4 0,06 0,8 3 0,75

32 8 0,03 0,77 5,1 0,64

64 16 0,01 0,76 9 0,56

33
Esempio: somma di n numeri in parallelo
Applichiamo la legge di Amdhal con p= 2, 4, 8, 16
Consideriamo quindi n= 8 , 16, 32, 64

n
4 è costante
p
n S(p,n) E(p,n)
L’efficienza è
p α (1-α)/p
“quasi costante”!
8 2 0,14 0,86 1,75 0,875

16 4 0,06 0,8 3 0,75

32 8 0,03 0,77 5,1 0,64

64 16 0,01 0,76 9 0,56

34
Quindi…
Aumentando sia n che p,
con un rapporto fissato,
le prestazioni
dell’algoritmo parallelo
non degradano

Ma
aumentando sia n che p
cosa ci aspettiamo dall’algoritmo parallelo?
35
Considerazioni …

Se p=2 ci si aspetta di
calcolare nel tempo T(1,n) la
somma di 2n numeri

T(1,n)  T(2,2n) Se p=4 ci si aspetta di

calcolare nel tempo T(1,n) la
somma di 4n numeri

T(1,n)  T(4, 4n)

In generale:

T( 1 ,n)  T( 2 , 2 n)  T( 4 , 4 n)  ...  T(p,pn)

36
considerazioni …
T( 1 ,n)  T( 2 , 2 n)  T( 4 , 4 n)  ...  T(p,pn)
..poichè
Pertanto... pT(1,n) = T(1,pn)

T (1, n) T (1, n) T (1, pn)

1 p p  p  Spideale
T ( p, pn) T ( p, pn) T ( p, pn)
Ovvero T(1,pn) è uguale al
tempo che si ottiene
moltiplicando per p il
tempo per risolvere su 1
processore il problema di
dimensione n…

37
Conclusioni

T(1,pn) pT(1,n)
SS(p,n)  
T(p,pn) T(p,np)

SPEEDUP SCALATO

38
Conclusioni

dividendo SS(p,n) per il numero di processori

SS(p,n) T(1,n)
ES(p,n)  
p T(p,pn)

EFFICIENZA SCALATA

39
Speedup ed Efficienza scalati

T( 1 ,n)  T( 2 , 2 n)  T( 4 , 4 n)  ...  T(p,pn)

T (1, n) T (1, n) T (1, pn)

1 p p  p  Spideale
T ( p, pn) T ( p, pn) T ( p, pn)

Aumentando n e p in rapporto costante

ES(p,n) = cost

40
Allora…

T(1,n1 )  I (p0 ,p1 ,n 0 )

la funzione I è detta ISOEFFICIENZA

esprime
la legge secondo cui deve
aumentare la complessità di tempo dell’algoritmo
a partire da p0 e da T(1, n0)
affinché l’efficienza non degradi.

41
Domanda

Come si calcola l’isoefficienza

per un qualsiasi algoritmo ?

OVVERO

Nel passare da p0 a p1 processori con p1 > p0,,

come deve aumentare (scalare)
la complessità dell’algoritmo
affinché l’efficienza scalata sia costante ?
42
Overhead totale Oh

T (1)
Sideale
( p)  p
T ( p)
Oh = pT(p) – T(1)
T(p) = (Oh + T(1)) /p
OVERHEAD totale

T(1) T(1) pT(1) p

S(p)    
T(p) (O h  T(1))/p O h  T(1) Oh
1
T(1)

L’OVERHEAD totale misura

quanto lo speed up differisce da quello ideale

43
 Come calcolare l’isoefficienza?
S ( p ,n ) 1
S(p ,n ) 1
1 1
= ,n ) 
0 0
E ( p ,n )   E( p
0 0 1 1 p O (n , p )
p O (n ,p )
0 0 1 h 1 1
0 h
1 1
T ( 1, n ) T (1, n )
0 1

Oh(n0 ,p0 ) Oh(n1,p1 )


T( 1, n0 ) T( 1, n1 )

Oh(n1,p1 )
T( 1, n1 )  T( 1, n0 )
Oh(n0 ,p0 ) ISOEFFICIENZA

C 44
 Calcoliamo l’isoefficienza nella somma

Oh(p) = p log2 p p1 log 2 p1

n1  1  (n0  1)  I(n0 ,p0 ,p1 )
p0 log 2 p0
T(1,n) = n-1
ISOEFFICIENZA

Nel passare da p0 a p1 con p1 > p0, la complessità

di tempo del problema deve aumentare, rispetto
alla dimensione iniziale n0, del fattore
C = (p1 log2 p1)/(p0 log2 p0)

45
 In generale…

Un algoritmo si dice scalabile se

l’efficienza scalata rimane costante (o non degrada)
al crescere del numero dei processori e
della dimensione del problema,
In un rapporto costante pari a C=I(p0,p1,n0)

46
La somma è un algoritmo scalabile?

C
n p log p
1 1 2 1

n0 p 0 log 2 p 0 p0 = 4 n0 = 64
p1 = 8 n1 = 3? x n0 = 192

p2 = 16 n2 = 8?x n0 = 512
C = (8 x 3) / (4 x 2) = 3

C = (16 x 4) / (4 x 2) = 8

47
La somma è un algoritmo scalabile?

C
n1 p 1 log 2 p 1

n0 p 0 log 2 p 0 p0 = 4 n0 = 64 T(4) = 17
p1 = 8 n1 =192 T(8) = 26

p2 = 16 n2 = 512 T(16) = 35

n
T(p)= ( -1 +log2 p) tcalc
p

48
somma di n numeri con p processori: isoefficienza
Calcoliamo l’efficienza secondo i T(p) calcolati
Efficienza

p
n 1 4 8 16
64 1.0 0.91 0.57 0.33

192 1.0 0.97 0.91 0.79

512 1.0 0.97 0.96 0.91

L’efficienza scalata rimane costante

al crescere di p e di n
La somma è scalabile! 49
… per oggi è tutto!

50