1

ANALIZA I PROIECTAREA ALGORITMILOR PARALELI

1. PARAMETRI DE PERFORMAN I MODELE PENTRU SISTEME
PARALELE

1.1. Concepte de baz

Dezvoltarea tehnologiei VLSI a permis crearea de maini care dein sute sau
chiar mii de procesoare care comunic ntre ele pentru rezolvarea unor probleme
date. Scopul realizrii acestor maini este de a obine timpi de procesare ct mai mici
pentru rezolvarea de probleme complexe care, n unele cazuri, sunt aproape
imposibil de procesat pe mainile clasice (uniprocesor) existente.
Practic, creterea spectaculoas a puterii de calcul nu s-a concretizat
ntotdeauna n mod direct n creterea performanei sistemului. Mai multe motive
stau la baza inegalitii existente ntre puterea de calcul disponibil i performana
obinut. Pentru a obine performana maxim pentru un anumit sistem de calcul
trebuie s se pstreze, pe ct este posibil, ct mai multe procesoare active. ns,
acest lucru depinde foarte mult de algoritmul utilizat. Se poate ca problema n sine s
fie de aa natur nct ea s nu admit pentru rezolvare un algoritm paralel eficient.
Dac totui algoritmul paralel ales este eficient pentru problema dat, s-ar putea ca
acesta s nu se potriveasc n ntregime pe arhitectura mainii pe care este executat.
n concluzie, nu orice algoritm paralel poate fi mapat eficient pe o main
paralel real sau, se poate, ca din necesitatea meninerii ct mai multor procesoare
active pe o perioad ct mai mare de timp s se ajung la execuia unei cantiti
nsemnate de calcule redundante. Mai mult, dac dou sau mai multe procesoare
coopereaz n rezolvarea unei probleme, apare necesitatea existenei unei structuri
eficiente de comunicare i coordonare a procesoarelor. Eficiena i complexitatea
acestei structuri depinde de numrul procesoarelor existente n sistem i de modul
de comunicare a acestora.
nelegerea naturii i a gradului n care toi aceti factori afecteaz negativ
performanele algoritmilor i arhitecturilor paralele, va duce n mod negreit la
mbuntirea semnificativ a acestora.

1.2. Modele paralele

Exist dou mari clase de modele paralele:
1. cu memorie partajat (shared memory architecture)
2. cu memorie nepartajat (non-shared memory architecture)

2
Reteaua
de
interconectare
P
1
P
2
P
p
M
1
M
2
M
q

a) Shared memory architecture (p procesoare i un sistem de memorie partajat cu
q - ci de ntreesere);

Reteaua
de
interconectare
P
1
P
2
P
p


b) Non-shared memory architecture;

Reteaua de interconectare
P
1
P
2
P
3
P
4
P
5
P
6
P
7
P
8
M
1
M
2
M
3
M
4
M
5
M
6
M
7
M
8


c) Sistem cu memorie partajat pentru a interconecta 8 procesoare la un sistem de
memorie ntreesut cu 8 ci prin intermediul comutatoarelor crossbar;

P
1
P
2 P
3
P
4
P
5
P
6
P
7
P
0

d) Reea de tip hipercub;

Fig. 1.1 Exemple de modele paralele [Lak90].
3
n arhitecturile cu memorie partajat, procesoarele comunic prin scrierea,
respectiv citirea datelor n/din memoria partajat. Dei n cazul acestor arhitecturi
apare necesitatea sincronizrii globale a procesoarelor pentru transmiterea datelor,
ele au dou avantaje extrem de importante:

permit proiectantului de algoritmi accesul la date n mod
transparent;
pot simula orice form de comunicare dintre cele permise de
modelele cu memorie nepartajat.

Comunicaiile dintre procesoare n cazul arhitecturilor cu memorie
nepartajat, se realizeaz prin transmiterea de mesaje (message-passing), iar
sincronizarea procesoarelor este esenial pentru transmiterea datelor. Un avantaj
major al acestor arhitecturi este acela c pot exploata imediat topologia reelei de
interconectare pentru a rezolva n mod eficient o clas de probleme specifice.
Un model general utilizat pentru studiul calcului paralel este paracalculatorul.
Acesta const dintr-un set de procesoare identice ) p i 1 ( , P
i
, fiecare avnd o
memorie local. Memoria local reine programele i fiecare procesor utilizeaz
aceast memorie pentru calculele sale. Se presupune c fiecare procesor i cunoate
propriul index. Procesoarele pot rula sincron sau asincron. ntr-un model sincron,
toate procesoarele ruleaz un singur, dar pot opera pe diferite segmente de date, n
funcie de propriul index. ntr-o configuraie asincron, fiecare procesor poate rula
seturi diferite de programe.
n cazul n care procesoarele lucreaz sincron fiecare procesor comunic cu
celelalte prin scrierea/citirea n/din memoria partajat (aceast memorie are un
numr nelimitat de celule). Se poate presupune c datele se afl n primele N celule
de memorie M1, M2, . . ., MN ale memoriei partajate iar celelalte celule sunt iniializate
cu valoarea zero. Numrul de procesoare (p) trebuie s fie o funcie dependent de
dimensiunea problemei (N, Nlog2N, 2
N
, etc.). ntr-un pas oarecare, fiecare procesor
poate fie s execute calcule, fie s scrie/citeasc n/din memoria partajat.
O clasificare a modelului cu memorie partajat este dat de modalitile de
accesare a memoriei partajate de ctre procesoare [Lak90]:

a) Concurrent Read and Concurrent Write (CRCW). Sunt permise
scrierile/citirile simultane n/din aceeai locaie de memorie de ctre
procesoare diferite. Acest model poate fi clasificat mai departe n funcie
de modul n care este rezolvat conflictul care apare la scriere:

Priority Write CRCW: atunci cnd survin mai multe cereri de
scriere, procesorul cu index minim va avea prioritate la scriere;
Common Write CRCW: toate procesoarele vor scrie aceeai
cantitate de date atunci cnd apar cereri simultane de scriere.

4
b) Concurrent Read but Exclusive Write (CREW). Permit citiri simultane
dintr-o celul de memorie de ctre mai mult procesoare, ns nu permit
dect unui singur procesor s scrie la un moment dat n celula
respectiv. La fel ca i modelul CRCW, acest model permite conflicte n
faza de fetch (instruciune sau operand). Acest model mai este denumit i
PRAM (Parallel Random Access Memory).

c) Exclusive Read and Exclusive Write (EREW). Acest model nu permite
citiri/scrieri simultane din aceeai celul de memorie. Modelul este
cunoscut sub numele de PRAC (Parallel Random Access Computer) i este
mai apropiat de realitate. Modelul EREW poate fi redus la un numr fix
de celule de memorie i permite implementarea restriciilor de
acces/celul. Dac exist un singur procesor care are drept de citire i un
singur procesor care are drept de scriere pentru fiecare celul de
memorie, atunci fiecare locaie acioneaz ca o legtur unidirecional
ntre cele dou procesoare. n acest fel, modelul EREW poate simula uor
arhitectura cu memorie nepartajat cu reea de interconectare fix, cum
ar fi hipercubul.


1.3. Msurarea performanei sistemelor paralele

Exist mai multe ci de evaluare a performanei calculatoarelor i a
algoritmilor paraleli. Ca i standard, s-a impus ca vrful de performan al unei
maini s fie exprimat n uniti de milioane de instruciuni executate ntr-o secund
(MIPS), sau de milioane de operaii n virgul flotant executate/secund (MFLOPS).


6
10 executie de Timpul
program ni instructiu de Numar
MIPS

= ( 1.1)


6
10 executie de Timpul
ta tan flo virgula in operatii de Numar
MFLOPS

= ( 1.2)

Dei aceti parametri sunt simplu de neles i de utilizat, ei nu reflect corect
performanele reale ale sistemelor de calcul. De exemplu, se poate estima timpul de
execuie al unui program dac se cunoate numrul su de instruciuni i valorile
parametrilor MIPS sau MFLOPS. ns, aceti parametri sunt dependeni de setul de
instruciuni main i de programul evaluat. Mai mult, nu toate instruciunile n
virgul flotant au aceeai complexitate i acelai timp de execuie [Gri00].
Pentru evaluarea corect a performanelor reale ale sistemelor de calcul s-a
propus utilizarea unor programe standard, care, executate n condiii identice, s
ofere posibiliti de analiz a calculatoarelor (buclele Livermore, Linpack, Perfect
Club, Whetstone, Dhrystone, SPEC etc.).
5
n realitate, performana realizat (atins) poate fi mult mai mic dect
performana de vrf. n mod cert, performana atins la ora actual este n funcie de
gradul de mapare (de potrivire) a algoritmilor pe arhitectura pe care acetia ruleaz
[Lak90].

1.3.1. Accelerarea

Cea mai bun msur a eficacitii algoritmilor paraleli este raportul de
accelerare (Sp) fa de cel mai bun algoritm serial, care este definit ca raportul dintre
timpul necesar de a rezolva aceeai problem utiliznd cea mai bun metod serial
cunoscut i timpul necesar de a rezolva aceeai problem cu un algoritm paralel
care utilizeaz p procesoare.
Astfel, dac T(N) semnific timpul cerut de cel mai bun algoritm serial pentru
a rezolva o problem de dimensiune N, i Tp(N) semnific timpul luat de algoritmul
paralel care utilizeaz p procesoare n rezolvarea aceleiai probleme, atunci [Lak90]
[Cul99]:


) N ( T
) N ( T
S
p
p
= ( 1.3)

Este evident c Sp este o funcie dependent de N (N este dimensiunea
problemei), iar p este numrul de procesoare.
Practic, exist mai multe variante alternative ale definiiei accelerrii [Gri00]:

relativ, cnd T(N) este timpul de execuie al variantei paralele pe un
singur procesor al sistemului paralel;

real, cnd se compar timpul execuiei paralele cu timpul de execuie
pentru varianta serial cea mai rapid, pe un procesor al sistemului
paralel;

absolut, cnd se compar timpul de execuie al algoritmului paralel cu
timpul de execuie al celui mai rapid algoritm serial, executat de
procesorul serial cel mai rapid;

asimptotic, cnd se compar timpul de execuie al celui mai bun
algoritm serial cu funcia de complexitate asimptotic a algoritmului
paralel, n ipoteza existenei numrului necesar de procesoare;

relativ asimptotic, cnd se folosete complexitatea asimptotic a
algoritmului paralel executat pe un procesor.


6
1.3.2. Eficiena

O alt msur a performanei este eficiena procesorului Ep (randamentul unui
procesor) care este definit ca raportul ntre rata de accelerare i numrul de
procesoare:

=
p
S
E
p
p
Accelerare / procesor ( 1.4)

Nu toi algoritmii seriali admit accelerare atunci cnd sunt implementai
paralel. Dar toi algoritmii paraleli pot fi serializai n mod direct. Deoarece
algoritmul paralel care utilizeaz p (>1) procesoare trebuie s se execute cel puin att
de repede ca algoritmul serial, este necesar ca:

1 S
p
( 1.5)

n multe cazuri trebuie s comparm performana aceluiai algoritm executat
pe o main serial i una paralel. n acest caz accelerarea este definit ca:


) N ( T
) N ( T
S
p
1 *
p
= ( 1.6)

Ti(N) timpul necesar executrii algoritmului pe i procesoare

Eficiena devine:


p
S
E
*
p *
p
= cu 1 S
*
p
( 1.7)

Mai mult, o iteraie a algoritmului paralel care utilizeaz p procesoare va lua
ce mult p pai atunci cnd este implementat serial:

) N ( T p ) N ( T
p 1
p S 1
*
p
i 1 E 0
*
p
( 1.8)

Deoarece ) N ( T ) N ( T
1
, rezult c:


*
p p
S S ( 1.9)

Se definete acceleraia liniar sau ideal ( ) p ( ) pentru o problem dat ca
fiind o valoare constant independent de dimensiunea problemei i a numrului de
procesoare utilizate n rezolvarea acesteia (fig. 1.2).
7
0
N
P
( ) p


Fig. 1.2. Reprezentarea grafic a acceleraiei ideale ((p)).

Se spune despre un algoritm c are acceleraie optim ( ) N ( S
p
) dac acceleraia
sa tinde asimptotic ctre acceleraia liniar (fig. 1.3).

) N ( ) N ( S
p
= ( 1.10)


S
p
0
N
P
( ) p


Fig. 1.3. Reprezentarea grafic a acceleraiei optime (Sp(N)).

Este evident c un algoritm cu acceleraie optim poate avea o eficien
sczut i, de asemenea, un algoritm cu un bun randament/procesor s nu aib o
accelerare mare (un algoritm serial bun poate fi un algoritm paralel prost i, invers,
algoritmul serial poate fi un algoritm paralel rezonabil [Lak90]).
Un alt factor care influeneaz performana este numrul total de operaii
scalare solicitate de algoritm. n cazul algoritmilor seriali funcia de complexitate a
algoritmului este dat de numrul de operaii scalare efectuate. O metod obinuit
prin care se poate obine o cretere a accelerrii sistemului, este de a introduce calcule
scalare suplimentare (redundante). Factorul de redundan Rp al unui
algoritm/procesor este definit ca fiind raportul dintre numrul total de operaii
8
scalare efectuate de algoritmul paralel cu numrul de operaii scalare efectuate de
algoritmul serial.

1 R
p
( 1.11)

n continuare se prezint un algoritm paralel de adunare a N numere x1, x2, ...,
xN, stocate n primele N celule de memorie M1, M2, ... MN (fig. 1.4). Se utilizeaz
pentru calculul sumei celor N numere, N/2 procesoare. Coninutul celulelor de
memorie pe parcursul execuiei programului este dat n figura 1.5.a. Calculele
efectuate n algoritm sunt reprezentate n arborele binar din figura 1.5.b.

/* Fie N = 2n pentru orice n 1. Fie x
1
, x
2
, ..., x
N
valori stocate n M
1
, M
2
, ... M
N
.
Suma final a celor N valori va fi stocat n celula M
1
. Se presupune c exist N
procesoare, ns doar N/2 vor fi utilizate. */

inc=1;
FOR j=1 TO log
2
N DO
FOR i { 1+2kinc | k = 0, 1, ..., N/2
j
- 1 } DO IN PARALLEL
READ M
i
and M
i+inc
;
ADD contents of M
i
and M
i+inc
;
WRITE the sum in M
i
;
END
inc=2inc;
END
Fig. 1.4. Algoritmul paralel de adunare a N numere utiliznd N/2 procesoare pe un
model CREW cu memorie partajat


j M
1
M
2
M
3
M
4
M
5
M
6
M
7
M
8

0 1 2 3 4 5 6 7 8
1 3 2 7 4 11 6 15 8
2 10 2 7 4 26 6 15 8
3 36 2 7 4 26 6 15 8
a) Coninutul celulelor de memorie de-a lungul execuiei algoritmului;

x
1
x
2
x
3
x
4
x
5
x
6
x
7
x
8
x + x
1 2
x + x
3 4
x + x
5 6
x + x
7 8
x + x +
1 2
x + x
3 4
x + x +
5 6
x + x
7 8
x + x +
1 2
x + x +
3 4
x + x + x + x
5 7 8 6


b) reprezentarea algoritmului sub form de arbore;
Fig. 1.5. Algoritmul de adunare asociativ (algoritmul Heller).
9
Algoritmul, denumit Associative fan-in Algorithm, exploateaz proprietatea
de asociativitate a operaiei de adunare, care n mod natural se poate implementa
prin metoda divide et impera.



=
+
= =
+ =
2 / N
1 i
) i 2 / N (
2 / N
1 i
i
N
1 i
i
x x x ( 1.12)

Fiecare termen din partea dreapt a ecuaiei (1.12) poate fi la rndul lui
exprimat ca dou sume de N/4 subtermeni, .a.m.d. Acest algoritm, la fel ca un
algoritm serial, necesit N-1 operaii. Numrul de operaii, respectiv numrul de
procesoare utilizate, se njumtete pe fiecare faz a algoritmului. Din aceast
cauz, accelerarea i eficiena sistemului vor avea valori foarte mici pentru o valoare
N mare.


N log
N
N log
1 N
S
2 2
2 / N

= ( 1.13)

= N cnd atunci 0
N log
2
2
N
S
E
2
2 / N
2 / N
( 1.14)

N/2 numrul de procesoare utilizate (p)
N-1 numrul de operaii executate de algoritmul serial
log2N numrul de pai paraleli executai

Pentru a crete accelerarea i eficiena trebuie ca dimensiunea problemei (N)
s fie mult mai mare dect numrul de procesoare p existente n sistem (Dorina de
a rezolva probleme de dimensiuni tot mai mari crete odat cu dimensiunea i
puterea de calcul a calculatoarelor [Lak90]).
ndeplinirea acestui deziderat se realizeaz dac algoritmul va utiliza p
procesoare (1 < p << N). Se va divide setul celor N numere n p grupuri, fiecare
coninnd
(
(
(

p
N
numere. Se va atribui cte un grup la fiecare din cele p procesoare.
Fiecare procesor va calcula serial suma aferent grupului gestionat i apoi va furniza
suma astfel calculat n
(
(
(

p
N
- 1 pai.
Cele p sume pariale obinute pot fi adunate utiliznd diverse strategii. Una
dintre acestea este de a combina cele p sume pariale ntr-un arbore binar cu
(
p log
2

pai (fig. 1.6).
10
Grup 1
S + S
1 2
S + S + S
1 2 3 4
+ S
Grup 2 Grup 3 Grup 4
S + S
3 4


Fig. 1.6. Arborele binar utilizat n algoritmul de adunare paralel.
Si reprezint suma elementelor din grupul i.

Rezult c timpul de execuie al acestui algoritm va fi dat de:


(
p log 1
p
N
) N ( T
2 p
+
(
(
(

= ( 1.15)


(
p log 1
p
N
1 N
S
2
p
+
(
(
(

= ( 1.16)

Fie
p log p
N
L
2
= factorul de ncrcare al sistemului. Atunci, fiecare procesor va
avea p log L
2
numere de procesat. Rezult c:


1 L
Lp
p log ) 1 L (
p log Lp
S
2
2
p
+
=
+
( 1.17)


1 L
L
E
p
+
( 1.18)

Se observ c pentru L , accelerarea este liniar dup p, iar eficiena
(randamentul) 1 E
p
.
O problem este denumit complet asimptotic paralelizabil dac admite un
algoritm cu accelerare optim. n mod cert, accelerarea optim se obine prin alegerea
dimensiunii problemei ca fiind o funcie de dimensiunea p a numrului de
procesoare utilizate.
Algoritmul prezentat anterior este fundamental pentru soluionarea unui
mare numr de probleme: calculul produsului intern al unui vector, gsirea
maximului sau a minimului unor numere, calculul disjunciei/conjunciei variabilelor
booleene etc.
Din acest exemplu se observ c avnd orice algoritm paralel care se bazeaz
pe o structur arborescent, el poate fi convertit imediat ntr-un program paralel i
mapat pe o arhitectur bazat pe modelul cu memorie partajat.
11

1.3.3. Costul

Costul este definit ca fiind produsul dintre timpul de execuie al algoritmului
paralel i numrul de procesoare utilizate n execuia algoritmului respectiv (se
presupune c fiecare procesor execut acelai numr de instruciuni) [Gri00].

p T C
p p
= ( 1.19)

Pentru ca o aplicaie paralel s fie optim din punctul de vedere al costului
trebuie ca valoarea acestuia s fie egal cu timpul de execuie al celei mai bune
variante secveniale:


1 p
T C = ( 1.20)

1.3.4. Legile accelerrii

Legea lui Amdahl

Pentru evidenierea acestei legi am luat ca exemplu o aplicaie care realizeaz
testarea porilor logice din cadrul unui circuit digital. n figura 1.7 se prezint
caracteristica procesului de testare. Pe axa x se reprezint timpul de testare al
circuitului (cicli main), iar pe axa y se reprezint numrul de pori logice testate la
momentul respectiv de timp [Cul99].



Fig. 1.7. Caracteristica procesului de testare a circuitelor logice digitale [Cul99].

Aria de sub grafic reprezint totalitatea calculelor efectuate de sistemul
paralel. Aceast arie mprit la numrul de cicli necesari rulrii programului ne va
da accelerarea obinut pe un numr nelimitat de procesoare.
12
Putem scrie:

cicli . Nr
Aria
S ( 1.21)

Pentru p procesoare, dac fk este numrul de puncte de pe axa x n care se
testeaz k circuite, atunci ecuaia (1.21) devine:

=
(
(
(

1 k
k
1 k
k
p
p
k
f
k f
S ( 1.22)

Se observ uor c

=

1 k
k
k f reprezint totalitatea calculelor efectuate. Prin
normalizare i presupunnd c s reprezint fraciunea inerent de cod secvenial din
program, obinem:

p
s 1
s
1
S
p

+
( 1.23)

Aceast ecuaie este cunoscut ca legea lui Amdahl i ne arat c indiferent de
numrul de procesoare i de arhitectura mainii, accelerarea obinut va fi
ntotdeauna mrginit superior datorit fraciunii de cod secvenial care apare n
cadrul oricrui program.

Ecuaia Gustafson-Barsis

Legea lui Amdahl nu reflect cazul n care aplicaiile admit paralelism la date.
Gustafson i Barsis au modelat matematic un astfel de caz [Gri00].
S-a plecat de la ipoteza conform creia, timpul de execuie al unui program
paralel cu paralelism de date poate fi normalizat:

1 T
p
= ( 1.24)

Timpul de execuie al programului paralel pe un procesor este dat de:

) 1 p ( s p T ) s 1 ( p sT T T T
p p par sec 1
= + = + = ( 1.25)
iar
s ) s 1 ( p s sp p
1
) 1 p ( s p
T
T
S
p
1
p
+ = + =

= = ( 1.26)

Din ecuaia (1.26) rezult c Sp = O(p) ceea ce nseamn c accelerarea va crete
13
proporional cu creterea numrului de procesoare. Eficiena n acest caz va fi
constant Ep = O(1) indiferent de variaia lui p sau n.

1.3.5. Parametri calitativi

Granularitatea

Granularitatea aplicaiei se definete ca fiind dimensiunea (grain size) minim
a unei uniti secveniale dintr-un program, exprimat n numr de instruciuni. n
cadrul unei uniti considerate secveniale nu se execut operaii de sincronizare sau
comunicare cu alte procese. Un proces este compus din uniti secveniale de
granulariti diferite. n figura 1.8, se prezint structura unei aplicaii compuse din
mai multe activiti paralele (procese sau fire de execuie). Apar puncte de
sincronizare/comunicare; fiecare proces sau fir va avea propria granularitate.
Granularitatea acestei aplicaii va fi dat de valoarea minim a granularitii pentru
toate activitile paralele componente [Gri00].

Start
1
2
3 4 5
6
7
Stop
Crearea activitatilor
paralele (proces, fir)
Puncte de sincronizare
sau comunicatie


Fig. 1.8. Structura unei aplicaii paralele.

Se definete granularitatea unui sistem ca fiind valoarea minim a
granularitii aplicaiilor, valoare sub care performana scade n mod semnificativ.
Scderea de performan se explic prin faptul c n cazul aplicaiilor cu
granularitate mic, timpul de sincronizri/comunicaii devine comparabil cu timpul
de execuie paralel.
Spre deosebire de granularitatea programelor paralele care trebuie s fie
relativ mare, n cazul sistemelor este de dorit s avem o granularitate ct mai mic,
astfel nct acestea s poat executa o palet larg de programe (fig. 1.9). O
granularitate mic pentru un sistem de calcul nseamn un timp de execuie foarte
mic pentru primitivele de calcul paralel (fork, join, barrier etc.).

14
Sistem
G
r
a
n
u
l
a
r
i
t
a
t
e
Timp


Fig. 1.9. Granularitatea sistemului vs. granularitatea aplicaiei.


Scalabilitatea

Scalabilitatea unui sistem paralel reprezint proprietatea acestuia de a asigura
creterea accelerrii odat cu creterea numrului de procesoare. Scalabilitatea
sistemului este ns dependent de gradul de paralelism al aplicaiei, de
granularitatea aplicaiei i, nu n ultimul rnd, de granularitatea sistemului. Dac
prin creterea numrului de procesoare se obine o cretere liniar a accelerrii, se
spune c sistemul este scalabil liniar.
Pentru a beneficia de proprietatea de scalabilitate trebuie ca n programele
paralele s existe ct mai multe procese concurente, astfel nct odat cu creterea
numrului de procesoare s nu se modifice codul ci doar s se redistribuie procesele.
n plus, prezena n sistem a mai multor procese dect procesoare va permite
mascarea operaiilor de comunicaie. Aceast dependen a scalabilitii att de
software ct i de hardware este reprezentat n fig. 1.10.


localitatea
referintei
acces la
date comune
concurenta
comunicatia
echilibrarea incarcarii
dimensiunea memoriei
raportul calcule/comunicatii
dezechilibre arhitecturale
performantele I/E
ALGORITM/SOFTWARE HARDWARE


Fig. 1.10. Factori care influeneaz scalabilitatea [Gri00].

15

2. MULTICALCULATOARE I MULTIPROCESOARE

Performana unui algoritm paralel se msoar prin valorile accelerrii i
eficienei obinute pe mainile actuale. Timpul de citire/scriere n/din memorie este
critic dependent de topologia reelei de interconectare a procesoarelor i respectiv, a
procesoarelor cu memoria. Pentru proiectarea eficient a algoritmilor paraleli trebuie
s se cunoasc n detaliu modul de organizare a datelor pentru accesul paralel,
costurile de comunicaie, maparea sau portabilitatea algoritmilor pe diverse
arhitecturi.
Calculatoarele paralele sunt clasificate n dou mari grupuri:

1. Multicalculatoare cu memorie distribuit
2. Multiprocesoare cu memorie partajat

n organizarea cu memorie partajat un set de procesoare va fi conectat la un
set de memorie comun prin intermediul unui bus de vitez mare sau prin una sau
mai multe reele de interconectare dinamice multinivel. Procesoarele comunic prin
scrierea n, i citirea din, memoria comun (partajat).
n organizarea cu memorie distribuit fiecare procesor este conectat la
memoria local (proprie) prin intermediul unei reele statice (fixe) de interconectare.
O alt trstur fundamental de importan teoretic ct i practic se refer
la portabilitatea algoritmilor pe diverse arhitecturi paralele. Analiza portabilitii va
conduce n mod natural la simularea (ncapsularea) unui set de grafuri n altul.
Exist doi parametri cheie care caracterizeaz calitatea ncapsulrii:
expansiunea i dilataia. Expansiunea se refer la suprancrcarea hardware exprimat
n numr de procesoare utilizate, iar dilatarea la creterea comunicaiilor necesare
simulrii unui graf de ctre altul. De exemplu o strategie des utilizat pentru
obinerea acestor arhitecturi cu un hipercub este de a utiliza codificri bazate pe
codul Gray.

2.1. Multicalculatorul hipercub

2.1.1. Structura recursiv a unui hipercub N-noduri b-baz

Fie N i b dou valori ntregi astfel nct 2 b N i fie k un ntreg astfel nct
k 1 k
b N b < <

. Fie } 1 m , , 2 , 1 , 0 { m >= < .

Un hipercub N-noduri b-baz notat (N, b, k) este un graf G = (V, E), unde

V = { x | x este un ntreg pe k digii reprezentat n baza b, i xi <b>},
i
E = { (x, y) | x, y V, i exist 1 j k astfel nct xj yj i xi = yi pentru orice i j }

16
Mulimea V reprezint mulimea etichetelor nodurilor din graful G, iar
mulimea E reprezint mulimea muchiilor hipercubului aferent lui G.
Dou noduri din graful G sunt conectate dac i numai dac etichetele lor
difer printr-o valoare de 1. Dac baza b = 2, acest graf este denumit hipercub (N, b,
k). Dac N = b
k
, atunci graful G este denumit hipercub complet (N, b, k) de
dimensiune k, sau pur i simplu cub (N, b, k). Dac N b
k
, G este denumit cub
incomplet (N, b, k) (fig. 2.1.).

000
001
011 010
100
101
111 110


Fig. 2.1. Structura unui hipercub (8,2,3).

Cubul (N, b, k) admite o caracterizare recursiv. Dac A este un set de iruri
peste <b>, atunci se definete

B = xA = { x | A i x <b> },

unde x este un ir obinut prin concatenarea lui x i .
Pentru mulimea nodurilor se definete o mulime de seturi V
(i)
, i = 0, 1, ..., k-1,
unde


U
> <
=
b x
) i (
x
) i (
V V ( 2.1)

iar
) i (
x
V este definit recursiv astfel:

{ } > < = b x pentru x V
) 0 (
x
, ( 2.2)

> < =

b x pentru xV V
) 1 i ( ) i (
x
( 2.3)

Rezult c
) i (
x
V const dintr-un ir peste <b> de lungime i+1, n care primul
simbol este x. Astfel,

> < = b x pentru 1 V
) 0 (
x
i b V
) 0 (
= ( 2.4)

17
i, pentru 1 i ,

> < = b x pentru b V
i ) i (
x
i
1 i ) i (
b V
+
= ( 2.5)

Pentru mulimea muchiilor se definete o mulime de seturi E
(i)
, i = 0, 1, ..., k-1,
unde

{ }
U U
t s cu V t , s ; V ) t , s ( E E
) 0 ( ) 1 i (
b x
) i (
x
) i (
< =

> <
( 2.6)
cu
) 1 b ( b
2
1 i
E
1 i ) i (

+
=
+
( 2.7)

Pentru cazul general, graful G va fi definit ca

) E , V ( G
) i ( ) i ( ) i (
= ( 2.8)

cu V
(i)
i E
(i)
definite n (2.1) i (2.6).
n continuare se prezint un exemplu de construire a unui hipercub (N=8, b=2,
k=3) pe baza relaiilor de recursivitate (2.1 2.8) (tab. 2.1 i 2.2).
Pornind de la datele iniiale, se observ c hipercubul definit este complet:
2
3
=8 (b
k
= N). Trebuie s construim graful complet al cubului G
(i)
, i = 0, 1, ..., k-1.

x
) i (
x
V
0 1
V
(i)
0 {0} {1} {0,1}
1 {00,01} {10,11} {00,01,10,11} i
2 {000,001,010,011} {100,101,110,111} {000,001,010,011,100,101,110,111}

Tabelul 2.1. Obinerea etichetelor aferente fiecrui nod din graf

x ) i (
x
E
0 1
E
(i)
0 {0,1} {0,1}
1 {(00,01)} {(10,11)} {(00,01),(10,11),(00,10),(01,11)}
i
2
{(000,001),(010,011),
(000,010),(001,011)}
{(100,101),(110,111),
(100,110),(101,111)}
{(000,001),(010,011),(000,010),
(001,011),(100,101),(110,111),
(100,110),(101,111)}

Tabelul 2.2. Obinerea perechilor de noduri interconectate (muchiilor) n hipercub

Pe baza mulimilor V
(2)
i E
(2)
se poate construi reprezentarea grafic a
hipercubului definit anterior (fig. 2.1.)


18
2.1.2. Proprietile topologice ale unui hipercub (N, b, k)

1) Dac b = N, atunci cubul (N, N, 1) este un graf complet cu N noduri.

2) ntr-un cub complet (N, b, k)

a. Gradul fiecrui nod este N log ) 1 b (
b

b. Exist N log N ) 1 b (
2
1
b
muchii

3) Diametrul unui cub (N, b, k) este N log
b
. Diametrul este definit ca fiind
valoarea maxim a cilor cele mai scurte existente ntre perechile de
noduri ale unui cub. Aceast valoare maxim apare ntre dou noduri
atunci cnd etichetele acestora difer pe fiecare digit. Atta timp ct
diametrul specific ntrzierea maxim de comunicaie, algoritmii
implementai pe cuburi de baz b (b > 2) vor avea ntrzieri mai mici dect
un hipercub (b = 2).

4) Avnd date N i d, exist k i b astfel nct diametrul unui cub (N, b, k)
este mai mic sau egal cu d.


2.2. Multiprocesoare cu memorie partajat

2.2.1. Concepte de baz

Trstura caracteristic a multiprocesoarelor cu memorie partajat este aceea
c un banc comun de module de memorie cu adresare ntreesut este conectat la un
set de procesoare printr-o reea, unde fiecare procesor este o main independent
(fig. 2.2).

Reteaua
de
interconectare
P
1
P
2
P
p
M
1
M
2
M
q


Fig. 2.2. Arhitectura cu memorie partajat.

Un factor important care deseori degradeaz performana global a acestui tip
de arhitectur paralel este legat de conflictele de acces la memorie. Dac k
19
) N k 1 ( < din N procesoare genereaz adrese care sunt rezidente ntr-un singur
modul de memorie, atunci sunt necesari k cicli pentru a furniza datele, iar
performana algoritmului poate s fie degradat cu factorul k. Astfel, pentru a pstra
randamentul global, este necesar ca:

a) procesoarele s genereze adrese astfel nct dou procesoare s nu
solicite date din acelai modul;
b) datele trebuie s fie distribuite n modulele de memorie pentru a se
permite accesul n paralel
c) reeaua de interconectare trebuie s fie capabil s furnizeze ct mai
rapid datele solicitate de ctre respectivele procesoare.

Cea mai simpl reea de interconectare este magistrala de mare vitez (high
speed bus) (fig. 2.3). n aceast reea procesoarele nu pot accesa simultan memoria.
Prin stabilirea numrului de procesoare i a modulelor de memorie n avans, se poate
calcula lrgimea de band necesar magistralei pentru a servi toate accesele
(fetch/store) cu o ntrziere prestabilit. Aceast schem nu se utilizeaz n cazul unui
numr mare de procesoare datorit creterii lrgimii magistralei.

High Speed Bus
P
1
P
2
P
p
M
1
M
2
M
q


Fig. 2.3. Structura high speed bus.

La cellalt capt al spectrului se afl reeaua NN crossbar, care are N intrri i
N ieiri. Procesoarele sunt conectate la intrri, iar modulele de memorie la ieiri (fig.
2.4). La intersecia liniei i cu coloana j exist un comutator cu dou stri (on/off).
Starea on a acestui comutator realizeaz o conexiune ntre procesorul Pi i modulul
Mj. Astfel, ntr-o astfel de reea exist N
2
comutatoare.

P
1
M
1
P
2
P
3
P
4
M
2
M
3
M
4
P
1
M
1
P
2
P
3
M
2
M
3
M
4
M
5

Fig. 2.4. Reele crossbar de dimensiune 44 i 35.
20
Fie N N : o permutare. O reea de interconectare realizeaz permutarea
dac exist o stare a comutatoarelor n reea astfel nct intrarea i este conectat la
ieirea (i) pentru N i 0 < . O reea crossbar NN poate realiza N! permutri. Se
definete capacitatea de combinare (CP) a unei reele de interconectare ca fiind
raportul dintre numrul de permutri realizate i numrul total de permutri. n
cazul reelelor crossbar CP = 1.
Procesul care calculeaz starea comutatoarelor pentru realizarea conexiunilor
este denumit proces de rutare. Un dezavantaj major al acestei reele este costul mare
exprimat n numrul de comutatoare utilizate care este dat de produsul dintre
numrul intrrilor (procesoarelor) i numrul ieirilor (modulelor de memorie).
Exist o serie de factori care nu favorizeaz crearea de reele crossbar foarte
mari: limitarea numrului de pini, tolerana la defect, ntreinerea etc. Din punct de
vedere tehnologic este economic s se implementeze comutatoare mici, de fiabilitate
ridicat, de dimensiuni 22 sau 44. Aceast restricie conduce la ideea implementrii
de reele crossbar NN utiliznd comutatoare 22. n figura 2.5 a i b, se prezint un
comutator 22. O reea crossbar 22 are 4 comutatoare 1 j , i 0 , s
j , i
, plasate la
intersecia liniei i cu coloana j. Prin setarea lui s00 i s11 i resetarea celorlalte dou, se
realizeaz permutarea identic

|
|

\
|
=
1 0
1 0
( 2.9)

i se instaleaz starea on a comutatorului (fig. 2.5 c). Dac se seteaz comutatoarele s01
i s10 i se reseteaz celelalte dou, permutarea realizat va fi


|
|

\
|
=
0 1
1 0
( 2.10)

comutatorul trece n starea off (fig. 2.5 d). Starea comutatoarelor poate fi controlat
printr-un singur bit. Valoarea 0 corespunde strii on (through), iar valoarea 1 pentru
starea off (cross).
Starea unei reele construite dintr-un comutator 22 corespunde setrii
individuale a comutatorului. n mod cert, o reea format din L comutatoare 22 va
avea 2
L
stri distincte. O reea 44 trebuie s aib cel puin un nivel cu dou
comutatoare 22 (fig. 2.6).
Cele mai importante topologii de reele de interconectare utilizate n practic,
sunt (fig. 2.7):
a) Reele cu acces complet: n reea exist cel puin o cale de la fiecare intrare
ctre fiecare ieire;
b) Reele cu cale unic: exist o cale unic ntre fiecare pereche in/out;
c) Reele cu blocare: exist cel puin o permutare nerealizat de ctre aceasta
(CP < 1);
d) Reele fr blocare: realizeaz toate permutrile posibile (CP = 1).
21
0
1
0 1
IN
OUT
S
00
S
01
S
10
S
11

0
1
IN OUT
0
1

a) Structura unui comutator 22 crossbar b) Simbolul unui comutator 22 crossbar

0
1
IN OUT
0
1
bit de control = 0

0
1
IN OUT
0
1
bit de control = 1

c) Starea on.
|
|

\
|
=
1 0
1 0
d) Starea off.
|
|

\
|
=
0 1
1 0


Fig. 2.5. Comutatorul 22 crossbar.


0
1
0
1
S
1
2
3
2
3
S
2

0
1
0
1
S
1
2
3
2
3
S
2
S
3
S
4

a) Reea 44 cu un singur nivel b) Reea 44 cu dou nivele

0
1
0
1
S
1
2
3
2
3
S
2
S
3
S
4

0
1
0
1
S
1
2
3
2
3
S
2
S
3
S
4
S
5
S
6

c) Reea 44 cu dou nivele d) Reea 44 cu trei nivele

Fig. 2.6. Exemple de reele de dimensiune 44 implementate
cu comutatoare 22 crossbar.

Astfel, numrul cilor i factorul CP depind critic de numrul de nivele i de
schema de interconectare dintre nivele pentru reeaua respectiv.
22
Fie N = 2
n
i o reea cu k nivele construit cu comutatoare 22:
1) Exist cel mult
2
kN
comutatoare 22;
2) ntr-o reea cu k nivele, n k , exist cel mult o cale ntre fiecare
intrare/ieire;
3) Sunt necesare n nivele pentru ca aceast reea s posede proprietatea de
acces complet;
4) Numrul de permutri realizate de o reea cu k nivele este de cel mult
N k 1 pentru 2
2
kN
;
5) ntr-o reea cu o singur cale numrul de permutri realizate este egal cu
numrul de stri distincte ale reelei;
6) Dac este permutarea realizat de o reea cu acces complet, atunci, n
general, cel puin o stare a reelei realizeaz aceeai permutare .

Topologii de retea
Statice Dinamice
Crossbar Uninivel Multinivel
Fara blocare Rearanjabile Cu blocare


Fig. 2.7. Taxonomia reelelor de interconectare.


2.2.2. Reele de interconectare cu blocare

Reelele cu blocare fac parte din clasa reelelor cu cale unic i au o
caracteristic recursiv.
Fie N = 2
n
. BL2 este o reea cu un nivel constnd dintr-un comutator crossbar
22. Pentru N 4 i presupunnd c putem crea reeaua BLN/2 rezult reeaua BLN din
figura 2.8.
Primul nivel const din N/2 comutatoare 22 numerotate de la 0 la 1
2
N
.
Acest nivel este urmat de dou reele BLN/2 identice denumite subreele (cea de
deasupra = top, respectiv, cea de dedesubt = bottom). Ieirea top/bottom aferent
comutatorului i este conectat la intrarea i a subreelei top/bottom. Ieirile subreelei
top sunt numerotate de la 0 la 1
2
N
, iar cele ale subreelei bottom de la
2
N
la N 1.
23
0
1
0
1


a) BL2;

0
1
0
1
2
3 N/2-1
2i+1
N/2
N/2+1
N-2
N-1 N-1
0
1
i
N/2-1
BL
N/2
0
1
i
N/2-1
BL
N/2
INPUT OUTPUT
0
1
i
N/2 -1


b) Structura BLN;

0
1
0
1
2
3
4
5
6
7
INPUT OUTPUT
S
11
S
12
S
13
S
14
S
21
S
22
S
23
S
24
S
31
S
32
S
33
S
34
2
3
4
5
6
7


c) Un exemplu de BL8;

Fig. 2.8. Exemple de reele cu blocare BLN.

Din definiia anterioar, rezult c aceast reea are log2N nivele cu
2
N

comutatoare 22 pe fiecare nivel. Numrul total de comutatoare 22 utilizate pentru
construcia BLN este N log
2
N
2
.
Fie x <N>, N = 2
n
, i x = xn xn-1 ... x2 x1 n binar. Amestecarea perfect (perfect
shuffle) este permutarea N N : astfel nct

24

n 1 2 2 n 1 n
x x x ... x x ) x (

= ( 2.11)

unde (x) se obine prin rotirea la stnga cu o poziie a biilor din reprezentarea lui x.
n exprimare zecimal, rezult

N mod
N
x 2
x 2 ) x (
|
|

\
|
(

+ = ( 2.12)

Dac
k
reprezint produsul lui de k ori (
k
= ..., de k ori), atunci


-1
=
n-1


unde
-1
este inversa amestecrii perfecte.
Permutarea cu reversie de bii este N N : , unde


n 1 n 2 1
x ...x x x (x)

= ( 2.13)

Permutarea fluture este N N : astfel nct


n 2 3 2 n 1 n 1
x x x ... x x x ) x (

= ( 2.14)

Permutarea de conversie N N : e
i
este


1 2 3 1 i
i
1 i 1 n n i
x x x ... x x x ... x x ) x ( e
+
= ( 2.15)

unde y reprezint complementul lui y.
Fie E un set de 2
N/2
permutri realizate de
2
N
comutatoare 22 ntr-o reea
crossbar. Pe baza acestei ipoteze se definesc alte tipuri de reele.
O reea omega (N) NN are log2N nivele de comutatoare 22, iar
interconexiunile dintre nivele sunt amestecate perfect (fig. 2.9). Mai mult, intrrile
sunt conectate cu primul nivel dup modelul de amestecare perfect. Astfel, N poate
fi notat astfel:

( )
n
N
E = ( 2.16)

Reeaua n-cub binar indirect (CN) prezentat n figura 2.10 este definit de
relaia


1
) n ( ) 3 ( ) 2 ( N
E E ..... E E C

= ( 2.17)

25
Aceast reea este denumit cub binar indirect deoarece menine relaiile
existente ntr-un hipercub. n schema din figura 2.10, prin setarea n cruce (cross) a
comutatoarelor de pe nivelul 1 i setarea n starea normal (through) a celorlalte
comutatoare, C8 realizeaz conexiuni ntre procesoarele aflate de-a lungul axei primei
dimensiuni a cubului. Se realizeaz astfel conexiuni ntre procesoarele (000, 001) (010,
011) (100, 101) (110, 111). n cazul general, prin setarea cross a comutatoarelor de pe
nivelul i i setarea through a celorlalte comutatoare, se observ c CN simuleaz
interconectarea nodurilor unui cub de-a lungul dimensiunii i (de aici rezult numele
de cub binar indirect, unde N = 2
n
).

000
001
010
011
100
101
110
111
S
11
S
12
S
13
S
14
S
21
S
22
S
23
S
24
S
31
S
32
S
33
S
34
000
001
010
011
100
101
110
111
Nivel 1 Nivel 2 Nivel 3
E E E


Fig. 2.9. Reeaua omega ( )
3
8
E = .

000
001
010
011
100
101
110
111
S
11
S
12
S
13
S
14
S
21
S
22
S
23
S
24
S
31
S
32
S
33
S
34
000
001
010
011
100
101
110
111
Nivel 1 Nivel 2 Nivel 3
E E E
(2)

(3)

1

Fig. 2.10. Exemplu de cub binar indirect
1
) 3 ( ) 2 ( N
E E C

= .
26
Avnd dat o reea de interconectare multinivel, prin interschimbarea
intrrilor cu ieirile obinem o nou reea denumit reea invers (fig. 2.11).

0
1
0
1
2
3 N/2-1
2i+1
N/2
N/2+1
N-2
N-1 N-1
BL
N/2
BL
N/2
INPUT OUTPUT
0
1
i
N/2 -1


Fig. 2.11. Reeaua invers BLN.

Dou reele sunt echivalente din punct de vedere topologic dac o reea poate
fi obinut din cealalt prin reetichetarea intrrilor/ieirilor. Echivalena funcional a
dou reele apare atunci cnd ele realizeaz acelai set de permutri.
Fie N = 2
n
i fie ca intrrile i ieirile fiecrui nivel din reeaua s fie
numerotate de la 0 la N 1 n binar. Conectarea procesorului aferent nodului de
intrare s (surs) cu zona (modulul) de memorie aferent nodului de ieire d
(destinaie), unde

1 2 1 n n
s s ... s s s

=
i

1 2 1 n n
d d ... d d d

=

se va face prin traseul s d, traseu denumit cale(s, d).
O secven de ci unice cu proprietate de acces complet vor determina
obinerea unui arbore binar complet cu n nivele n care fiecare nod de intrare
reprezint rdcina, iar toate cele N noduri de ieire reprezentnd frunzele (fig. 2.12).
Pentru fiecare nod al acestui arbore se eticheteaz ramura superioar cu 0, iar
cea inferioar cu 1. Prin concatenarea acestor etichete de-a lungul fiecrei ci de la
rdcin la frunze obinem etichetele pentru ieirea corespunztoare frunzei
respective. Acest mod de etichetare conduce la un algoritm de rutare.
Fie u1, u2 ... un comutatoarele de-a lungul cii s d (fig. 2.13). Aceast cale este
incident cu comutatorul uk pe nivelul k. Starea comutatorului uk va fi setat n aa
fel nct cale(s, d) trece prin ramura de sus a lui uk dac dn-k+1 = 0 i prin ramura de jos
dac dn-k+1 = 1. Deoarece starea comutatorului uk depinde de dn-k+1, rezult c dn-k+1
poate fi utilizat ca i bit de control. Acest algoritm este denumit algoritm de rutare
bazat pe identificatorul destinaiei (destination tag control algorithm).

27
000
001
010
011
100
101
s = 110
111
000
001
010
011
100
101
110
111
Nivel 1 Nivel 2 Nivel 3
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1


Fig. 2.12. Arbore binar complet cu n nivele


000
001
010
011
100
101
110
111
000
001
010
011
100
101
110
111
Nivel 1 Nivel 2 Nivel 3
v
1
u
1
w
1
u
2
v
2
v
3
u
3


Fig. 2.13. O reprezentare a algoritmului de rutare bazat pe identificatorul destinaiei
110 010, 001 001, 011 000.


2.2.3. Reele de interconectare fr blocare

Primul proiect prin care s-a implementat fizic o reea de interconectare cu CP =
1, dar care s necesite mai puin de N
2
comutatoare, a fost dezvoltat de Clos i Benes
[Lak90].
Fie N = n
2
pentru n 2. Reeaua Clos cu trei nivele simetrice const din n copii
de nm i mn comutatoare pentru nivelele 1 i 3, unde m = 2n 1. Nivelul 2 este
realizat cu m comutatoare nn (fig. 2.14).


28
1
2
n
1
2
n
1
2
n
INPUT OUTPUT
Nivel 1
(n comutatoare de
dimensiune nm)
Nivel 2
(m comutatoare de
dimensiune nn)
Nivel 3
(n comutatoare de
dimensiune mn)


Fig. 2.14. Reea Clos cu trei nivele cu N = n
2
i m = 2n-1.

Interconexiunile dintre nivele satisfac regula de distributivitate care spune c
ieirea i a comutatorului j dintr-un nivel este conectat cu intrarea j a comutatorului i
din nivelul urmtor (fig. 2.15).

23
23
22
22
22
32
32
1
2
3
4
1
2
3
4
INPUT OUTPUT
Nivel 1 Nivel 2 Nivel 3

Fig. 2.15. Reea Clos cu trei nivele: N = 4, n = 2, m = 3.

Fie ca primele n 1 procesoare ataate la comutatorul 1 (nivel 1) s fie
conectate la un set de n 1 module de memorie printr-un set S de n 1 comutatoare
din nivelul 2, unde S = {s1, s2, ..., sn-1}. Similar, fie ca primele n 1 module de memorie
ataate la ieirea comutatorului 1 de pe nivelul 3 s fie conectate la un set de n 1
procesoare printr-un set t de n 1 comutatoare de pe nivelul 2, unde T = {t1, t2, ..., tn-1}.
29
Dac cel de-al n-lea procesor dorete s acceseze locaii de memorie din al n-
lea modul, iar aceast conexiune este fcut prin comutatorul u de pe nivelul2, o
condiie necesar i suficient care permite tuturor comunicaiilor s se execute
independent, este ca seturile S, T i {u} s fie mutual disjuncte. Deoarece |S| + |T| +
{u} = 2n 1, stratul din mijloc al reelei va conine 2n 1 comutatoare. Nivelele 1 i 3
vor conine cte n
2
m comutatoare. De aici rezult c pentru o reea Clos NN (cu N =
n
2
) cu trei nivele, costul va fi

N 3 N 6 m n 3 ) 3 , n ( C
2 / 3 2 2
= = ( 2.18)

Se observ intuitiv c reelele fr blocare au un cost mai mic dect reelele cu
blocare. n tabelul 2.3 se realizeaz o comparaie ntre costul reelelor Clos i costul
reelelor cu blocare (se observ c pentru N 36, reelele Clos sunt mai economice
dect reelele crossbar cu un singur nivel).

Numr de comutatoare
N Reea Crossbar
(N
2
)
Reea Clos cu 3 nivele
(6N
3/2
3N)
4 16 36
9 81 135
16 256 336
25 625 675
36 1296 1188
49 2401 1911
64 4096 2880
81 6561 4131
100 10000 5700

Tabelul 2.3. O comparaie ntre costurile reelelor crossbar i Clos.

30

3. PARALELISMUL LA NIVELUL OPERAIILOR ARITMETICE

Paralelismul poate fi obinut n cel puin patru moduri:

la nivel aritmetic
la nivel de instruciune
la nivel de expresie
la nivel de proces (task)

Identificarea paralelismului la aceste nivele se face att hardware prin structuri
specifice, ct i software prin implementarea de algoritmi paraleli eficieni.
Pentru o accelerare global a sistemului, este esenial s se utilizeze cei mai
buni algoritmi pentru execuia operaiilor aritmetice de baz. Extragerea
paralelismului la nivelul instruciunilor a condus la crearea de arhitecturi moderne,
cu putere mare de calcul i execuie rapid. Analiza expresiilor conduce la programe
organizate eficient, care n conjuncie cu paralelizarea operaiilor matematice i a
execuiei instruciunilor vor conduce la execuii rapide ale aplicaiilor. Sistemele de
operare moderne au ca sarcin repartizarea i distribuirea eficient a proceselor (task-
urilor) n sistemul paralel. De asemenea, programatorul trebuie s identifice
paralelismul existent n aplicaiile create i s utilizeze algoritmi care s exploateze
eficient acest grad de paralelism.


3.1. Analiza algoritmilor de adunare paralel. Algoritmul lui Brent

Implementarea hardware a acestor algoritmi se bazeaz pe operaiile pe bit
AND i OR necesare pentru execuia operaiilor aritmetice de baz. Acesta este
nivelul cel mai jos de paralelism denumit bit level sau micro level parallelism.
Fie a = aN aN-1 ... a2 a1 i b = bN bN-1 ... b2 b1 dou numere ntregi reprezentate n
binar ce vor fi adunate. Fie s = (a + b) mod 2
N
unde s = sN sN-1 ... s2 s1 este suma celor
dou numere. Se tie c


1 i i i i
c b a s

= ( 3.1)

unde c0 = 0 i pentru i = 1 ... N

=
=
=

i i i
i i i
1 i i i i
b a g
b a p
) c g ( p c
( 3.2)

unde simbolurile , , reprezint operaiile logice OR-Exclusiv, OR i AND, iar ci
31
este transportul dinspre bitul de pe poziia i. n calculul sumei s avem nevoie de
valorile biilor de transport c0 la cN-1. Deoarece c0 = 0, rezult

( ) ( )
( ) ( ) ( ) ( )

=
=
=

... g p ... g p g p c
g p g p c
g p c
1 1 1 i 1 i i i i
1 1 2 2 2
1 1 1
( 3.3)

Biii de propagare pi (i = 1 ... N) i generare gi (i = 1 ... N) pot fi calculai n
paralel utiliznd N pori AND i N pori OR cu dou intrri. Dac toi biii de
transport ci (i = 1 ... N-1) sunt cunoscui, termenii si (i = 1 ... N) se pot calcula n doar
doi pai. Dac TA(N) este timpul necesar pentru adunarea a dou numere binare, iar
TC(N-1) este timpul de calcul pentru N-1 bii de transport, atunci

3 ) 1 N ( T ) N ( T
C A
+ = ( 3.4)

Din (3.4) se observ c n adunarea a dou numere binare, valoarea timpului
de calcul este puternic influenat de operaia de obinere a biilor de transport. n
continuare se propune un algoritm paralel pentru calculul acestor bii (fig. 3.1).
Fie r 1 i q 1 astfel nct N = rq. Pentru i = 1 ... r se definesc urmtorii
termeni


( ) ( )

=
=
= =
=
+ +
+
+
i i i
1 q ) 1 i ( 1 q ) 1 i ( iq iq i
r 1 i r i
1 q ) 1 i ( iq i
E D F
... q p ... q p E
1 D , P ... P D
p ... p P
( 3.5)


Fie N = 8, r = 4 i q = 2. Atunci


4 4 4 1 3 3 3 2 2 2 1 1 1
7 7 8 8 4 5 5 6 6 3
3 3 4 4 2 1 1 2 2 1
4 4 3 3 4 2 2 3 4 1
7 8 4 5 6 3 3 4 2 1 2 1
E E D F E D F E D F E D F
)) g p ( g ( p E )) g p ( g ( p E
)) g p ( g ( p E )) g p ( g ( p E
1 D P D P P D P P P D
p p P p p P p p P p p P
= = = = =
= =
= =
= = = =
= = = =
( 3.6)

Din (3.6), prin asociativitate, comutativitate i distributivitate, rezult


1 2 3 4 8
F F F F c = ( 3.7)
i pentru cazul general


1 1 r r N
F F F c =

L ( 3.8)
32
n cazul algoritmului clasic de adunare, calculul biilor de transport se face n
N pai (TC(N)=N). Utiliznd algoritmul lui Brent (fig. 3.1) reiese c timpul necesar
obinerii bitului de transport final va fi [Lak90]:


( ( (
{ } q log ) 1 r ( log ), q ( T max r log 1 ) N ( T
2 2 C 2 C
+ + + ( 3.9)
unde

(
( )
2 / 1
2 C
N log 2 k cu ,
2
) 1 k ( k
) N ( T
+
( 3.10)

Din (3.4), (3.9) i (3.10) rezult c adunarea a dou numere binare de lungime
N se efectueaz n aproximativ log2N pai utiliznd algoritmul lui Brent i n N pai
utiliznd algoritmul clasic.
Pentru cazul prezentat anterior (N =8, r = 4, q = 2) calculul biilor de transport
se va face n 8 pai utiliznd algoritmul clasic i n maxim 6 pai utiliznd algoritmul
lui Brent. Performanele obinute nu sunt spectaculoase, ns odat cu creterea
numrului de bii ai valorilor a i b acestea vor crete considerabil.

a
N
a
N-1
a
1
b
N
b
N-1
b
1
. . . . . .
Calculeaza p si g , i = 1, . . . , N
intr-un singur pas, utilizand 2N porti
i i
p , g , i = 1, . . . , N
i i
p , i = 1, . . . , N
i
Calculeaza E, i = 1, . . . , r
in T (q) pasi,
utilizand s(q) porti
i
C
Calculeaza P , i = 1, . . . , r
in log q pasi,
utilizand r(q-1) porti
i
2
P , i = 1, . . . , r
i
Calculeaza D, i = 1, . . . , r
in log (r-1) pasi,
utilizand (r/2) porti
i
2
log r
2
Calculeaza F, i = 1, . . . , r
intr-un singur pas, utilizand r porti
i
D, i = 1, . . . , r
i
E, i = 1, . . . , r
i
Calculeaza C
in log r pasi, utilizand (r-1) porti
N
2
C
N

Fig. 3.1. Schem de calcul paralel al bitului de transport.
33

3.2. Analiza algoritmilor de nmulire paralel

Fie a = aN aN-1 ... a2 a1 i b = bN bN-1 ... b2 b1 dou numere ntregi reprezentate n
binar ce vor fi adunate. Fie s = (a b) mod 2
N
unde s = sN sN-1 ... s2 s1 este produsul celor
dou numere.

3.2.1. Algoritmul clasic de nmulire varianta paralel

Fie a = 1101 i b=1101. Se calculeaz n paralel produsele pariale x1 ... x4 pe
baza operaiei logice AND

x1 = 0001101
x2 = 0000000
x3 = 0110100
x4 = 1101000

Se adun dou ct dou valorile astfel obinute executnd calculele n paralel

x1 + x2 = 00001101
x3 + x4 = 10011100

n final se obine s = x1 + x2 + x3 + x4 = 10101001 care reprezint produsul
numerelor a i b (fig. 3.2). Timpul de execuie al acestui algoritm va fi (log2N)
2
(spre
deosebire de algoritmul clasic care se efectueaz n N
2
pai).

/* Fiind date numerele a = aN aN-1 ... a2 a1 i b = bN bN-1 ... b2 b1, s se
gseasc produsul s = ab = s2N s2N-1 ... s2 s1 */
Pasul 1:
Se calculeaz cele N produse pariale x1, x2, ..., xN de lungime 2N-1
fiecare.

x1 = 0 0 0 ... 0 aN^b1 aN-1^b1 ... a2^b1 a1^b1
x2 = 0 0 0 ... aN^b2 aN-1^b2 aN-2^b2 ... a1^b2 0
... ... ... ... ... ... ... ... ... ...
xN = aN^bN aN-1^bN ... ... ... ... a1^bN ... 0 0

unde ai^bj reprezint operaia AND logic
Pasul 2:
Se adun n paralel cele N produse pariale obinute n pasul 1.

Fig. 3.2. Algoritmul clasic de nmulire varianta paralel

34

3.2.2. Algoritmul de nmulire Ofman - Wallace

Ofman i Wallace au creat un algoritm paralel rapid de nmulire a dou
numere ntregi pe N bii cu timp de execuie log2N. Algoritmul se bazeaz pe
modificarea (mbuntirea) pasului 2 din algoritmul prezentat anterior (fig. 3.2).
Fie x, y, z numere ntregi pe N bii. Exist dou numere ntregi pe N + 1 bii
astfel nct

b a z y x + = + + ( 3.11)

unde a i b pot fi obinute n paralel din x, y, z n trei pai.
Fie a = aN-1 aN ... a2 a1 i b = bN-1 bN ... b2 b1. Se definesc aN+1 = 0 i b1 = 0, iar
pentru 1 i N


1 i i i i i
b 2 a z y x
+
+ = + + ( 3.12)

Operaiile + i reprezint adunarea i respectiv nmulirea celor doi termeni.
nmulind cu 2
i-1
i apoi adunnd se obine relaia (3.11). Termenii ai i bi au
urmtoarea form


i i i i i 1 i
i i i i
z ) y x ( ) y x ( b
z y x a
=
=
+
( 3.13)

iar calculul acestora se poate face n paralel utiliznd schema din figura 3.3.

+
+
z
i
x
i
y
i
z
i
x
i
y
i
a
i
b
i+1


Fig. 3.3. Circuit pentru calculul termenilor ai i bi+1

Exemplu:

Fie x = 1011, y = 0111, z = 1101 trei produse pariale obinute n pasul 1 al
algoritmului clasic de nmulire (se observ uor c a = 00001 i b = 11110). Forma
35
acestor produse este x0,1, x0,2, ..., x0,N0 (N0 = N), unde x0,i = xi sunt biii de pe poziia
(2N-1) pentru fiecare produs parial.
n prima etap se mparte grupul de produse pariale n
(

3
N
0
grupuri de cte
trei ntregi fiecare. Aplicnd metoda Ofman - Wallace pentru fiecare grup se obin
(

3
N
2
0
ntregi de 2N bii lungime (practic a i b). Prin adunarea (cu alinierea fa de
bitul cel mai puin semnificativ) restului de produse pariale (
(

3
N
3 N
0
0
) se obin


(

=
(

+
(

=
3
N
N
3
N
3 N
3
N
2 N
0
0
0
0
0
1
( 3.14)

ntregi pe 2N bii.
Reiternd, se formeaz
(

3
N
1
grupuri de trei ntregi avnd lungimea de 2N
bii i se obin


(

=
(

+
(

=
3
N
N
3
N
3 N
3
N
2 N
1
1
1
1
1
2
( 3.15)

ntregi avnd 2N+1 bii. Dup i pai rezult


(

3
N
N N
1 i
1 i i
( 3.16)

ntregi de lungime 2N+1-i bii. Algoritmul se repet pn cnd Ni < 3.
Deoarece aceste valori ntregi se obin n paralel pe baza circuitului din fig. 3.3,
rezult c n final se va efectua o singur adunare a dou valori pe 2n-1+i bii, care va
necesita log2N pai (spre deosebire de algoritmul paralel anterior care necesita
(log2N)
2
pai).

3.2.3. Algoritmul de nmulire Karatsuba Ofman (divide et impera)

Se bazeaz pe strategia divide et impera i permite nmulirea a dou valori
ntregi de N bii, unde N = 2
n
. Numerele ntregi a i b se pot rescrie astfel

+ =
+ =
0
2 / N
1
0
2 / N
1
B 2 B b
A 2 A a
( 3.17)

36
unde Ai i Bi, i = 0 sunt numere ntregi de
2
N
bii. A0 este restul i A1 este ctul
mpririi lui a la 2
N/2
(n mod identic, B0 i B1 reprezint restul, respectiv ctul,
mpririi lui b la 2
N/2
). Se definesc r0, r1 i r2 astfel nct

=
+ + =
=
1 1 2
0 1 0 1 1
0 0 0
B A r
) B B ( ) A A ( r
B A r
( 3.18)

Produsul numerelor a i b va fi


0
2 / N
0 2 1
N
2
r 2 ) r r r ( 2 r b a + + = ( 3.19)

i este obinut n urma a trei nmuliri (recursive) a ntregilor de
2
N
bii i un total de
6 operaii adunare/scdere a unor termeni de cel mult 2N bii. nmulirile cu 2
N
i 2
N/2

implic doar operaii de deplasare efectuate pe o singur perioad de tact. Rezult c
n operaia de nmulire doar operaiile de adunare/scdere consum timp, iar acest
timp va fi (log2N)
2
.
Metoda Karatsuba Ofman este elegant i se poate implementa recursiv, ns
necesit ca timp de execuie (log2N)
2
pai. Acest timp de execuie reprezint o valoare
foarte mare n comparaie cu metoda Ofman Wallace bazat pe modificarea
algoritmului clasic (log2N pai).
37

4. STRATEGII PENTRU CREAREA PROGRAMELOR PARALELE

4.1. Scopurile procesului de paralelizare

Scopul major al utilizrii mainilor paralele este de a mbunti performana
prin obinere de accelerare fa de cea mai bun performan obinut pe un sistem
uniprocesor.
Fiecare din paii utilizai n crearea programelor paralele are un rol important
n atingerea complet a acestui scop i fiecare pas are propriul subset de scopuri care
vizeaz performana.
Crearea unui program efectiv paralel necesit evaluarea costului i a
performanei. n plus, fa de costul n bani al mainii respective, trebuie luate n
considerare cerinele de resurse ale programului pe acea arhitectur (de exemplu
memoria utilizat) i efortul necesar dezvoltrii unui program satisfctor. Dei
costurile i impactul acestora sunt deseori dificil de cuantificat, ele sunt foarte
importante i de multe ori performana sistemului este sacrificat pentru reducerea
acestora.
Proiectanii de algoritmi trebuie s se concentreze pe soluiile performante
care solicit resurse minimale i care nu necesit eforturi de programare excesive.
Proiectanii de arhitecturi de calcul trebuie s ncerce s proiecteze sisteme de
nalt performan care s faciliteze utilizarea eficient a resurselor de ctre
algoritmi, precum i reducerea efortului de programare i toate acestea la un cost
sczut. O arhitectur n care performana crete gradual cu creterea efortului de
programare poate fi preferat uneia care este capabil s furnizeze performan mai
bun, dar care necesit eforturi excesive de programare pentru a obine performane
acceptabile.

4.2. Pai n procesul de paralelizare

Un task este definit ca fiind o sarcin de lucru dintr-un proces. task-ul
reprezint cea mai mic unitate de concuren care poate fi exploatat de ctre un
program. Codul unui task poate fi executat doar de ctre un singur procesor, iar
concurena este exploatat doar prin task-uri.
Un proces este o entitate abstract care execut task-uri. Programele paralele
sunt compuse din procese comunicante (cooperante), fiecare dintre ele executnd un
subset de task-uri din program.
Task-urile sunt asignate (atribuite) proceselor printr-un mecanism de atribuire.
Procesele trebuie s comunice i s se sincronizeze cu alte procese, pentru a-i putea
executa propriile task-uri. n final, calea prin care procesele execut propriul task este
ca ele s ruleze pe procesoarele fizice existente n maina de calcul.
Diferena dintre procese i procesoare (din punct de vedere al paralelismului)
const n faptul c n timp ce procesoarele sunt resurse fizice, procesele furnizeaz o
38
metod convenabil de abstractizare sau virtualizare a unui multiprocesor: iniial
programele paralele sunt scrise avnd n vedere procesele i nu procesoarele;
maparea proceselor pe procesoare revine pasului urmtor.
Numrul de procese dintr-un program nu va fi identic cu numrul
procesoarelor disponibile programului. Dac exist mai multe procese, ele sunt
multiplexate pe procesoarele disponibile. De asemenea, unele procesoare vor rmne
neutilizate dac numrul proceselor din program este mai mic dect al procesoarelor.
Se definesc [Cul99] patru pai n procesul de creare a programelor paralele
(fig. 4.1):

1. Decompoziia calculelor n task-uri
2. Atribuirea de task-uri n procese
3. Coordonarea acceselor la date i asigurarea comunicrii i
sincronizrii dintre procese
4. Maparea (legarea) proceselor de procesoare


D
E
C
O
M
P
O
Z
I
T
I
E
A
T
R
I
B
U
I
R
E
p0 p1
p2 p3
C
O
O
R
D
O
N
A
R
E
p0 p1
p2 p3
M
A
P
A
R
E
P0 P1
P2 P3
Calcul
secvential
Task-uri Procese Program
paralel
Procesoare
Partitionare


Fig. 4.1. Paii parcuri n procesul de paralelizare.

Etapele de decompoziie i atribuire fac parte din procesul de partiionare
deoarece n aceast etap se divid calculele efectuate de ctre un program n procese
cooperante. n faza de coordonare se gestioneaz accesele la date, comunicaiile i
sincronizrile ntre procese. n faza de mapare se face alocarea proceselor pe
procesoarele existente n sistem.


39
4.2.1. Decompoziia

Reprezint divizarea calculelor ntr-o colecie de task-uri. n general, task-urile
devin disponibile dinamic, pe msur ce programul se execut. Numrul de task-uri
disponibile la un moment dat variaz pe timpul execuiei programului. Acest numr
ne furnizeaz limita superioar a numrului de procese (respectiv procesoare) care
pot fi utilizate efectiv la acel moment de timp.
De aceea, scopul major n decompoziia datelor este de a extrage (a etala)
suficient concuren pentru a pstra procesele ocupate ct mai mult timp. ns dac
timpul ocupat de task-urile de coordonare tinde s devin comparabil cu timpul
ocupat de task-urile utile se va obine un randament sczut pentru sistemul de calcul.
Gradul sczut de concuren reprezint o limitare important a accelerrii
obinute prin paralelism. ntr-o problem fundamental nu conteaz doar concurena
disponibil ci i cantitatea de concuren care poate fi obinut prin paralelism.
Impactul concurenei disponibile este codificat n legea lui Amdahl (ec. 1.21).
Dac anumite secvene din execuia programului nu dein concuren suficient (n
funcie de numrul procesoarelor utilizate), atunci unele procesoare vor fi neutilizate
o fraciune din timpul de execuie, iar accelerarea sistemului va fi neoptimal.

4.2.2. Atribuirea

Atribuirea este un mecanism prin care task-urile vor fi distribuite proceselor.
Scopul atribuirii este de a echilibra ncrcarea proceselor, de a reduce
cantitatea de comunicaii interproces i de a reduce calculele suplimentare aprute
(pe parcursul execuiei programului) pentru implementarea acestui mecanism.
Comunicaia interprocese este costisitoare, mai ales atunci cnd procesele
ruleaz pe procesoare diferite, iar atribuirile pentru procesarea task-urilor pot genera
suprancrcri la rulare.
Programele sunt structurate n faze, iar task-urile candidate pentru
decompoziie din cadrul unei faze sunt uor de identificat. O atribuire corect a task-
urilor se poate face fie prin analiza codului, fie prin nelegerea aplicaiei la nivel nalt
(pseudocod). Dac acest lucru nu se poate face, se vor aplica tehnici euristice.
Dac atribuirea este determinat complet de la nceputul programului sau
imediat dup citirea i analiza intrrilor i dac nu se modific dup aceea, ea este
denumit static sau predeterminat. Atribuirea dinamic se face n timpul rulrii
programului, pentru a rezolva dezechilibrul ncrcrii procesoarelor.
Decompoziia i atribuirea reprezint cele mai importante etape n procesul de
paralelizare; ele sunt independente de arhitectura sistemului i de modelul de
programare, iar costurile i complexitatea aplicaiilor influeneaz deciziile luate n
aceste etape.
Din punctul de vedere al arhitectului, se presupune c programele care vor
rula pe main sunt partiionate rezonabil i nu se poate interveni dac calculele nu
sunt paralelizate destul , sau dac exist dezechilibre ntre procese.
40
Din punctul de vedere al programatorului, trebuie acionat independent (n
sensul decompoziiei i atribuirii) de modelul de programare sau de arhitectur.

4.2.3. Coordonarea

Este pasul n care att arhitectura ct i modelul de programare joac roluri
eseniale. Pentru a executa task-urile asignate, procesele au nevoie de mecanisme de
identificare i accesare a datelor, de a schimba date (de a comunica) cu alte procese i
de a se sincroniza cu acestea. Coordonarea utilizeaz mecanismele disponibile pentru
a atinge corect i eficient aceste scopuri.
Alegerile efectuate n coordonare sunt mai mult dependente de modelele de
programare (i de modul n care primitivele modelului de programare sunt
suportate) dect de alegerile efectuate n paii anteriori.
n acest pas se rezolv urmtoarele probleme:

organizarea structurilor de date;
planificarea temporar a task-urilor n cadrul unui proces pentru a
exploata localitatea datelor;
se alege modul de comunicare interproces: implicit sau explicit, dac se
va face prin mesaje mici sau mari;
organizarea comunicaiei i sincronizrii ntre procesele rezultate din
atribuire.

Limbajul de programare este important deoarece acesta este pasul n care
programul este scris, iar realizarea echilibrrii proceselor este puternic influenat de
mecanismele disponibile n limbaj i de costurile acestora.
Scopurile principale n coordonare sunt:

reducerea costurilor de comunicaie i sincronizare;
pstrarea localitii n referina datelor;
planificarea task-urilor astfel nct toate celelalte task-uri de care depind
acestea s se fi executat deja;
reducerea suprancrcrii aprute datorit managementului
paralelismului.

Sarcina proiectanilor de arhitecturi este de a pune la dispoziie primitivele
necesare care simplific partea de coordonare.

4.2.4. Maparea

Procesele cooperante care rezult n urma pailor anteriori constituie un
program paralel complex. Maparea proceselor pe procesoare poate fi fcut de ctre
program sau de ctre sistemul de operare.
41
n cazul cel mai simplu, procesoarele de pe main sunt partiionate n
subseturi i doar un singur program ruleaz la un moment dat pe un subset. Aceast
metod este deseori denumit partajarea spaiului. Programul poate lega
procesele de procesoare pentru a nu permite migrarea acestora n timpul execuiei;
poate controla exact perechile procesor-proces pentru a asigura localitatea
comunicaiilor.
Schemele de partajare a spaiului, mpreun cu mecanismele simple de
partajare a timpului sunt tipice deja n sistemele multiprocesor. La cealalt extrem,
sistemul de operare poate alege dinamic ce proces va rula la un moment dat (fr a
permite utilizatorului s intervin n mapare), pentru a gestiona n mod corect
partajarea resurselor i utilizarea acestora.
Fiecare procesor poate folosi un criteriu de planificare multiprogram pentru a
gestiona procese din acelai sau din programe diferite, iar procesele pot fi mutate de
la procesor la procesor aa cum dicteaz planificatorul.
Sistemul de operare poate extinde criteriul de planificare pentru a include
caracteristici specifice multiprocesoarelor. De exemplu, se pot crea procese
planificate s ruleze pe acelai procesor ct mai mult timp posibil, astfel nct
procesul poate reutiliza starea sa din cache-ul procesorului respectiv.
Majoritatea sistemelor de operare moderne se afl undeva ntre aceste dou
extreme: utilizatorul poate solicita sistemului s i pstreze anumite proprieti
(drepturi de control i mapare), dar sistemul de operare este n msur de a modifica
maparea dinamic pentru managementul eficient al resurselor mainii.
Maparea i managementul de utilizare a resurselor n sistemele
multiprogramate sunt domenii deschise cercetrii.

4.3. Paralelizarea calculelor i paralelizarea accesului la date

Metodele de paralelizare ale proceselor descrise anterior au fcut referire doar
la calculele efectuate n program i nu la datele accesate. Datorit modelului de
programare sau din consideraii de performan, trebuie s realizm decompoziia i
atribuirea datelor pentru fiecare proces. n multe clase de probleme calculele i datele
sunt att de strns legate ntre ele, nct decompoziia este dificil de realizat pentru
fiecare n parte.
Mediile de programare permit programatorului s specifice decompoziia i
atribuirea structurilor de date. Atribuirea calculelor se va face dup atribuirea
datelor.

4.4. Exemplu de paralelizare a unui program

Pentru paralelizarea unui program secvenial, programatorul trebuie s
parcurg paii de decompoziie, atribuire i coordonare. Ultimul pas (maparea) va fi
efectuat de ctre sistemul de operare.

42
Fie
2
x 1
4
) x ( f
+
= . Graficul funciei f(x) este prezentat n figura 4.2. Aria de sub
grafic reprezint valoarea .

x
y
4
0
0 1
1 + x
2
4
f(x) =


Fig. 4.2. Reprezentarea grafic a funciei
2
x 1
4
) x ( f
+
= .

n continuare se propune [Sun00] o metod simpl de calcul a valorii ,
utiliznd un program secvenial i apoi un program paralel. Algoritmul se bazeaz
pe metoda dreptunghiurilor (fig. 4.3).

x
y
4
0
0 1


Fig. 4.3. Descompunerea ariei de sub f(x) prin regula dreptunghiului.

43
Din figura 4.3 rezult c

=
1
0
) x ( f . Aria de sub grafic poate fi calculat astfel:

=
=
n
1 i
i
) x ( f width S ( 4.1)

unde
n
1
width = , iar ) 5 , 0 i ( width x
i
= .
Programul secvenial pentru calculul valorii , poate fi implementat dup
urmtorul algoritm:


float f(int x)
{
return 4 / (1 + x * x);
}

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

cin >> n;
width = 1.0 / n;
sum = 0;
pi = 0;

for (i = 1; i n; i++)
{
xi = width * (i 0.5);
sum = sum + f(xi);
}

pi = width * sum;
cout << pi;


Paralelizarea programului ncepe cu faza de decompoziie. Procesul de
decompoziie se bazeaz pe programul secvenial descris anterior. n aceast etap,
bucla din programul anterior va fi descompus n patru task-uri (patru bucle).
Dreptunghiurile din care este format aria vor fi numerotate n ordine de la 0 la 3
(fig. 4.4). Fiecare bucl va calcula o sum parial a nlimilor dreptunghiurilor
alocate ei (bucla 0 va calcula suma nlimilor pentru dreptunghiurile 0, bucla 1
pentru dreptunghiurile 1 etc.).
n etapa de atribuire, cele patru task-uri vor fi ataate la patru procese. Este
clar, c dup aceast etap se poate stabili numrul maxim de procesoare (4) care vor
fi implicate n execuia acestui program. Dac se dorete utilizarea unui numr ct
mai mare de procesoare, calculele pot fi divizate n ct mai multe task-uri (de
exemplu un numr egal cu numrul de dreptunghiuri), urmnd ca sistemul de
operare sa stabileasc numrul de procesoare utilizate.

44
x
y
4
0
0 1
0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3


Fig. 4.4. Asignarea dretunghiurilor.

Coordonarea se va face prin intermediul procesorului principal, prin
colectarea rezultatelor de la celelalte procesoare implicate n execuia programului
paralel. n continuare se prezint o variant paralel de calcul a valorii .


float f(int x)
{
return 4 / (1 + x * x);
}

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

cin >> n;
width = 1.0 / n;
sum = 0;
pi = 0;

for (i = 1; i n; i++)
{
for (j = 0; j < nrproc; j++) do in parallel
{
P[j]:
xi = width * (i 0.5);
sum(j) = sum(j) + f(xi);
}
}

for (k = 0; k < nrproc; k++)
{
P[0]: sum = sum + sum(k);
}
pi = width * sum;
cout << pi;


45

5. ALGORITMI PARALELI NUMERICI

5.1. Adunarea a N numere

Algoritmul secvenial pentru adunarea a N numere are funcia complexitate
de timp O(N), ceea ce reprezint valoarea optim.


sum = 0;
for (i=0;i<n;i++) sum = sum +a[i];


Varianta paralel este dependent de dimensiune N = p. Se vor aduna p/2
perechi de numere, pe un traseu de tip arbore binar. Dup p log
2
pai, se obine n
nodul rdcin suma final a celor N numere. Rezult c

N) O(log p) O(log p) T(N, (N) T
2 2 p
= = = ( 5.1)

|
|

\
|
= = =
p log
p
O
) N (log O
) N ( O
) N ( T
) N ( T
) N ( S
2 2 p
1
p
( 5.2)

|
|

\
|
= =
p log
1
O
p
) N ( S
) N ( E
2
p
p
( 5.3)

Din ecuaia (5.3) se observ c eficiena acestui algoritm tinde ctre zero atunci
cnd N (respectiv p) are valoare foarte mare. Motivul se regsete n faptul c
algoritmul se bazeaz la un moment dat pe numai dou niveluri ale arborelui, n
timp ce celelalte procesoare sunt neutilizate (fig. 5.1).

P0 P1 P2 P3 P4 P5 P6 P7
P0
P0
P0
P2 P4 P6
P4
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
a[0]+a[1]+a[2]+a[3]+a[4]+a[5]+a[6]+a[7]


Fig. 5.1. Algoritmul paralel de adunare a N numere utiliznd p = N procesoare.
46
Algoritmul de adunare prezentat anterior se refer doar la faza global. Dac
se consider i faza local, procesoarele vor aduna local L = N/p valori, cu algoritmul
secvenial n O(L).
Timpul total de calcul va fi O(L) + O(log2p) = O(L + log2p). Dac N este mult
mai mare dect p, atunci

(L) O p) log O(L (N) T
HL 2 p
= + = ( 5.4)

iar accelerarea devine


|
|
|
|

\
|
+
=
+
=
p log
p
N
N
O
) p log L ( O
) N ( O
) N ( S
2
2
p
( 5.5)
iar pentru N >> p se obine

) p ( O ) N ( S
HL p
= ( 5.6)

De aici rezult c Ep(N) = OHL(1) i imediat se observ c problema este
complet paralelizabil.
Raportul N/p (L) va trebui ales de aa manier nct fazele local i global s
aib aceeai complexitate.


) N ( T ) N ( T
) N ( T
) N ( S
global
p
local
p
1
p
+
= ( 5.7)

Cei doi termeni de la numitor sunt asimptotic egali. Prin procesare de tip
pipeline, se obine


) N ( T
) N ( T
) N ( S
local
p
1
p
= ( 5.8)

Accelerarea ideal se obine cnd L = O(log2p), adic N = O(plog2p). Se vor
lansa n execuie noi instane ale problemei pe fiecare pas, astfel nct dei fiecare
instan necesit timpul O(log2p), arborele poate rezolva probleme de nsumare la o
rat de una la fiecare log2p uniti de timp.


5.2. Calculul sumelor pariale (prefixul paralel)

Problema calculrii sumelor pariale reprezint o generalizare a algoritmului
de nsumare.
47
Fiind date N valori, a1, a2, ..., aN se dorete calcularea sumelor S1, S2, ..., SN,
unde

=
=
i
1 j
j i
a S .
Algoritmul secvenial al acestei probleme este:


for (i = 0; i n -1; i++)
{
sum[i] = 0;
for (j = 0; j i; j++) sum[i] = sum[i] + a[j];
}


ntr-un sistem EREW cu p procesoare aceste sume se calculeaz n timpul
O(log2n), prin exploatarea asociativitii i meninerii ocupate a ct mai multor
procesoare. Algoritmul este prezentat n continuare.


void ALLSUMS(a
1
, a
2
, ..., a
N
)
{
for (j = 0; j log
2
p -1; j++)
{
for (i = 2
j
+ 1; j p; j++) do in parallel
{
P[i]:
(1) obine a[i - 2
j
] de la P[i 2
j
] prin memoria comun;
(2) nlocuiete a[i] cu a[i - 2
j
] + a[i];
}
}
}


Operaia de adunare poate fi nlocuit de orice alt operaie asociativ:
nmulire, scdere, operaie boolean etc.
Pentru produs putem rezolva problema prin metoda divide et impera. Se
noteaz cu PR(i,j) produsul a1 a2 ... aj. Trebuie s se calculeze PR(1,k) pentru 1
k N. Se presupune c N = 2
n
i c se poate rezolva problema prefixului paralel
pentru N/2 elemente. Algoritmul const n mprirea la jumtate a mulimii de
intrare i rezolvarea fiecrei pri prin inducie.
Astfel, se obin PR(l,k) i PR(N/2+1, N/2+k) pentru 1 k N/2. Valorile
PR(1,m), cu N/2 < m N, se pot obine prin calculul PR(l,N/2) PR(N/2+1, m).
Datele de intrare se mpart n dou mulimi disjuncte, la fiecare apel recursiv
al algoritmului. Dac sunt N procesoare i problema are dimensiunea N, atunci vom
avea dou subprobleme de dimensiune N/2. Combinarea va consuma N/2 pai, ce
pot fi executai n paralel pe un model CREW, deoarece toate procesoarele folosesc
a[middle]. Mai multe procesoare citesc simultan a[middle] i scriu rezultatele n locaii
diferite.
48
Astfel, obinem

) N (log O ) p , N ( T
2
= ( 5.9)
i
)
N log
1
( O E
2
= ( 5.10)

deoarece algoritmul secvenial se execut n O(N) pai. Datorit celui de-al doilea
apel recursiv, numrul total de pai este O(Nlog2N). Mai jos este prezentat algoritmul
de calcul al prefixului paralel.


void ParallelPrefix(left, right)
{
if (right - left) = 1
{
a[right] = a[left] a[right];
}
else
{
middle = (left + right - 1)/2;
do in parallel
{
ParallelPrefix(left, middle); //atribuie lui P[1] la P[N/2]
ParallelPrefix(middle + 1, right); //atribuie lui P[N/2+1] la P[N]
}
for(i = middle + 1; i right; i++) do in parallel
{
a[i] = a[middle] a[i];
}
}
}


5.3. Operaii cu matrice

Matricele sunt des utilizate n aplicaii, indiferent de caracterul acestora.
Prelucrarea matricelor poate fi paralelizat prin descompunerea domeniului. Exist
mai multe posibiliti (fig. 5.2):

Descompunerea are loc pe linii sau pe coloane, fiecare procesor
primind una sau mai multe linii, sau coloane. La rndul ei, aceasta
poate fi pe bloc, cnd liniile sau coloanele alocate unui procesor sunt
vecine, sau ciclic, cnd alocarea se face cu o funcie modulo numrul
de procesoare.
Descompunerea pe submatrice, ptratice sau nu, cte una alocat
fiecrui procesor.
49

P0
P1
P2
P3
P4
P6
P8
P9
P0 P1 P3 P4 P5
P0 P1
P3


Fig. 5.2. Descompunerea unei matrice.

5.3.1. nmulirea matricelor

Algoritmul secvenial de nmulire a matricelor este prezentat n continuare.


for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
c[i][j] = 0;
for (k = 0; k < N; k++) c[i][j] = c[i][j] + a[j][k] b[k][j];
}
}


Acest algoritm are complexitatea O(N
3
). Evident, el poate fi paralelizat n mai
multe moduri. Fiecare iteraie a celor dou bucle exterioare este independent, iar
fiecare iteraie a buclei interioare poate fi executat separat. n principiu, toate cele N
;

nmuliri pot fi executate simultan, ca i cele N
2
adunri. Cu N
3
procesoare,
complexitatea funciei de timp este

N) O(log N) log O(1
2 2
= + ( 5.11)

ceea ce ar reprezenta limita inferioar a timpului de execuie pentru acest algoritm
paralel. Din (5.11) rezult expresia funciei de cost

N log N ) N ( C
2 3
3
= ( 5.12)

care ne arat c aceasta nu este optimal.
n cazul unei arhitecturi de tip hipercub, pe care s-ar putea implementa
aceast soluie se va consuma un timp important pentru comunicaii. n faza de
iniializare ar trebui distribuite 2N
2
date la N
3
procesoare. Mai mult, elementele
matricelor vor avea copii multiple n sistem.
50
Atunci cnd numrul procesoarelor este relativ mic (sau mai mic dect N), se
prefer descompunerea pe blocuri sau submatrice [Gri00].

A B C
=


Fig. 5.3. nmulirea a dou matrice folosind mprirea pe blocuri.

Dac matricele A i B sunt ptratice i sunt mprite n M blocuri (n fapt, tot
matrice, dar de dimensiuni mai mici) a cte N/M N/M elemente (sau s s, unde s =
N/M), algoritmul poate fi rearanjat n urmtoarea form:


for (p = 0; p < M; p++)
{
for (q = 0; q < M; q++)
{
C
p,q
= 0;
for (r = 0; r < s; r++) C
p,q
= C
p,q
+ A
p,r
B
r,q
;
}
}


De data aceasta bucla interioar const n operaii cu matrice. Dac p = M
2
,

fiecare procesor va evalua o iteraie a buclei interioare. Complexitatea calculelor
efectuate de un procesor este O(N), iar numrul mesajelor este redus fa de situaia
unui sistem cu N
3
procesoare. ns, colectarea rezultatelor va avea complexitatea
O(N
2
).
n figura 5.4 se prezint operaia de nmulire a dou matrice ptratice cu
divizarea n patru submatrice.

A B C
=
A11 A12
A22 A21
B11 B12
B22 B21
C11 C12
C22 C21


Fig. 5.4. nmulirea matricelor folosind mprirea n submatrice.

51
Fiecare submatrice a lui C se obine prin evaluarea unei ecuaii matriceale de
forma

j 2 2 i j 1 1 i j , i
B A B A C + = ( 5.13)
unde 1 i, j 2.
Se pot folosi patru procesoare, cte unul pentru fiecare submatrice rezultat, fie
opt procesoare care lucreaz n doi pai. n primul pas, procesoarele execut
nmulirile, dup care, n pasul doi, patru procesoare calculeaz sumele.
Acest algoritm poate fi realizat i sub forma unei proceduri recursive, fiecare
submatrice fiind mprit n patru, la fiecare apel. Apelurile vor continua pn la un
grad al matricelor care asigur o granularitate acceptabil.
Exist i alte soluii paralele pentru nmulirea matricelor, bazate pe utilizarea
sistemelor cu topologie de tip torus [Gri00]. Cannon a produs un sistem cu topologie
de tip torus, la care fiecare procesor memoreaz un element, sau submatrice dup
caz, din fiecare matrice operand. Prin deplasri circulare, factorii produsului din
bucla cea mai interioar vor fi adui n acelai procesor. Toate procesoarele execut
produsele, dup care are loc, sincron, o nou deplasare a tuturor elementelor.
Operaia se repet de un numr de ori egal cu o dimensiune a torus - ului.


5.3.2. Rezolvarea sistemelor de ecuaii liniare. Eliminarea gaussian

Fiind dat sistemul de ecuaii liniare (5.14), se cere s se determine
necunoscutele xi, cu 0 i n-1.

= + + + +
= + + + +
= + + + +
=
= + + + +




0 0 0 0 1 1 0 2 n 2 n 0 1 n 1 n 0
1 0 0 1 1 1 1 2 n 2 n 1 1 n 1 n 1
2 0 0 2 1 1 2 2 n 2 n 2 1 n 1 n 2
1 n 0 0 1 n 1 1 1 n 2 n 2 n 1 n 1 n 1 n 1 n
b x , a x , a x , a x , a
b x , a x , a x , a x , a
b x , a x , a x , a x , a
b x , a x , a x , a x , a
L L L L
L L L L
L L L L
L L L L L L L L L L L L L L L L L L L L L L L
L
( 5.14)

Forma matricial a sistemului este Ax = b, unde A este o matrice N x N, iar b
este o matrice N x 1.
Ideea acestei metode este de a transforma sistemul iniial de ecuaii ntr-unul
de form triunghiular (superioar, sau inferioar), la care coeficienii de pe
diagonala principal au valoarea 1.
Metoda se bazeaz pe proprietatea sistemelor de a fi echivalente cu cele
produse prin nlocuirea unui linii a matricei A cu suma dintre ea i o alt linie,
nmulit cu o constant. Alegerea acestei constante este astfel fcut nct
coeficientul unei necunoscute s devin nul i astfel, treptat, s se elimine toi factorii
de sub, sau de deasupra diagonalei principale. Se ncepe cu prima linie i se continu
pn la ultima (fig. 5.5).

52
1
0
.
.
.
0
1
0 1
0 0 1
0..........1
0..........0
0..........0
1
0 1
0 0 1
0............1
0..............01
0....................01


Fig. 5.5. Procesul de eliminarea gaussian.

Cnd s-a ajuns la linia i, se nlocuiete fiecare linie j de sub ea cu


|
|

\
|
+ =
i , i
i , j
a
a
) i linia ( ) j linia ( ) j linia ( , ( 5.15)

ceea ce are ca efect anularea tuturor elementelor de pe coloana i, aflate sub linia i. Se
observ c
0
a
a
a a a
i , i
i , j
i , i i , j i , j
=
|
|

\
|
+ = ( 5.16)

Dac aj,i este nul sau apropiat ca valoare de zero, mprirea nu mai poate avea
loc. n aceast situaie, se folosete pivotarea parial, care const n schimbarea
poziiilor liniei i cu linia de sub ea care are valoarea cea mai mare pe coloana i, peste
toate elementele de pe coloana i, situate sub linia i. Verificarea coeficientului ai,i
trebuie s se fac pentru fiecare linie i nu poate fi executat nainte de a ncepe
eliminarea gaussian.
Algoritmul secvenial (O(N
3
)) este prezentat n continuare.


for (i = 0; i < N -1; i++)
{
for (j = i +1; j < N; j++)
{
c = a[j][i]/a[i][i];
for (k = i; k < N; k++) a[j][k] = a[j][k] a[i][k] c;
b[j] = b[j] b[i] c;
}
}


Dac analizm secvena anterioar de instruciuni, observm imediat
posibilitile de paralelizare. Fiecare indice j al buclei interioare poate fi alocat unui
procesor, dar, n acelai timp, modificarea coeficienilor din linia j poate fi realizat
independent una de alta, ceea ce reprezint un nivel dublu de paralelism, exploatat
ntr-adevr de unii algoritmi paraleli.
53
Dac presupunem c p = N, fiecare procesor va primi o linie: procesorul Pi va
primi elementele a[i][j], unde 0 j N. La nceput, procesorul P0 va trimite
elementele liniei sale tuturor celorlalte procesoare (broadcasting). Apoi, fiecare
procesor calculeaz constanta c i modific coeficienii liniei sale. Procedura se repet
cu P1, P2, ..., PN-2. Elementele trimise de Pi la procesoarele Pi+1, Pi+2, ... sunt a[i][i+1],
a[i][i+2], ..., a[i][n -1].
54


6. ALGORITMI PARALELI NENUMERICI

Pe lng operaiile numerice, calculatoarele efectueaz un volum
impresionant de operaii nenumerice, cum ar fi sortri, cutri, interclasri, utilizate
n aplicaii multimedia, inteligen artificial, compilatoare etc.

6.1. Exploatarea static a paralelismului la nivelul instruciunilor

Reorganizarea codului (scheduling) reprezint procesul de aranjare a
instruciunilor din cadrul unui program obiect astfel nct acesta s se execute ntr-un
mod cvasioptimal din punct de vedere al timpului de procesare. Procesul de
reorganizare a instruciunilor determin creterea probabilitii ca procesorul s
aduc simultan din cache-ul de instruciuni mai multe instruciuni independente
[Vin00a].
Procesul de reorganizare implic utilizarea unor algoritmi de analiz a
codului extrem de compleci, bazai pe tehnici euristice.
Studiul acestor algoritmi prin prisma procesrii paralele, poate conduce la
crearea de compilatoare extrem de eficiente i performante.

6.1.1. Partiionarea unui program n basic-block"-uri

Algoritmul de partiionare const principial n urmtorii 2 pai:

1) Determinarea setului de lideri n cadrul programului. Se numete lider
prima instruciune dintr-un program, instruciunea destinaie a oricrei instruciuni
de branch sau orice instruciune urmtoare unei instruciuni de branch.
2) Partiionarea programului n uniti secveniale i construirea grafului de
control. Fiecare unitate secvenial conine un singur lider i toate instruciunile de la
acest lider pn la urmtorul, exclusiv. Se determin predecesorii imediai fa de o
unitate secvenial de program. Poate fi un predecesor imediat al unei uniti
secveniale date orice unitate secvenial care se poate executa naintea unitii date.
Se determin succesorii unei uniti secveniale de program. Se numete succesor al
unei uniti secveniale de program orice unitate secvenial de program care poate
s se execute dup execuia celei curente.
Un exemplu de partiionare a unui program n basic-block"-uri (i graful de
control aferent) este reprezentat n figura 6.1.

55
A;
B;
DO{
D;
E;
IF (F){
G;
H;
}
ELSE {
I;
}
J;
K;
L;
} WHILE (C);


Fig. 6.1. Partiionarea unui program n basic-block uri [Vin00a].


I1: ADD R1,R11,R12
I2: ADD R1,R1,R13
I3: SLL R2,R3,#4 ; R2R3 deplasat logic la stnga cu 4 poziii binare
I4: AND R2,R1,R2
I5: ADD R1,R14,R15
I6: ADD R1,R1,R16
I7: ADD R1,R1,#6
I8: LD R1,(R1)
I9: LD R4,(R4)
I10: ADD R1,R4,R1
I11: OR R1,R1,R2
I12: ST R1,(R4)

Dup cum se va vedea, n stabilirea unei secvene reorganizate de program n
vederea unei procesri cvasioptimale pe un procesor superscalar sau VLIW, graful
dependenelor de date aferent unei uniti secveniale de program se va dovedi
deosebit de util. Un arc n acest graf semnific o dependen RAW ntre cele 2 stri.
Instruciunile care utilizeaz date din afara unitii secveniale de program se vor
plasa n vrful grafului astfel nct n ele nu va intra nici un arc. Pentru o instruciune
dat se caut n jos proxima dependen RAW. Cu aceste reguli simple, graful
dependenelor de date corespunztor secvenei de program anterioare este prezentat
mai jos (fig. 6.2).

56


Fig. 6.2. Graful dependenelor de date asociat.

n stnga arcului este scris latena operaiei respective. n dreapta arcului este
scris latena maxim a drumului msurat dintr-un vrf al arcului pn n starea
respectiv. Graful dependenelor specific deci relaii de ordine ntre instruciuni
absolut necesare execuiei corecte a programului dat.

6.1.2. Graful precedenelor
Se obine pe baza grafului dependenelor de date n baza faptului c exist
cazuri n care acesta poate s nu cuprind toate precedenele necesare unei corecte
reorganizri. Altfel spus, acest graf nu pune n eviden relaiile de preceden strict
n lansarea n execuie, impuse de ctre dependenele de tip WAR respectiv WAW
ntre instruciuni.

6.1.3. Conceptul cii critice
Calea critic a grafului dependenelor de date o reprezint drumul cu laten
maxim. Conceptul cii critice este important deoarece el indic faptul c dup
scheduling, profitnd la maxim de paralelismul ntre instruciuni, programul se va
putea executa n minimum 8 cicli, adic ntr-un timp egal cu latena cii critice. Prin
strategia sa, scheduler-ul va trebui ca n fiecare ciclu, pe ct posibil, s execute cte o
instruciune din calea critic ncercnd simultan s suprapun peste aceast
instruciune i alte instruciuni independente din program.
ntr-un procesor ipotetic avnd resurse infinite, scheduler-ul optim ar trebui
pur i simplu s urmeze calea critic, suprapunnd peste operaiile de aici operaii
din alte ci. n cazul apariiei unui hazard WAW sau WAR ntre instruciuni trebuie
redenumite registrele implicate.
57
O reorganizare optim ar nsemna s se simuleze execuia tuturor variantelor
posibile de programe reorganizate i s se msoare ratele de procesare aferente,
alegndu-se varianta de program cu rata cea mai mare. Pentru programe mari acest
deziderat ar implica uneori sptmni sau chiar ani de procesare devenind deci
prohibit. n practic se prefer algoritmi euristici bazai pe graful dependenelor, care
dau rezultate apropiate de cele optimale, n schimb necesit timpi de execuie
acceptabili. Aadar, problema optimalitii teoretice a scheduling-ului nu se pune din
cauz de probleme de timp. n plus algoritmii euristici utilizai n practic dau
rezultate bune.

6.1.4. Algoritmul LIST SCHEDULING" (LS)
Este unul dintre cei mai reprezentativi algoritmi n acest sens, fapt pentru care
va fi prezentat pe scurt. Timpul de execuie este rezonabil ntruct algoritmul se
execut ntr-o singur trecere prin graful dependenelor, genernd n majoritatea
cazurilor reorganizri optimale.
Algoritmul LS parcurge graful dependenelor asociat unitii secveniale de
program de jos n sus. n fiecare pas se ncearc lansarea n execuie a instruciunilor
disponibile. Dup ce aceste instruciuni au fost puse n execuie, instruciunile
precedente devin disponibile spre a fi lansate n pasul urmtor. Fiecrei instruciuni i
se ataeaz un grad de prioritate egal cu latena cii instruciunii. Dac apare un
conflict la resurse hardware comune ntre 2 sau mai multe instruciuni, are prioritate
instruciunea cu un grad de prioritate mai mare. Preciznd c iniial se seteaz un
contor de cicli la o valoare maxim, paii algoritmului sunt urmtorii:

1) Instruciunea cea mai prioritar dintre instruciunile disponibile n setul
curent este lansat n execuie dac nu necesit o resurs ocupat n acest ciclu.
2) Dac o instruciune a fost pus n execuie n pasul 1, resursele utilizate de
aceasta vor fi setate ca fiind ocupate pentru un numr de cicli egali cu latena
instruciunii. Pentru exemplul nostru se va considera latena instruciunilor LOAD
de 2 cicli, iar latena celorlalte instruciuni de un ciclu.
3) Dac instruciunea a fost lansat n execuie n pasul 1 ea va fi tears din
lista instruciunilor disponibile n acel ciclu. Dac instruciunea nu a fost lansat n
execuie datorit unui conflict, reorganizarea va continua cu o alt instruciune
disponibil.
4) Se repet paii 1-3 pn cnd nu mai exist nici o instruciune disponibil n
acest ciclu.
S) Se decrementeaz contorul de cicli.

6) Se determin urmtorul set de instruciuni disponibile. Precizm c o
instruciune este disponibil dac diferena ntre numrul ciclului n care a fost
lansat n execuie instruciunea succesoare i numrul ciclului curent este egal
cu latenta instruciunii.
58
7) Dac setul determinat la pasul 6 este consistent se trece la pasul 1. n caz
contrar, reorganizarea este complet.

6.1.5. Problema optimizrii globale n cadrul procesoarelor MEM. Tehnica
TRACE SCHEDULING" (TS)
Optimizarea basic-block"-urilor aferente unui program nu implic n mod
necesar optimizarea ntregului program datorit problemelor legate de
instruciunile de ramificaie.
Reorganizarea programelor care conin branch-uri este mai dificil ntruct
aici mutrile" de instruciuni pot cauza incorectitudini ale programului reorga-
nizat care ar trebui corectate. Aceast optimizare se mai numete i optimizare
global.
Problema optimizrii globale este una deschis la ora actual, avnd o natur
NP-complet. Se prezint n continuare n acest sens doar tehnica numit Trace
Scheduling", datorit faptului c este oarecum mai simpl i mai clar documentat.
Se definete o cale (Trace") ntr-un program ce conine salturi condiionate, o
ramur particular a acelui program legat de o asumare dat a adreselor acestor
salturi. Rezult deci c un program care conine n salturi condiionate va avea 2n
posibile ci (trace-uri). Aadar, o cale a unui program va traversa mai multe uniti
secveniale din acel program. n figura 6.3 se prezint un program compus din 2 ci
distincte, i anume TRACE1 i TRACE2.

A;
B;
C;
IF (D) {
E;
F;
}
ELSE {
G;
}
H;
I;


Fig. 6.3. Exemplu de trace-uri pe o secven de program [Vin00a].

Tehnica TS este similar cu tehnicile de reorganizare n basic-block-uri, cu
deosebirea c aici se va reorganiza o ntreag cale i nu doar un basic-block. n
esen, ea se bazeaz pe optimizarea celor mai probabile ci n a fi executate.
Pentru a putea aplica TS compilatorul trebuie s aib criterii rezonabile de
predicie a salturilor condiionate, n vederea construirii cilor cu cea mai mare
59
probabilitate de execuie. n general, predicia software se face pe baza informaiilor
rezultate din execuia anterioar a programului neoptimizat (profilings) sau a altor
algoritmi euristici nglobai n compilator.

6.1.6. Optimizarea buclelor de program
Este foarte important pentru c n buclele de program se pierde cea mai
mare parte a timpului de execuie aferent respectivului program, dup regula
binecunoscut care afirm c ,,n 90% din timp se execut cca. 10% din program"
[Vin00b].
Exist dou tehnici importante utilizate n optimizarea buclelor:
loop unrolling
software pipelining
Aplicarea celor dou tehnici asupra unei bucle dintr-un program va conduce
la expandarea pe vertical a buclei respective. Spre deosebire de loop unrolling,
tehnica software pipelining va consuma mai puin spaiu de cod.
Tehnica loop unrolling se va concentra pe eliminarea codurilor redundante
din cadrul buclelor (actualizri de contoare, loop-uri). Bucla se va procesa la vitez
maxim doar pe parcursul iteraiilor desfurate.
Tehnica software pipelining va determina obinerea unei viteze mari de
execuie pe timpul procesrii ntregii bucle.


6.2. Paralelizarea operaiei de sortare

Pornind de la o secven dat
} s , , s , s { S
n 2 1
K =
, peste care este definit o relaie
de ordine liniar notat cu <, se cere s se creeze, prin rearanjarea elementelor lui S,
o nou secven
} ' s , , ' s , ' s { ' S
n 2 1
K =
, astfel nct
1 i i
' s ' s
+
<
, unde i = 1, ..., n-1.
Exist dou categorii de algoritmi pentru sortare: algoritmi care folosesc
operaii de comparaie a dou elemente, urmat de schimbarea eventual a poziiei i
algoritmi care folosesc codificarea elementelor sau distribuia lor particular n
domeniul de valori.
Algoritmii secveniali au pentru primul caz, funcia complexitate de timp cea
mai bun O(nlog2n), iar n cel de-al doilea O(n). Prin urmare nici un algoritm paralel
nu trebuie s aib un cost superior lui O(nlog2n). n mod similar, o limit inferioar
pentru timpul de sortare a n elemente cu p procesoare este O((nlog2n)/p), pentru p
nlog2n, sau O(n/p), n cel de-al doilea caz.

6.2.1. Algoritmul quicksort

Algoritmul de sortare quicksort se bazeaz pe metoda divide et impera.
Utiliznd aceast metod rezolvarea problemei se face prin mprirea, de o manier
recursiv, n subprobleme de dimensiuni din ce n ce mai mici, pe o cale descendent,
60
pn la atingerea cazului de baz sau elementar. Se rezolv subproblemele de la
acest nivel, dup care se combin rezultatele, pe o cale ascendent, pn la furnizarea
soluiei problemei.


void Divide&Impera(P)
{
if P este cazul elementar
{
Rezolv P;
}
else
{
mparte P n P i P;
call Divide&Impera(P);
call Divide&Impera(P);
Combin rezultatele pentru P i P;
}
}


Pe baza algoritmului prezentat anterior se dezvolt algoritmul secvenial de
sortare quicksort care are complexitatea O(nlog2n). Acest algoritm alege la nceput un
pivot, fa de care se compar toate celelalte elemente. El poate fi un element
oarecare (de exemplu, primul), sau medianul mulimii. Medianul, notat cu simbolul
k, este acel element al mulimii pentru care jumtate din elementele acesteia sunt mai
mici sau egale cu el, iar cealalt jumtate este format din elemente mai mari sau
egale cu el. Dup gsirea medianului, operaie de complexitate O(n), se construiesc
dou submulimi egale i pentru fiecare se apeleaz procedura secvenial quicksort.
Cu S s-a notat mulimea de n elemente.


void Quicksort(S,n)
{
if (n 2) and (s2<s1)
{
Interschimb pe s1 cu s2;
}
else
{
Gsete medianul mulimii S, notat k;
Construiete S = {s S | s k, |S| = S/2};
Construiete S = {s S | s k, |S| = S/2};
call Quicksort(S,k);
call Quicksort(S,k);
}
}


Prin divizarea n dou, la fiecare apel al procedurii, se creeaz un arbore binar.
61
Acest arbore este parcurs n sens descendent cnd se efectueaz apelurile la
procedura recursiv i n sens ascendent, la revenirea din apel. Subproblemele
elementare se regsesc ca frunze ale arborelui. Soluia problemei va fi furnizat, n
final, de nodul rdcin.
n varianta secvenial, la un moment dat, este parcurs un singur nod al
arborelui. Execuia paralel ofer posibilitatea parcurgerii simultane a mai multor
noduri, toate de la un acelai nivel. n felul acesta, funcia complexitate de timp se
poate reduce de log2p ori, unde p este numrul de procesoare. Procesorul P0 iniiaz
calculele, apoi nc un procesor devine activ, la nivelul doi vor fi patru procesoare
active, pn cnd pe nivelul i, final, vor fi active 2
i
procesoare. Dezavantajul utilizrii
acestui algoritm este c utilizarea tuturor procesoarelor se va face doar pe nivelul
final, situaie care se reflect n eficiena sistemului (fig. 6.1).

P0 P1 P2 P3 P4 P5 P6 P7
P0
P0
P0
P2 P4 P6
P4


Fig. 6.1. Utilizarea procesoarelor n algoritmul quicksort secvenial.

n continuare se prezint o variant paralelizat a algoritmului quicksort,
prezentat anterior. Cu p se noteaz numrul de procesoare din sistem.


void ParallelQuicksort(S,n,p)
{
if (n p)
{
P0 call Quicksort(S,n);
}
else
{
mparte S n p submulimi a n/p elemente;
for (i = 1; i p; i++) do in parallel
{
Pi : call seq_median(Si,ki);
}
Determin M, medianul celor p mediani determinai anterior;
for (i = 1; i p; i++) do in parallel
{
62
Construiete S = {s S | s M, |S| = n/2};
Construiete S = {s S | s M, |S| = n/2};
}
call ParallelQuicksort(S,n,p);
call ParallelQuicksort(S,n,p);
}
}


Dac numrul de elemente al mulimii este mai mic dect numrul de
procesoare, procesorul P0 folosete procedura quicksort secvenial pentru a ordona
mulimea - subproblema elementar. Dac nu, mulimea iniial este mprit n p
submulimi egale, alocate procesoarelor. Fiecare procesor determin medianul
submulimii proprii, dup care toate procesoarele determin medianul medianilor,
notat cu M (cu o procedur paralel). Se poate demonstra uor, din modul de
determinare, c este garantat c jumtate din elementele lui S sunt mai mici sau egale
cu M, iar cealalt jumtate este format din elemente mai mari sau egale cu M. Apoi,
fiecare procesor mparte submulimea alocat n dou mulimi. Prima are elementele
mai mici sau egale cu M, cealalt are elementele mai mari sau egale cu M. Aceast
operaie presupune c, prin concatenare, se construiesc implicit submulimile S cu
jumtate din elementele lui S, mai mici sau egale cu M, i S, cu restul de elemente,
mai mari sau egale cu M. Acum, se poate face apelul recursiv pentru cele dou sub-
mulimi create.
Nu este obligatoriu ca sistemul de calcul s aib o topologie de tip arbore
binar, deoarece aceast topologie poate fi creat, n mod virtual, i pe alte topologii,
cum ar fi cea de hipercub. ntr-adevr, la hipercub, procesoarele care comunic au
adresa diferit ntr-o singur poziie binar, ceea ce reprezint exact definiia
vecinilor ntr-un hipercub.

6.2.2. Algoritmul de sortare pe baza rangului

ntr-o mulime sortat, fiecare element are o poziie indicat de rangul su.
Acesta este un numr natural care se obine ca sum ntre numrul de elemente mai
mici dect elementul respectiv plus unu. Ideea algoritmului de sortare pe baza
rangului este de a se parcurge toat secvena de elemente, pentru fiecare element n
parte, i a se numra cte elemente sunt mai mici dect acesta. Vor fi n pai a n-1
operaii, ceea ce nseamn c, n aceast form, algoritmul are complexitatea
inacceptabil O(n
2
). Dac folosim un sistem paralel cu p = n procesoare, fiecare
procesor poate calcula rangul unui element, cu O(n) operaii. Timpul se reduce, dar
funcia cost are aceeai complexitate ca la algoritmul secvenial. Dac se folosesc n
2

procesoare (timpul devine constant, O(l)) se obine soluia de sortare cea mai rapid.
Se presupune c sistemul paralel este cu memorie comun, de tip CRCW (fig. 6.2).

63
P11 P12 P1N
P21 P22 P2N
PN1 PN2 PNN
s1 s2 sN
rang s1
rang s2
rang sN
Memoria
comuna

Fig. 6.2. Sortarea pe baza rangului pe un sistem CRCW.

n pasul 1, fiecare linie de procesoare primete un element al secvenei; n
pasul 2, fiecare procesor compar elementul su cu un element al secvenei; n pasul
3, procesoarele scriu concurent n memorie n locaia rezervat pentru memorarea
rangului elementului lor, rezultatul comparaiei anterioare, dup care un procesor
memoreaz elementul n poziia din secven dat de rang.
n memorie se afl secvena S, nesortat la nceputul execuiei algoritmului, i
un vector cu n componente, care va memora rangul fiecrui element al secvenei.
Procesoarele sunt organizate ca o plas, fiecare fiind identificat cu doi indici,
unul de linie, i, i unul de coloan, j. Elementele secvenei de sortat sunt distribuite
procesoarelor, astfel nct primul element este primit de toate procesoarele de pe
prima linie, al doilea de procesoarele de pe a doua linie, .a.m.d., prin operaii
concurente de citire. n pasul urmtor, procesoarele de pe prima coloan compar
elementul pe care l au cu primul element al secvenei, procesoarele de pe coloana a
doua fac aceeai operaie cu al doilea element al secvenei, .a.m.d., memornd
rezultatul comparaiei ntr-un indicator intern. n ultimul pas, toate procesoarele
execut scrieri concurente (valoarea indicatorului intern este scris n memorie),
astfel nct toate procesoarele de pe linia i scriu n locaia rezervat variabilei rang i.
Scrierea concurent se realizeaz prin memorarea n locaia respectiv a sumei
tuturor valorilor de nscris. Mai trebuie doar, ca un procesor s scrie elementul
secvenei n poziia indicat de rangul su.
n continuare este prezentat algoritmul de sortare pe baza rangului utiliznd
un sistem CRCW.


void CRCWsort(S)
{
Pas I:
for (i = 1; i n; i++) do in parallel
64
{
for (j = 1; j n; j++) do in parallel
{
Pij: read si;
}
}
Pas II:
for (i = 1; i n; i++) do in parallel
{
for (j = 1; j n; j++) do in parallel
{
if ((si > sj) or (si = sj and i > j)) cij = 1;
else cij = 0;
}
}
Pas III:
for (i = 1; i n; i++) do in parallel
{
for (j = 1; j n; j++) do in parallel
{
Pij: write cij n (rang i);
}
}
for (i = 1; i n; i++) do in parallel
{
Pi1: write si n S[1 + (rang i)]
}
}


Dezavantajul acestui algoritm este numrul mare de procesoare, care trebuie
s fie egal cu cel al elementelor de sortat. Dei este foarte rapid, fiecare pas
consumnd un timp constant, costul este O(n
2
). Numrul procesoarelor poate fi
redus, fiecare primind responsabilitatea calculrii rangului unui grup de elemente.
Sistemul este tot de tipul CRCW, iar un procesor primete n/p elemente. Operaiile
efectuate secvenial au complexitatea O(n
2
/p).

6.2.3. Algoritmul shearsort
Tot o arhitectur de tip plas, cu p = n este folosit i de algoritmul shearsort.
nti, numerele sunt distribuite procesoarelor. Apoi, ca la algoritmul de sortare par-
impar, se execut un numr de pai, 1, 2, 3, ... care se difereniaz ca operaii,
funcie de indicele par sau impar al pasului.
n paii impari (1, 3, 5, ... ), se execut sortarea independent a fiecrei linii de
numere, n sensuri alternative (prima linie cresctor de la stnga la dreapta, a doua
descresctor, ...). n paii pari (2, 4, ...), se sorteaz coloanele n mod independent,
plasnd numrul cel mai mic al fiecrei coloane pe prima linie, iar cel mai mare pe
ultima.
Dup log2n + 1 pai, numerele sunt sortare, sub forma unui "arpe", de la
65
procesorul P11 la
n 1
P , dup care urmeaz
n 2
P , ... (fig. 6.3). Sortarea pe linii i coloane
se poate face cu orice algoritm de sortare. Funcia complexitate de timp a acestui
algoritm este O(n
1/2
(log2n + 1)).

11 8 14 21
3 9 12 1
7 4 18 6
19 2 20 5
8 11 14 21
12 9 3 1
4 6 7 18
20 19 5 2
4 6 3 1
8 9 5 2
12 11 7 18
20 19 14 21
1 3 4 6
9 8 5 2
7 11 12 18
21 20 19 14
1 3 4 2
7 8 5 6
9 11 12 14
21 20 19 18
1 2 3 4
8 7 6 5
9 11 12 14
21 20 19 18
Sirul initial
Sirul sortat
1 2 3 4
5


Fig. 6.3. Sortarea a n numere prin algoritmul shearsort.

6.2.4. Algoritm de sortare bitonic
Se spune c o secven de numere este bitonic dac este satisfcut una din
urmtoarele dou condiii:
ncepe ca o secven monoton cresctoare, dup care, ncepnd cu un
anumit element, devine monoton descresctoare;
exist o deplasare circular a indicilor elementelor, astfel nct s poat fi
verificat condiia anterioar.
Un exemplu de secven bitonic este secvena {11, 18, 22, 9, 5, 2}, la fel {10,
14, 5,1, 0, 8} deoarece reprezint o deplasare ciclic a secvenei {0, 8, 10, 14, 5, 1 }.
Algoritmul de sortare bitonic folosete o procedur recursiv pentru
producerea secvenei sortate, plecnd de la o secven bitonic. Vom presupune c
ambele subsecvene, cresctoare i descresctoare, au acelai numr de elemente:

1 2 / n 2 1 0
a ... a a a

i
1 n 2 2 / n 1 2 / n 2 / n
a ... a a a
+ +


Construim dou secvene:

S = {min(a0, an/2), min(a1, an/2+1), min(an/2-1, an-1)}
S = {max(a0, an/2), max(a1, an/2+1), max(an/2-1, an-1)}

n S exist un element bi, pentru care toate elementele care l preced fac parte
din secvena iniial ascendent, iar cele care urmeaz fac parte din secvena
66
descendent. n S exist un element bi, pentru care toate elementele care l preced
fac parte din secvena iniial descendent, iar cele care urmeaz fac parte din
secvena ascendent. Astfel, cele dou secvene nou create sunt bitonice. Din modul
de construire, toate elementele din S sunt mai mici dect toate elementele din S.
Procesul continu, n mod recursiv, pn la crearea unor subsecvene reduse la un
element. n acel moment, practic s-a sortat secvena iniial. Metoda prezentat poate
fi implementat sub forma unei reele dedicate, denumit reeaua de interclasare
bitonic (bitonic merging network). Ea are log2n nivele cu n/2 comparatoare pe fiecare
nivel. Aceast reea poate fi folosit la sortarea unei secvene neordonate de numere.
nti, acestea sunt mprite n subsecvene a cte dou elemente, subsecvene care
sunt bitonice. Acestea sunt interclasate pe primul nivel, una lng alta, n ordine
ascendent i descendent. Pe nivelul doi se interclaseaz cte dou secvene a dou
elemente, ordonate cresctor, respectiv descresctor. Procesul continu iterativ, la
fiecare nivel dimensiunea secvenelor dublndu-se fat de dimensiunea de la nivelul
anterior i pstrndu-se bitonice. n final, se produce o secven bitonic cu toate
elementele secvenei iniiale, secven care este de fapt sortat. Aceast reea poart
numele de reeaua de sortare bitonic. Complexitatea funciei de timp este
O( n log
2
2
).

6.3. Paralelizarea operaiei de cutare

Operaia de cutare se folosete pentru a se afla dac un element x se afl ntr-
o secven de elemente, S = {s1, ..., sn}. Rspunsul poate fi o simpl confirmare, sau
returnarea elementului mpreun cu poziia sa, sau returnarea numrului de copii ale
elementului respectiv din secvena respectiv, eventual nsoit de informaii
suplimentare care sunt memorate mpreun cu fiecare copie.
Varianta secvenial a algoritmului parcurge secvena S element cu element,
dac aceasta nu este sortat. Sfritul este determinat fie de gsirea elementului
cutat, fie de epuizarea secvenei.


void Search(S,x,k)
{
i = 1;
k = 0;
while (i n and k = 0) do
{
if (si = x) k = i;
i = i +1;
}
}


n cazul cel mai defavorabil, execuia acest algoritm consum un timp de
complexitatea O(n), ceea ce este optimal, avnd n vedere c i aceast operaie face
67
parte din clasa operaiilor de comparaie. Dac S este sortat, procedura de cutare
binar (binary search) poate returna indicele elementului egal cu x n O(log2n).

6.3.1. Cutarea ntr-o secven neordonat

Se presupune c elementele lui S nu sunt nici ordonate i nici distincte. n
cazul unui sistem paralel cu memorie comun, dup ce fiecare procesor primete
elementul cutat, va putea folosi procedura de cutare secvenial pe subsecvena
atribuit lui (de exemplu, prin indici). Varianta paralel a algoritmului este
prezentat mai jos.


void ParallelSearch(S,x,k)
{
Pas I:
for (i = 1; i p; i++) do in parallel
{
read x;
}
Pas II:
for (i = 1; i p; i++) do in parallel
{
Si {s(i-1)(n/p), ... , si(n/p)};
Search(Si,x,ki);
}
Pas III:
for (i = 1; i p; i++) do in parallel
{
if (ki > 0) k ki;
}
}


Dac se folosete un sistem EREW, pasul 1 se realizeaz cu operaia de emisie
n O(log2p). n pasul 2, procedura de cutare secvenial consum, n cazul cel mai
defavorabil, O(n/p) pai. Procedura de memorare a rezultatului, care folosete o
regul adecvat de rezolvare a conflictelor, se va execut n O(log2p)


|
|

\
|
+ =
p
n
O ) p (log O ) n ( t
2
( 6.1)
iar costul devine

O(n) p) O(plog C(n)
2
+ = ( 6.2)

care nu este optimal.
Pentru un model CREW, pasul 1 se execut n timp constant (O(1)), iar paii 2
68
i 3 sunt ca n cazul EREW. Timpul asimptotic rmne nemodificat.
n cazul CRCW, paii 1 i 3 se execut n timp constant (O(1)), iar pasul 2 ca la
EREW. Timpul total de execuie devine O(n/p), iar costul C(n) = O(n), ceea ce este
optimal.
Pentru orice sistem paralel cu memorie distribuit, algoritmul de cutare
paralel are aceleai faze ca cel prezentat anterior. Acum, ns, operaiile de trimitere
a elementului cutat i de distribuire a subsecvenelor lui S la procesoare consum un
timp semnificativ. Dup aceast faz iniial, toate procesoarele execut simultan
cutarea. n final, rezultatul (sau rezultatele) se returneaz unui procesor master,
responsabil de furnizarea rspunsului.

6.3.2. Cutarea ntr-un sistem paralel de tip arbore binar

Se presupune c arborele are p = n frunze pentru cutarea ntr-o secven cu n
elemente. Nodul rdcin primete valoarea lui x i trimite o copie fiecrui nod-fiu.
De asemenea, acest procesor va furniza rspunsul.
Fiecare nod face dou copii ale valorii primite de la printe i le trimite fiilor
si; ulterior, va primi valori de la fii si, le va combina i le va transmite nodului
printe. Procesul continu pn cnd toate frunzele au primit o copie a lui x.
Simultan, toate frunzele compar s cu x; dac sunt egale, frunza produce 1 la ieire,
altfel produce 0. n etapa final se combin rezultatele produce de frunze, n sensul
ascendent de parcurgere al arborelui: fiecare nod calculeaz funcia OR a intrrilor
sale i transmite rezultatul printelui. Procesul continu pn la rdcin.
Parcurgerea descendent a arborelui are complexitatea O(log2n), compararea
se execut ntr-un timp constant (O(1)), iar parcurgerea n sens ascendent mai ia
O(log2n). Deci, rspunsul se obine n O(log2n). Aceast topologie are mai multe
avantaje. n primul rnd, se pot executa operaii complexe, care presupun efectuarea
de operaii i pe nivelurile intermediare ale arborelui. Astfel, se poate determina
elementul cel mai apropiat ca valoare de cel cutat, dac acesta nu este gsit, sau
toate elementele aflate la un anumit ecart fa de x. Un alt avantaj const n
posibilitatea procesrii simultane a mai multor operaii de cutare, de o manier
pipeline. n acest mod, eficiena sistemului crete.







69

7. INSTRUMENTE UTILIZATE N PROGRAMAREA PARALEL.
BIBLIOTECA MPI (MESSAGE PASSING INTERFACE)

MPI (Message Passing Interface) este o ncercare de a standardiza un set de
rutine pentru schimbul de mesaje, rutine care s fie folosite de un spectru larg de
aplicaii i care s se poat implementa eficient pe o gam larg de sisteme paralele
sau distribuite eterogene. Efortul de standardizare a nceput n aprilie 1992 i a fost
finalizat n mai 1994, cu o modificare (versiunea 1.1) n iunie 1995. Pentru a asigura
viabilitatea standardului, la elaborarea acestuia au participat numeroase firme
productoare de calculatoare (Convex, Cray Research, IBM, Intel, Meiko , Parasoft,
Thinking Machines Corporation), universiti din SUA (Cornell, Edinburgh Parallel
Computing Center, Mississippi State University, Rice University, University of
Tennessee, Yale University) i organizaii guvernamentale (Argonne National
Laboratory, Lawrence Livermore National Laboratory, NASA Ames Research
Center, National Science Foundation, Oak Ridge National Laboratory,
Supercomputing Research Center). O alt cauz a succesului acestui standard este
maturitatea, realizat prin nglobarea de caracteristici existente n bibliotecile de
schimb de mesaje existente la ora elaborrii standardului (PVM, P4, Zipcode,
PARMACS , TCGMSG, Express). MPI a fost creat pentru promovarea sistemelor
distribuite oferind:
portabilitate i uurin n folosire
un set de funcii de referin pentru proiectanii de hardware
bibliotec de funcii standard pentru industria software

Standardul MPI definete o interfa de programare prin schimb explicit de
mesaje, interfa de programare ce poate fi utilizat pentru scrierea de aplicaii pe
sisteme de tip MIMD (Multiple Instruction Stream, Multiple Data Stream) cu
memorie distribuit. Este important de neles c MPI este o bibliotec de funcii, nu
un limbaj. MPI definete nume de funcii, secvene de apel i rezultatele pentru un
set de funcii care pot fi apelate n programe C sau Fortran 77 (sunt n faza de
elaborare i conveniile pentru programe C++ i Fortran 90). Compilarea programelor
care folosesc MPI se face cu un compilator standard C sau Fortran iar n faza de
editare a legturilor este introdus i biblioteca MPI. Aceste dou faze sunt de obicei
ascunse programatorului, cruia i se ofer un pseudo-compilator (de exemplu mpicc,
care ascunde faza de editare de legturi). Principalele faciliti pe care le ofer MPI
sunt:
comunicaie punct-la-punct n medii eterogene;
rutine pentru lucrul cu grupuri de procese;
comunicaie colectiv i operaii de calcul globale n cadrul unui grup;
contexte de comunicare i comunicatori pentru dezvoltarea de
biblioteci de funcii utilizabile n programe paralele;
70
rutine pentru definirea de topologii virtuale de grup;
interfa pentru efectuarea de msurtori de performan (profiling);
rutine pentru accesul la un set de valori globale

Pentru o bun nelegere a MPI, este necesar clarificarea noiunilor de proces
i grup de procese. Procesul MPI este unitatea fundamental de calcul, fiind
constituit dintr-un fir de control independent i un spaiu de adrese privat. Procesele
MPI se execut n stil MIMD, fr a avea ns descrise mecanisme de ncrcare a
codului pe procesoare, atribuire a proceselor pe procesoare sau mecanisme de creare
i distrugere de procese. Aceste mecanisme sunt de obicei, n cadrul implementrilor
existente, mprumutate de la sistemul de operare pe care se ruleaz procesul MPI,
fapt ce creeaz dificulti de portare ntre sisteme de operare diferite. Numrul de
procese MPI este cunoscut de la nceperea execuiei aplicaiei i nu poate fi modificat.
Grupurile de procese n MPI sunt dinamice, adic se pot crea i distruge n timpul
rulrii programului. Apartenena la grup este static, n sensul c un proces nu poate
fi eliminat dintr-un grup dect prin distrugerea grupului. Grupurile se pot
suprapune, adic un proces poate face parte din mai multe grupuri simultan.
Procesele sunt identificate n cadrul grupului printr-un ntreg (rank) care ia valori
ntre 0 i n-1, unde n este numrul proceselor din grup. Dup iniializarea unei
aplicaii MPI, exist un singur grup, numit MPI_COMM_WORLD, care include toate
procesele MPI care formeaz aplicaia.

7.1. Aspecte ale programrii folosind MPI

Standardul MPI a fost proiectat astfel nct programatorul nceptor s nu
simt complexitatea de la primele programe. O aplicaie MPI simpl se poate face
cunoscnd doar un numr de 6-7 funcii din cele peste 150 definite de standard.
Aceste 6 funcii vor fi prezentate (ca nume de funcii C) n ordinea n care apar de
obicei n programele MPI:
MPI_Init() este funcia care iniializeaz variabilele locale MPI i
ntiineaz sistemul global MPI despre execuia unui nou proces MPI. Funcia
acioneaz i ca barier de iniializare, n sensul c nici un proces MPI nu-i poate
continua execuia pn cnd nu au executat toate celelalte procese partea de
iniializare. Dei aceast funcie apare la nceputul unui program, locul ei poate fi
oriunde.
MPI_Comm_rank() ntoarce identificatorul procesului MPI n cadrul
grupului specificat n lista de parametri.
MPI_Comm_size() ntoarce numrul de procese care fac parte din
grupul specificat ca parametru,
MPI_Send() i MPI_Recv() sunt funciile de baz care implementeaz
comunicaia prin mesaje ntre procese.
MPI_Finalize() pentru anunarea sistemului MPI despre terminarea
procesului MPI.
71
MPI_Barrier() acioneaz ca un punct de sincronizare total ntre
procesele membre ale unui grup.

Stilul de programare care poate fi folosit cu MPI se ncadreaz fie n MIMD, n
cazul n care procesele MPI provin din programe diferite, fie n stilul SPMD (Single
Program Multiple Data), dac procesele MPI provin din acelai program, dar execut
poriuni diferite pe baza unor instruciuni de condiie.

7.2. Comunicaia punct-la-punct

Scopul principal al MPI este de a oferi un set de funcii pentru transmisia de
mesaje ntre diferite procese MPI. Din acest motiv, MPI nglobeaz o sum de
mecanisme de comunicaie prezente n alte sisteme. Astfel, comunicaia punct-la-
punct prevzut de MPI definete mai multe moduri de comunicaie i de blocare.
Prin mod de comunicaie se nelege legea care guverneaz iniierea i terminarea
unei operaii de transmisie sau recepie. Modul de blocare stabilete condiiile n care
se poate refolosi zona de date indicat de programator ca surs sau destinaie a
transferului de date.
Pentru MPI, o operaie este considerat terminat local n cadrul unui proces
dac procesul a terminat partea sa de operaie (att n comunicaia punct-la-punct,
ct i n cea colectiv). O operaie de comunicare este terminat global dac toate
procesele implicate n comunicare au terminat local prile ce le revin din operaia de
comunicare.
MPI ofer 4 moduri de comunicaie. n modul standard de transmisie operaia
de trimitere poate ncepe chiar dac operaia corespunztoare de recepie nu a
nceput. n modul ready operaia send poate ncepe doar dac operaia
corespunztoare de recepie a nceput. n modul sincron, operaia de trimitere poate
ncepe oricnd, dar nu se poate termina dect atunci cnd mesajul a ajuns la receptor.
Modul n care transmisia este terminat indiferent de operaia pereche de recepie se
numete cu buffer-e, datorit necesitii pstrrii mesajului n zone temporare pentru
a asigura transmisia. n acest ultim mod, utilizatorul poate furniza sistemului un
buffer pentru a permite ca operaia de trimitere s se termine ntotdeauna nainte ca
mesajul s fie recepionat la destinaie.
Modul de comunicaie trebuie combinat cu un mod de blocare pentru a obine
funcia ce urmeaz a se utiliza. MPI definete dou moduri de blocare:

fr blocare (imediat), n care funciile de transmisie sau recepie se
termin nainte ca informaia s fie trimis/recepionat. Buffer-ul
indicat ntr-o funcie neblocant nu trebuie folosit pn la detectarea
sfritului funciei iniiate.
cu blocare, caz n care dup terminarea funciei buffer-ul de transmisie
sau recepie poate fi refolosit.

72
n cazul comunicaiei imediate, MPI definete funcii care execut testul de
terminare a operaiei. Testul se poate face asupra terminrii tuturor operaiilor dintr-
o mulime (MPI_Waitall), a unei operaii dintr-o mulime (MPI_Waitany) sau a cel
puin unei operaii (MPI_Waitsome). O aplicaie poate reduce latena de comunicare
prin intermediul acestor operaii imediate, presupunnd c platformele hardware pe
care se face implementarea includ mecanisme care permit rutarea i gestiunea
mesajelor n paralel cu alte calcule.
O alt facilitate a MPI este reprezentat de funcia MPI_Sendrecv(), care
permite, n acelai timp, transmiterea i ateptarea unui mesaj de la procesul
partener, cu sau fr refolosirea buffer-elor implicate n operaii.
Identificarea mesajelor n cadrul MPI se face prin identificatorul sursei (rank)
i o etichet ataat mesajului. Ambele valori sunt interpretate relativ, n cadrul zonei
de comunicaie identificat de un comunicator. Este posibil ca recepia s fie fcut
indiferent de surs (MPI_ANY_SOURCE) sau de etichet (MPY_ANY_TAG).

7.3. Structuri de date n MPI

MPI a fost proiectat pentru a opera n medii neomogene, ceea ce a impus
introducerea unui mod propriu de reprezentare a datelor. MPI definete anumite
tipuri de date abstracte, conversia ntre diferitele moduri de reprezentare a acestora
pe arhitecturi diverse fiind realizat implicit de ctre subnivelul de comunicaie MPI.
Pe lng un set de 8 tipuri de date fundamentale (ntreg, real simpl i dubl precizie,
complex simpl i dubl precizie, logic, caracter i octet), MPI ofer mecanisme
pentru construcia de tipuri de date agregate, ca structuri, vectori. Noul tip de date se
construiete ca o list de perechi (tip date, deplasament) i poate fi folosit apoi la fel
ca un tip fundamental n MPI.

7.4. Comunicaia colectiv

Comunicaia colectiv permite difuzarea ctre toate procesele unui grup,
sincronizarea la bariere, mprirea/adunarea datelor de la procesele unui grup,
operaii globale cum ar fi sum, mi nim, maxim, plus comunicaie de tip all-to-all.
Toate aceste operaii se pot mpri n dou mari clase: operaii de transfer de date i
operaii de calcul global.
Rutinele de transfer de date se refer la difuzarea datelor (broadcast),
distribuirea (scatter) i colectarea rezultatelor (gather) spre sau de la procesele unui
grup. Colectarea de rezultate se poate face de ctre toate procesele (all-gather) sau de
ctre un singur proces. De asemenea, exist operaii all-to-all, n care fiecare proces
trimite date ctre, respectiv recepioneaz date de la celelalte procese.
Operaiile de calcul global (sau, mai pe scurt, globale) pot fi mprite n
operaii de reducere, n care funcia de reducere se aplic pe toate datele
corespunztoare fiecrui proces din grup, i operaii de scanare, n care funcia de
reducere se aplic pe datele proceselor cu rank mai mic dect cel al procesului care
73
execut operaia. Funcia de reducere trebuie s fie asociativ i comutativ.
Rezultatul unei operaii globale poate fi cunoscut de toate procesele sau doar de un
singur proces. n operaiile globale pot fi folosite att operaiile predefinite n MPI ct
i cele definite de utilizator.
n cadrul comunicaiei colective, nu se folosesc etichete de mesaj. Coordonarea
comunicaiei proceselor este implicit, iar toate rutinele de comunicaie colectiv se
blocheaz pn cnd se termin local.

7.5. Contextul de comunicare

MPI introduce noiunea de context de comunicare sau comunicator centru a
defini cadrul unei comunicaii colective, adic procesele care sunt implicate n
aceast comunicare.
Un comunicator definete un context de comunicare care este, de fapt, un
grup de procese implicate ntr-un subset al calculului efectuat. Prin introducerea
comunicatorilor, comunicaia ntre subseturi de procese ale programului poate fi
separat de alte comunicaii din cadrul programului. Comunicaia ntre procese din
grupuri distincte este posibil prin definirea unui inter-comunicator.
Comunicaia inter-grupuri este, de obicei, gestionat de un conductor al
grupului. Grupurile pot fi create i prin intermediul reuniunii, interseciei, diferenei
ntre grupuri deja existente, iniial toate procesele aparinnd comunicatorului
MPI_COMM_WORLD.
Noiunea de comunicator este fundamental pentru definirea ntr-un mod
modular a bibliotecilor de funcii care pot fi invocate de procesele utilizator.
Putndu-i defini propriul comunicator (care este alocat de ctre sistem, asigurndu-
se astfel unicitatea), procesele definite de codul din biblioteci pot schimba mesaje fr
a interfera cu comunicaia dintre procesele aplicaiei utilizatorului. Alte probleme
legate de implementarea unei biblioteci ca un set de procese cum ar fi codul reentrant
sau invocri multiple pot fi rezolvate prin intermediul atributelor unui comunicator.

7.6. Topologii virtuale

Un atribut al unui comunicator este topologia virtual, care este topologia
structurii de interconectare a proceselor dintr-un grup. Topologia virtual este
folosit pentru a mapa procesele pe arhitectura fizic. Topologia implicit este cea
aleatoare.
Topologia este definit prin grupul de procese, numrul de conexiuni al
fiecrui proces i partenerul pentru fiecare conexiune. Deoarece grilele carteziene
sunt foarte rspndite, MPI definete operaii pentru acest tip de topologie. Astfel,
MPI definete operaii pentru mutarea datelor de-a lungul unei dimensiuni a grilei,
precum i executarea de operaii colective de-a lungul unei direcii a grilei.
Topologia virtual este distinct de graful programului, pentru c dou
procese pot comunica chiar dac n topologie nu sunt conectate. Topologia virtual
74
descrie acei comunicatori care trebuie considerai de maparea grupului de procese pe
arhitectura fizic. Noiunea de topologie virtual este util pentru atingerea
portabilitii performanelor atunci cnd nu este disponibil un mecanism eficient de
mapare a topologiei virtuale pe un calculator masiv paralel.
n concluzie, MPI este un standard pentru programarea sistemelor distribuite
prin modelul schimbului de mesaje care merit s fie luat n seam. Existena a cel
puin trei implementri publice de calitate (MPICH, LAM, CHIMP) permite fiecrui
programator dornic de a nva MPI s poat rula programe MPI pe o reea de
calculatoare. MPI nu impune folosirea unor alte instrumente de programare, iar
utilitarele scrise pentru o versiune de MPI se pot folosi i pentru celelalte. Definirea
interfeei prin care programatorul are acces la informaiile de performan conduce la
posibilitatea de a scrie instrumente de analiz care s nu fie n legtur direct cu
codul surs al diferitelor implementri. Operaiile de transmisie i recepie imediat
permit suprapunerea calculelor cu operaiile de comunicare, ceea ce duce la un
model perfect asincron de programare i la creteri de performan. Mecanismele de
lucru cu grupuri de procese asigur robusteea prin apartenena static la grup,
evitndu-se astfel probleme de concuren legate de intrarea sau prsirea grupului
de ctre membri si. Folosirea pentru transmisie a zonelor de date furnizate de
programator evit suprancrcri legate de copieri inutile. Mecanismele introduse de
comunicatori permit crearea de biblioteci de funcii paralele care se pot executa n
cadrul oricrui program fr a exista riscul de interferen ntre traficul aplicaiei i
cel al funciilor de bibliotec. Suportul pentru topologii virtuale face posibil
utilizarea unor mecanisme automate sau semiautomate pentru rularea eficient pe
arhitecturi masiv paralele.


75

8. BIBLIOGRAFIE

[Cul98] Culler E. D., Singh J. P., Gupta A. Parallel Computer Architecture: A
Hardware/Software Approach, Morgan Kaufmann Publishers, 1998, cap. 2.
{Gri00] D. Grigora Calculul Paralel, Ed. Agora, 2000, cap. 2, 4, 6-8;
[Lak90] S. Lakshmivarahan, Sudarshan K. Dhall Analysis and Design of Parallel
Algorithms, Ed. McGraw-Hill, 1990, cap. 1-4;
[Vin00a] Vinan L. Microarhitecturi de procesare a informaiei - Editura Tehnic,
Bucureti, 2000, cap. 5;
[Vin00b] Vinan L. Arhitecturi de procesoare cu paralelism la nivelul
instruciunilor - Editura Academiei Romne, Bucureti, 2000, cap. 3;