Richiami CPD1

Università degli Studi di Napoli
Parthenope
Richiami di Calcolo Parallelo 1
A cura di:
Livia Marcellino - Luigia Ambrosio
Powered by LATEX
II
Indice
1
Introduzione
1.1 Il calcolo parallelo ad alte prestazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Tipi di parallelismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.1 Parallelismo temporale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.2 Parallelismo spaziale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.3 Parallelismo asincrono . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3 Classificazione di Flynn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.1 Architetture multiprocessore a memoria condivisa (SM) e a memoria distribuita
(DM) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.2 Reti di interconnessione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.4 Calcolo parallelo vs calcolo distribuito . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Somma di N numeri
2.1 Algoritmo sequenziale . . . . . . . . . . . . . . . . . . . . . . .
2.2 Decomposizione del problema . . . . . . . . . . . . . . . . . .
2.3 Algoritmo parallelo in ambiente MIMD Distribuited-Memory
2.3.1 I Strategia . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.2 II Strategia . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.3 III Strategia . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.4 Confronto fra le tre strategie . . . . . . . . . . . . . . .
2.4 Algoritmo parallelo in ambiente MIMD Shared Memory . . .
2.4.1 I strategia . . . . . . . . . . . . . . . . . . . . . . . . . .
2.4.2 II strategia . . . . . . . . . . . . . . . . . . . . . . . . . .
2.4.3 III strategia . . . . . . . . . . . . . . . . . . . . . . . . .
1
1
3
3
5
6
6
7
8
9
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
10
10
10
11
12
13
16
18
19
19
21
21
Parametri di valutazione di un software parallelo

3.1 Parametri di valutazione di un software sequenziale . . . . . . . . . . . . .
3.2 Parametri di valutazione di un software parallelo . . . . . . . . . . . . . .
3.2.1 Speed up S(p), Overhead totale Oh , Efficienza E(p) . . . . . . . . . .
3.2.2 Legge di Ware (Amdahl) . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.3 Speed up scalato, efficienza scalata, Isoefficienza . . . . . . . . . . .
3.2.4 Legge di Gustafson . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.5 Costi di comunicazione . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.6 Calcolo di T(1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3 Analisi degli algoritmi in ambiente MIMD DM per il calcolo della somma
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
23
23
23
24
26
30
31
32
32
32
III
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3.4
4
3.3.1 I strategia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.2 II strategia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.3 III strategia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.4 Confronto fra le tre strategie . . . . . . . . . . . . . . . . . . . . . .
Analisi degli algoritmi in ambiente MIMD SM per il calcolo della somma .
Prodotto matrice per vettore

4.1 Algoritmo sequenziale . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Algoritmo parallelo in ambiente MIMD Distributed-Memory . . . . . . .
4.2.1 I Strategia: distribuzione della matrice A per blocchi di righe . .
4.2.2 Analisi delle prestazioni . . . . . . . . . . . . . . . . . . . . . . . .
4.2.3 II Strategia: distribuzione della matrice A per blocchi di colonne
4.2.5 III Strategia: decomposizione della matrice A per blocchi . . . . .
4.3 Algoritmo parallelo in ambiente MIMD Shared Memory . . . . . . . . .
Bibliografia
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
33
37
43
43
45
.
.
.
.
.
.
.
.
.
46
46
47
47
49
51
57
64
71
79
80
IV
Capitolo 1
Introduzione
1.1
Il calcolo parallelo ad alte prestazioni
Per calcolo parallelo si intende la disciplina che studia la decomposizione di un problema in piu`
parti risolvibili concorrentemente su architetture di calcolo avanzate costituite da piu` processori o piu`
core.
Impiegando il calcolo parallelo e` possibile risolvere in tempo utile problemi con domini di larga
scala (es. previsioni meteorologiche, previsione della propagazione di uno tsunami, crash test per la
progettazione di veicoli piu` sicuri, ecc.). Ovviamente allaumentare della dimensione del dominio da
trattare e della velocità con cui bisogna ottenere una risposta, corrisponde un aumento della potenza
di calcolo necessaria espressa in flops (floating operations per second). Il calcolo parallelo consente di
soddisfare questa crescente richiesta di risorse di calcolo (ed eventualmente di memoria) contenendo
anche i costi: un software puo` essere reso piu` efficiente usando N processori economici al posto di
un solo processore costoso e piu` potente.
Il progetto TOP500 [1], avviato per la prima volta nel 1993, due volte allanno stila lelenco dei
500 piu` potenti calcolatori paralleli del pianeta. Le prestazioni di un calcolatore vengono valutate
tramite il bechmark HPL (High Performance Linpack) [2] 1 . Attualmente (aprile 2012) il supercomputer piu` potente al mondo e` il K computer con 10 petaflops (10 biliardi di operazioni floating
point al secondo). Confrontando gli elenchi stilati negli anni dal progetto Top500 e` evidente che il
supercomputing ha subito una significativa evoluzione negli anni: la tecnologia avanzata di oggi
sarà la tecnologia superata di domani.
Per comprendere la necessità dellutilizzo del calcolo parallelo e` importante osservare che lefficienza
di un software e` misurata come il suo turnaround time (o tempo di esecuzione) e dipende sia dalla
complessità di tempo dellalgoritmo che dalla potenza di calcolo dellarchitettura adottata:
= k T(n)
1
Il benchmark HPL e` una versione portabile, parallela e gratuita del benchmark High Performance Computing di
LINPACK usata per supercomputer a parallelismo massivo. LINPACK e` una libreria software di algebra lineare scritta
in Fortran appositamente per supercomputer. Questa libreria viene usata come test per misurare quanto rapidamente un
computer risolve un sistema denso di equazioni lineari
di ordine N del tipo Ax = b impiegando il metodo di eliminazione

di Gauss con pivoting (complessità O 23 N3 + 2N2 ) [3].
in cui
k e` una costante moltiplicativa
T(n) e` la complessità di tempo, cioè il numero di operazioni eseguite dallalgoritmo considerato
e` il tempo di esecuzione di una operazione floating point e dipende dal periodo di clock del
calcolatore adottato
In generale per ridurre il tempo di esecuzione bisogna ridurre T(n) e .
Riduzione della complessità algoritmica T(n) : riorganizzando opportunamente lalgoritmo oppure trovandone un altro con complessità inferiore.
Tuttavia, per alcune classi di problemi esistono algoritmi ottimali cioè con complessità di tempo
minima: il tempo di esecuzione di un algoritmo ottimale rappresenta un limite inferiore alla
complessità computazionale della classe di algoritmi considerata2 .
Riduzione del tempo di esecuzione di una operazione floating point : Negli anni si e` avuto un
rapido incremento della frequenza di clock dei processori. Ad oggi (aprile 2012) uno dei piu`
potenti processori per i comuni laptop e` lIntel Core i7-3820 con frequenza di clock pari a 3.6Ghz:
il tempo di esecuzione di unoperazione floating point in questo caso e`
i73820 =
1
= 3.6 109 s = 3.6ns
3.6 109
puo` essere ulteriormente ridotto adottando delle tecniche di miniaturizzazione (nanotecnologia e microprocessori). Ad esempio si potrebbe ridurre la distanza d tra una CPU e la memoria
in modo da ridurre la distanza d che i dati devono percorrere
d = c
in cui c e` la velocità della luce.
Il processo di miniaturizzazione non puo` procedere allinfinito per ovvi limiti tecnologici come
ad esempio problemi di packaging, raffreddamento e dispersione.
In definitiva, sia la complessità dellalgoritmo che il tempo di esecuzione di una operazione floating
point presentano dei limiti al di sotto dei quali non e` possibile scendere.
Per ridurre ulteriormente il tempo desecuzione si puo` riorganizzare il software sfruttando il calcolo
parallelo (fig. 1.1): il problema originario di dimensione N viene decomposto in P sottoproblemi di
dimensione NP risolti contemporaneamente su piu` calcolatori.
Nel seguito di questo documento vedremo come decomporre, affrontare e risolvere in termini
paralleli il calcolo della somma di N numeri, del prodotto matrice vettore e del prodotto matrice
matrice.
2
Ad esempio lalgoritmo classico per il prodotto di due matrici n n ha complessità T(n) = n3 , mentre lalgoritmo di
Strassen e` ottimale ed ha complessità T(n) = nlog2 7 .
Figura 1.1: Lidea di base del calcolo parallelo: suddividere il problema originario di dimensione N in P sottoproblemi di
dimensione NP risolti contemporaneamente su piu` calcolatori.
1.2
Tipi di parallelismo
E possibile definire diversi tipi di parallelismo. Il parallelismo temporale consente di aumentare

il throughput di ununica CPU, mentre il parallelismo spaziale e asincrono sono in grado di sfruttare
la presenza di piu` unità elaborative.
Attualmente tutti i microprocessori usano forme diverse di parallelismo e nessun sistema in
commercio si puo` definire puramente sequenziale.
1.2.1
Parallelismo temporale
Il parallelismo temporale si basa sulla tecnica della catena di montaggio o pipeline: piu` entità eseguono contemporaneamente fasi successive dello stesso lavoro. Questo tipo di parallelismo prevede
la scomposizione di unistruzione in fasi dette stadi o segmenti della pipeline ovvero nelle operazioni
elementari proprie del processore.
I processori con ALU pipelined implementano il parallelismo temporale sia sul ciclo di istruzioni che
su quello dei dati.
Su un processore tradizionale e` eseguito un solo segmento alla volta, mentre nei processori pipelined
in un dato istante temporale possono essere eseguiti concorrentemente piu` segmenti.
Questo tipo di parallelismo e` detto temporale perchè agisce sulla sequenza temporale con cui un
insieme di dati viene elaborato.
In generale il rapporto fra il tempo di esecuzione di un algoritmo su un calcolatore pipelined
con S segmenti e su un calcolatore tradizionale e` pari allinverso del numero di segmenti S1 : passando da un processore tradizionale ad un processore pipelined il tempo desecuzione si riduce di S
volte.
Il tempo di latenza di una pipeline e` il tempo che intercorre tra linizio della operazione e lapparire
del primo risultato. Questo valore dipende dal numero di segmenti della pipeline e dal tempo di
esecuzione di ciascun segmento. Una struttura di tipo pipeline con un elevato tempo di latenza e`
ottimale solo se la sequenza su cui si opera e` molto lunga: solo in questo caso il tempo di avvio (cioè
il tempo per andare a regime) diventa trascurabile rispetto al tempo di esecuzione delle operazioni a
regime.
Esempio 1: Confrontiamo i tempi di calcolo della somma di N coppie di valori floating point
con un processore tradizionale e con un processore pipelined. In input abbiamo 2 vettori a e b
di N elementi ed in output abbiamo un terzo vettore c, anchesso di N componenti, il cui i-simo

elemento e` definito come
ci = ai + bi
i = 1, . . . , N
In questo caso una pipeline e` unoperazione di somma floating point ed e` composta da 4 fasi:
white1. confronto degli esponenti
white2. shift della mantissa del numero con esponente piu` piccolo
white3. somma tra le mantisse
white4. normalizzazione del risultato
Consideriamo la coppia (ai , bi ) = (0.956, 1.23): in un sistema aritmetico floating point con
base 10, precisione -3, esponente minimo -2, esponente massimo 2 i valori numerici considerati
vengono rappresentati come (0.956 100 , 0.123 101 ) e i segmenti corrispondenti sono
white1. confronto degli esponenti: esp(0.956 100 ) < esp(0.123 101 )
white2. shift della mantissa: 0.956 100 = 0.095 101
white3. somma tra le mantisse: 0.123 + 0.095 = 0.028
white4. normalizzazione del risultato: 0.028 101 = 0.280 100
Su un processore tradizionale si calcola la somma di una sola coppia di numeri alla volta (fig.
1.2a). Al contrario in un processore pipelined vengono eseguite contemporaneamente tutte le
fasi della somma su coppie distinte di valori float (fig. 1.2b).
Sia tu il tempo desecuzione di un segmento. Con un calcolatore tradizionale il tempo necessario per sommare una coppia di valori e` 4tu e il tempo per sommare N coppie di valori e`
T(N) = 4Ntu .
Usando un calcolatore pipelined, a regime ad ogni passo vengono eseguite contemporaneamente
tutte le fasi delloperazione di somma su coppie diverse di numeri. Il tempo necessario per
andare inizialmente a regime e` 4tu ; le N 1 somme successive richiedono un tempo pari a
(N 1)tu . Complessivamente il tempo per sommare N coppie di valori con un processore
pipelined e` Tpipelined (N) = 4tu + (N 1)tu = (3 + N)tu .
Il rapporto fra Ttradizionale (N) e Tpipelined (N) indica di quanto si riduce il tempo desecuzione di
un algoritmo con dimensione dellinput N adottando un processore pipelined invece di un
processore tradizionale. Valutiamo landamento di questo rapporto al crescere della dimensione
dellinput N
Tpipelined (N)
(3 + N)tu 1
lim
= lim
=
N Ttradizionale (N)
N
4Ntu
4
Il tempo necessario per calcolare la somma di N coppie di valori con un processore pipelined e` 4
volte minore di quello richiesto da un processore tradizionale. Non a caso 4 e` anche il numero di
segmenti in cui e` stata suddivisa la pipeline.
Sia il tempo di latenza che il tempo per andare a regime sono pari a 4tu , il tempo a regime richiesto
dalle N 1 operazioni di somma rimanenti e` (N 1)tu : maggiore e` il numero N di coppie di valori
da sommare, tantopiu` il tempo di latenza e` ottimale cioè 4tu diventa piccolo rispetto a (N 1)tu .
Attualmente tutti i microprocessori usano una struttura a pipeline per migliorare le loro prestazioni.
(a)
(b)
Figura 1.2: (1.2a) Somma di N coppie di numeri su un processore tradizionale. (1.2b) Somma di N coppie di numeri su un
processore pipelined.
Il parallelismo temporale e` stato usato nella costruzione di processori vettoriali (fig. 1.3) che operano
efficientemente su dati strutturati sotto forma di vettori memorizzati in appositi registri vettoriali
Figura 1.3: Schema di un processore vettoriale.
Questo tipo di parallelismo viene implementato nei calcolatori tradizionali basati sullo schema di
Von Neumann (fig. 1.4).
Figura 1.4: Schema classico della macchina di Von Neumann.
1.2.2
Parallelismo spaziale
Il parallelismo spaziale e` in grado di far eseguire contemporaneamente a piu` unità le stesse

istruzioni su dati diversi. Questo tipo di parallelismo non e` pensato per le macchine di Von Neumann
(fig. 1.4), ma viene implementato a livello ALU (Arithmetic Logic Unit) sui calcolatori con una sola
unità di controllo (CU - Control Unit) che controlla piu` unità funzionali (fig. 1.5). Lunità di controllo
impartisce alle unità funzionali lo stesso insieme di istruzioni: tutte le ALU eseguono le stesse
operazioni parallelamente su insiemi di dati diversi.
Figura 1.5: Parallelismo spaziale: una sola unità di controllo controlla piu` unità funzionali. Tutte le ALU eseguono
parallelamente le stesse operazioni su insiemi di dati diversi.
1.2.3
Parallelismo asincrono
Il parallelismo asincrono e` in grado di far eseguire contemporaneamente a piu` unità istruzioni

diverse su dati diversi. Questo tipo di parallelismo viene implementato a livello di CPU (Central
Processing Unit) in un calcolatore con piu` CPU (fig. 1.6).
Figura 1.6: Parallelismo asincrono: piu` ALU lavorano contemporaneamente effettuando azioni diverse su dati diversi.
Ogni ALU e` controllata da una diversa CU.
1.3
Classificazione di Flynn
Le architetture parallele sono classificate secondo la tassonomia di Flynn in base al numero di flussi
di dati elaborabili simultaneamente e al numero di flussi di istruzioni che possono essere eseguite
ad ogni istante. Si parla di flusso singolo se viene elaborata una sola istruzione o dato alla volta,
altrimenti si parla di flusso multiplo.
Le principali classi architetturali della tassonomia di Flynn (fig. 1.7) sono:
SISD (Single Instruction Single Data): in questa classe rientrano i calcolatori tradizionali
(modello di Von Neumann) con un solo processore. Il singolo processore elabora un solo flusso
di dati in modo sequenziale con un singolo flusso di istruzioni.
MISD (Multiple Instruction Single Data): questi calcolatori sono in grado di eseguire piu` istruzioni contemporaneamente su un unico flusso di dati; rientrano in questa categoria i calcolatori
in cui viene implementato il parallelismo temporale
SIMD (Single Instruction Multiple Data): questa architettura presenta piu` ALU controllate
da una sola CU e consente di eseguire la stessa istruzione su piu` flussi di dati (fig. 1.5). Questi
calcolatori implementano il parallelismo spaziale.
MIMD (Multiple Instruction Multiple Data: questo tipo di architettura e` costituita da piu` CPU
(fig. 1.6) e consente di eseguire istruzioni diverse su flussi di dati diversi. Questi calcolatori
implementano il parallelismo asincrono e sono alla base della costruzione di macchine parallele
general purpose
Figura 1.7: Tassonomia di Flynn.
Questa tassonomia va ulteriormente dettagliata per prendere in considerazione le caratteristiche

essenziali dei calcolatori paralleli come ad esempio la tipologia di memoria e linterconnessione fra
le diverse componenti.
1.3.1
Architetture multiprocessore a memoria condivisa (SM) e a memoria distribuita

(DM)
I sistemi MIMD possono essere suddivisi in sistemi a memoria condivisa (Shared Memory - SM,
fig. 1.8a) detti multicore e sistemi a memoria distribuita (Distributed Memory - DM, fig. 1.8b) detti
multiprocessori. I sistemi multicore presentano una memoria globale condivisa fra tutti i core; nei
sistemi multiprocessore ciascun processore ha una propria memoria locale.
I calcolatori MIMD a memoria distribuita vanno ulteriormente classificati in Massive Parallel Processors (MPP) e Distributed Shared Memory (DSM). Le macchine MPP sono composte da centinaia di
processori indipendenti che lavorano in parallelo. Le macchine DSM presentano una memoria locale
ad ogni processore con alta velocità di accesso e una memoria virtuale ad accesso piu` lento condivisa
fra tutti i processori.
I calcolatori MIMD a memoria condivisa vengono ulteriormente classificati in Symmetric MultiProcessor (SMP) e ASymmetric MultiProcessor (ASMP). Nelle macchine SMP tutti i processori hanno lo
stesso ruolo e il tempo di accesso alla memoria e` costante per ogni processore e per qualsiasi area
della memoria. Nelle macchine ASMP i processori possono avere ruoli diversi e i tempi daccesso alle
(a) MIMD shared memory
(b) MIMD distributed memory
Figura 1.8: (1.8a) Architettura MIMD con shared memory. (1.8b) Architettura MIMD con distributed memory.
aree della memoria possono differire.

La tassonomia di Flynn in realtà e` molto piu` complessa, ne abbiamo visto una versione semplificata
(fig. 1.9).
Figura 1.9: Semplificazione della tassonomia di Flynn completa.
1.3.2
Reti di interconnessione
Le macchine MIMD si differenziano anche per la tipologia di connessione fra i diversi processori:
la tipologia di connessione adottata influenza il tempo daccesso alla memoria e quindi le prestazioni
del sistema.
In un calcolatore MIMD a memoria condivisa, la memoria e le CPU possono essere collegate con un
bus singolo, con bus multipli oppure in modo diretto (fig. 1.10).
Nei sistemi MIMD a memoria distribuita si possono adottare anche schemi di connessione piu`
(a) bus singolo
(b) bus multipli
(c) connessione diretta
Figura 1.10: Modalità di connessione CPU-memoria in un sistema MIMD con memoria condivisa.
complessi (fig. 1.11).
(a) rete ad anello
(d) mesh
(b) Connessione totale fra i

nodi
(c) Rete ad ipercubo
(e) Struttura toroidale
(f) Rete a stella
Figura 1.11: Modalità di connessione CPU-memoria in un sistema MIMD con memoria distribuita.
1.4
Calcolo parallelo vs calcolo distribuito
Bisogna avere ben chiara la differenza fra un ambiente di calcolo parallelo e un ambiente di calcolo
distribuito.
Sia il calcolo parallelo che quello distribuito sono impiegati per risolvere problemi su larga scala in
maniera efficiente.
Un ambiente di calcolo distribuito e` un sistema costituito da piu` nodi autonomi, indipendenti ed
eterogenei. I nodi sono delle risorse preesistenti fisicamente distribuite collegate da reti geografiche
(loosely couped systems). Lobiettivo principale di un sistema distribuito e` il riuso di risorse esistenti.
Un ambiente di calcolo parallelo e` un sistema costituito da piu` nodi dipendenti gli uni dagli altri ed
omogenei collegati da switch specializzati e dedicati (tightly couped systems). Lobiettivo principale
di un sistema parallelo e` lefficienza.
Capitolo 2
Somma di N numeri
2.1
Algoritmo sequenziale
Dati N numeri a1 , a2 , . . . , aN , il calcolo della somma

S = a1 + a2 + + aN
con un calcolatore tradizionale prevede ad ogni passo la somma di una coppia di valori. Complessivamente lalgoritmo richiede N 1 passi corrispondenti alle N 1 somme.
Procedura 2.1: Algoritmo sequenziale per la somma di N numeri.
begin
sumtot := a(0);
for i = 1 to N-1 do
sumtot := sumtot + a(i);
end for
end
Affrontiamo questo stesso problema in ambiente MIMD con memoria condivisa e distribuita.
2.2
Decomposizione del problema
Come introdotto nel paragrafo 1.1, il problema di partenza, cioè la somma complessiva, puo` essere
decomposto in p sottoproblemi, ovvero p somme parziali, ciascuno di dimensione Np . Ciascuno dei
p processori/core disponibili calcola la somma di Np elementi e alla fine le somme parziali vengono
combinate in modo opportuno per ottenere la somma totale.
Esempio 2: Supponiamo di voler calcolare la somma di N = 20 elementi in parallelo con 5

processori/core (fig. 2.5). Ogni processore/core calcola la somma di
10
N
p
20
5
= 4 elementi per un
totale di 5 somme parziali. Un generico processore pi (i [0, 4]) calcola la somma parziale si degli
elementi {a4i , ..., a4(i+1)1 }.
s0 = a0 + a1 + a2 + a3
s1 = a4 + a5 + a6 + a7
s2 = a8 + a9 + a10 + a11
s3 = a12 + a13 + a14 + a15
s4 = a16 + a17 + a18 + a19
Infine
S = s0 + s1 + s2 + s3 + s4
La fase di combinazione delle somme parziali e` la piu` importante: a tal proposito sono state
introdotte diverse strategie. La scelta di una particolare strategia per la combinazione dei risultati
intermedi va fatta basandosi sul tipo di architettura adottata e sulle esigenze in termini di tempo di
calcolo e prestazioni.
2.3
Algoritmo parallelo in ambiente MIMD Distribuited-Memory
In un ambiente a memoria distribuita (fig.2.1) i dati vengono distribuiti fra i processori e ogni
processore calcola la somma parziale dei dati che ha nella propria memoria locale.
Figura 2.1: Se N = 20 e disponiamo di 5 processori avremo 5 somme parziali su 4 elementi ciascuna: il processore pi
(i [0, 4]) calcola la somma parziale si degli elementi {a4i , ..., a4(i+1)1 }. In un ambiente a memoria distribuita ogni
processore calcola contemporaneamente la somma degli elementi contenuti nelle propria memoria locale.
i
h
Il processore Pi calcola la somma degli elementi di indice i i Np , (i + 1) Np 1 . Ogni processore,
quindi, effettua
N
p
1 addizioni: tutti i processori eseguono le stesse operazioni ma su dati diversi. Le
N
p
1 operazioni di addizione di ciascun processore vengono eseguite concorrentemente: ad esempio

mentre P0 somma a0 e a1 , il processore P1 somma a N e a N +1 , il processore P2 somma a2 N e a2 N +1 e cos`
p
via: questa e` solo la prima delle
N
p
operazioni di addizione eseguite concorrentemente.
11

In seguito P0 somma (a0 + a1 ) e a2 , il processore P1 somma a N + a N +1 e a N +2 , il processore P2 somma
p
p
p

a2 N + a2 N +1 e a2 N +2 e cos` via.
p
Alla fine di questa prima fase di calcolo, ogni processore Pi avrà in memoria la sua somma parziale
si .
Le somme parziali vanno combinate per ottenere la somma complessiva SUMTOT.
Di seguito sono riportate tre strategie per combinare insieme le somme parziali, tutte basate su espliciti
scambi di messaggi.
2.3.1
I Strategia
Il calcolo della somma complessiva puo` essere demandato ad un unico processore. Ad ogni passo
un processore diverso invia ad un processore prefissato, ad esempio P0 , la propria somma parziale.
Di volta in volta P0 aggiorna la variabile SUMTOT che contiene il risultato finale (fig. 2.2). In generale
al k-simo passo il processore Pk invia al processore P0 la propria somma parziale sk e il processore P0
calcola
SUMTOT = SUMTOT + sk
(a)
(b)
Figura 2.2: Il calcolo della somma viene demandato al processore P0 che inizializza la variabile
somma parziale s0 .
(2.2a) Allistante t1 il processore P1 invia a P0 la propria somma parziale s1 , P0 riceve
come SUMTOT = SUMTOT + s1 cioè SUMTOT = s0 + s1 .
(2.2b) Allistante t2 il processore P2 invia a P0 la propria somma parziale s2 , P0 riceve
come SUMTOT = SUMTOT + s2 cioè SUMTOT = s0 + s1 + s2 .
(2.2c) Allistante t3 il processore P3 invia a P0 la propria somma parziale s3 , P0 riceve
come SUMTOT = SUMTOT + s3 cioè SUMTOT = s0 + s1 + s2 + s3 .
Procedura 2.2: Prima strategia per la somma di N numeri in ambiente MIMD DM.
begin
forall P_i,
0 <= i <= p-1 do
h := i* (N/p)
s_i := 0
12
(c)
SUMTOT con la propria
s1 ed aggiorna SUMTOT
for j = h to h + (N/p) -1 do
s_i := s_i + a(j)
end for
// processore leader:
// ricezione ed aggregazione delle somme parziali
// degli altri processori
if P_0 then
sumtot := s_0
for k = 1 to p-1 do
receive s_k from P_k
sumtot := sumtot + s_k
end for
// altri processori:
// invio della propria somma parziale al processore leader
else
send s_i to P_0
end if
end forall
end
2.3.2
II Strategia
La seconda strategia prevede laggregazione di coppie di somme parziali. Ad ogni passo i processori attivi vengono raggruppati in coppie: in ogni coppia un processore invia la propria somma
parziale e laltro la riceve e la aggrega con la propria somma parziale.
Il numero di processori attivi si dimezza da un passo allaltro: di conseguenza il numero complessivo
di passi di comunicazione/aggregazione e` log2 p e le coppie di processori comunicanti cambiano ad
ogni passo.
Questo procedimento si ripete finchè non resta un solo processore attivo cioè il processore leader P0
che calcola la somma finale.
log (p)k
Ad un generico passo k (k [0, log2 p 1]) ci sono 2log2 (p)k processori attivi e 2 22
= 2log2 (p)k1
coppie di processori in comunicazione.
Definiamo i criteri per lindividuazione dei processori attivi e delle coppie di processori (ricevente, mittente).
I processori attivi sono quelli con identificativo divisibile per 2k ; i processori attivi con identificativo
non divisibile per 2k+1 inviano la propria somma parziale ai processori attivi con identificativo divisibile per 2k+1 .
Vediamo come funziona questa strategia con p = 8 processori (fig. 2.3). Avremo complessivamente
log2 p = log2 8 = 3 passi di comunicazione/aggregazione.
Al primo passo k = 0 tutti i processori sono attivi: infatti 2log2 (p)k = 230 = 8 e qualsiasi identificativo e` divisibile per 2k = 20 = 1.
log (p)k
Ci sono 2 22
= 2log2 (p)k1 = 22 = 4 coppie di processori comunicanti. I processori riceventi sono
tutti quelli per cui risulta i%20 = i%1 = 0 e i%21 = i%2 = 0 cioè tutti i processori con identificativo
pari: P0 , P2 , P4 e P6 . I processori mittenti sono quelli per cui risulta i%20 = i%1 = 0 e i%21 = i%2 , 0
13
cioè tutti i processori con identificativo dispari: P1 , P3 , P5 e P7 .

P1 invia s1 a P0 che calcola s0,1 = s0 + s1 , P3 invia s3 a P2 che calcola s2,3 = s2 + s3 e cos` via.
Al secondo passo k = 1 ci sono 2log2 (p)k = 231 = 4 processori attivi, infatti solo gli identificativi
pari sono divisibili per 2k = 21 = 2.
Ci sono 2log2 (p)k1 = 2311 = 2 coppie di processori comunicanti. I processori riceventi sono tutti
quelli per cui risulta i%2 = 0 e i%4 = 0 cioè tutti i processori con identificativo divisibile per 4; nel
nostro caso P0 e P4 . I processori mittenti sono quelli per cui risulta i%2 = 0 e i%4 , 0 cioè tutti i
processori con identificativo divisibile per 2 ma non per 4; nel nostro caso P2 e P6 .
P2 invia s2,3 a P0 che calcola s0,1,2,3 = s0,1 + s2,3 , P6 invia s6,7 a P4 che calcola s4,5,6,7 = s4,5 + s6,7 .
Al terzo ed ultimo passo k = 2 ci sono 2log2 (p)k = 232 = 2 processori attivi e 2log2 (p)k1 = 2321 = 1
coppia di processori comunicanti.
I processori riceventi sono tutti quelli per cui risulta i%4 = 0 e i%8 = 0 cioè tutti i processori con
identificativo divisibile per 8; nel nostro caso P0 . I processori mittenti sono quelli per cui risulta
i%4 = 0 e i%8 , 0 cioè tutti i processori con identificativo divisibile per 4 ma non per 8; nel nostro
caso P4 .
P4 invia s4,5,6,7 a P0 che calcola 0,1,2,3,4,5,6,7 = s0,1,2,3 + s4,5,6,7 .
Di seguito e` riportato lo schema generale dellalgoritmo.
Procedura 2.3: Seconda strategia per la somma di N numeri in ambiente MIMD DM.
begin
forall P_i,
0 <= i <= p-1 do
h := i* (N/p)
s_i := 0
s_i := s_i + a_j
end for
end forall
for k = 0 to (log2 p -1) do
forall P_i,
i = 0 to p-1 do
// individuazione dei partecipanti alla comunicazione
if (i mod 2k ==0)
// individuazione dei riceventi
if(i mod 2(k+1) )
receive s_{i+2k} from P_{i+2k}
s_i := s_i + s_{i+2k}
// individuazione dei mittenti
else
send s_i to P_{i-2k}
end if
end forall
end for
14
Figura 2.3: Il calcolo della somma complessiva viene demandato al processore P0 .

Al primo passo k = 0 sono attivi tutti i processori. Le coppie di processori in comunicazione sono (P0 , P1 ),
(P2 , P3 ), (P4 , P5 ), (P6 , P7 ). Tutte le coppie di processori aggregano concorrentemente le proprie somme parziali: il
processore P1 invia la propria somma parziale s1 al processore P0 che a sua volta calcola s0,1 = s0 +s1 ed inizializza
SUMTOT = s0,1 . Contemporaneamente il processore P3 invia la propria somma parziale s3 al processore P2 che
a sua volta calcola s2,3 = s2 + s3 , P5 invia la propria somma parziale s5 al processore P4 che a sua volta calcola
s4,5 = s4 + s5 , P7 invia la propria somma parziale s7 al processore P6 che a sua volta calcola s6,7 = s6 + s7 .
Al secondo passo k = 1 sono attivi i 4 processori P0 , P2 , P4 , P6 . Le coppie di processori in comunicazione
sono (P0 , P2 ) e (P4 , P6 ). Tutte le coppie di processori aggregano concorrentemente le proprie somme parziali:
il processore P2 invia la propria somma parziale s2,3 al processore P0 che a sua volta calcola s0,1,2,3 = s0,1 + s2,3 ;
contemporaneamente il processore P6 invia la propria somma parziale s6,7 al processore P4 che a sua volta calcola
s4,5,6,7 = s4,5 + s6,7 .
Al terzo ed ultimo passo k = 2 sono attivi solo i due processori P0 e P4 , cè una sola coppia di processori (P0 , P4 ):
P4 invia a P0 la somma parziale s4,5,6,7 . P0 riceve s4,5,6,7 e calcola la somma complessiva SUMTOT.
15
end
Viene presentato anche uno schema alternativo di questo algoritmo che gioca opportunamente
con lo step (2k ) fra coppie di processori attivi variabile ad ogni passo k.
Procedura 2.4: Schema alternativo della seconda strategia per la somma di N numeri in ambiente MIMD DM.
begin
forall P_i,
0 <= i <= p-1 do
h := i* (N/p)
s_i := 0
s_i := s_i + a_j
end for
end forall
//step fra due processori attivi
q1 := 2k
//step fra una coppia di mittenti/riceventi
q2 := 2(k+1)
forall P_i,
i = q1 to p step q2 do
send s_i to P_{i-q1}
end forall
forall P_i,
i = 0 to p step q2 do
receive s_{i+q1} from P_{i+q1}
s_i := s_i + s_{i+q1}
end forall
end for
end
Questa strategia e` certamente migliore della precedente perchè prevede meno passi temporali ma
il carico di lavoro non e` distribuito in modo equilibrato fra tutti i processori (caratteristica tipica degli
algoritmi ad albero) .
2.3.3
III Strategia
Anche la terza strategia, come la seconda, e` basata sullaccoppiamento dei processori e sullaggregazione di somme parziali. Questa strategia, a differenza della seconda, mantiene attivi tutti i
processori e alla fine tutti i processori contengono in memoria la somma complessiva.
Ad ogni passo i processori vengono raggruppati in coppie: i processori di una coppia si scambiano i
propri risultati parziali e li aggregano. Quello che cambia rispetto alla seconda strategia e` il criterio
applicato per lindividuazione delle coppie di processori comunicanti.
Ad un generico passo k un processore i fa coppia con il processore con identificativo i + 2k : 2k , quindi,
puo` essere considerato come uno step fra gli identificativi dei processori in comunicazione ad ogni
16
passo. Lo step per lindividuazione delle coppie di processori raddoppia da un passo allaltro, quindi
il numero complessivo di passi di comunicazione/aggregazione e` log2 p.
Ad un generico passo k (k [0, log2 p 1]) lo step per lindividuazione delle coppie e` 2k : una coppia,
quindi, ha questa struttura:
(Pi , Pi+2k )
oppure
(Pi2k , Pi )
Entrambi i processori di una coppia agiscono sia da mittente che da ricevente: Pi invia si a Pi+2k ,
Pi+2k invia si+2k a Pi , entrambi calcolano si,i+2k = si + si+2k .
Vediamo come funziona questa strategia con p = 8 processori (fig. 2.4).
Al primo passo k = 0 le coppie di processori sono del tipo (Pi , Pi+1 ), infatti lo step e` 2k = 20 = 1. Le
coppie di processori in comunicazione sono (P0 , P1 ), (P2 , P3 ), (P4 , P5 ), (P6 , P7 ). P0 , P2 , P4 , P6 inviano
rispettivamente s0 , s2 , s4 , s6 a P1 , P3 , P5 , P7 e P3 , P5 , P7 inviano rispettivamente s1 , s3 , s5 , s7 a P0 , P2 , P4 ,
P6 ; P0 e P1 calcolano s0,1 , P2 e P3 calcolano s2,3 , P4 e P5 calcolano s4,5 , P6 e P7 calcolano s6,7 .
Al secondo passo k = 1 le coppie di processori sono del tipo (Pi , Pi+2 ), infatti lo step e` 2k = 21 = 2.
Le coppie di processori in comunicazione sono (P0 , P2 ), (P1 , P3 ), (P4 , P6 ), (P5 , P7 ). P0 e P1 inviano
s0,1 rispettivamente a P2 e P3 , P2 e P3 inviano s2,3 rispettivamente a P0 e P1 , P4 e P5 inviano s4,5
rispettivamente a P6 e P7 , P6 e P7 inviano s6,7 rispettivamente a P4 e P5 .
Al terzo passo k = 2 le coppie di processori sono del tipo (Pi , Pi+4 ), infatti lo step e` 2k = 22 = 4. Le
coppie di processori in comunicazione sono (P0 , P4 ), (P1 , P5 ), (P2 , P6 ), (P3 , P8 ). P0 , P1 , P2 e P3 inviano
s0,1,2,3 rispettivamente a P4 , P5 , P6 e P7 , P4 , P5 , P6 e P7 inviano s4,5,6,7 rispettivamente a P0 , P1 , P2 e P3 .
Figura 2.4: Al primo passo k = 0 lo step per lindividuazione delle coppie di processori e` 20 = 1. Le coppie di processori in
comunicazione sono del tipo (Pi , Pi+1 ) ovvero (P0 , P1 ), (P2 , P3 ), (P4 , P5 ), (P6 , P7 ).
Al secondo passo k = 1 lo step per la formazione delle coppie e` pari a 21 = 2 e le coppie di processori in
comunicazione sono del tipo (Pi , Pi+2 ) ovvero (P0 , P2 ), (P1 , P3 ),(P4 , P6 ),(P5 , P7 ).
Al terzo ed ultimo passo k = 2 (log2 8 = 3) lo step per la formazione delle coppie e` pari a 22 = 4: le coppie in
comunicazione sono (P0 , P4 ), (P1 , P5 ),(P2 , P6 ),(P3 , P7 ). Ciascun processore dispone di tutte le somme parziali per
poter calcolare la somma complessiva.
17
Procedura 2.5: Terza strategia per la somma di N numeri in ambiente MIMD DM.
begin
forall P_i,
0 <= i <= p-1 do
h := i* (N/p)
s_i := 0
s_i := s_i + a_j
end for
end forall
forall P_i,
i = 0 to p-1 do
resto := i mod 2(k+1)
if (resto < 2k)
receive s_{i+2k} from P_{i+2k}
send s_{i+2k} to P_{i+2k}
s_i := s_i + s_{i+2k}
else
receive s_{i-2k} from P_{i-2k}
send s_{i-2k} to P_{i-2k}
s_i := s_i + s_{i-2k}
end if
end forall
end for
end
A differenza dalla seconda strategia, il lavoro e` equidistribuito fra i processori; inotre al termine della
procedura tutti i processori conoscono il risultato finale. Daltro canto pero` questa strategia rispetto
alle altre due strategie richiede un maggior numero di operazioni e di comunicazioni.
2.3.4
Confronto fra le tre strategie
In ogni strategia ogni processore Pi calcola la propria somma parziale si ed invia questo valore
agli altri processori al fine di calcolare la somma totale. Nelle prime due strategie solo il processore
incaricato di calcolare la somma totale ne conosce il valore, nel terzo approccio invece tutti i processori
conoscono la somma complessiva.La seconda e la terza strategia si differenziano per il numero di
comunicazioni necessarie; tuttavia esse hanno lo stesso tempo desecuzione perchè piu` comunicazioni
vengono realizzate in parallelo.
Le prestazioni di un algoritmo in ambiente parallelo non sono influenzate dal numero di operazioni
bens` dal numero di passi temporali: ad ogni passo temporale, infatti, vengono eseguite piu` operazioni
concorrentemente.
Nella prima strategia per calcolare la somma totale sono necessari p 1 passi computazionali per
consentire ai p 1 processori rimanenti di inviare al processore leader le proprie somme parziali.
Le altre due strategie invece richiedono log2 p passi perchè effettuano unaggregazione delle coppie
di somme parziali.
18
2.4
Algoritmo parallelo in ambiente MIMD Shared Memory
In un ambiente a memoria condivisa (fig.2.5) tutti i core accedono simultaneamente ad aree diverse
(dati differenti) della stessa memoria globalmente condivisa. Ogni core calcola la somma parziale di
N
p elementi.
Figura 2.5: Se N = 20 e disponiamo di 5 core avremo 5 somme parziali su 4 elementi ciascuna: il core Ci (i [0, 4]) calcola
la somma parziale si degli elementi {a4i , ..., a4(i+1)1 }. In un ambiente a memoria condivisa tutti i core accedono
contemporaneamente ad aree diverse della memoria condivisa.
Indichiamo con SUMTOT la variabile in memoria condivisa in cui vogliamo memorizzare la somma
complessiva S: ogni core deve aggiornare questa variabile. Se due o piu` core tentassero di accedere
contemporaneamente alla variabile SUMTOT si avrebbe una corsa critica (race condition) e il contenuto
della variabile SUMTOT diverrebbe inconsistente.
Abbiamo visto che in un ambiente MIMD a memoria distribuita la concorrenza delle operazioni per
laggiornamento della variabile SUMTOT puo` essere controllata con espliciti scambi di messaggi. In
un ambiente MIMD a memoria condivisa tale concorrenza puo` essere controllata attraverso degli
opportuni meccanismi di sincronizzazione degli accessi in memoria che coordinano gli accessi in
memoria dei core.
Le strategie per combinare insieme i risultati parziali in ambiente MIMD SM sono analoghe a quelle
viste nel paragrafo precedente in ambiente MIMD DM ma si basano sulla sincronizzazione degli
accessi piuttosto che sullo scambio di messaggi.
2.4.1
I strategia
Si possono coordinare tutti i core facendo s` che uno alla volta aggiorni la variabile SUMTOT in
memoria condivisa con la propria somma parziale (fig. ??).
Per rendere esclusivo ed atomico laccesso di un core alla memoria si possono usare, ad esempio, i
semafori (fig. 2.6).
Nella figura 2.7 questo procedimento viene riassunto per p = 8 core.
Procedura 2.6: Prima strategia per la somma di N numeri in ambiente MIMD SM.
begin
sumtot := 0;
19
(a)
(b)
(d)
(c)
(e)
Figura 2.6: SUMTOT inizialmente vale 0. I 5 core possono essere sincronizzati nellaggiornamento della somma totale
SUMTOT con un semaforo che assume valori nel range i [0, 4].
(2.6a) Inizialmente il semaforo vale 0, quindi il core abilitato allaggiornamento di SUMTOT e` C0 . Questo core
effettua lassegnamento SUMTOT = SUMTOT +s0 ed incrementa di ununità il valore del semaforo.
(2.6b) Il valore del semaforo e` 1 quindi il core abilitato allaggiornamento di SUMTOT e` C1 . Questo core effettua
lassegnamento SUMTOT = SUMTOT +s1 ed incrementa di ununità il valore del semaforo.
(2.6c) Il valore del semaforo e` 2 quindi il core abilitato allaggiornamento di SUMTOT e` C2 . Questo core effettua
(2.6d) Il valore del semaforo e` 3 quindi il core abilitato allaggiornamento di SUMTOT e` C3 . Questo core effettua
(2.6e) Il valore del semaforo e` 4 quindi il core abilitato allaggiornamento di SUMTOT e` C4 . Questo core effettua
20
(a)
(b)
(c)
Figura 2.7: Il calcolo della somma complessiva viene demandato al core C0 .

(2.7a) Al primo passo k = 0 il core C0 inizializza la variabile condivisa SUMTOT con la propria somma parziale s0 .
(2.8b) Al secondo passo k = 1 il core C1 incrementa il valore della variabile SUMTOT con la propria somma
parziale s1 .
Nei passi successivi gli altri core effettuano le stesse operazioni.
(2.8c) Allultimo passo il core C7 incrementa il valore della variabile SUMTOT con la propria somma parziale s7 .
for i = 0 to p-1 do
s_i := 0
h := i*(N/p)
s_i := s_i + a(j)
end for
lock(sumtot)
sumtot := sumtot + s_i;
unlock(sumtot)
end for
end
2.4.2
II strategia
Facendo uso di diversi tipi di memorie con diverse visibilità (scope) e di meccanismi di sincronizzazione si possono aggregare coppie di somme parziali. I risultati intermedi vengono memorizzati
nella memoria privata del core coinvolto, quindi piu` somme intermedie possono essere effettuate
concorrentemente perchè coinvolgono aree di memoria diverse. Il risultato finale viene memorizzato
nella memoria privata del core leader C0 e nella memoria condivisa fra tutti i core.
Nella figura 2.8 questo procedimento viene riassunto per p = 8 core.
2.4.3
III strategia
La terza strategia e` una versione modficata della seconda in cui ad ogni passo tutti i core sono
attivi e si scambiano i propri risultati parziali: alla fine tutti i core conoscono la somma complessiva.
Le somme intermedie vengono realizzate concorrentemente perchè avvengono in memoria locale
coinvolgendo variabili private.
21
(a)
(b)
(c)
Figura 2.8: Il calcolo della somma complessiva viene demandato al core C0 .

(2.8a) Al primo passo k = 0 sono attivi tutti i core. Le coppie di core in collaborazione sono (C0 , C1 ), (C2 , C3 ),
(C4 , C5 ) e (C6 , C7 ). Tutte le coppie di core aggregano concorrentemente le proprie somme parziali: ad esempio il
core C0 calcola s0,1 = s0 + s1 e memorizza il risultato nella propria memoria privata.
(2.8b) Al secondo passo k = 1 sono attivi i core C0 , C2 , C4 e C6 e le coppie di core in collaborazione sono (C0 , C2 )
e C4 , C6 ). Tutte le coppie di core aggregano concorrentemente le proprie somme parziali: ad esempio il core C0
calcola s0,1,2,3 = s0,1 + s2,3 e memorizza il risultato nella propria memoria privata.
(2.8c) Al terzo ed ultimo passo solo i due processori P0 e P4 sono attivi, cè una sola coppia di processori (P0 , P4 ):
P4 invia a P0 la somma parziale s4,5,6,7 . P0 riceve s4,5,6,7 e calcola la somma complessiva SUMTOT.
22
Capitolo 3
Parametri di valutazione di un software

parallelo
In questo capitolo introdurremo le basi per la valutazione dellefficienza di algoritmi e software
in ambiente parallelo.
I parametri di valutazione di un software in ambiente parallelo SIMD-DM o SIMD-SM sono gli stessi;
per questo motivo le considerazioni che faremo sul numero e sullutilizzo dei processori valgono
anche per ambienti mmulticore.
Porteremo avanti come esempio il calcolo della somma di N numeri visto nel capitolo precedente.
3.1
Parametri di valutazione di un software sequenziale
Lefficienza di un algoritmo misura luso di risorse quali CPU e spazio in memoria da parte dellalgoritmo stesso.
La complessità di tempo T(n) indica il tempo desecuzione di un algoritmo; in un algoritmo sequenziale la complessità di tempo e` legata al numero di operazioni eseguite. La complessità di spazio
S(n) quantifica lo spazio necessario per memorizzare le variabili utilizzate dallalgoritmo. Sia la complessità di spazio che quella di tempo sono funzioni della dimensione del problema n.
Ad esempio il numero di passi temporali dellalgoritmo sequenziale per la somma di n valori (fig.
3.2, par. 4.1) dipende dal numero di operazioni (cioè di addizioni) richieste: la complessità di tempo
di questo algoritmo sequenziale infatti e` pari a T(n) = n 1 addizioni, mentre la complessità di spazio
e` S(n) = n.
3.2
Parametri di valutazione di un software parallelo
In un algoritmo parallelo ad ogni istante vengono eseguite piu` operazioni concorrentemente: per
questo motivo il tempo di esecuzione di un algoritmo parallelo e` minore rispetto al caso sequenziale
e non e` influenzato dal numero di operazioni bens` dal numero di passi temporali.
23
3.2.1
Speed up S(p), Overhead totale Oh , Efficienza E(p)
Il concetto di efficienza va opportunamente ridefinito per gli algoritmi paralleli.

Siano T(1) e T(p) il tempo desecuzione di un algoritmo in un ambiente di calcolo dotato rispettivamente di 1 e di p processori/core o, piu` in generale, con p processi/thread.
Def. : Lo speed up S(p) indica di quanto si riduce il tempo desecuzione di un algoritmo su p processori
rispetto alla versione sequenziale ed e` definito come il rapporto di T(1) su T(p):
T(1)
T(p)
S(p) =
Maggiore e` lo speed up tantopiu` un algoritmo parallelo e` veloce rispetto al corrispondente algoritmo

sequenziale. Idealmente ci aspettiamo che un algoritmo in parallelo su p processori sia p volte piu`
veloce della corrispondente versione seriale cioè che T(p) sia p volte piu` piccolo di T(1):
S(2)ideale =
T(1)
=2
T(2)
...
T(1)
=4
T(4)
S(4)ideale =
...
S(p)ideale =
T(1)
=p
T(p)
In realtà ogni algoritmo e` composto da una parte seriale non parallelizzabile, quindi
S(p)reale =
T(1)
<p
T(p)
Un algoritmo parallelo, quindi, e` tantopiu` migliore quanto piu` lo speed up si avvicina allo speed up
ideale.
Def. : L overhead totale Oh (p) misura la differenza fra lo speed up ottenuto e lo speed up ideale:
Oh (p) = pT(p) T(1)
In una situazione ideale Oh = 0
S(p)ideale =
T(1)
=p
T(p)
Oh (p) = pT(p) T(1) = 0
S(p)reale =
T(1)
<p
T(p)
Oh (p) = pT(p) T(1) > 0
Nei casi reali Oh > 0
Minore e` loverhead totale tantopiu` lo speed up di un algoritmo e` vicino a quello ideale.

Attraverso loverhead totale possiamo dare una definizione alternativa del tempo desecuzione T(p)
Oh = pT(p) T(1)
T(p) =
O(h) + T(1)
p
e dello speed up
pT(1)
T(1)
T(1)
S(p) =
= O +T(1) =
=
h
T(p)
Oh + T(1)
p
24
pT(1)
T(1)
Oh +T(1)
T(1)
p
Oh
T(1)
+1
Al crescere del numero di processori p aumenta lo speed up ma aumenta anche loverhead

totale cioè lo speed up ottenuto e` sempre piu` lontano da quello ideale ottenibile con il numero di
processori p considerato.
Un algoritmo parallelo si dice efficiente se e` in grado di sfruttare tutte le risorse della macchina
parallela. Lo speed up da solo non basta a fornire informazioni sullefficienza dellalgoritmo parallelo
perchè non tiene conto della distribuzione del carico fra i processori. Per aumentare lefficienza
di un algoritmo parallelo non bisogna aumentare a dismisura il numero di processori perchè cio`
comporta un aumento dello speed up ma anche un aumento delloverhead totale e una riduzione
dello sfruttamento di ogni processore.
Esempio 3: Usando la seconda strategia per il calcolo della somma di N = 16 valori con p = 2
processori (fig. 3.4a) nella fase puramente parallela tutti i processori effettuano concorrentemente
16
2 1 = 7 addizioni; con p = 4 processori (fig. 3.4b) nella fase puramente parallela tutti i
processori effettuano concorrentemente 16
4 1 = 3 addizioni; con p = 8 processori (fig. 3.4c)
nella fase puramente parallela tutti i processori effettuano concorrentemente 16
8 1 = 1 addizione.
Allaumentare del numero di processori lo speed up aumenta ma le prestazioni degradano (tab.
3.7) perchè i processori sono via via sempre meno sfruttati. Ad esempio con p = 8 processori si
ha uno speed up quasi pari a 4 che non giustifica luso di tutte queste risorse di calcolo: con 8
processori ci aspettiamo di avere uno speed up ben maggiore.
Def. : Lefficienza E(p) di un algoritmo parallelo e` definita come il rapporto fra lo speed up e il numero
di processori e quantifica lo sfruttamento del parallelismo del calcolatore da parte dellalgoritmo:
E(p) =
Nel caso ideale
E(p)ideale =
S(p)
p
S(p)ideale p
= =1
p
p
Nel caso reale
S(p)reale
<1
p
Quanto piu` lefficienza di un algoritmo si avvicina ad 1 tanto piu` lalgoritmo parallelo sfrutta le risorse
di calcolo cioè e` efficiente.
Attraverso pochi semplici passaggi, possiamo dare una definiziona alternativa di speed up
E(p)reale =
E(p) =
S(p)
= S(p) = p E(p)
p
e di efficienza
E(p) =
S(p)
=
p
T(1)
T(p)
T(1)

Oh +T(1)
p
25
T(1)
=
Oh + T(1)
1
Oh
T(1)
+1
3.2.2
Legge di Ware (Amdahl)
La legge di Ware (Amdahl) consente di predire laumento dello speed up ottenibile usando piu`
processori o aumentando le dimensioni del problema.
Prima di formulare la legge di Ware bisogna fare delle considerazioni sul tempo di esecuzione di un
algoritmo.
Un algoritmo sequenziale e` composto da una parte seriale con tempo desecuzione Ts e da una
parte parallelizzabile con tempo desecuzione sequenziale Tc . T(1) dunque e` la somma del tempo
desecuzione della parte seriale e della parte parallelizzabile:
T(1) = Ts + Tc
Eseguendo lo stesso algoritmo in parallelo su p processori, la parte seriale viene comunque eseguita
nel tempo Ts mentre la parte parallelizzabile viene eseguita concorrentemente nel tempo Tpc (fig. 3.1):
T(p) = Ts +
Tc
p
Posto T(1) = 1, Ts = e Tc = (1 ); il tempo T(p) diventa
Figura 3.1: Un algoritmo sequenziale e` composto da un insieme di operazioni seriali e da un insieme di operazioni che
possono anche essere eseguite concorrentemente; il tempo desecuzione di un algoritmo sequenziale e` la combinazione dei tempi per lesecuzione della parte sequenziale e della parte parallelizzabile T(1) = Ts + Tc .
Parallelizzando lalgoritmo con p processori, il tempo desecuzione della parte seriale resta invariato, mentre il
tempo desecuzione della parte parallelizzabile diminuisce di un fattore pari a p. Il tempo desecuzione di un
algoritmo parallelo su p processori quindi e` T(p) = Ts + Tpc .
T(p) = Ts +
Tc
1
=+
p
p
Esempio 4: Lalgoritmo sequenziale per il calcolo della somma di N = 16 valori effettua 15

operazioni di addizione (fig. 3.2). In realtà 14 di queste addizioni possono essere eseguite concorrentemente, ad esempio adottando p = 2 processori ciascuno dei quali calcola la somma parziale
di una metà dei valori dati; le due somme parziali, infine, possono essere combinate insieme con
26
unaddizione che deve essere eseguita necessariamente in modalità seriale. Esprimiamo il tempo
desecuzione di questo algoritmo su un solo processore come somma della frazione di operazioni
da eseguire in modalità seriale e della frazione di operazioni parallelizzabili:

1
1
1
14
T(1) = Ts + Tc = + (1 ) =
+ 1
=
+
15
15
15 15
Applicando la prima strategia per il calcolo della somma in parallelo su p = 2 processori (fig. 3.3a),
le 14 addizioni parallelizzabili vengono eseguite concorrentemente mentre laltra addizione viene
sempre eseguita in sequenziale: ogni processore calcola la somma di 16 elementi effettuando 7
addizioni
14
1
1=
=
15
15
Eseguendo questo algoritmo su p = 4 processori (fig. 3.3b), vengono eseguite 3 operazioni
concorrentemente: P0 calcola la somma dei primi 4 elementi impiegando 3tcalc operazioni; contemporaneamente P1 , P2 e P3 calcolano la somma dei 4 elementi di propria competenza. Complessivamente vengono effettuate 12 addizioni impiegando 3tcalc operazioni. In seguito vengono
eseguite 3 addizioni in modalità seriale per ottenere la somma complessiva:
=
3
15
1=
12
15
Eseguendo questo algoritmo su p = 8 processori (fig. 3.3c), ogni processore calcola concorrentemente la somma di 2 valori, per un totale di 8 addizioni eseguite concorrentemente. In seguito
vengono eseguite 7 addizioni in modalità seriale per ottenere la somma complessiva:
=
7
15
1=
8
15
Applicando i vincoli di cui sopra, possiamo dedurre la legge di Ware: note le frazioni di operazioni
di un algoritmo eseguite in seriale e in parallelo, rispettivamente e (1 ), lo speed up ottenibile
eseguendo questo algoritmo in un ambiente di calcolo parallelo dotato di p processori e`
S(p) =
T(1)
1
=
T(p) + 1
p
Questa legge puo` essere applicata per studiare teoricamente se e` possibile ottenere speed up prossimi
allo speed up ideale al variare del numero di processori p o della dimensione del problema:
fissata la dimensione del problema N, allaumentare del numero p di processori lo speed up
tende a 1 :
1
1
lim S(p) = lim
=
p
p + 1
p
fissato il numero p di processori, allaumentare della dimensione del problema N lalgoritmo
diventa via via piu` parallelizzabile perchè aumenta il lavoro eseguito concorrentemente dai
27
p processori. Di conseguenza (cioè la frazione di operazioni eseguite in sequenziale) diventa

sempre piu` piccolo rispetto a (1 ) (cioè la frazione di operazioni eseguite in parallelo). Per
0 lo speed up tende ad avvicinarsi a quello ideale:
lim S(p) = lim
1
+
1
p
=p
incrementando contemporaneamente il numero di processori p e la dimensione del problema N

la frazione di operazioni eseguite in sequenziale tende a zero, lo speed up S(p, N) aumenta e
lefficienza E(p, N) e` quasi costante
A partire da queste considerazioni si puo` introdurre una definizione formale della legge di Ware
fissata la dimensione del problema N, allaumentare del numero di processori p non si
ottengono speed up vicini a quello ideale e le prestazioni degradano. Se p pmax si riesce
ad utilizzare in maniera efficiente lambiente di calcolo parallelo; superato questo valore le
prestazioni peggiorano,
fissato il numero di processori p, allaumentare della dimensione del problema N si possono
ottenere speed up prossimi a quello ideale. Non e` possibile aumentare in maniera indefinita
la dimensione N perchè le risorse hardware sono limitate. Le prestazioni dellalgoritmo
parallelo non degradano se N Nmax ; superato questo valore si potrebbero avere problemi
con la memoria hardware,
incrementando contemporaneamente il numero di processori p e la dimensione del problema
N le prestazioni dellalgoritmo in generale non degradano. Bisogna fare attenzione alle parti
sequenziali: anche una piccola parte seriale, infatti, puo` comprtare un significativo degrado
delle prestazioni allaumentare del numero di processori e della dimensione del problema.
Esempio 5: Lalgoritmo sequenziale per la somma di N = 16 valori esegue 15 addizioni (fig.

3.2). Applichiamo la legge di Amdahl per il calcolo dello speed up e dellefficienza della prima
strategia per la somma di N = 16 valori con p = 2, 4, 8 processori (fig. 3.3).
N
16
16
16
2
4
8
1
15
3
15
7
15
1
p
14 1
15 2
12 1
15 4
8 1
15 8
S(p)
S(p)ideale
E(p)
1.875
2.5
1.875
2
4
8
0.94
0.625
0.24
Lalgoritmo che usa p = 2 processori e` quello piu` efficiente e con speed up piu` prossimo allo
speed up ideale. Gli algoritmi con p = 4 o p = 8 processori presentano un maggiore speed up ma
sono meno efficienti; al crescere di p le prestazioni degradano perchè luso dei processori non e`
ottimizzato.
Ci sono algoritmi in cui non e` possibile separare esattamente la parte sequenziale da quella
parallela (es. seconda e terza strategia per il calcolo della somma di N valori): per questi algoritmi e`
28
stata introdotta una formulazione generale della legge di Ware

S(p) =
1 +
1
Pp1 k
k=2
p
p
in cui
1 e` la frazione di operazioni eseguite in modalità seriale su un solo processore
k e` la frazione di operazioni con parallelismo medio cioè eseguite parallelamente su k processori
(con k < p)
p e` la frazione di operazioni con parallelismo totale cioè eseguite parallelamente su tutti i p processori
Esempio 6: Lalgoritmo sequenziale per la somma di N = 16 valori esegue 15 addizioni (fig. 3.2).
Calcoliamo lo speed up ottenibile applicando la seconda strategia su p = 4 processori (fig. 3.4b).
Nella prima fase puramente parallela tutti i processori sono attivi e ogni processore effettua 3
addizioni: complessivamente vengono eseguite 12 addizioni in parallelo:
12
15
4 =
Nella seconda fase solo due processori sono attivi e vengono eseguite 2 addizioni
concorrentemente:
2
2 =
15
Nellultima fase e` attivo un solo processore che effettua lultima addizione:
1
15
1 =
quindi
S(p) =
1
1 +

P3
k=2
4
4
Non cè nessuna fase in cui lavorano contemporaneamente 3 processori:

3 = 0
quindi
S(p) =
1 +
2
2
4
4
1
1
15
2 1
15 2
12 1
15 4
1
5
15
=3
La legge di Ware e la legge di Ware generalizzata non tengono conto delle comunicazioni fra processori,
quindi si puo` parlare equivalentemente di processori o core e applicando queste due leggi allo stesso
algoritmo eseguito in ambiente MIMD DM e MIMD SM si ottengono gli stessi risultati.
29
3.2.3
Speed up scalato, efficienza scalata, Isoefficienza
Lo speed up scalato, lefficienza scalata e lisoefficienza vengono usati per mettere in relazione il
tempo di esecuzione di un algoritmo in modo seriale e in modo parallelo al variare del numero di
processori e della dimensione del problema.
Idealmente ci aspettiamo che il tempo necessario per calcolare la somma di N numeri con 1 processore sia uguale
al tempo necessario per calcolare la somma di 2N numeri con 2 processori o al tempo necessario per calcolare la
somma di 4N numeri con 4 processori o piu` in generale al tempo per calcolare la somma di pN numeri con p
processori:
T(1, N) = T(2, 2N) = T(4, 4N) = = T(p, pN)
Da questa catena di uguaglianze deriva
T(1, N)
=1
T(p, pN)
T(1, N)
=p
T(p, pN)
T(1,N)
Def. : Il rapporto p T(p,pN) e` detto speed up scalato SS(p, N)

SS(p, N) = p
T(1, N)
T(p, pN)
Si parla di speed up scalato perche questo parametro viene calcolato facendo variare sia p che N,
quindi scalando il problema. In una situazione ideale risulta pT(1, N) = T(1, pN) quindi
SS(p, N) =
T(1, pN)
T(p, pN)
Def. : Lefficienza scalata ES(p, N) si ottiene rapportando a p lo speed up scalato

ES(p, N) =
SS(p, N)
=
p
pT(1,N)
T(p,pN)
T(1, N)
T(p, pN)
Lefficienza e lo speed up scalato vengono applicati per lo studio della scalabilità degli algoritmi.
Def. : Un algoritmo si dice scalabile se lefficienza resta costante (o non degrada) al crescere del
numero di processori e della dimensione del problema.
Al fine di progettare algoritmi scalabili bisogna affrontare questo problema: Fissati il numero di
processori p0 , la dimensione iniziale del problema N0 e quindi T(p0 , N0 ), bisogna calcolare N1 e il tempo
T(p1 , N1 ) affinchè nel passare da p0 a p1 processori lefficienza rimanga costante
E(p0 , N0 ) = E(p1 , N1 )
Def. : Lisoefficienza I di un algoritmo e` una funzione
I(N0 , p0 , p1 )
che descrive la legge secondo cui devono aumentare la dimensione del problema e il numero di
processori affinchè lefficienza resti costante. A partire da un problema di dimensione N0 il cui
30
algoritmo e` eseguito su p0 processori, lisoefficienza determina il valore k secondo il quale deve

aumentare la dimensione del problema affinchè lefficienza su p1 processori resti costante:
T(1, N1 ) =
p1
kp0
T(1, N0 ) =
T(1, N0 ) = kT(1, N0 )
p0
p0
k deve essere tale che

E(p0 , N0 ) = E(p1 , N1 )
cioè
S(p0 , N0 ) S(p1 , N1 )
=
p0
p1
1
Oh (p0 ,N0 )
T(1,N0 )
+1
1
Oh (p1 ,N1 )
T(1,N1 )
+1
Oh (p0 , N0 )
Oh (p1 , N1 )
+1=
+1
T(1, N0 )
T(1, N1 )
Oh (p0 , N0 ) Oh (p1 , N1 )
=
T(1, N0 )
T(1, N1 )
In conclusione, lisoefficienza stabilisce la seguente relazione fra T(1, N0 ) e T(1, N1 )
T(1, N1 ) = T(1, N0 )
Il rapporto
3.2.4
Oh (p1 ,N1 )
Oh (p0 ,N0 )
Oh (p1 , N1 )
Oh (p0 , N0 )
e` il valore di k in grado di garantire lisoefficienza.
Legge di Gustafson
La legge di Gustafson e` una variante della legge di Ware che consente di stabilire se, dato un certo
numero di processori, e` possibile ottenere speed up scalati prossimi allo speed up ideale.
Assumiamo che T(p) sia unitario
T(p) = Ts +
Tc
Tc
= 1 =
= 1 Ts
p
p
quindi
T(1) = Ts + Tc = Ts + p(1 Ts )
Sostituendo Ts con 0 < 1 otteniamo la seguente definisione di speed up scalato:
SS(p) =
T(1) Ts + p(1 Ts )
=
= 0 + p(1 0 ) = p + (1 p)0
T(p)
1
Questuguaglianza esprime la legge di Gustafson.
31
3.2.5
Costi di comunicazione
Il tempo di esecuzione di un algoritmo distribuito su p processori dipende anche dal tempo di

comunicazione tra i processori Tcom .
T(p) = Ts +
Tc
+ Tcom
p
Introduciamo alcuni parametri di valutazione di un software parallelo che considerano il tempo di

comunicazione.
Def. : Loverhead di comunicazione unitario OC e` il rapporto fra il tempo che il processore impiega
per effettuare una comunicazione con un altro processore e il tempo che il processore impiega per
effettuare unoperazione floating point:
tcom
OC =
tcalc
Questo parametro dipende dallambiente di calcolo, in generale vale che OC > 1. Loverhead di
comunicazione totale OC(p) e` il rapporto fra il tempo speso da un algoritmo nella comunicazione e
il tempo di esecuzione
T(p)com
OC(p) =
T(p)calc
OC(p) indica il peso delle comunicazioni sul tempo di esecuzione dellalgoritmo.
3.2.6
Calcolo di T(1)
La modalità di calcolo del tempo T(1) riveste un ruolo fondamentale nel calcolo dello speed up e
in merito a tutte le considerazioni che possono essere fatte di conseguenza.
T(1) puo` essere calcolato come il tempo desecuzione del miglior algoritmo sequenziale che risolve
il problema considerato. Lo speed up ottenuto facendo riferimento a questa prima definizione di
T(1) quantifica la riduzione del tempo di risoluzione di un problema in ambiente parallelo. Questa
definizione di T(1) e` poco applicabile perchè per un problema non e` sempre possibile individuare il
miglior algoritmo sequenziale e reperire il software che lo implementa.
In alternativa T(1) puo` essere calcolato come il tempo desecuzione di un algoritmo parallelo in
sequenziale su un solo processore. In questo caso lo speed up indica quanto un determinato algoritmo
si presta allesecuzione in parallelo. Il problema e` che lesecuzione di un algoritmo parallelo in
sequenziale potrebbe comportare lesecuzione di piu` operazioni del necessario.
In generale conviene utilizzare per T(1) il tempo di esecuzione dellalgoritmo parallelo che gira su
un unico processore.
3.3
Analisi degli algoritmi in ambiente MIMD DM per il calcolo della

somma
Consideriamo lalgoritmo sequenziale per la somma di N = 16 valori. Ad ogni passo lunico

processore utilizzato incrementa la somma parziale sommando un nuovo elemento per un totale di
15 passi computazionali (fig. 3.2).
T(1)16 = 15tcalc
32
Piu` in generale, lalgoritmo sequenziale per la somma di N valori ha costo pari a N 1 addizioni.
Figura 3.2: Per sommare N = 16 elementi con un algoritmo sequenziale sono necessarie 15 addizioni.
T(1) = N 1
Le tre strategie per il calcolo della somma di N numeri viste nel capitolo precedente hanno in comune
la prima fase di calcolo puramente parallela, durante la quale vengono eseguite concorrentemente
N
a
p 1 addizioni. Una volta ottenute le p somme parziali, le tre strategie si distinguono per la modalit`
e il numero di comunicazioni/aggregazioni fra i processori per il calcolo della somma complessiva a
partire dalle somme parziali.
T(p) = Tsomme parziali + Tcomunicazione + Taggregazione =
3.3.1
N
1 + Tcomunicazione + Taggregazione
p
I strategia
Applichiamo la prima strategia per il calcolo della somma di N = 16 valori con p = 2, 4, 8 processori
(fig. 3.3).
Se disponiamo di 2 processori P0 e P1 , entrambi calcolano la somma parziale di 8 elementi e infine la
somma complessiva viene ottenuta come somma delle due somme parziali (fig. 3.3a). I due processori
calcolano concorrentemente la somma degli 8 elementi di propria competenza: vengono effettuate 7
operazioni di addizione su ciascun processore, per un totale di 14 addizioni. Infine il processore P1
invia la propria somma parziale s1 a P0 e P0 calcola la somma complessiva SUMTOT = s0 + s1 .
Complessivamente vengono eseguite 15 operazioni di addizione in 8 passi temporali (i primi 7 passi
sono necessari per ottenere le due somme parziali, lultimo per aggregarle); va aggiunto un passo
temporale di comunicazione per linvio di s1 .
T(2)16 = 7tcalc + tcom + tcalc = 8tcalc + tcom
Se disponiamo di 4 processori P0 , P1 , P2 e P3 , ciascuno calcola la somma parziale di 4 elementi, poi
uno ad uno i risultati intermedi vengono comunicati al processore leader P0 che li aggrega insieme
ottenendo la somma finale (fig. 3.3b). Ogni processore calcola concorrentemente la somma dei 4
elementi di propria competenza tramite tre operazioni di addizione: vengono effettuate 3 operazioni
di addizione su ciascun processore, per un totale di 12 addizioni. In seguito un processore alla volta
invia a P0 la propria somma parziale: allistante t il processore P1 invia s1 a P0 (una comunicazione),
P0 riceve s1 e calcola SUMTOT = s0 + s1 (una addizione); successivamente il processore P2 invia s2 a P0
33
(una comunicazione), P0 riceve s2 e calcola SUMTOT = SUMTOT +s2 (una addizione); infine il processore
P3 invia s3 a P0 (una comunicazione), P0 riceve s3 e calcola SUMTOT = SUMTOT +s3 (una addizione).
sono necessari per ottenere le quattro somme parziali, gli altri tre per aggregarle); vanno aggiunti tre
passi temporali di comunicazione per linvio di s1 , s2 e s3 .
T(4)16 = 3tcalc + 3tcom + 3tcalc = 6tcalc + 3tcom
Se disponiamo di 8 processori ciascuno calcola la somma parziale di 2 elementi, poi uno ad uno
i risultati intermedi vengono comunicati al processore leader P0 che li aggrega insieme ottenendo
la somma finale (fig. 3.3c). Ogni processore calcola concorrentemente la somma dei 2 elementi di
propria competenza con unoperazione di addizione: gli 8 processori eseguono concorrentemente
unaddizione ciascuno, per un totale di 8 addizioni. In seguito un processore alla volta invia a P0
la propria somma parziale: allistante t il processore P1 invia s1 a P0 (una comunicazione), P0 riceve
s1 e calcola SUMTOT = s0 + s1 (una addizione); successivamente il processore P2 invia s2 a P0 (una
comunicazione), P0 riceve s2 e calcola SUMTOT = SUMTOT +s2 (una addizione); ... ; infine il processore
P7 invia s7 a P0 (una comunicazione), P0 riceve s7 e calcola SUMTOT = SUMTOT +s7 (una addizione).
Complessivamente vengono eseguite 15 operazioni di addizione in 8 passi temporali (il primo passo
e` necessario per ottenere le otto somme parziali, gli altri sette per aggregarle); vanno aggiunti sette
passi temporali di comunicazione per linvio di s1 , s2 , ... e s7 .
T(8)16 = 1tcacl + 7tcom + 7tcalc = 8tcalc + 7tcom
Nella tabella 3.1 sono riportati i tempi desecuzione appena calcolati (ignorando le comunicazioni)
e i conseguenti speed up, speed up ideale, overhead totale e efficienza. Lo speed up maggiore si ottiene
con 4 processori: il tempo desecuzione e` 2.5 volte piu` piccolo rispetto alla versione sequenziale,
mentre lalgoritmo con prestazioni piu` vicine a quelle ideali fa uso di 2 processori.
Lo speed up dellalgoritmo con 8 processori e` lontano da quello ideale e questo algoritmo e` poco
efficiente. Questo algoritmo, infatti, non sfrutta le risorse disponibili: ogni processore al primo
passo (fig. 3.3c) effettua una sola operazione di addizione; inoltre lo speed up ottenuto (1.875) e`
insignificante rispetto al numero di processori adottati.
p
T(p)
S(p)
S(p)ideale
Oh (p)
E(p)
8tcalc
2 8 15 = 1
6tcalc
4 6 15 = 9
8tcalc
15tcalc
8tcalc = 1.875
15tcalc
6tcalc = 2.5
15tcalc
8tcalc = 1.875
8 8 15 = 49
1.875
2 = 0.94
2.5
4 = 0.625
1.875
8 = 0.23
Tabella 3.1: Analisi della prima strategia per la somma di 16 valori su p = 2, 4, 8 processori. Lalgoritmo che usa 2 processori
e` quello piu` efficiente, lalgoritmo che usa 4 processori e` quello piu` veloce.
Piu` in generale questo algoritmo calcola la somma di N valori su p processori con tempo
!
N
1 tcalc + (p 1)tcalc + (p 1)tcom
T(p) =
p
34
(a)
(b)
(c)
Figura 3.3: (3.3a) Per sommare N = 16 elementi con la prima strategia impiegando due processori sono necessari complessivamente 8 passi temporali (ignorando le comunicazioni): nei primi 7 passi temporali i due processori calcolano
le somme parziali dei primi e degli ultimi (risp. in blu e in verde) 8 elementi, lultimo istante temporale serve
per calcolare la somma complessiva a partire dalle due somme parziali.
(3.3b) Per sommare N = 16 elementi con la prima strategia impiegando quattro processori sono necessari complessivamente 6 passi temporali (ignorando le comunicazioni): nei primi 3 passi temporali i quattro processori
calcolano le somme parziali degli elementi di propria competenza, negli altri tre passi temporali le somme
parziali vengono combinate insieme una ad una.
(3.3c) Per sommare N = 16 elementi con la prima strategia impiegando otto processori sono necessari complessivamente 8 passi temporali (ignorando le comunicazioni): al primo passo ogni processore calcola la somma
della coppia di valori di pripria competenza, gli altri 7 istanti temporali sono necessari per combinare insieme
una alla volta le somme parziali.
In generale
tcom = ctcalc
con 2 < c < 3
quindi
!
N
T(p) =
1 tcalc + (p 1)tcalc + c(p 1)tcalc
p
Nella tabella 3.2 vengono definiti schematicamente lo speed up, lefficienza e loverhead totale di
questo algoritmo con N generico ignorando e tenendo in considerazione i costi di comunicazione:
Oh (p)

1 tcalc + (p 1)tcalc
N1

<p
N
1
+(p1)
p

i
1 tcalc + (p 1)tcalc (N 1)tcalc

T(p)
S(p)
p
h
N
p
E(p)

1 tcalc + (p 1)tcalc + c(p 1)tcalc

N1
<p
N
1
+(p1)+c(p1)
p

i
1 tcalc + (p 1)tcalc + c(p 1)tcalc (N 1)tcalc

N
p
h
N
p
N
p

N
p 1 +(p1)
p
N
p 1
+(p1)+c(p1)
p
Tabella 3.2: Analisi della prima strategia per la somma di N valori su p processori.
Esercizio 1 : Applichiamo la legge di Amdahl per il calcolo dello speed up e dellefficienza

della prima strategia per la somma di N = 32 valori con p = 2, 4, 8, 16 processori. I valori
riportati nella tabella 3.3 indicano chiaramente che per p = 2 o p = 4 questo algoritmo sfrutta
35
in modo efficiente lambiente di calcolo parallelo; con un numero maggiore di processori le

prestazioni degradano perchè i processori non sono sfruttati abbastanza o, in altri termini,
perchè la parte parallela distribuita fra i vari processori diminuisce. Per questo motivo non
conviene usare un numero eccessivo di processori.
N
32
32
32
32
2
4
8
16
1
31
3
31
7
31
15
31
= 0.484
1
p
30 1
31 2 =
28 1
31 4 =
24 1
31 8 =
15
31
7
31
3
31
0.032
S(p)
S(p)ideale
E(p)
1.9
3.1
3.1
1.9
2
4
8
16
0.97
0.77
0.39
0.12
Tabella 3.3: Applicazione della legge di Amdahl per il calcolo dello speed up e dellefficienza del primo algoritmo per la
somma di N = 32 valori con p = 2, 4, 8, 16 processori.

della prima strategia per la somma di N = 8, 16, 32, 64 valori con 2 processori. I valori riportati
nella tabella 3.4 indicano chiaramente che al crescere del numero di elementi da sommare
N, lalgoritmo diventa via via piu` parallelizzabile quindi la frazione di operazioni eseguite
(1)
in seriale tende a zero; al contrario la frazione di operazioni eseguite in parallelo p e`
costante. Lo speed up e lefficienza sono perlopiu` costanti, o meglio al crescere di N lo speed
up tende ad avvicinarsi a quello ideale e lalgoritmo diventa sempre piu` efficiente: questo
perchè aumenta lo sfruttamento dei processori disponibili. Tuttavia non e` possibile aumentare
in maniera indefinita la dimensione del problema N perchè ogni processore ha una memoria
di dimensioni finite cioè puo` memorizzare non piu` di Nmax elementi!
N
8
16
32
64
2
2
2
2
1
7
1
15
1
31
1
63
1
p
61
72 =
14 1
15 2 =
30 1
31 2 =
62 1
63 2 =
3
7
7
15
15
31
31
63
S(p)
S(p)ideale
E(p)
1.75
1.88
1.93
1.97
2
2
2
2
0.875
0.94
0.96
0.99
somma di N = 8, 16, 32, 64 valori con 2 processori.

della prima strategia per la somma di N = 8, 16, 32, 64 valori con p = 2, 4, 8, 16 processori. Negli
esempi considerati il rapporto Np = 4 e` costante. I valori riportati nella tabella 3.5 indicano che
al crescere del numero di processori e della dimensione del problema le prestazioni degradano:
cio` accade perchè questa strategia presenta una non trascurabile parte sequenziale che aumenta
36
8
16
32
64
2
4
8
16
1
7
3
15
7
31
15
63
1
p
61
3
72 = 7
3
12 1
15 4 = 15
24 1
3
31 8 = 31
48 1
3
63 16 = 63
S(p)
S(p)ideale
E(p)
1.75
2.5
3.1
3.51
2
4
8
16
0.875
0.625
0.39
0.22
somma di N = 8, 16, 32, 64 valori con p = 2, 4, 8, 16 processori.
allaumentare del numero di processori. Questo e` proprio il risultato che ci aspettavamo: la

prima strategia e` la peggiore fra le tre strategie presentate.
Finora abbiamo ignorato i costi di comunicazione; considerando il tempo di comunicazione le
prestazioni dellalgoritmo possono cambiare notevolmente. Posto
OC =
tcom
= 2 = tcom = 2tcalc
tcalc
ricalcoliamo il tempo desecuzione, lo speed up, lo speed up ideale, e lefficienza di questo algoritmo
per N = 16 elementi su p = 2, 4, 8 processori; aggiungiamo a questi parametri anche loverhead di
comunicazione unitario per stabilire il peso della comunicazione sul tempo di calcolo di ogni algoritmo
(tab. 3.6). Lalgoritmo piu` efficiente e piu` veloce e` quello che usa 4 processori: questo algoritmo
bilancia meglio degli altri due il numero di operazioni eseguite concorentemente dai processori e il
numero di comunicazioni. Nellalgoritmo parallelo che fa uso di 4 processori la comunicazione ha
un peso maggiore sul tempo desecuzione. Ignorando i costi di comunicazione lo speed up maggiore
si ottiene con 4 processori, mentre lalgoritmo con prestazioni piu` vicine a quelle ideali fa uso di 2
processori (tab. 3.1).
p
T(p)
8tcalc + 7tcom = 22tcalc
S(p)
15tcalc
22tcalc
15tcalc
12tcalc
15tcalc
22tcalc
S(p)ideale
E(p)
OC(p)
= 0.68
= 1.25
= 0.68
0.68
2 = 0.34
1.25
4 = 0.31
1.875
8 = 0.04
7tcom
14
8tcalc = 8 tcalc = 1.75
3tcom
6
6tcalc = 6 tcalc = 1
7tcom
14
Tabella 3.6: Analisi della prima strategia per la somma di 16 valori su p = 2, 4, 8 processori tenendo presenti i tempi di
comunicazione. Lalgoritmo che usa 4 processori e` quello piu` efficiente e piu` veloce.
3.3.2
II strategia
Applichiamo la seconda strategia per il calcolo della somma di N = 16 valori con p = 2, 4, 8 processori (fig. 3.4).
Se disponiamo di 2 processori, entrambi effettuano concorrentemente 7 addizioni, dopodichè il processore P1 invia la propria somma parziale s1 a P0 che calcola SUMTOT = s0 + s1 (fig. 3.4a).
37
sono necessari per ottenere le due somme parziali, lultimo per aggregarle); va aggiunto un passo
temporale di comunicazione per linvio di s1 .
T(2)16 = 8tcalc + tcom
Se disponiamo di 4 processori (fig. 3.3b), ciascuno calcola la somma parziale di 4 elementi. Ogni
processore effettua 3 operazioni di addizione per un totale di 12 operazioni concorrenti: questa prima fase impiega 3 unità temporali. Successivamente si formano due coppie di processori
(mittente, ricevente/aggregante) (fig. 3.4b): nella coppia (P0 , P1 ) il processore P1 invia s1 a P0 che calcola
s0,1 = s0 + s1 ; contemporaneamente nella coppia (P2 , P3 ) il processore P3 invia s3 a P2 che calcola
s2,3 = s2 + s3 . Al termine di questo primo passo di comunicazione restano attivi solo i processori P0 e
P2 . Si forma, quindi, la coppia (P0 , P2 ): P2 invia s2,3 a P0 che calcola SUMTOT = s0,1 + s2,3 .
sono necessari per ottenere le quattro somme parziali, gli altri due per aggregarle). Vanno aggiunti
due passi temporali di comunicazione: al primo passo vengono inviati concorrentemente s1 a P0 e s3
a P2 , al secondo passo viene inviato s2,3 a P0 .
T(4)16 = 3tcalc + 2tcom + 2tcom = 5tcalc + 2tcom
Se disponiamo di 8 processori (fig. 3.4c), ciascuno calcola la somma parziale di 2 elementi: vengono
effettuate concorrentemente 8 addizioni in un solo passo temporale. Allistante successivo le 8 somme
parziali vengono aggregate a 2 a 2: vengono eseguite 4 addizioni in un unico passo temporale. Allo
step successivo le 4 somme parziali vengono aggregate di nuovo a coppie: si eseguono 2 operazioni
di addizione in un solo passo temporale. Infine le 2 somme parzali vengono combinate insieme per
ottenere la somma totale.
Complessivamente vengono eseguite 15 operazioni di addizione in 4 passi temporali (8 addizioni al
primo passo, 4 al secondo, 2 al terzo, 1 al quarto); vanno aggiunti tre passi temporali di comunicazione.
T(8)16 = 1tcalc + 3tcom + 3tcalc = 4tcalc + 3tcom
Nella tabella 3.7 sono riportati i tempi desecuzione calcolati precedentemente (ignorando le
comunicazioni) e i conseguenti speed up, speed up ideale, overhead totale e efficienza. Lo speed
up maggiore si ottiene con 8 processori: il tempo desecuzione e` 3.75 volte piu` piccolo rispetto alla
versione sequenziale, mentre lalgoritmo col minor overhead e` quello che usa 2 processori.
Lalgoritmo piu` efficiente e` quello che usa 2 processori. Questo algoritmo fa un miglior uso delle
risorse e il suo speed up e` prossimo a quello ideale: ogni processore al primo passo (fig. 3.4a) effettua 7
operazioni di addizione. Lalgoritmo che usa 8 processori e` piu` veloce ma non e` efficiente perchè non
sfrutta le risorse disponibili: ogni processore al primo passo (fig. 3.4c) effettua una sola operazione
di addizione. In altre parole lalgoritmo con 8 processori non fa un uso ottimizzato delle risorse: con
8 processori ci si aspetterebbe una riduzione del tempo di esecuzione molto piu` grande
Piu` in generale questo algoritmo calcola la somma di N valori su p processori con tempo
!
!
N
N
T(p) =
1 tcalc + (log2 p)tcalc + (log2 p)tcom =
1 tcalc + (log2 p)tcalc + c(log2 p)tcalc
p
p
38
(a)
(b)
(c)
Figura 3.4: (3.4a) Per sommare N = 16 elementi con la seconda strategia impiegando due processori sono necessari complessivamente 8 passi temporali (ignorando le comunicazioni): nei primi 7 passi temporali i due processori calcolano
(3.4b) Per sommare N = 16 elementi con la seconda strategia impiegando quattro processori sono necessari
complessivamente 5 passi temporali (ignorando le comunicazioni): nei primi 3 passi temporali i quattro processori calcolano le somme parziali degli elementi di propria competenza, negli altri due passi temporali le somme
parziali vengono combinate insieme a coppie.
(3.4c) Per sommare N = 16 elementi con la seconda strategia impiegando otto processori sono necessari complessivamente 4 passi temporali (ignorando le comunicazioni): al primo passo ogni processore calcola la somma
della coppia di valori di propria competenza, gli altri 3 istanti temporali sono necessari per combinare insieme
le coppie di somme parziali.
T(p)
S(p)
S(p)ideale
Oh (p)
E(p)
8tcalc
O(2 log2 2) = 2
0.94
5tcalc
O(4 log2 4) = 8
0.75
4tcalc
15tcalc
8tcalc = 1.875
15tcalc
5tcalc = 3
15tcalc
4tcalc = 3.75
O(8 log2 8) = 24
0.47
Tabella 3.7: Analisi della seconda strategia per la somma di 16 valori su p = 2, 4, 8 processori. Lalgoritmo piu` efficiente e`
quello che usa 2 processori ma lalgoritmo piu` veloce e` quello che usa 8 processori; daltro canto loverhead
totale ottenibile con 8 processori e` maggiore delloverhead totale ottenuto usando 2 processori. Inoltre usando
8 processori si ottiene uno speed up appena pari a 4.
e overhead
Oh (p) = pT(p) T(1)
!
N
1 + log2 p (N 1)
=p
p
= N p + p log2 p N + 1
= O(p log2 p)
questo algoritmo con N generico ignorando e tenendo in considerazione i costi di comunicazione:
questo algoritmo con p = 2k ignorando e tenendo in considerazione i costi di comunicazione:
Esercizio 4 : Applichiamo la legge di Amdahl generalizzata per il calcolo dello speed up
e dellefficienza del secondo algoritmo per la somma di N = 32 valori con p = 2, 4, 8, 16
39
Oh (p)

1 tcalc + (log2 p)tcalc
N1

<p
n
1 +(log2 p)
p

i
1 + (log2 p) tcalc (N 1)tcalc
= O(p log2 p)

T(p)
S(p)
p
h
N
p
N
p
N
p 1
E(p)
h
N
p
+(log2 p)

1 tcalc + (log2 p)tcalc + c(log2 p)tcalc
N1

<p
n
1 +(log2 p)+c(log2 p)
p

i
1 + (log2 p) + c(log2 p) tcalc (N 1)tcalc
= O(p log2 p)

N
p
N
p 1
+(log2 p)+c(log2 p)
Tabella 3.8: Analisi della seconda strategia per la somma di N valori su p processori.
T(p)
S(p)
N
2k

1 tcalc + ktcalc
N1
<p
n
2k
Oh (p)
h
N
2k
1 +k
1 + k tcalc (N 1)tcalc = O(2k k)

N
k 1 +k
h
N
2k

1 tcalc + ktcalc + cktcalc
N1

<p
n
k 1 +k+ck
2

i
1 + k + ck tcalc (N 1)tcalc = O(2k k)
E(p)
N
2k
N
1
2k
+k+ck
2k
Tabella 3.9: Analisi della seconda strategia per la somma di N valori su p = 2k processori.
processori. I valori riportati nella tabella 3.10 indicano chiaramente che lalgoritmo con p = 2
e` quello piu` efficiente ed usa in modo ottimizzato le risorse. Gli algoritmo con p = 4, 8, 16
processori presentano un maggior speed up ma non fanno un uso ottimizzato delle risorse:
al crescere del numero di processori adottati le prestazioni degradano perchè i processori non
sono sfruttati abbastanza.
N
32
p
2
32
32
32
8
16
1
31
1
31
1
31
1
31
30
31
2
31
2
31
2
31
4
28
31
4
31
4
31
24
31
8
31
16
16
31
S(p)
1
1
31
= 1
30 1 = 16 = 1.94
1 + 22
31 + 31 2
1
1
31
= 1
2 1 28 1 9 = 3.4
1 + 22 + 44
31 + 31 2 + 31 4
1
1
31
= 1
2 1
4 1 24 1 = 6 = 5.17
+
+
+
1 + 22 + 44 + 88
31 31 2 31 4 31 8
1
1
31
2 4 8 16 = 1
2 1
4 1
8 1 16 1 = 5 =
1 + 2 + 4 + 8 + 16
31 + 31 2 + 31 4 + 31 8 + 31 16
6.2
S(p)ideale
2
E(p)
0.97
0.85
0.65
16
0.38
Tabella 3.10: Applicazione della legge di Amdahl generalizzata per il calcolo dello speed up e dellefficienza del secondo
algoritmo per la somma di N = 32 valori con p = 2, 4, 8, 16 processori.
Esercizio 5 : Applichiamo la legge di Amdahl generalizzata per il calcolo dello speed up e

dellefficienza della seconda strategia per la somma di N = 8, 16, 32, 64 valori con 2 processori. I
valori riportati nella tabella 3.11 indicano chiaramente che al crescere del numero di elementi da
sommare N, lalgoritmo diventa via via piu` parallelizzabile quindi piu` efficiente; la frazione
di operazioni eseguite in seriale tende a zero, il carico di ciascun processore cresce lentamente
40
e lo speed up tende ad avvicinarsi a quello ideale. Non si puo` aumentare in maniera indefinita
la dimensione del problema N perchè ogni processore ha una memoria limitata!
N
8
p
2
16
32
64
1
7
1
15
1
31
1
63
6
7
14
15
30
31
62
63
S(p)
=
1
1
= 1 6 1
1 + 22
7+7 2
1
1
= 1
14 1
1 + 22
15 + 15 2
1
1
= 1
30 1
1 + 22
31 + 31 2
1
1
= 1
62 1
1 + 22
63 + 63 2
7
4 = 1.75
= 15
8 = 1.875
31
= 16
= 1.94
63
= 32 = 1.97
S(p)ideale
2
E(p)
0.875
0.94
0.97
0.98
Tabella 3.11: Applicazione della legge di Amdahl per il calcolo dello speed up e dellefficienza del secondo algoritmo per
la somma di N = 8, 16, 32, 64 valori con 2 processori.
Esercizio 6 : Applichiamo infine la legge di Amdahl generalizzata per il calcolo dello speed up
e dellefficienza della seconda strategia per la somma di N = 8, 16, 32, 64 valori con p = 2, 4, 8, 16
processori. Negli esempi considerati il rapporto Np = 4 e` costante. I valori riportati nella
tabella 3.12 indicano che incrementando contemporaneamente il numero di processori p e la
dimensione del problema N lefficienza e` quasi costante.
N
8
16
p
2
4
32
64
16
1
7
1
15
1
31
1
63
6
7
2
15
2
31
2
63
4
12
15
4
31
4
63
16
1
1 6
7+7
24
31
8
63
1
2
S(p)
= 47 = 1.75
1
1
2 1 12 1
15 + 15 2 + 15 4
48
63
=3
1
31
1
2 1
4 1 24 1 = 6 = 5.17
31 + 31 2 + 31 4 + 31 8
63
1
1
2 1
4 1
8 1 48 1 = 7 = 9
63 + 63 2 + 63 4 + 63 8 + 63 16
S(p)ideale
2
E(p)
0.875
0.75
0.646
16
0.56
Tabella 3.12: Applicazione della legge di Amdahl per il calcolo dello speed up e dellefficienza della seconda strategia per
la somma di N = 8, 16, 32, 64 valori con p = 2, 4, 8, 16 processori.
Esercizio 7 : Calcoliamo il valore k che garantisce lefficienza del secondo algoritmo per la
somma di N valori sia costante:
N1 1 = (N0 1)
p1 log2 p1
= I(p0 , p1 , N0 )
p0 log2 p0
Per garantire la costanza dellefficienza scalata dellalgoritmo per il calcolo della somma di N
valori, la dimensione del problema e il numero di processori devono aumentare di un fattore
k=
p1 log2 p1 N1
=
p0 log2 p0 N0
41
Verifichiamo la scalabilità di questo algoritmo. Per p0 = 4 processori e N0 = 64 valori il

tempo
di esecuzione
in sequenziale e` T(1, 64) = 63, mentre quello in parallelo e` T(4, 64) =

64
4 1 + log2 64 tcalc = 9tcalc .
Passiamo a p1 = 8 processori: dobbiamo determinare il valore N1 che garantisca lisoefficienza
N1 :
N1 8 log2 8
24
=
= N1 = 64 = 192
64
4 log2 4
8
Passiamo a p2 = 16 processori: dobbiamo determinare il valore N2 che garantisca lisoefficienza

facendo riferimento a N0 , p0 , T(1, N0 )
N2 :
N2 16 log2 16
64
=
= N2 = 64 = 512
64
4 log2 4
8
Calcoliamo il tempo desecuzione in ciascun caso:

T(1, 64) = 63
64
T(4, 64) =
1 + log2 4 = 16 1 + 2 = 17
4
64
T(8, 64) =
1 + log2 8 = 8 1 + 3 = 10
8
64
T(16, 64) =
1 + log2 16 = 4 1 + 4 = 7
16
T(1, 192) = 191
192
T(4, 192) =
1 + log2 4 = 48 1 + 2 = 49
4
192
T(8, 192) =
1 + log2 8 = 24 1 + 3 = 26
8
192
1 + log2 16 = 12 1 + 4 = 15
T(16, 192) =
16
T(1, 512) = 511
512
T(4, 512) =
1 + log2 4 = 128 1 + 2 = 129
4
512
T(8, 512) =
1 + log2 8 = 64 1 + 3 = 66
8
512
T(16, 512) =
1 + log2 16 = 32 1 + 4 = 35
16
Per definizione, lalgoritmo della somma e` scalabile se al crescere di p e N lefficienza e` costante.
Nella tabella 3.13 viene mostrata lefficienza per N = 64, 192, 512 e p = 4, 8, 16: i risultati ottenuti
dimostrano che lefficienza scalata e` costante se la dimensione del problema viene aumentata
p log p
di un fattore pari a p10 log2 p10 e il numero di processori viene aumentato di un fattore pari a 4:
2
sotto questi vincoli il secondo algoritmo per il calcolo della somma e` scalabile.
Finora abbiamo ignorato i costi di comunicazione; considerando il tempo di comunicazione le prestazioni dellalgoritmo possono cambiare notevolmente. Ricalcoliamo il tempo desecuzione, lo speed
42
p
n
64
192
512
16
1
1
1
0.92
0.97
0.99
0.78
0.91
0.96
0.56
0.79
0.91
Tabella 3.13: Valutazione dellefficienza del secondo algoritmo della somma per p = 1, 4, 8, 16 e n = 64, 192, 512.
up, lo speed up ideale, e lefficienza di questo algoritmo per N = 16 elementi su p = 2, 4, 8 processori;

aggiungiamo a questi parametri anche loverhead di comunicazione unitario per stabilire il peso della
comunicazione sul tempo di calcolo di ogni algoritmo (tab. 3.14). Lalgoritmo piu` veloce e` quello che
usa 4 processori, ma quello piu` efficiente ne usa 2. Nellalgoritmo parallelo che fa uso di 2 processori
la comunicazione ha un peso minore sul tempo desecuzione. Ignorando i costi di comunicazione,
lalgoritmo piu` efficiente e` quello che usa 2 processori ma lalgoritmo piu` veloce e` quello che usa 8
processori (tab. 3.7).
p
T(p)
S(p)
(7 + log2 2)tcalc + log2 2tcom = 10tcalc
15tcalc
10tcalc = 1.5
15tcalc
9tcalc = 1.67
15tcalc
10tcalc = 1.5
S(p)ideale
2
4
8
E(p)
OC(p)
1.5
2 = 0.75
1.67
4 = 0.42
1.5
8 = 0.19
1tcom
2
2tcom
4
3tcom
6
Tabella 3.14: Analisi della seconda strategia per la somma di 16 valori su p = 2, 4, 8 processori tenendo presenti i tempi di
comunicazione. Lalgoritmo che usa 2 processori e` quello piu` efficiente ed e` quello in cuila comunicazione ha
un peso minore sul tempo desecuzione.
3.3.3
III strategia
Applichiamo la terza strategia per il calcolo della somma di N = 16 valori con p = 2, 4, 8 processori
(fig. 3.5).
Il tempo desecuzione di questa strategia e` identico alla seconda strategia: cambia solo il numero
di operazioni di comunicazione/addizione effettuate concorrentemente ad ogni passo. Le coppie di
processori, infatti, non sono del tipo (mittente, ricevente) ma ciascuno dei due processori invia allaltro
la propria somma parziale e somma due risultati parziali. Ad ogni passo, inoltre, tutti i processori
sono attivi e alla fine tutti conoscono il risultato complessivo. Valgono le stesse considerazioni
sullo speed up, lefficienza, loverhead, la legge di Ware generalizzata, lisoefficienza e loverhead di
comunicazione fatte per la seconda strategia.
3.3.4
Confronto fra le tre strategie
La strategia piu` costosa in termini di operazioni di comunicazione/aggregazione e` sicuramente la

prima: infatti essa richede p 1 passi di comunicazione a fronte dei log2 p passi richiesti dalla seconda
e dalla terza strategia.
Sia con la prima che con la seconda strategia alla fine il risultato e` noto solo al processore leader,
43
(a)
(b)
(c)
Figura 3.5: (3.4a) Per sommare n = 16 elementi con la terza strategia impiegando due processori sono necessari complessivamente 8 passi temporali (ignorando le comunicazioni): nei primi 7 passi temporali i due processori calcolano
(3.4b) Per sommare n = 16 elementi con la terza strategia impiegando quattro processori sono necessari complessivamente 5 passi temporali (ignorando le comunicazioni): nei primi 3 passi temporali i quattro processori
calcolano le somme parziali degli elementi di propria competenza, negli altri due passi temporali i processori si
scambiano i propri risultati parziali e li aggregano.
(3.4c) Per sommare n = 16 elementi con la seconda strategia impiegando otto processori sono necessari complessivamente 4 passi temporali (ignorando le comunicazioni): al primo passo ogni processore calcola la somma
della coppia di valori di propria competenza, gli altri 3 istanti temporali sono necessari per lo scambio e
laggregazione di coppie di risultati parziali. Notiamo che da un passo allaltro le coppie cambiano.
mentre con la terza strategia e` noto a tutti. La scelta fra una strategia e laltra non puo` cadere soltanto
sul numero di processori che sono a conoscenza del risultato finale: si potrebbe usare, ad esempio, la
seconda strategia e poi fare in modo che alla fine il processore leader invii in broadcast a tutti gli altri
processori il risultato finale, con costo pari ad unoperazione di comunicazione.
Nella prima e nella seconda strategia il numero di processori attivi (cioè coinvolti nelle operazioni di
comunicazione/aggregazione) diminuisce ad ogni passo.
In particolare nella prima strategia ad ogni passo e` attivo un solo processore che invia il proprio
risultato parziale al leader, mentre nella seconda strategia ad un generico passo k (k [0, log2 p 1])
sono attivi 2log2 pk ed il numero di processori attivi si dimezza da un passo allaltro.
Al contrario nella terza strategia ad ogni passo sono attivi tutti i processori, quindi tutte le risorse
di calcolo disponibili sono sempre coinvolte: cio` potrebbe indurre a pensare che la terza strategia
sia piu` efficiente della seconda perchè sfrutta tutti i processori. In realtà piu` processori effettuano
concorrentemente le stesse operazioni; sarebbe piu` conveniente poter utilizzare per altri scopi la
potenza di calcolo dei processori che effettuano le stesse operazioni.
Il criterio usato ad ogni passo dal secondo e terzo algoritmo per individuare lo step fra due
processori comunicanti e` ma nella terza strategia ad ogni passo tutti i processori sono coinvolti
nella comunicazione: cio` significa che ad ogni passo la terza strategia prevede che venga eseguito
un numero maggiore di comunicazioni. Tuttavia tale caratteristica non ha alcun effetto sul tempo
desecuzione perchè le comunicazioni vengono effettuate in parallelo.
Queste tre strategie funzionano meglio quando N e` divisibile per p, altrimenti processori diversi
saranno caricati diversamente. La suddivisione dei dati fra i processori avviene in questo modo: si
calcola il resto della divisione
di N per p e tutti i processori con identificativo
l m
j k minore di tale resto
N
calcolano la somma di p elementi, mentre gli altri calcolano la somma di Np elementi.
Ad esempio se N = 30 e p = 4 (fig. 3.6) ci saranno alcuni processori piu` carichi perchè N non e`
divisibile per p. In particolare i primi N mod p = 30 mod 4 = 2 processori calcolano la somma di
44
l m
l m
j k j k
N
30
= 30
=
8
elementi,
mentre
gli
altri
calcolano
la
somma
di
4
p = 4 = 7 elementi. I processori
P0 e P1 effettuano una somma in piu` rispetto a P2 e P3 .
Nei calcoli per lefficienza, il tempo richiesto da questa parte di calcolo in parallelo e` pari al massimo fra
i tempi richiesti da ciascun processore, cioè 8tcalc . La seconda e la terza strategia sono particolarmente
N
p
Figura 3.6: Distribuzione di N = 30 valori fra p = 4 processori. I primi 2 processori calcolano la somma di 8 elementi
ciascuno, mentre gli ultimi 2 processori calcolano la somma di 7 elementi ciascuno. Il tempo richiesto da questa
fase di calcolo delle somme parziali e` 8tcalc .
adatte quando il numero di processori e` una potenza di due p = 2k
3.4
Analisi degli algoritmi in ambiente MIMD SM per il calcolo della

somma
Le strategie per la somma di N numeri in ambiente MIMD SM (par. 2.4) sono identiche a quelle
in ambiente MIMD DM (par. 2.3): vengono effettuate concorrentemente le stesse operazioni e le
stesse comunicazioni fra coppie di processori. Per questo motivo le prestazioni delle tre strategie
considerate in ambiente MIMD SM sono identiche a quelle viste per le tre strategie in ambiente
MIMD DM. Piuttosto che gestire le comunicazioni fra i processori, bisogna sincronizzare gli accessi
dei core alla memoria condivisa. Anche le considerazioni sulla legge di Ware restano valide perchè
essa non tiene conto delle comunicazioni.
45
Capitolo 4
Prodotto matrice per vettore

4.1
Algoritmo sequenziale
Il prodotto matrice vettore fra una matrice A <MN e un vettore colonna x <N genera un
vettore colonna y <M
Ax = y
A <MN , x <N , y <M
Il generico elemento y(i) e` dato dal prodotto scalare delli-sima riga della matrice A per il vettore x:
y(i) = Ai x
in cui indica loperazione di prodotto scalare e Ai indica la riga i-sima della matrice A.
Figura 4.1: Prodotto matrice vettore.
In un calcolatore tradizionale il vettore y e` generalmente calcolato componente per componente

secondo un ordine prestabilito.
Procedura 4.1: Algoritmo sequenziale per il prodotto matrice vettore.
begin
for i = 0 to M-1 do
y(i) := 0
for j = 0 to N-1 do
y(i) := y(i) + A(i,j) * x(j)
end for
46
end for
end
Il numero di operazioni da effettuare per il calcolo di un elemento y(i), con i [0, M1], come prodotto
scalare fra li-sima riga della matrice A e il vettore x e`
N + N 1 = 2N 1
Sia Ai che x sono vettori di N componenti, quindi per calcolarne il prodotto puntuale sono necessarie
N moltiplicazioni e per calcolare la somma del vettore di N componenti ottenuto dal prodotto componente per componente bisogna eseguire (N 1) addizioni.
Il prodotto fra una matrice A <MN e un vettore x <N consta di M prodotti scalari, uno per ogni
elemento del vettore y, quindi il tempo di calcolo del prodotto matrice vettore su un solo processore e`
T(1) = M(2N 1)tcalc
Affrontiamo questo stesso problema in ambiente MIMD con memoria distribuita e condivisa.
4.2
Algoritmo parallelo in ambiente MIMD Distributed-Memory
Di seguito sono riportate tre strategie per il calcolo del prodotto matrice vettore in ambiente MIMD
DM. Ogni strategia si basa sulla decomposizione della matrice A in blocchi e sullindipendenza degli
M prodotti scalari di dimensione N necessari per calcolare il vettore y.
4.2.1
I Strategia: distribuzione della matrice A per blocchi di righe
Se si hanno p processori, la matrice A <MN viene decomposta per righe in p blocchi di

dimensione M
p N (fig. 4.2), ciascuno memorizzato ed elaborato da un processore diverso: ogni
blocco e` indicato come Ai con i [0, p 1]. Il vettore x viene replicato per intero su tutti i p processori
(fig. 4.3).
Figura 4.2: Decomposizione della matrice A in p blocchi per riga. I blocchi ottenuti vengono distribuiti fra i processori.
47
Figura 4.3: Il vettore x viene replicato per intero su tutti i p processori.
Un generico processore Pi , con i [0, p 1], moltiplica il blocco Ai di dimensione

vettore x e calcola il sottovettore yi di
M
p
M
p
N per il
componenti.
Il problema originario, cioè il prodotto di una matrice A <MN per un vettore x <N , e` stato
decomposto in p sottoproblemi di dimensione M
p N risolvibili contemporaneamente su p processori:
ogni processore calcola concorrentemente il prodotto matrice vettore fra una matrice M
p N e un
vettore di N componenti. Tutti i processori eseguono lo stesso algoritmo ma su dati diversi.
A questo punto il vettore y e` spezzettato fra i p processori: nella memoria locale del primo processore ci saranno i primi M
a
p elementi del vettore y, nella memoria locale del secondo processore ci sar`
la seconda M
` necessario costruire
p -upla di elementi del vettore y e cos` via. Se per qualche motivo e
per intero il vettore y, tutti i processori possono scambiarsi i propri risultati parziali e combinarli
opportunamente: alla fine di questo procedimento ogni processore sarà a conoscenza del vettore y.
Questa strategia non richiede alcuna interazione fra i processori, ma prevede la replica del vettore
x su tutti i processori.
Procedura 4.2: Prima strategia per il prodotto matrice vettore in ambiente MIMD DM.
begin
// calcolo
for i = 0 to p-1 do
h := i*(M/p)
xlocal = x
Alocal = A([h,h + (M/p) -1],[0,N-1])
for j := 0 to (M/p) -1 do
ylocal(j) := 0
for k := 0 to N-1 do
ylocal(j) := ylocal(j) + Alocal(j,k) * xlocal(k)
end for
end for
end for
end
48
Esempio 7: Vediamo come viene calcolato il prodotto righe colonne di una matrice A di dimensione 66 per un vettore x di 6 componenti su 2 processori (fig. 4.4). Ogni processore si occupa di
6
una sottomatrice della matrice A di dimensione M
p N = 2 6 = 3 6; in altre parole la matrice
A viene suddivisa in p = 2 blocchi per righe ed ogni blocco viene assegnato ad un processore.
In questo esempio il processore P0 memorizza il blocco A0 = A([0, 2], [0, 5]), mentre il processore
P1 tiene in memoria il blocco A1 = A([3, 5], [0, 5]). Ciascuno dei due processori memorizza nella
propria memoria locale anche il vettore x.
Il processore P0 calcola il blocco y0 = y([0, 2]) del vettore y
y(0) A(0, 0)x(0) + A(0, 1)x(1) + A(0, 2)x(2) + A(0, 3)x(3) + A(0, 4)x(4) + A(0, 5)x(5)
y(1) = A(1, 0)x(0) + A(1, 1)x(1) + A(1, 2)x(2) + A(1, 3)x(3) + A(1, 4)x(4) + A(1, 5)x(5)
y(2)
A(2, 0)x(0) + A(2, 1)x(1) + A(2, 2)x(2) + A(2, 3)x(3) + A(2, 4)x(4) + A(2, 5)x(5)
P5
j=0 A(0, j)x(j)

P5
= j=0 A(1, j)x(j)

P5
j=0 A(2, j)x(j)

= A0 x
Il processore P1 calcola il blocco y1 = y([3, 5]) del vettore y
y(3) A(3, 0)x(0) + A(3, 1)x(1) + A(3, 2)x(2) + A(3, 3)x(3) + A(3, 4)x(4) + A(3, 5)x(5)
y(4) = A(4, 0)x(0) + A(4, 1)x(1) + A(4, 2)x(2) + A(4, 3)x(3) + A(4, 4)x(4) + A(4, 5)x(5)
A(5, 0)x(0) + A(5, 1)x(1) + A(5, 2)x(2) + A(5, 3)x(3) + A(5, 4)x(4) + A(5, 5)x(5)
y(5)
P5
j=0 A(3, j)x(j)
P5
= j=0 A(4, j)x(j)
P5 A(5, j)x(j)
j=0
= A1 x
Il prodotto matrice vettore originario e` stato decomposto in due prodotti matrice vettore: ogni
processore calcola il prodotto fra una matrice 36 e un vettore di 6 componenti.
" # "
# "
#
y0
y([0, 2])
A0 x
y=
=
=
y1
y([3, 5])
A1 x
4.2.2
Analisi delle prestazioni
Ricordiamo che il numero di operazioni per il prodotto scalare fra due vettori di lunghezza
N e` 2N 1 e che il tempo di calcolo del prodotto matrice vettore su un solo processore e` T(1) =
M(2N 1)tcalc . Abbiamo visto che il prodotto matrice vettore puo` essere espresso come M prodotti
scalari di lunghezza N fra loro indipendenti: eseguendo lalgoritmo appena descritto su p processori
M
la matrice A viene suddivisa in p blocchi M
p N e vengono eseguiti concorrentemente p prodotti
49
Figura 4.4: Calcolo del prodotto di una matrice A di dimensione 6 6 per un vettore x di 6 elementi decomponendo A in p = 2
blocchi per righe. Il processore P0 memorizza il vettore x (in blu) e il bloccoA0 = A([0, 2], [0, 5]) (in giallo) e calcola
il blocco y0 = y([0, 2]) (in verde). Il processore P1 memorizza il vettore x (in blu) e il bloccoA1 = A([3, 5], [0, 5])
(in rosso) e calcola y1 = y([3, 5]) (in rosa).
scalari di lunghezza N (fig. 4.5).

Il tempo desecuzione su p processori ignorando i costi di comunicazione e`
T(p) =
M
(2N 1)tcalc
p
Lo speed up ottenuto e`
S(p) =
T(1) M(2N 1)tcalc

M(2N 1)
= M
=p
=p
T(p)
M(2N 1)
p (2N 1)tcalc
Ricordiamo che p e` proprio il valore dello speed up ideale: cio` sta ad indicare che lalgoritmo
per il calcolo del prodotto matrice vettore con decomposizione per righe e` particolarmente adatto
allesecuzione in un ambiente di calcolo parallelo.
Ricordiamo che loverhead e` la differenza fra lo speed up ottenuto e lo speed up ideale: per il prodotto
matrice vettore calcolato con la decomposizione per righe loverhead Oh e` nullo:
Oh = pT(p) T(1) = p
M
(2N 1)tcalc M(2N 1)tcalc = 0
p
Vediamo, infine, se questo algoritmo e` efficiente. Ricordiamo che un algoritmo parallelo si dice
efficiente se e` in grado di sfruttare tutte le risorse della macchina parallela:
E(p) =
S(p) p
= =1
p
p
Anche il valore dellefficienza e` pari a quello ideale.

A conferma dei nostri risultati, applichiamo la legge di Ware per predire laumento dello speed up
con p processori. Il prodotto matrice vettore e` composto solo da M prodotti scalari parallelizzabili,
non presenta operazioni da eseguire in modo sequenziale, quindi
T(1) = Ts + Tc = 0 + Tc = Tc
50
(a)
(b)
(c)
(d)
Figura 4.5: Prodotto fra una matrice A <86 ed un vettore x <6 su 2 processori. Ogni processore si occupa di un blocco
4 6 della matrice A: P0 si occupa del blocco A0 = A([0, 3], [0, 5]) e P1 si occupa del blocco A1 = A([4, 7], [0, 5]).
Vengono eseguiti concorrentemente 28 = 4 prodotti scalari di lunghezza 6.
(4.5a) Al primo passo P0 calcola il prodotto scalare fra la riga A(0, [0, 5]) e il vettore x mentre il processore P1
concorrentemente calcola il prodotto scalare fra la riga A(4, [0, 5]) e il vettore x.
(4.5b) Al secondo passo P0 calcola il prodotto scalare fra la riga A(1, [0, 5]) e il vettore x mentre il processore P1
(4.5c) Al terzo passo P0 calcola il prodotto scalare fra la riga A(2, [0, 5]) e il vettore x mentre il processore P1
(4.5d)Al quarto passo P0 calcola il prodotto scalare fra la riga A(3, [0, 5]) e il vettore x mentre il processore P1
Posto T(1) = 1, Ts = e Tc = (1 ), il tempo T(p) diventa

T(p) = Ts +
Tc
1
1 1
=+
=0+
=
p
p
p
p
Anche lo speed up calcolato con la legge di Ware e` pari a p

S(p) =
T(1) 1
= 1 =p
T(p)
p
4.2.3
II Strategia: distribuzione della matrice A per blocchi di colonne
Se si hanno p processori, la matrice A <MN viene decomposta per colonne in p blocchi di

dimensione M Np (fig. 4.6), ciascuno memorizzato ed elaborato da un processore diverso: ogni
blocco e` indicato come Ai con i [0, p 1]. Il vettore x viene distribuito per righe fra i p processori
(fig. 4.7): ogni blocco e` indicato come xi con i [0, p 1].
Un generico processore Pi , con i [0, p 1], moltiplica il blocco Ai per il sottovettore xi e calcola
un vettore ri di M componenti:
ri = Ai xi
i [0, p 1]
Il problema originario, quindi, e` stato decomposto in p sottoproblemi di dimensione M

N
p
N
p
N
p:
ogni
processore calcola il prodotto matrice vettore fra una matrice M e un vettore di componenti.
Tutti i processori eseguono concorrentemente lo stesso algoritmo ma su dati diversi.
A questo punto nella memoria locale di ogni processore Pi si trova un vettore ri di M componenti che
contribuisce alla costruzione del vettore risultato y.
y=
p1
X
ri = r0 + r1 + r2 + + rp1 = A0 x0 + A1 x1 + A2 x2 + + Ap1 xp1
i=0
51
Figura 4.6: Decomposizione della matrice A in p blocchi per colonna. I blocchi ottenuti vengono distribuiti fra i processori.
Figura 4.7: Il vettore x viene distribuito fra tutti i p processori.
Per ottenere il vettore y bisogna calcolare la somma vettoriale di tutti i vettori ri . Si puo` usare una
qualsiasi delle tre strategie per il calcolo della somma di N valori (par. 2.3.1, 2.3.2, 2.3.3).
Usando questa strategia tutti i dati sono distribuiti tra i processori, anche il vettore x.
Procedura 4.3: Seconda strategia per il prodotto matrice vettore in ambiente MIMD DM.
begin
//calcolo
for i = 0 to p-1 do
h := i*(N/p)
xlocal = x([h,h+ (N/p) - 1])
Alocal = A([0,M-1],[h,h + (N/p) - 1])
for j := 0 to M -1 do
r_i(j) := 0
for k := 0 to (N/p) -1 do
r_i(j) := r_i(j) + Alocal(j,k) * xlocal(k)
end for
end for
end for
// strategia di comunicazione
end
52
Figura 4.8: Esempio del processo di scambio/aggregazione dei risultati parziali fra 8 processori con la terza strategia per
la somma degli N elementi di un vettore (par. 2.3.3). Al primo passo le coppie (P0 , P1 ), (P2 , P3 ), (P4 , P5 ) e
(P6 , P7 ) si scambiano i propri risultati parziali ri e ne calcolano la somma. Al secondo passo questo stesso
procedimento di scambio viene ripetuto fra coppie adiacenti di processori: P0 e P1 inviano r0,1 rispettivamente
a P2 e P3 , P4 e P5 inviano r4,5 rispettivamente a P6 e P7 , P2 e P3 inviano r2,3 rispettivamente a P0 e P1 , P6 e
P7 inviano r6,7 rispettivamente a P2 e P3 . Ogni processore aggrega i risultati parziali nella propria memoria:
P0 , P1 , P2 e P3 calcolano r0,1,2,3 = r0,1 + r2,3 = r0 + r1 + r2 + r3 ; concorrentemente P4 , P5 , P6 e P7 calcolano
r4,5,6,7 = r4,5 + r6,7 = r4 + r5 + r6 + r7 . Infine lo scambio viene ripetuto fra gruppi di 4 processori: P0 , P1 , P2 e P3
inviano r0,1,2,3 rispettivamente a P4 , P5 , P6 e P7 ; concorrentemente P4 , P5 , P6 e P7 inviano r4,5,6,7 rispettivamente
a P0 , P1 , P2 e P3 . Ciascun processore dispone di tutti i risultati parziali per poter calcolare il prodotto matrice
vettore finale (ovvero la somma vettoriale di tutti i risultati parziali): ad esempio P0 calcola y = r0,1,2,3 + r4,5,6,7 =
r0 + r1 + r2 + r3 + r4 + r5 + r6 + r7 .
53
Procedura 4.4: Prima strategia di comunicazione.
forall P_i,
0 <= i <= p-1 do
if P_0 then
y := r_0
for k = 1 to p-1 do
receive r_k from P_k
y := y + r_k
end for
else if P_i then
send r_i to P_0
end if
end forall
Procedura 4.5: Seconda strategia di comunicazione.

forall P_i,
i = 0 to p-1 do
// individuazione dei partecipanti alla comunicazione
if (i mod 2k ==0)
// individuazione dei riceventi
if(i mod 2(k+1) )
receive r_{i+2k} from P_{i+2k}
r_i := r_i + r_{i+2k}
// individuazione dei mittenti
else
send r_i to P_{i-2k}
end if
end forall
end for
Procedura 4.6: Terza strategia di comunicazione.

forall P_i,
i = 0 to p-1 do
resto := i mod 2(k+1)
if (resto < 2k)
receive r_{i+2k} from P_{i+2k}
send r_{i+2k} to P_{i+2k}
r_i := r_i + r_{i+2k}
else
receive r_{i-2k} from P_{i-2k}
send r_{i-2k} to P_{i-2k}
r_i := r_i + r_{i-2k}
54
end if
end forall
end for
Esempio 8: Vediamo come viene calcolato il prodotto righe colonne di una matrice A di dimensione 66 per un vettore x di 6 componenti su 2 processori (fig. 4.9). Ogni processore si occupa di
una sottomatrice della matrice A di dimensione M Np = 6 26 = 6 3; in altre parole la matrice A
viene suddivisa in p = 2 blocchi di colonne ed ogni blocco viene assegnato ad un processore. Ad
esempio il processore P0 memorizza il blocco A0 = A([0, 5], [0, 2]), mentre il processore P1 tiene in
memoria il blocco A1 = A([0, 5], [3, 5]).
Il vettore x viene partizionato per righe in p = 2 blocchi e distribuito fra i 2 processori: il processore
P0 memorizza il blocco x([0, 2]), il processore P1 memorizza il blocco x([3, 5]).
Il processore P0 calcola il vettore risultato parziale r0 di 6 elementi:
P
2j=0 A(0, j)x(j)
A(0,
0)x(0)
+
A(0,
1)x(1)
+
A(0,
2)x(2)
P2
A(1,
j)x(j)
A(1, 0)x(0) + A(1, 1)x(1) + A(1, 2)x(2) P j=0
A(2, 0)x(0) + A(2, 1)x(1) + A(2, 2)x(2) j=0 A(2, j)x(j)

0
r0 = A x0 =
= P2
A(3, 0)x(0) + A(3, 1)x(1) + A(3, 2)x(2) j=0 A(3, j)x(j)
A(4, 0)x(0) + A(4, 1)x(1) + A(4, 2)x(2) P2
P j=0 A(4, j)x(j)
A(5, 0)x(0) + A(5, 1)x(1) + A(5, 2)x(2)

2 A(5, j)x(j)
j=0
Il processore P1 calcola il vettore risultato parziale r1 di 6 elementi:
P
5j=3 A(0, j)x( j)
A(0, 3)x(3) + A(0, 4)x(4) + A(0, 5)x(5) P5
A(1, 3)x(3) + A(1, 4)x(4) + A(1, 5)x(5) P j=3 A(1, j)x( j)

5
A(2, 3)x(3) + A(2, 4)x(4) + A(2, 5)x(5) j=3 A(2, j)x( j)

1
= P
r1 = A x1 =
A(3, 3)x(3) + A(3, 4)x(4) + A(3, 5)x(5) 5j=3 A(3, j)x( j)
A(4, 3)x(3) + A(4, 4)x(4) + A(4, 5)x(5) P5 A(4, j)x( j)

j=3
A(5, 3)x(3) + A(5, 4)x(4) + A(5, 5)x(5)

P5 A(5, j)x( j)
j=3
Il prodotto matrice vettore originario e` stato decomposto in due prodotti matrice vettore: ogni
Infine i due processori si scambiano i risultati parziali (fig. 4.10) e calcolano il vettore y come
somma vettoriale di r0 e r1 :
y = r0 + r1 = A0 x0 + A1 x1 = A([0, 5], [0, 2])x([0, 2]) + A([0, 5], [3, 5])x([3, 5])
55
Figura 4.9: Calcolo del prodotto di una matrice A di dimensione 6 6 per un vettore x di 6 elementi decomponendo A in
p = 2 blocchi per colonne. Il processore P0 memorizza il sottovettore x0 = x([0, 2]) (in giallo) e il bloccoA0 =
A([0, 5], [0, 2]) (in rosso) e calcola r0 = A0 x0 (in verde). Il processore P1 memorizza il sottovettore x1 = x([3, 5]) (in
arancione) e il bloccoA1 = A([0, 5], [3, 5]) (in blu) e calcola r1 = A1 x1 (in fucsia).
Figura 4.10: Scambio dei risultati parziali tra i processori nella seconda strategia per il calcolo del prodotto matrice vettore.
56
4.2.4
Eseguendo la seconda strategia su p processori la matrice A viene suddivisa in p blocchi M

vengono eseguiti concorrentemente M prodotti scalari di lunghezza
Il tempo desecuzione di questa prima fase su p processori e`
!
N
T(p) = M 2 1 tcalc
p
N
p
N
p
(fig. 4.11).
Una volta calcolati questi M prodotti scalari, i processori devono scambiarsi i propri risultati parziali
(a)
(b)
(c)
(d)
Figura 4.11: Prodotto fra una matrice A <86 ed un vettore x <6 su 2 processori. Ogni processore si occupa di
un blocco 8 3 della matrice A: P0 si occupa della sottomatrice A0 = A([0, 7], [0, 2]) e del sottovettore x0 =
x([0, 2]), P1 si occupa della sottomatrice A1 = A([0, 7], [3, 5]) e del sottovettore x1 = x([3, 5]). Vengono eseguiti
concorrentemente 8 prodotti scalari di lunghezza 62 = 3.
(4.11a) Al primo passo P0 calcola il prodotto scalare fra il blocco A(0, [0, 2]) e il vettore x([0, 2]) mentre il
processore P1 concorrentemente calcola il prodotto scalare fra il blocco A(0, [3, 5]) e il vettore x([3, 5]).
(4.11b) Al secondo passo P0 calcola il prodotto scalare fra il blocco A(1, [0, 2]) e il vettore x([0, 2]) mentre il
processore P1 concorrentemente calcola il prodotto scalare fra il blocco A(1, [3, 5]) e il vettore x([3, 5]).
(4.11c) Al terzo passo P0 calcola il prodotto scalare fra il blocco A(2, [0, 2]) e il vettore x([0, 2]) mentre il processore
P1 concorrentemente calcola il prodotto scalare fra il blocco A(2, [3, 5]) e il vettore x([3, 5]).
(4.11d)Al quarto passo P0 calcola il prodotto scalare fra la riga A(3, [0, 2]) e il vettore x([0, 2]) mentre il processore
P1 concorrentemente calcola il prodotto scalare fra il blocco A(3, [3, 5]) e il vettore x([3, 5]), e cos` via nei passi
successivi.
e farne la somma vettoriale per costruire il vettore y. A tal proposito si puo` usare una delle tre strategie
viste nel capitolo 2 per la somma di un vettore di N elementi: a seconda della strategia adottata si
hanno prestazioni differenti.
Prima strategia
Indichiamo con P0 il processore scelto per il calcolo e la memorizzazione del vettore risultato y.
I processori devono comunicare, uno alla volta, il proprio risultato parziale a P0 ; P0 di volta in volta
calcola la somma vettoriale del proprio risutato parziale e del risultato parziale ricevuto (par. 2.3.1).
Ad un generico passo i di comunicazione/aggregazione (fig. 2.2) il vettore Pi invia a P0 gli M elementi
del vettore ri ; P0 riceve ri ed effettua M addizioni per calcolare la somma vettoriale di due risultati
parziali. Il numero di passi di comunicazione/aggregazione e` pari a p 1. Il costo complessivo delle
operazioni di comunicazione/aggregazione e`
(p 1)Mtcom + (p 1)Mtcalc
57
Nella tabella 4.1 sono riportati il tempo desecuzione, loverhead, lo speed up e lefficienza di
questa strategia ignorando i costi di comunicazione.
T(p)

M 2 Np 1 tcalc + M(p 1)tcalc = 2 Np 2 + p Mtcalc
M(2N1)

= 2N1
2 N 2+p
M 2 Np 2+p

p
pM 2 Np 2 + p M (2N
2N1 1
2 N 2+p p
S(p)
Oh (p)
E(p)
1)
Tabella 4.1: Prestazioni della strategia per il calcolo del prodotto matrice vettore basata sulla decomposizione per colonne
e sulla strategia riportata nel paragrafo 2.3.1 per lo scambio e laggregazione dei risultati intermedi ignorando
i costi di comunicazione.
Allaumentare della dimensione del problema lo speed up tende a quello ideale e lalgoritmo diventa sempre piu` efficiente perchè maggiore e` la dimensione dei sottoproblemi trattati parallelamente
quindi maggiore e` lo sfruttamento dei processori:
2N 1
2N 1 1
= p
= 1
lim S(p) = lim N
lim E(p) = lim N
N
N 2 2 + p
N
N 2 2 + p p
p
p
Allaumentare del numero di processori le prestazioni degradano perchè la dimensione dei sottoproblemi trattati parallelamente e` sempre minore cioè i processori non vengono sfruttati abbastanza:
2N 1
2N 1 1
= 0
= 0
lim S(p) = lim N
lim E(p) = lim N
p
p 2 2 + p
p
p 2 2 + p p
p
p
Applichiamo la legge di Ware. In questo algoritmo ci sono p processori che effettuano concorrentemente M prodotti scalari di dimensione Np , dopodichè i p risultati parziali di lunghezza M vengono
sommati puntualmente per ottenere il vettore y , quindi
!
N
1
= M(p 1)
=M 2 1
p
p
Per poter applicare la legge di Ware bisogna impostare
T(1) = M(2N 1) = +
1
=1
p
quindi bisogna normalizzare e 1

p

N
2 Np 1
1 M 2p 1
=
=
p
M(2N 1)
2N 1
M(p 1)
p1
=
M(2N 1) 2N 1
Calcoliamo, infine, lo speed up secondo la legge di Ware

S(p) =
T(1)
=
T(p)
1
p1
2N1
2 Np 1
2N1
1
p1+2 Np 1
2N1
58
2N 1
p 1 + 2 Np 1
Anche la legge di Amdhal conferma i risultati mostrati nella tabella 4.1.

Nella tabella 4.2 vengono ricalcolati i parametri della tabella 4.1 considerando anche i costi di
comunicazione; a questi parametri e` stato aggiunto anche loverhead totale di comunicazione per
stabilire il peso della comunicazione sul tempo di calcolo. Per semplicità di calcolo abbiamo realisticamente imposto che tcom = 2tcalc .
T(p)

M 2 Np 1 tcalc + M(p 1)tcalc + M(p 1)tcom = M 2 Np + 3p 4 tcalc
S(p)
M(2N1)

= N2N1
2 +3p4
M 2 Np +3p4

p
N
pM 2 p + 3p 4 M (2N 1)
2N1 1
2 Np +3p4 p
2(p1)
M(p1)tcom

= 2 N +p2
N
M 2 p 1 tcalc +M(p1)tcalc
p
Oh (p)
E(p)
OC
Tabella 4.2: Prestazioni della strategia per il calcolo del prodotto matrice vettore basata sulla decomposizione per colonne e
sulla strategia riportata nel paragrafo 2.3.1 per lo scambio e laggregazione dei risultati intermedi considerando
anche i costi di comunicazione.
Anche in questo caso allaumentare della dimensione del problema lo speed up tende a quello
ideale e questa strategia diventa sempre piu` efficiente
2N 1 1
2N 1
= 1
= p
lim E(p) = lim N
lim S(p) = lim N
N
N 2 + 3p 4 p
N
N 2 + 3p 4
p
p
mentre allaumentare del numero di processori le prestazioni degradano
2N 1 1
2N 1
= 0
= 0
lim E(p) = lim N
lim S(p) = lim N
p
p 2 + 3p 4 p
p
p 2 + 3p 4
p
p
Inoltre allaumentare della dimensione del problema N loverhead totale di comunicazione tende a
zero perchè ogni processore esegue sempre piu` operazioni concorrentemente, quindi
il tempo necessa

rio per le comunicazioni M(p 1)tcom diventa piccolo rispetto al tempo di calcolo M 2 Np + (p 1) tcalc .
Al contrario allaumentare del numero di processori loverhead totale di comunicazione e` costante:
in particolare per p che tende a infinito cè un overhead totale di comunicazione e` del 100% perchè ci
saranno sempre piu` comunicazioni da dover effettuare.
2(p 1)
2(p 1)
= 0
= 2
lim OC = lim N
lim OC = lim N
p
p 2 + p 2
N
N 2 + p 2
p
p
Seconda strategia
Indichiamo con P0 il processore scelto per il calcolo e la memorizzazione del vettore risultato
y. Concorrentemente coppie di processori si scambiano i propri risultati parziali e ne calcolano la
somma vettoriale: un generico processore mittente (Sender) PS invia il proprio risultato parziale rS
59
di M elementi al processore ricevente (Receiver) PR che calcola la somma vettoriale r(S,R) = rS + rR ;

questo procedimento viene eseguito inizialmente fra coppie di processori adiacenti poi viene ripetuto
coinvolgendo coppie di processori sempre piu` lontani finchè alla fine solo P0 ha il vettore risultato y
(par. 2.3.2, fig. 2.3).
Vengono spesi log2 (p) passi computazionali per effettuare la comunicazione/aggregazione dei risulp
tati parziali. Ad esempio al primo passo ci sono 2 comunicazioni/aggregazioni concorrenti fra i p
processori: a ciascuna di queste operazioni corrispondono lo scambio di M valori e la loro somma
vettoriale
p
p
M tcom + M tcalc
2
2
p
Al secondo passo vengono effettuate 4 comunicazioni/aggregazioni concorrenti fra i 2 processori

attivi: a ciascuna di queste operazioni corrispondono lo scambio di M valori e la loro somma vettoriale
p
p
M tcom + M tcalc
4
4
Il numero complessivo di istanti temporali impiegati nellesecuzione concorrente delle operazioni di
comunicazione/aggregazione e`
M log2 (p)tcom + M log2 (p)tcalc = (cM log2 (p) + M log2 (p))tcalc
dove si e` posto tcom = ctcalc .
T(p)
S(p)
Oh (p)
E(p)

M 2 Np 1 tcalc + M log2 (p)tcalc = M 2 Np 1 + log2 (p) tcalc
M(2N1)

= N 2N1
2 p 1+log2 (p)
M 2 Np 1+log2 (p)

pM 2 Np 1 + log2 (p) M (2N
2N1
1
2 Np 1+log2 (p) p
1)
Tabella 4.3: Prestazioni della strategia per il calcolo del prodotto matrice vettore basata sulla decomposizione per colonne
e sulla strategia riportata nel paragrafo 2.3.2 per lo scambio e laggregazione dei risultati intermedi ignorando
i costi di comunicazione.
Al crescere della dimensione N il problema considerato diventa via via sempre piu` parallelizzabile: per questo motivo lo speed up tende a quello ideale e questa strategia diventa sempre piu`
efficiente:
2N
1
2N
1
1
= p
= 1
lim S(p) = lim N
lim E(p) = lim N
N
N 2 1 + log (p) p
N
N 2 1 + log (p)
2
2
p
p
Tuttavia non e` possibile aumentare a dismisura la dimensione del problema perchè ogni processore
ha una memoria limitata; di conseguenza nelle situazioni reali otterremo sempre speed up minori di
60
quello ideale ed efficienza minore di 1

S(p) =
2N 1
2 Np
1 + log2 (p)
<p
E(p) =
2N 1
2 Np
1
<1
1 + log2 (p) p
Viceversa allaumentare del numero di processori questa strategia diventa via via sempre meno
parallelizzabile quindi le prestazioni degradano:
1
2N
1
2N
1
= 0
= 0
lim S(p) = lim N

lim
E(p)
=
lim
p
p 2 1 + log (p)
p
p 2 N 1 + log (p) p
2
2
p
p
Applichiamo la legge di Ware generalizzata per verificare la correttezza dello speed up definito
in maniera classica nella tabella 4.3. La seconda strategia per la somma di N numeri consta di log2 p
passi di comunicazione/aggregazione e ad un generico passo k (k [0, log2 p 1]) ci sono 2log2 (p)k
processori attivi che eseguono concorrentemente M somme fra coppie di risultati parziali. La legge
di Ware generalizzata , quindi, puo` essere riformulata come segue per lalgoritmo considerato:
S(p) =
1 +
1
Pp1 k
k=2
p
p
1 +
1
Plog2 p 2log2 pk
k=1
2log2 pk
p
p
in cui
1 e` la frazione di operazioni eseguite quando e` attivo un solo processore; nellalgoritmo analizzato
1 corrisponde alla somma vettoriale conclusiva eseguita da P0 fra due risultati parziali ottenuti
coinvolgendo le prime e le ultime N2 colonne della matrice A con costo pari a M.
2log2 pk e` la frazione di operazioni eseguite concorrentemente quando sono attivi 2log2 pk processori
(con k [1, log2 p1]) ovvero nei passi intermedi. I processori attivi calcolano concorrentemente
la somma vettoriale di coppie di risultati parziali. Complessivamente ad un passo intermedio
k vengono eseguite M2log2 pk addizioni concorrentemente.
p e` la frazione di operazioni eseguite concorrentemente quando sono attivi tutti i processori. Nellalgoritmo analizzato allinizio tutti i processori eseguono
concorrentemente M prodotti scalari
N
N
di lunghezza p ; in totale vengono eseguite pM 2 p 1 operazioni concorrentemente.
Per poter applicare la legge di Ware generalizata deve risultare
T(1) = M(2N 1) = 1 +
log
2 p1
X
k=1
2log2 pk
2log2 pk
p
p
da cui si ricava:
1 =
M
1
=
M(2N 1) 2N 1
2log2 pk =
M2log2 pk
M(2N 1)
61
2log2 pk
2N 1
p =

pM 2 Np 1
M(2N 1)

p 2 Np 1
2N 1
Calcoliamo lo speed up secondo la legge di Ware:

S(p) =
1
Plog2 p1 2log2 pk
1 +
1
2N1
=
1
2N1
=
=
=
p
p
2log2 pk
k=1
Plog2 p1 2log2 pk
2N1 2log2 pk
k=1
1
Plog2 p1
1
2N1
k=1

p 2 Np 1
1
2N1 p
2 Np 1
2N1
1
1
2N1
1
2N1
1
2N1
1+
Plog2 p1
k=1

1 + 2 Np 1
1

1 + log2 p 1 + 2 Np 1
1
log2 p + 2 Np 1
2N 1
log2 p + 2 Np 1
Lo speed up calcolato con la legge generalizzata di Ware e quello definito in modo classico nella
tabella 4.3 coincidono.
Esempio 9: Calcoliamo lo speed up dellalgoritmo considerato con p = 4 processori applicando

la generalizzazione della legge di Ware:
S(p) =
=
=
1 +
1
Plog2 41 2log2 4k
2log2 4k
k=1
1 +
P1
1 +
2
2
1
2k
2
k=1
22k
4
4
4
4
4
4
1 , 2 e 4 sono le frazioni di operazioni eseguite concorrentemente quando sono attivi rispettivamente

p = 1, 2, 4 processori. Quando sono attivi p = 4 processori essi effettuano complessivamente
4M 2 Np 1 operazioni, quando sono attivi p = 2 processori essi effettuano complessivamente
2M addizioni, infine quando e` attivo un solo processore esso effettua M addizioni per calcolare la
somma vettoriale di due risultati parziali. 1 , 2 e 4 devono essere tali che
T(1) = M(2N 1) = 1 +
62
2 4
+
2
4
da cui si ricava:
1 =
2 =
4 =
M
M(2N1)
2M
M(2N1)
4M(2 N4 1)
M(2N1)
=
=
=
1
2N1
2
2N1
4( N2 1)
2N1
Lo speed up e`
S(p) =
=
=
=
1 +
2
2
4
4
1
1
2N1
2 1
2N1 2
4( N2 1) 1
2N1 4
1
+
2N 1
1
2N1
N
2
1
2N1
N
2 1
2N1
+1
Per completezza calcoliamo lo speed up anche applicando la definizione classica contenuta nella
tabella 4.1:
2N 1
2N 1
2N 1
2N 1
S(p) = N
= N
= N
= N
2 p 1 + log2 (p) 2 4 1 + log2 (4)
2 1+2
2 +1
Gli speedup calcolati con la legge di Ware generalizzata e con la definizione classica di speed up
coincidono.
Nella tabella 4.4 vengono ricalcolati il tempo desecuzione, loverhead, lo speed up e lefficienza
della strategia per il calcolo del prodotto matrice vettore basato sulla decomposizione per colonne
e sulla strategia riportata nel paragrafo 2.3.2 per lo scambio e laggregazione dei risultati intermedi
considerando anche i costi di comunicazione; e` presente anche loverhead totale di comunicazione
per stabilire il peso della comunicazione sul tempo di calcolo.

T(p)
M 2 Np 1 tcalc + M log2 (p)tcalc + M log2 (p)tcom = M 2 Np 1 + 3 log2 (p) tcalc
S(p)
Oh (p)
E(p)
OC
M(2N1)

= N 2N1
2 p 1+3 log2 (p)
M 2 Np 1+3 log2 (p)

N
pM 2 p 1 + 3 log2 (p) M (2N 1)
2N1
1
2 Np 1+3 log2 (p) p
M log2 (p)tcom
2 log2 p

= 2 N 1+log
N
M 2 p 1 tcalc +M log2 (p)tcalc
2 (p)
p
Tabella 4.4: Prestazioni della strategia per il calcolo del prodotto matrice vettore basata sulla decomposizione per colonne e
63
Anche in questo caso allaumentare della dimensione del problema lo speed up tende a quello
ideale e questa strategia diventa sempre piu` efficiente
1
2N
1
2N
1
= p
= 1
lim S(p) = lim N
lim E(p) = lim N
N
N 2 1 + 3 log (p)
N
N 2 1 + 3 log (p) p
2
2
p
p
mentre allaumentare del numero di processori le prestazioni degradano
1
2N
1
2N
1
= 0
= 0
lim E(p) = lim N
lim S(p) = lim N
p
p 2 1 + 3 log (p) p
p
p 2 1 + 3 log (p)
2
2
p
p
Inoltre allaumentare della dimensione del problema N la comunicazione ha un peso sempre
minore sui tempi di calcolo perchè lalgoritmo diventa sempre piu` parallelizzabile quindi il

tempo necessario per le comunicazioni M(p 1)tcom diventa piccolo rispetto al tempo di calcolo M 2 Np + (p 1) tcalc . Al contrario allaumentare del numero di processori loverhead totale di
comunicazione resta costante.
2
log
p
2
log
p
2
2
= 0
= 2
lim OC = lim N
lim
OC
=
lim
p
p 2 N 1 + log (p)
N
N 2 1 + log (p)
2
2
p
p
Terza strategia
Le prestazioni ottenute usando la terza strategia (par. 2.3.3) per lo scambio e laggregazione dei
risultati intermedi sono identiche a quelle ottenute usando la seconda strategia viste nel paragrafo
precedente: questo perchè il numero di passi di comunicazione/aggregazione e` sempre log2 p ma ad
ogni passo tutti i p processori si scambiano i risultati intermedi e ne calcolano la somma vettoriale;
di conseguenza il numero di operazioni di comunicazione/aggregazione ad ogni passo e` maggiore
rispetto alla seconda strategia ma queste operazioni vengono eseguite concorrentemente.
Anche applicando la legge di Ware si ottiene lo stesso speed up perchè il numero di operazioni di
comunicazioni eseguite ad ogni passo e` finito (pari a p) e, inoltre, queste comunicazioni avvengono
in parallelo.
Ad ogni passo, inoltre, tutti i processori sono attivi e alla fine tutti conoscono il risultato complessivo.
4.2.5
III Strategia: decomposizione della matrice A per blocchi
La terza strategia e` una combinazione delle altre due: la matrice A viene decomposta per blocchi
di righe e colonne e il vettore x viene decomposto per righe.
Siano dati una matrice A <MN , un vettore b <N e una griglia di processori p Npx py . La
N
matrice A viene decomposta in px p y blocchi di dimensione M
` indicato con Ai, j
px p y ; ogni blocco e
con i [0, px 1] e j [0, p y 1] (fig. 4.12). Il vettore x viene distribuito per righe e replicato fra i
processori (fig. 4.13) della stessa colonna della griglia di processori: ogni blocco e` composto da pNy
elementi ed e` indicato come x j con j [0, p y 1].
Ogni blocco viene memorizzato ed elaborato da un processore diverso. Un generico processore
Pi j con i [0, px 1] e j [0, p y 1] memorizza il blocco Ai, j e il sottovettore x j e calcola un vettore ri, j
di M
px componenti:
ri, j = Ai,j x j
64
Figura 4.12: Decomposizione della matrice A in px p y blocchi. I blocchi ottenuti vengono distribuiti fra i processori.
Figura 4.13: Il vettore x viene distribuito per righe e replicato fra i processori.
Il problema originario, quindi, e` stato decomposto in px p y sottoproblemi di dimensione

N
processore calcola il prodotto matrice vettore fra una matrice M
px p y e un vettore di
Tutti i processori eseguono concorrentemente lo stesso algoritmo ma su dati diversi.
N
py
M
px
pNy : ogni
componenti.
Procedura 4.7: Terza strategia per il prodotto matrice vettore in ambiente MIMD DM.
begin
// fase di calcolo
for i = 0 to px-1 do
for j = 0 to py-1 do
ibegin := i*(M/px)
jbegin := j*(N/py)
xlocal = x([jbegin,jbegin+ (N/py) - 1])
Alocal = A([ibegin,ibegin+ (M/px) - 1],[jbegin,jbegin+ (N/py) 1])
for k = 0 to (M/px) - 1 do
r_{i,j}(k) := 0
for z = 0 to (N/py) - 1 do
r_{i,j}(k) := r_{i,j}(k) + Alocal(k,z) * xlocal(z)
end for
end for
65
end for
end for
// applicazione di una strategia di comunicazione/aggregazione
end
A questo punto nella memoria locale di ogni processore Pi,j si trova un vettore ri,j di
che contribuisce alla costruzione del vettore risultato y:
h
i

r
+
r
+
r
+
+
r
0,0
0,2
0,1
0,p
1
y
h
i
y0
r1,0 + r1,1 + r1,2 + + r1,py 1

1
h
i
y = y2 =
r2,0 + r2,1 + r2,2 + + r2,py 1
h
i
ypx 1
rpx 1,0 + rpx 1,1 + rpx 1,2 + + rpx 1,py 1
A0,0 x0 + A0,1 x1 + A0,2 x2 + + A0,py 1 xpy 1
A1,0 x0 + A1,1 x1 + A1,2 x2 + + A1,py 1 xpy 1
A2,0 x0 + A2,1 x1 + A2,2 x2 + + A2,py 1 xpy 1

=
Apx 1,0 x0 + Apx 1,1 x1 + Apx 1,2 x2 + + Apx 1,py 1 xpy 1
Ppy 1
Pi=0 A0,i xi
py 1
i=0 A1,i xi
Pp 1
y
=
A
x
2,i
i
i=0
Pp 1
y
A
x
px 1,i i
i=0
M
px
componenti
In altre parole, combinando insieme i risultati parziali di un gruppo di p y processori sulla stessa riga
della griglia di processori si ottengono M
px componenti del vettore risultato finale y; sia i la riga di
processori, con i [0, px 1], allora combinandone i risultati parziali si ottiene li-sima
M
px
M
px -upla
del
vettore y. Gli
gruppi di processori di cardinalità p y , eventualmente, devono scambiarsi i propri
risultati parziali e calcolarne la somma vettoriale. I risultati di ciascun gruppo , poi, devono essere
organizzati insieme per costruire il vettore y.
A tal proposito si puo` usare una delle tre strategie viste nel capitolo 2 per la somma di un vettore di
N elementi: a seconda della strategia adottata si hanno prestazioni differenti.
Usando la prima strategia (par. 2.3.1), in ogni gruppo di p y processori (quelli su una stessa riga della
griglia di processori) viene eletto un processore leader; tutti gli altri processori di un gruppo inviano
uno alla volta il proprio risultato parziale al leader che a sua volta combina i risultati parziali ricevuti
e il proprio risultato parziale.
Ad esempio con una griglia di 2 8 processori ci sono 2 gruppi da 8 processori (fig. 4.14). Il leader
della prima riga e` il processore P0,0 , il leader della seconda riga e` il processore P1,0 . I 7 processori
non leader della prima riga inviano uno alla volta il proprio risultato parziale a P0,0 : a sua volta
il processore leader P0,0 aggrega i risultati parziali calcolando y0 . Concorrentemente i 7 processori
non leader della seconda riga inviano uno alla volta il proprio risultato parziale a P1,0 : a sua volta
il processore leader P1,0 aggrega i risultati parziali calcolando y1 . Anche usando la seconda strategia
66
Figura 4.14: Applicazione della prima strategia per il calcolo della somma di N valori (par. 2.3.1) per la combinazione dei
risultati parziali del prodotto matrice vettore ottenuti con la decomposizione della matrice A per blocchi.
In ogni riga della griglia di processori viene eletto un processore leader: il leader della prima riga e` P0,0 , il
leader della seconda riga e` P1,0 .
In ogni riga un processore alla volta invia il proprio risultato parziale al corrispondente processore leader che
aggrega il proprio risultato arziale col risultato parziale ricevuto.
Ci sono p y 1 = 7 passi di comunicazione: al primo passo (in blu) il processore P0,1 invia il proprio risultato
parziale r0,1 al leader della propria riga P0,0 che a sua volta calcola y0 = r0,0 + r0,1 ; concorrentemente il processore
P1,1 invia il proprio risultato parziale r1,1 al leader della seconda riga P1,0 che a sua volta calcola y1 = r1,0 + r1,1 .
Al secondo passo (in marrone) il processore P0,2 invia il proprio risultato parziale r0,2 al leader della propria
riga P0,0 che a sua volta aggiorna y0 = y0 + r0,2 ; concorrentemente il processore P1,2 invia il proprio risultato
parziale r1,2 al leader della seconda riga P1,0 che a sua volta aggiorna y1 = y1 + r1,2 .
Questo procedimento di comunicazione/aggregazione viene ripetuto da tutti gli altri processori: alla fine P0,0
e P1,0 hanno in memoria rispettivamente i blocchi y0 e y1 del vettore risultato y.
67
(par. 2.3.2) viene eletto un processore leader in ogni riga della griglia di processori; ci sono log2 p y
passi di comunicazione/aggregazione in cui di volta in volta coppie sempre diverse di processori in
ogni riga della griglia di processori si scambiano concorrentemente i propri risultati parziali. Ad
ogni passo il numero di processori attivi per riga si dimezza e cambiano le coppie di processori
in comunicazione. Le comunicazioni fra le coppie di processori attivi di ogni riga della griglia di
processori avvengono in parallelo. Alla fine ogni processore leader conosce un blocco del vettore
risultato y.
Ad esempio con una griglia di 2 8 processori ci sono 2 gruppi da 8 processori (fig. 4.15). Il
leader della prima riga e` il processore P0,0 , il leader della seconda riga e` il processore P1,0 . Ci sono
log2 p y = log2 8 = 3 passi di comunicazione/aggregazione. Al primo passo tutti gli 8 processori di
ciascuna riga comunicano fra loro; al secondo passo in ogni riga della griglia di processori sono
attivi 4 processori su 8; al terzo ed ultimo passo in ogni riga della griglia di processori avviene
una comunicazione/aggregazione e i due processori leader calcolano i blocchi y0 e y1 . Adottando la
Figura 4.15: Applicazione della seconda strategia per il calcolo della somma di N valori (par. 2.3.2) per la combinazione dei
Ci sono log2 p y = log2 8 = 3 passi di comunicazione/aggregazione.
Al primo passo (in blu) ci sono 4 coppie di processori in comunicazione per ogni riga. Le coppie di processori
comunicanti nella prima riga della griglia di processori sono (P0,0 , P0,1 ), (P0,2 , P0,3 ), (P0,4 , P0,5 ) e (P0,6 , P0,7 ); le coppie
di processori comunicanti nella seconda riga della griglia di processori sono (P1,0 , P1,1 ), (P1,2 , P1,3 ), (P1,4 , P1,5 ) e
(P1,6 , P1,7 ): tutte queste comunicazioni/aggregazioni avvengono in parallelo.
Al secondo passo (in rosa) il numero di processori attivi per riga diventa pari a 4: le coppie di processori
comunicanti nella prima riga della griglia di processori sono (P0,0 , P0,2 ) e (P0,4 , P0,6 ); le coppie di processori
comunicanti nella seconda riga della griglia di processori sono (P1,0 , P1,2 ) e (P1,4 , P1,6 ).
Al terzo ed ultimo passo (in azzurro) in ogni riga cè una sola coppia di processori in comunicazione cioè
(P0,0 , P0,4 ) e (P1,0 , P1,4 ): i due processori leader calcolano i blocchi y0 e y1 .
terza strategia (par. 2.3.3) si hanno sempre log2 p y passi di comunicazione ma ad ogni passo tutti i
68
processori sono attivi. Le comunicazioni fra coppie di processori avvengono in parallelo. Alla fine
tutti i processori di una stessa riga i (con i [0, px 1]) della griglia di processori sono a conoscenza
del blocco yi .
Ad esempio con una griglia di 2 8 processori ci sono 2 gruppi da 8 processori (fig. 4.16) ci sono
log2 p y = log2 8 = 3 passi di comunicazione/aggregazione; ad ogni passo sono sempre attivi tutti i
processori. Le coppie di processori in comunicazione cambiano da un passo allaltro e alla fine gli 8
processori della prima riga della griglia conoscono il blocco y0 , mentre gli 8 processori della seconda
riga della griglia conoscono il blocco y1 .
Figura 4.16: Applicazione della terza strategia per il calcolo della somma di N valori (par. 2.3.3) per la combinazione dei
Ci sono log2 p y = log2 8 = 3 passi di comunicazione/aggregazione; ad ogni passo sono attivi tutti i processori
ma le coppie in comunicazione vengono via via rideterminate.
Al primo passo (in blu) comunicano parallelamente tutte le coppie di processori della stessa riga della griglia
di processori con ID contiguo cioè (P0,0 , P0,1 ), (P0,2 , P0,3 ), (P0,4 , P0,5 ), (P0,6 , P0,7 ), (P1,0 , P1,1 ), (P1,2 , P1,3 ), (P1,4 , P1,5 ) e
(P1,6 , P1,7 ).
Al secondo passo (in rosa) le coppie di processori in comunicazione vengono determinate con step pari a 2:
(P0,0 , P0,2 ), (P0,1 , P0,3 ), (P0,4 , P0,6 ), (P0,5 , P0,7 ), (P1,0 , P1,2 ), (P1,1 , P1,3 ), (P1,4 , P1,6 ) e (P1,5 , P1,7 ).
Al terzo ed ultimo passo (in azzurro) lo step per lindividuazione delle coppie di processori comunicanti e` pari
a 4: (P0,0 , P0,4 ), (P0,1 , P0,5 ), (P0,2 , P0,6 ), (P0,3 , P0,7 ), (P1,0 , P1,4 ), (P1,1 , P1,5 ), (P1,2 , P1,6 ) e (P1,3 , P1,7 ). Gli 8 processori della
prima riga calcolano il blocco y0 , gli 8 processori della seconda riga calcolano il blocco y1 .
Esempio 10: Vediamo come viene calcolato il prodotto righe colonne di una matrice A di dimensione 66 per un vettore x di 6 componenti su una griglia di px p y = 2 2 processori (fig. 4.17).
N
6 6
Ogni processore si occupa di una sottomatrice della matrice A di dimensione M
px p y = 2 2 = 33;
69
in altre parole la matrice A viene suddivisa in px p y = 4 blocchi 3 3 ed ogni blocco viene assegnato
ad un processore.
Il vettore x viene partizionato per righe in p y = 2 blocchi di pNy = 62 = 3 elementi e distribuito fra i
4 processori: P0,0 e P1,0 memorizzano il blocco x([0, 2]), P0,1 e P1,1 memorizzano il blocco x([3, 5]).
Il prodotto matrice vettore originario viene decomposto in quattro prodotti matrice vettore: ogni
Il processore P0,0 calcola il vettore risultato parziale r0,0 di 3 elementi:
r0,0
P2
A(0, 0)x(0) + A(0, 1)x(1) + A(0, 2)x(2) P j=0 A(0, j)x(j)
= A(1, 0)x(0) + A(1, 1)x(1) + A(1, 2)x(2) = 2j=0 A(1, j)x(j) = A0,0 x0
P2
A(2, 0)x(0) + A(2, 1)x(1) + A(2, 2)x(2)

j=0 A(2, j)x(j)
r0,1
P5
A(0, 3)x(3) + A(0, 4)x(4) + A(0, 5)x(5) P j=3 A(3, j)x(j)
= A(1, 3)x(3) + A(1, 4)x(4) + A(1, 5)x(5) = j=3 A(4, j)x(j) = A0,1 x1
P5
A(2, 3)x(3) + A(2, 4)x(4) + A(2, 5)x(5)

A(5, j)x(j)
j=3
r1,0
P2
A(3, 0)x(0) + A(3, 1)x(1) + A(3, 2)x(2) P j=0 A(3, j)x(j)
= A(4, 0)x(0) + A(4, 1)x(1) + A(4, 2)x(2) = 2j=0 A(4, j)x(j) = A1,0 x0
P2
A(5, 0)x(0) + A(5, 1)x(1) + A(5, 2)x(2)

j=0 A(5, j)x(j)
r1,1
P5
A(3, 3)x(3) + A(3, 4)x(4) + A(3, 5)x(5) P j=3 A(3, j)x(j)
= A(4, 3)x(3) + A(4, 4)x(4) + A(4, 5)x(5) = j=3 A(4, j)x(j) = A1,1 x1
P5
A(5, 3)x(3) + A(5, 4)x(4) + A(5, 5)x(5)

A(5, j)x(j)
j=3
A questo punto bisogna mettere in comunicazione i processori per calcolare il vettore y. Le

prime 3 componenti del vettore y sono date dalla somma vettoriale di r0,0 e r0,1 infatti
y([0, 2]) = r0,0 + r0,1 = A([0, 2], [0, 2])x([0, 2]) + A([0, 2], [3, 5])x([3, 5])
P2
P
j=0 A(0, j)x( j) + 5j=3 A(0, j)x( j)
P2
P5
= j=0 A(1, j)x( j) + j=3 A(1, j)x( j)
P5
P2
j=0 A(2, j)x( j) +

j=3 A(2, j)x( j)
P5
j=0 A(0, j)x( j)

P5
= j=0 A(1, j)x( j)

P5
j=0 A(2, j)x( j)

= A0,0 x0 + A0,1 x1
70
Analogamente le ultime 3 componenti del vettore y sono date dalla somma vettoriale di r1,0 e r1,1
infatti
y([3, 5]) = r1,0 + r1,1 = A([3, 5], [0, 2])x([0, 2]) + A([3, 5], [3, 5])x([3, 5])
P2
P
P
j=0 A(3, j)x( j) + 5j=3 A(3, j)x( j) 5j=0 A(3, j)x( j)
P2
P5
P5
= j=0 A(4, j)x( j) + j=3 A(4, j)x( j) = j=0 A(4, j)x( j)
P5
P2
P5
j=0 A(5, j)x( j) +

j=3 A(5, j)x( j)
j=0 A(5, j)x( j)
= A1,0 x0 + A1,1 x1
Per calcolare i blocchi di y basta fare in modo che i processori sulla stessa riga della griglia di
processori si scambino i propri risultati parziali e ne calcolino la somma. A tal fine applichiamo
la terza strategia per la somma di N valori (par. 2.3.3, fig. 4.18) : P0,0 invia r0,0 a P0,1 , P0,1
invia r0,1 a P0,0 , P1,0 invia r1,0 a P1,1 , P1,1 invia r1,1 a P1,0 . Successivamente P0,0 e P0,1 calcolano
y([0, 2]) = r(0,0),(0,1) = r0,0 + r0,1 , P1,0 e P1,1 calcolano y([3, 5]) = r(1,0),(1,1) = r1,0 + r1,1 .
A questo punto P0,0 e P0,1 conoscono la prima metà del vettore y e P1,0 e P1,1 conoscono la seconda
parte. Per fare in modo che tutti i processori conoscano il vettore y per intero si realizza unultima
fase di comunicazione e scambio fra i processori: P0,0 e P0,1 inviano r(0,0),(0,1) rispettivamente a P1,0
e P1,1 ; P1,0 e P1,1 inviano r(1,0),(1,1) rispettivamente a P0,0 e P0,1 .
Ciascun processore e` in grado di ricostruire y per intero.
# "
"
# "
#
r(0,0),(0,1)
A([0, 2], [0, 5])x
A([0, 2], [0, 2])x([0, 2]) + A([0, 2], [3, 5])x([3, 5])
=
=
y=
r(1,0),(1,1)
A([3, 5], [0, 5])x
A([3, 5], [0, 2])x([0, 2]) + A([3, 5], [3, 5])x([3, 5])
4.2.6
Eseguendo la terza strategia su una griglia di px p y processori la matrice A viene suddivisa in

N
M
N
px p y blocchi M
px p y e vengono eseguiti concorrentemente px prodotti scalari di lunghezza p y (fig.
4.19).
Il tempo necessario per lesecuzione concorrente di questi prodotti scalari e`
!
M N
2 1 tcalc
T(px , p y ) =
px p y
Una volta calcolati questi M
a p y devono scambiarsi i
px prodotti scalari, i processori a gruppi di cardinalit`
propri risultati parziali e farne la somma vettoriale per costruire i blocchi del vettore y. A tal proposito
si puo` usare una delle tre strategie viste nel capitolo 2 per la somma di un vettore di N elementi: a
seconda della strategia adottata si hanno prestazioni differenti.
Prima strategia
In ogni gruppo di p y processori (quelli su una stessa riga della griglia di processori) viene eletto
un processore leader; tutti gli altri processori di un gruppo inviano uno alla volta il proprio risultato
71
Figura 4.17: Calcolo del prodotto di una matrice A di dimensione 6 6 per un vettore x di 6 elementi decomponendo A
in px p y = 2 2 = 4 blocchi 3 3. Il processore P0,0 memorizza il sottovettore x0 = x([0, 2]) (in giallo) e il
bloccoA0,0 = A([0, 2], [0, 2]) e calcola r0,0 = A0,0 x0 . Il processore P0,1 memorizza il sottovettore x1 = x([3, 5]) (in
arancione) e il bloccoA0,1 = A([0, 2], [3, 5]) e calcola r0,1 = A0,1 x1 . Il processore P1,0 memorizza il sottovettore
x0 = x([0, 2]) (in giallo) e il bloccoA1,0 = A([3, 5], [0, 2]) e calcola r1,0 = A1,0 x0 . Il processore P1,1 memorizza il
sottovettore x1 = x([3, 5]) (in arancione) e il bloccoA1,1 = ([3, 5], [3, 5]) e calcola r1,1 = A1,1 x1 .
Figura 4.18: Scambio dei risultati parziali tra i processori nella terza strategia per il calcolo del prodotto matrice vettore.
72
Figura 4.19: Prodotto fra una matrice A <86 ed un vettore x <6 su 22 processori. Ogni processore si occupa
di un blocco 4 3 della matrice A: P0,0 si occupa della sottomatrice A0,0 = A([0, 3], [0, 2]) e del sottovettore
x0 = x([0, 2]), P0,1 si occupa della sottomatrice A0,1 = A([0, 3], [3, 5]) e del sottovettore x1 = x([3, 5]), P1,0 si
occupa della sottomatrice A1,0 = A([4, 7], [0, 2]) e del sottovettore x0 = x([0, 2]), P1,1 si occupa della sottomatrice
A1,1 = A([4, 7], [3, 5]) e del sottovettore x1 = x([3, 5]).
Vengono eseguiti concorrentemente 4 prodotti scalari di lunghezza 3.
parziale al leader che a sua volta combina i risultati parziali ricevuti e il proprio risultato parziale. Ad
esempio il primo gruppo e` individuato dai processori P0,j con j [0, p y 1] e il leader e` il processore
P0,0 . Tutti gli altri p y 1 processori inviano uno alla volta al processore leader gli M
px elementi del
proprio risultato parziale; di volta in volta il processore leader calcola la somma vettoriale fra il
proprio risultato parziale e il risultato parziale ricevuto. Ogni trasmissione ha costo M
px tcom ed ogni
somma vettoriale ha costo pari a M
px tcalc ; il numero di operazioni di comunicazione/aggregazione in
un gruppo e` p y 1. Le operazioni di comunicazione/aggregazione in gruppi diversi avvengono
simultaneamente: mentre il leader del primo gruppo P0,0 riceve ed aggrega i risultati parziali del
proprio gruppo contemporaneamente il leader del secondo gruppo P1,0 riceve ed aggrega i risultati
parziali del proprio gruppo e cos` via fino ad arrivare al leader dellultimo gruppo Ppx 1,0 . Il costo
complessivo delle operazioni di comunicazione/aggregazione quindi e`
(p y 1)
M
M
M
M
M
tcom + (p y 1) tcalc = (p y 1) ctcalc + (p y 1) tcalc = (c + 1)(p y 1) tcalc
px
px
px
px
px
Allaumentare della dimensione del problema questa strategia diventa sempre piu` efficiente
perchè aumenta la dimensione dei sottoproblemi trattati parallelamente e quindi aumenta lo sfruttamento dei processori:
2N 1
1
lim E(p) = lim N

= 1
N
N 2
p
2
+
p
y
y
py
Allaumentare di p y le prestazioni degradano perchè aumenta il numero di comunicazioni necessarie per ricostruire i blocchi del vettore y e perchè la dimensione dei sottoproblemi trattati
73
T(px , p y )
M
px

N
M
2 pNy 1 tcalc + (p y 1) M
t
=
2
2
+
p
y px tcalc
px calc
py
M(2N1)

2 pNy 2+p y pMx
S(px , p y )
Oh (px , p y )
(2N1)px
2 pNy 2+p y

N
M
N
px p y 2 py 2 + p y px M(2N 1) = M p y 2 py 2 + p y 2N + 1
(2N1)px 1
2 pNy 2+p y px p y
E(px , p y )
1
2N1
2 pNy 2+p y p y
Tabella 4.5: Prestazioni della strategia per il calcolo del prodotto matrice vettore basata sulla decomposizione a blocchi e
sulla strategia riportata nel paragrafo 2.3.1 per lo scambio e laggregazione dei risultati intermedi ignorando i
costi di comunicazione.
parallelamente e` sempre minore:
2N 1
1
lim E(p) = lim N

= 0
p y
p y 2
2 + py py
py
Nella tabella 4.6 questi parametri vengono ricalcolati considerando anche i costi di comunicazione;
viene calcolato anche loverhead totale di comunicazione.
T(px , p y )
M
px
2 pNy

M
M
N
1 tcalc + (p y 1) px tcom + (p y 1) px tcalc = 2 py + 3p y 4 M
px tcalc
M(2N1)

N
2 p y +3p y 4 pMx
S(px , p y )
Oh (px , p y )
(2N1)px
2 pNy +3p y 4

N
px p y 2 pNy + 3p y 4 M
M(2N
1)
=
M
p
+
3p
2N
+
1
2
y
y
px
py
(2N1)px
1
2 pNy +3p y 4 px p y
E(px , p y )
OC
M
px
1
2N1
2 pNy +3p y 4 p y
(p y 1) pMx tcom

2 pNy 1 tcalc +(p y 1) pMx tcalc
2(p y 1)
2 pNy +p y 2
Anche considerando i costi di comunicazione, allaumentare della dimensione del problema questa
strategia diventa sempre piu` efficiente perchè il problema diventa sempre piu` parallelizzabile
mentre allaumentare di p y le prestazioni degradano perchè le risorse di calcolo sono sempre meno
sfruttate:
2N 1
2N 1
1
1
lim E(p) = lim N

lim E(p) = lim N
=1
=0
p y
p y 2
N
N 2
p
p
p + 3p y 4 y
p + 3p y 4 y
y
zero perchè aumenta la dimensione dei sottoproblemi trattati parallelamente, quindi il tempo necessa-
74

N
M
rio per le comunicazioni (p y 1) M
t
diventa
piccolo
rispetto
al
tempo
di
calcolo
2
1
+
(p
1)
y
px com
py
px tcalc .
Al contrario allaumentare del numero di processori loverhead totale di comunicazione e` costante.
2(p y 1)
2(p y 1)
lim OC = lim N
lim OC = lim N
= 0
= 2
p y
p y 2
N
N 2
+ py 2
+ py 2
py
py
Applichiamo la legge di Ware generalizzata. Dobbiamo determinare px py (cioè la frazione di

operazioni eseguite quando sono attivi tutti i processori) e px (cioè la frazione di operazioni eseguite
solo dai leader di ogni riga).
Quando tutti i processori sono attivi, ciascuno effettua concorrentemente M
px prodotti scalari di lun

N
ghezza pNy , per un totale di px p y M
px 2 p y 1 operazioni eseguite concorrentemente su px p y processori.
In seguito, il processore leader di ciascuna riga calcola la somma vettoriale dei risultati parziali di
M
lunghezza M
px ottenuti dagli altri p y processori sulla sua stessa riga, per un totale di px (p y 1) px addizioni eseguite concorrentemente su px processori.
px py e px devono soddisfare questuguaglianza
T(1) = M(2N 1) =
da cui si ricava:
px py
px py
px p y
px
px
!
!
1
N
1
M N
2 1
= py 2 1
= px p y
px p y
M(2N 1)
py
2N 1
px = px (p y 1)
1
M
1
= (p y 1)
px M(2N 1)
2N 1
Lo speed up ottenibile con px p y processori quindi e`

S(p) =
px p y
px p y
1
+
px
px
1

p y 2 pNy 1
=
=
=
1
1
2N1 px p y
1
1
+ (p y 1) 2N1
px
1
2 pNy 1
1
1
2N1 px
1
1
+ (p y 1) 2N1
px
1
2 pNy
1 + py 1
1
(2N1)px
(2N 1)px
2 pNy 2 + p y
Lo speed up calcolato con la legge di Ware generalizzata e` identico allo speed up ottenuto secondo la
definizione classica mostrato nella tabella 4.5.
Seconda strategia
In ogni gruppo di p y processori (quelli su una stessa riga della griglia di processori) viene eletto
un processore leader. Le coppie di processori nella stessa riga si scambiano concorrentemente i propri
75
risultati parziali ( M
px elementi) e ne calcolano la somma vettoriale. Questo procedimento viene ripetuto per log2 p y passi fra coppie di processori sempre diverse e ad ogni passo il numero di processori
coinvolti si dimezza. Alla fine il processore leader contiene la somma vettoriale dei risultati parziali
dei processori sulla sua stessa riga.
M
Ogni comunicazione ha costo M
px tcom ed ogni somma vettoriale ha costo pari a px tcalc ; il numero di
passi di comunicazione/aggregazione in un gruppo e` log2 p y . Le operazioni di comunicazione/aggregazione vengono eseguite simultaneamente in gruppi diversi. Il costo complessivo delle operazioni
di comunicazione/aggregazione quindi e`
!
M
M
M
M
M
tcalc
log2 p y tcom + log2 p y tcalc = log2 p y ctcalc + log2 p y tcalc = (c + 1) log2 p y
px
px
px
px
px
T(px , p y )
M
px

N
M
t
=
1
+
log
p
2 pNy 1 tcalc + log2 p y M
2
2 y px tcalc
px calc
py
M(2N1)
S(px , p y )
Oh (px , p y )
E(px , p y )
px p y 2 pNy
1+
2 pNy 1+log2 p y
M
px
(2N1)px
2 pNy 1+log2 p y
N
log2 p y M
px M(2N 1) = M p y 2 p y
(2N1)px
2N1
1
1
= 2 N 1+log
2 N 1+log p y px p y
py py
py
py
1 + log2 p y 2N + 1
sulla strategia riportata nel paragrafo 2.3.2 per lo scambio e laggregazione dei risultati intermedi ignorando i
costi di comunicazione.
Allaumentare della dimensione del problema questa strategia diventa sempre piu` efficiente
perchè aumenta la dimensione dei sottoproblemi trattati parallelamente (ovvero la lunghezza dei
prodotti scalari) e quindi aumenta lo sfruttamento dei processori:
2N
1
1
= 1
lim E(p) = lim N
N
N 2
1 + log p y p y
py
Tuttavia non e` possibile aumentare a dismisura le dimensioni del problema a causa della memoria
limitata con cui e` equipaggiato ciascun calcolatore.
Allaumentare di p y le prestazioni degradano perchè aumenta il numero di comunicazioni necessarie per ricostruire i blocchi del vettore y e perchè la dimensione dei sottoproblemi trattati
parallelamente e` sempre minore:
2N 1
1
lim E(p) = lim N

=0
p y
p y 2
p
p 1 + log2 p y y
y
Nella tabella 4.8 questi parametri vengono ricalcolati considerando anche i costi di comunicazione;
viene calcolato anche loverhead totale di comunicazione per stabilire il peso della comunicazione sul
76
T(px , p y )
M
px

M
N
M
2 pNy 1 tcalc + log2 p y M
t
+
log
p
t
=
2
1
+
3
log
p
2 y px calc
2 y px tcalc
px com
py
M(2N1)

N
2 p y 1+3 log2 p y pMx
S(px , p y )
Oh (px , p y )
px p y 2 pNy
E(px , p y )
1+
(2N1)px
2 pNy 1+3 log2 p y
N
3 log2 p y M
px M(2N 1) = M p y 2 p y 1
(2N1)px
1
1
2N1
= 2 N 1+3
log p y p y
2 N 1+3 log p y px p y
py
log2 p y pMx tcom

M
N
M
px 2 p y 1 tcalc +log2 p y px tcalc
OC
py
+ 3 log2 p y 2N + 1
2 log2 p y
2 pNy 1+log2 p y
tempo di calcolo (tab. ). Per semplicità di calcolo abbiamo realisticamente imposto che pcom = 2tcalc .
Anche considerando i costi di comunicazione, allaumentare della dimensione del problema questa
strategia diventa sempre piu` efficiente perchè il problema diventa sempre piu` parallelizzabile
mentre allaumentare di p y le prestazioni degradano perchè le risorse di calcolo sono sempre meno
sfruttate:
2N 1
2N 1
1
1
lim E(p) = lim N

lim E(p) = lim N
=1
=0
p y
p y 2
N
N 2
p
p
p 1 + 3 log2 p y y
p 1 + 3 log2 p y y
y
zero perchè aumenta la dimensione dei sottoproblemi trattati parallelamente, quindi
il tempo necessa

N
rio per le comunicazioni (p y 1) M
px tcom diventa piccolo rispetto al tempo di calcolo 2 p y 1 + (p y 1)
M
px tcalc .
Al contrario allaumentare del numero di processori loverhead totale di comunicazione e` costante.
2
log
p
2
log
p
y
y
2
2
= 0
= 2
lim
OC
=
lim
lim OC = lim N
2 N 1 + log p y
p y
p y
N
N 2
1 + log p y
py
py
Applichiamo la legge di Ware generalizzata. Nella fase puramente di calcolo tutti i procesN
sori sono attivi: ogni processore effettua M
px prodotti scalari di lunghezza p y , per un totale di

N
N
px p y M
px 2 p y 1 = p y M 2 p y 1 operazioni eseguite concorrentemente su px p y processori. Usando la strategia definita nel paragrafo 2.3.2 per laggregazione dei dati, sono necessari altri log2 p y passi
di comunicazione/aggregazione per ottenere il risultato finale cioè per far s` che un generico leader
Pi,0 (con i [0, px 1]) contenga il blocco yi . Ad un generico passo k (k [1, log2 p y ]) ci sono 2log2 (py )k
processori attivi in ogni riga della griglia di processori per un totale di px 2log2 (py )k processori attivi.
Per ogni passo dobbiamo determinare px 2log2 (py )k cioè la frazione di operazioni eseguite quando sono
attivi 2log2 (py )k processori in ogni riga: ad ogni passo intermedio ogni processore attivo effettua la
log2 (p y )k M
log2 (p y )k
somma vettoriale fra due risultati parziali di lunghezza M
px per un totale di px 2
px = M2
77
operazioni eseguite concorrentemente su px 2log2 (py )k processori.

px py e i vari px 2log2 (py )k devono soddisfare questuguaglianza
X p 2log2 (py )k
x
log2 p y
T(1) = M(2N 1) = px py +
k=1
px 2log2 (py )k
da cui si ricava:
px py

!
p y 2 pNy 1
N
1
= pyM 2 1
=
py
M(2N 1)
2N 1
px 2log2 (py )k = M2log2 (py )k
1
2log2 (py )k
=
M(2N 1)
2N 1
Alla luce di queste considerazioni si puo` riformulare la legge di Ware per l algoritmo per il calcolo
del prodotto matrice vettore basato sulla decomposizione per blocchi e sulla strategia riportata nel
paragrafo 2.3.2 per lo scambio e laggregazione dei risultati intermedi:
S(p) =
=
px p y
px p y
1
Plog2 py
p y 2 pNy 1
2 pNy 1
1
2N1 px
=
=
log (p )k
px 2 2 y
log2 (p y )k
px 2
1

2N1
k=1
1
px p y
Plog2 py
k=1
1
Plog2 py
k=1
2log2 (p y )k
1
2N1 px 2log2 (p y )k
1
1
2N1 px
1
1
px (2N1)
2 pNy 1 +
Plog2 py
1
k=1
1
1
px (2N1)
2 pNy 1 + log2 p y
px (2N 1)
2 pNy
1 + log2 p y
Gli speedup calcolati con la legge di Ware generalizzata e con la definizione classica di speed (tab.
4.7) up coincidono.
Terza strategia
Le prestazioni ottenute usando la terza strategia (par. 2.3.3) per lo scambio e laggregazione dei
risultati intermedi sono identiche a quelle appena viste a proposito della seconda strategia: questo
perchè il numero di passi di comunicazione/aggregazione e` sempre log2 p y ma ad ogni passo tutti i
px p y processori sono attivi e si scambiano i risultati intermedi e ne calcolano la somma vettoriale;
di conseguenza il numero di operazioni di comunicazione/aggregazione ad ogni passo e` maggiore
rispetto alla seconda strategia ma queste operazioni vengono eseguite concorrentemente.
78
4.3
Algoritmo parallelo in ambiente MIMD Shared Memory
Le strategie per combinare insieme i risultati parziali in ambiente MIMD SM sono analoghe a
quelle viste nel paragrafo precedente in ambiente MIMD DM ma si basano sulla sincronizzazione
degli accessi piuttosto che sullo scambio di messaggi.
Le prestazioni sono identiche a quelle appena viste ignorando i costi di comunicazione in ambiente
MIMD DM perchè vengono effettuate concorrentemente le stesse operazioni fra coppie di processori.
79
Bibliografia
[1] Top500: lista dei 500 supercomputer non distribuiti piu` potenti al mondo www.top500.org
[2] Pacchetto software HPL - High Performance Linpack http://www.netlib.org/benchmark/
hpl
[3] Benchmark LINPACK http://www.top500.org/project/linpack
80

Richiami CPD1

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Richiami CPD1

Caricato da

Copyright:

Formati disponibili

Universit`a degli Studi di Napoli

Richiami di Calcolo Parallelo 1

Parametri di valutazione di un software parallelo

Prodotto matrice per vettore

Il calcolo parallelo ad alte prestazioni

E possibile definire diversi tipi di parallelismo. Il parallelismo temporale consente di aumentare

di N elementi ed in output abbiamo un terzo vettore c, anchesso di N componenti, il cui i-simo

Figura 1.3: Schema di un processore vettoriale.

Figura 1.4: Schema classico della macchina di Von Neumann.

Il parallelismo spaziale e` in grado di far eseguire contemporaneamente a piu` unit`a le stesse

Il parallelismo asincrono e` in grado di far eseguire contemporaneamente a piu` unit`a istruzioni

Figura 1.7: Tassonomia di Flynn.

Questa tassonomia va ulteriormente dettagliata per prendere in considerazione le caratteristiche

Architetture multiprocessore a memoria condivisa (SM) e a memoria distribuita

(a) MIMD shared memory

(b) MIMD distributed memory

aree della memoria possono differire.

Figura 1.9: Semplificazione della tassonomia di Flynn completa.

(a) bus singolo

(b) bus multipli

(c) connessione diretta

complessi (fig. 1.11).

(a) rete ad anello

(b) Connessione totale fra i

(c) Rete ad ipercubo

(e) Struttura toroidale

(f) Rete a stella

Calcolo parallelo vs calcolo distribuito

Dati N numeri a1 , a2 , . . . , aN , il calcolo della somma

Decomposizione del problema

Esempio 2: Supponiamo di voler calcolare la somma di N = 20 elementi in parallelo con 5

Algoritmo parallelo in ambiente MIMD Distribuited-Memory

1 addizioni: tutti i processori eseguono le stesse operazioni ma su dati diversi. Le

1 operazioni di addizione di ciascun processore vengono eseguite concorrentemente: ad esempio

via: questa e` solo la prima delle

operazioni di addizione eseguite concorrentemente.

cio`e tutti i processori con identificativo dispari: P1 , P3 , P5 e P7 .

Figura 2.3: Il calcolo della somma complessiva viene demandato al processore P0 .

Confronto fra le tre strategie

Algoritmo parallelo in ambiente MIMD Shared Memory

Figura 2.7: Il calcolo della somma complessiva viene demandato al core C0 .

Figura 2.8: Il calcolo della somma complessiva viene demandato al core C0 .

Parametri di valutazione di un software

Parametri di valutazione di un software sequenziale

Parametri di valutazione di un software parallelo

Speed up S(p), Overhead totale Oh , Efficienza E(p)

Il concetto di efficienza va opportunamente ridefinito per gli algoritmi paralleli.

Maggiore e` lo speed up tantopiu` un algoritmo parallelo e` veloce rispetto al corrispondente algoritmo

Oh (p) = pT(p) T(1) = 0

Oh (p) = pT(p) T(1) > 0

Nei casi reali Oh > 0

Minore e` loverhead totale tantopiu` lo speed up di un algoritmo e` vicino a quello ideale.

Al crescere del numero di processori p aumenta lo speed up ma aumenta anche loverhead

Nel caso reale

Legge di Ware (Amdahl)

Posto T(1) = 1, Ts = e Tc = (1 ); il tempo T(p) diventa

Esempio 4: Lalgoritmo sequenziale per il calcolo della somma di N = 16 valori effettua 15

p processori. Di conseguenza (cio`e la frazione di operazioni eseguite in sequenziale) diventa

 incrementando contemporaneamente il numero di processori p e la dimensione del problema N

Esempio 5: Lalgoritmo sequenziale per la somma di N = 16 valori esegue 15 addizioni (fig.

stata introdotta una formulazione generale della legge di Ware

Non c`e nessuna fase in cui lavorano contemporaneamente 3 processori:

Speed up scalato, efficienza scalata, Isoefficienza

incrementando contemporaneamente il numero di processori p e la dimensione del problema N