Alpd CURS

Cuprins Stadiul actual Despre curs De ce paralelism? De ce distribuiţie?
Bibliografie
Algoritmi paraleli şi distribuiţi
Mitică Craus
Universitatea Tehnică ”Gheorghe Asachi” din Iaşi
1/ 11
Cuprins Stadiul actual Despre curs De ce paralelism? De ce distribuiţie? Bibliografie
Cuprins
Stadiul actual
Despre curs
Ce se doreste?
Sistemul de evaluare
Conţinut
De ce paralelism? De ce distribuiţie?
Motive
Integrare şi conectivitate
Bibliografie
2/ 11
Stadiul actual
Viitorul este paralel!

Prezentul este distribuit! • Multicore - o nouă eră
• Oportunitate de a face
• Internetul
paralelismul mai usor pentru
• Web-ul oricine.
• Mediul academic este
• Intranetul pregatit.
• Reţelele de telefonie • Practicienii trebuie să facă
mobilă un efort de adaptare.
• Sistemele multiprocesor - ı̂n
• Reţelele ATM ale revenire
băncilor • Şi in acest sens mediul
• ..... academic este pregătit.
• Mediul de afaceri trebuie să
le folosească mai mult.
3/ 11
Ce se doreste?
Rezultatele ı̂nvăţării
• Cunoaşterea problemelor generice care
Obiectivele cursului pot fi rezolvate prin algoritmi paraleli şi
• Formarea unei viziuni de ansamblu distribuiţi;
asupra sistemelor de calcul • Abilitatea de a aplica algoritmul paralel
paralel/distribuit ; şi/sau distribuit adecvat unei probleme;
• Iniţiere ı̂n algoritmica si programarea • Capacitatea de a proiecta, implementa
paralelă şi distribuitǎ. şi testa algoritmi paraleli şi distribuiţi;
• Abilitǎţi de programare paralelǎ şi
distribuitǎ.
4/ 11
Sistemul de evaluare
Evaluarea continuă:
• Activitatea la laborator (M):
• Ponderea ı̂n nota finală: 30%
• Criterii de evaluare: rezolvarea temelor propuse şi calitatea soluţiilor.
• Teme de casă [1] (CC)
• Criterii de evaluare: rezolvarea temelor propuse şi calitatea soluţiilor.
Evaluarea finală: examen

• Proba 1:
• categoria de sarcini: test de cunoştinţe cu ı̂ntrebǎri deschise;
• condiţiile de lucru: fǎrǎ mijloace de informare accesibile studentului ı̂n timpul probei;
• ponderea ı̂n nota examenului: 50%
• Proba 2:
• categoria de sarcini: rezolvare de probleme;
• condiţiile de lucru: fǎrǎ mijloace de informare accesibile studentului ı̂n timpul probei;
• ponderea ı̂n nota examenului: 50%
5/ 11
Prelegeri
• Arhitecturi de calcul paralel/distribuit

• Modele de calcul paralel/distribuit
• Calcul de inaltă performanţă
• Comunicarea in sistemele de calcul paralel/distribuit
• Calcul paralel
• Algoritmi paraleli fundamentali
• Sortare paralelă
• Algoritmi paraleli pentru calculul matricial
• Algoritmi paraleli pentru sisteme de ecuaţii liniare
• Algoritmi paraleli pe grafuri
• Transformata Fourier
• Calcul distribuit
• Alegerea liderului
• Excluderea mutuală
6/ 11
Lucrări de laborator
• Introducere ı̂n OpenMP
• Introducere ı̂n MPI
• Prezentare CUDA/OpenCL
• Programe MPI de simulare a scenarilor de comunicare unu la toţi şi toţi la toţi pe
hipercub
• Programe MPI de simulare a scenarilor de comunicare unu la toţi şi toţi la unu pe un
arbore oarecare
• Programe OpenMP s, i MPI pentru pentru comprimare şi calcul prefixe (reducere)
• Temă de casă: MapReduce (program MPI, cu predare ı̂n săptămâna 14)
• Sortare paralelă (Muller-Preparata - program OpenMP, Par-impar – programe
OpenMP, MPI)
• Sortare paralelă (sortare bitonică pe hipercub, program MPI)
• Calcul matriceal (transpusa unei matrice şi ı̂nmulţirea a două matrice pătratice cu
algoritmul Cannon, program MPI + demo OpenCL/CUDA)
• Sisteme de ecuaţii liniare (program OpenMP + demo OpenCL/CUDA)
• Alegerea liderului pe un inel (program MPI pentru algoritmul LCR - LeLann, Chang
si Roberts)
• Aplicaţii ale alegerii liderului: sincronizarea ceasurilor ı̂n sisteme destribuite
7/ 11
Profesori
Curs
• Mitică Craus
Laborator
• Alexandru Archip
• Adrian Alexandrescu
• Cristian Mihai Amarandei
• Mitică Craus
8/ 11
Motive
• Aplicaţiile o cer:
• predicţia vremii, cutremurelor, tornadelor, uraganelor;
• simularea pe calculator a proceselor fizice, chimice, biologice;
• industria aeronautica (dinamica fluidelor) si a automobilelor (simularea coliziunilor);
• ingineria materialelor;
• nano tehnologiile;
• modelarea organelor;
• descoperirea de medicamente noi;
• grafica, video;
• robotica
• bazele de date, data mining;
• inteligenţa artificială.
• Tendinţele tehnologice
• integrarea masivă;
• interconectarea.
• Tendinţele arhitecturale
• arhitecturi multicore şi multiprocesor;
• clusterele, grid-urile, norii de calcul (cloud).
9/ 11
Integrare şi conectivitate

Integrare masivă
2,600,000,000
• Legea lui Moore: Gradul de integrare creşte

exponenţial 1,000,000
• 1971: 2,300 componente/circuit-integrat (C/CI);
• 1900: 1,000,000 C/CI; 2,300
• 2011: 2,600,000,000 C/CI. 1971 1990 2011
Figura 1 : Legea lui Moore
Conectivitate tot mai performantă

• viteza - Gigabit Ethernet;
• tehnologii de interconectare a sistemelor mobile.
10/ 11
Bibliografie
• V. Kumar, A. Grama A. Gupta & G Karypis, Introduction to Parallel Computing:

Design and Analysis of Algorithms, Addison Wesley, 2003
• H. Attiya, J. Welch, Distributed Computing: Fundamentals, Simulations and
Advanced Topics, John Wiley & Sons, Inc., 2004
• K. Berman, J. Paul, Algorithms: Sequential, Parallel, and Distributed, Thomson
Learning, Inc., 2005
• T. Mattson, B. Sanders, B. Massingill, Patterns for Parallel Programming,
Addison-Weslwy, 2005
11/ 11
Cuprins Introducere Modele de comunicare Topologii de comunicare Modele de calcul paralel/distribuit Bibliografie

Introducere, topologii de comunicare, modele de calcul
Mitică Craus
1/ 34
Cuprins
Introducere
Sisteme abstracte de calcul paralel/distribuit
Arhitecturi paralele/distribuite
Modele de comunicare
Taxonomie
Modelul de comunicare bazat pe memorie partajată
Modelul de comunicare bazat pe reţele de interconectare
Topologii de comunicare
Clasificare
Toplogii regulate
Graful complet
Lanţul, inelul şi steaua
Topologii arborescente
Plasele
Hipercubul
Evaluarea topologiilor regulate
Toplogii neregulate
Graful oarecare
Arborele oarecare
Modele de calcul paralel/distribuit
Taxonomii
Modelul Shared-Memory
Modelul PRAM
Modelul Message-Passing
Modelul sistolic
Bibliografie
2/ 34
Sisteme abstracte de calcul paralel/distribuit
• Un sistem abstract de calcul paralel/distribuit (SACP/D) este un ansamblu de

unităţi de procesare a datelor, care comunică ı̂ntre ele.
• Unitatea de procesare este un element atomic al sistemului, cu o structură internă
invizibilă.
• Se remarcă ı̂n această definiţie două componenente de bază ale unui SACP/D:
• componenenta computaţională;
• componenta comunicaţională.
3/ 34
Arhitecturi paralele/distribuite
• O arhitectură paralelă/distribuită este o implementare a unui SACP/D. Aceasta

ı̂nseamnă:
• maparea subsistemului computaţional pe o mulţime de maşini cu o funcţionalitate bine
definită şi
• asignarea relaţiilor de comunicare la un model de comunicare.
• Modelul de comunicare se referă la mediul de comunicare si modalitatea ı̂n care
unităţile de procesare comunică ı̂ntre ele.
• O arhitectură paralelă/distribuită execută algoritmi paraleli/distribuiţi.
• Definiţia unui algoritm paralel/distribuit poate fi derivată din definiţia unui algoritm
secvenţial, prin ı̂nlocuirea noţiunii de pas secvenţial cu cea de pas paralel.
• Pasul paralel poate fi un pas de sincronizare (pas paralel impropriu) sau un ansamblu
de paşi secvenţiali, executaţi ı̂n paralel ı̂n unităţile de procesare (pas paralel propriu).
• Observaţie: Paralelismul implică distribuţie dar distribuiţia nu implică paralelism.
Acesta ar putea fi punctul de plecare ı̂n diferenţierea algoritmilor paraleli de cei
distribuiţi.
4/ 34
Taxonomie
• Determinant ı̂n definirea unui model de comunicare este mediul de comunicare.
• Modelele de comunicare universal acceptate sunt cele bazate pe memoria partajată
şi reţelele de interconectare.
• Are la bază principiul comunicării prin variabile de memorie.
• Topologia de comunicare are potenţialul unui graf complet, deşi acesta nu este decât
o stea specială ı̂n care memoria comună este nodul central.
• Oricare două unităţi de procesare pot comunica doar prin intermediul memoriei
comune (centrul stelei). Aceasta reprezintă o vulnerabilitate.

• Oricare două unităţi de procesare comunică ı̂ntre ele prin canalul de comunicaţii care
le leagă sau prin intermediul unei secvenţe de canale care are la capete cele două
unităţi de procesare.
• Un astfel de model poate fi definit ca fiind format din:
• un graf G = (V , E ), care reprezintă topologia de comunicare şi
• o funcţie c : E → C , unde C este o mulţime de capacităţi de comunicare.
5/ 34

a. memorie locală privată şi memorie externă partajată;
b. memorie locală privată+partajată şi memorie externă partajată;
c. memorie locală privată+partajată.
Figura 1 : Modelul de comunicare bazat pe memorie partajată
6/ 34
Figura 2 : Modelul de comunicare bazat pe reţele de interconectare
7/ 34
Topologii de comunicare
Clasificare
• topologii regulate:
• graful complet;
• lanţul;
• inelul;
• steaua;
• arborele binar complet;
• arborele gras;
• fluturele;
• banyan
• plasa;
• plasa de arbori;
• hipercubul;
• amestecul prefect.
• topologii neregulate:
• graful oarecare;
• arborele.
8/ 34
Graful complet
• Reţelele peer-to-peer.
Figura 3 : Graful complet
9/ 34
Lanţul
• Mulţimea nodurilor V este organizată sub forma unui tablou unidimensional de

dimensiune n, prin intermediul unei funcţii de indexare I : V → L = {0, 1, ..., n − 1}.
• Dacă se notează cu Vi = I −1 (i), nodul Vi este conectat cu nodurile Vi−1 şi Vi+1 .
Fac excepţie nodurile V0 = I −1 (0) şi Vn−1 = I −1 (n − 1). Nodul V0 este conectat
doar cu nodul V1 . Nodul Vn−1 este conectat doar cu nodul Vn−2 .
Figura 4 : Lant, ul
10/ 34
Inelul
• Mulţimea nodurilor V este indexată prin intermediul unei funcţii

I : V → L = {0, 1, ..., n − 1}.
• Nodul Vi = I −1 (i) are vecini nodurile Vi 1 şi Vi⊕1 , unde este scăderea modulo n
iar ⊕ este adunarea modulo n.
Figura 5 : Lant, ul
11/ 34
Steaua
• Mulţimea nodurilor, V , este indexată prin intermediul unei funcţii

I : V → L = {0, 1, ..., n − 1}.
• Există un nodul special, V0 , la care sunt conectate toate nodurile.
• Comunicarea ı̂ntre noduri se realizează prin intermediul nodului V0 .
• Steaua este topologia specifică modelului de comunicare prin intermediul memoriei
comune.
Figura 6 : Steaua
12/ 34
Arborele binar complet

• Mulţimea nodurilor V este indexată prin intermediul unei funcţii
I : V → L = {0, 1, ..., n − 1}.
• Există un nodul special, V0 , numit radăcină. Radăcina nu are are părinte şi are doi
fii, V1 şi V2 .
• Fiecare nod interior are un părinte şi doi fii. Părintele unui nod interior Vi = I −1 (i)
este Vb(i−1)/2c . Fiii sunt V2i+1 şi V2i+2 .
• Frunzele au un părinte, nu au fiii şi sunt situate pe acelaşi nivel. Părintele unei
frunze Vi = I −1 (i) este Vb(i−1)/2c .
• Între oricare două noduri exista un singur drum. Numarul conexiunilor este n − 1.
Figura 7 : Arborele binar complet

Figura 8 : Comunicarea
13/ 34
Arborele gras
• Arbore binar complet.
• Fiecare pereche de noduri dispune de un canal de comunicare propriu.
• Numărul de muchii care leagă un nod interior de fii este egal cu 2h−nivel−1 , unde h
este adâncimea arborelui iar nivel(rădăcină)=1, nivel(frunză)=h.
Figura 9 : Arborele gras
14/ 34
Fluturele
• Arbore cu mai multe rădăcini!

• Exact un drum ı̂ntre oricare două noduri de pe
frontieră.
• Mulţimea nodurilor V este organizată ca un
tablou bidimensional de dimensiune nxm,
n = 2m−1 , prin intermediul unei funcţii de
indexare I : V → L = {(i, j)/0 ≤ i < n, 0 ≤ j < m}.
• Notăm cu Vi,j nodul dat de I −1 ((i, j)). Nodul
Vi,j , situat pe coloana j este conectat la coloana
j + 1 prin nodurile Vi,j+1 şi
Vi⊕2m−j−2 +bi/2m−j−1 cx2m−j−1 ,j+1 , unde ⊕ este
adunarea modulo 2m−j−1 .
Figura 10 : Fluturele
15/ 34
Topologia Banyan
• Tot arbore cu mai multe rădăcini!

• Mulţimea nodurilor V este organizată ca un
tablou bidimensional de dimensiune nxm,
n = 2m−1 , prin intermediul unei funcţii de
indexare I : V → L = {(i, j)/0 ≤ i < n, 0 ≤ j < m}.
• Notăm cu Vi,j nodul dat de I −1 ((i, j)). Nodul
Vi,j , situat pe coloana j este conectat la coloana
j + 1 prin nodurile Vbi/2c⊕0+bi/2m−j−1 cx2m−j−1 ,j+1
şi Vbi/2c⊕2m−j−2 +bi/2m−j−1 cx2m−j−1 ,j+1 , unde ⊕ este
adunarea modulo 2m−j−1 .
Figura 11 : Topologia Banyan
16/ 34
Plasa
• Este o generalizare a topologiei de tip lanţ.
• Mulţimea nodurilor V este organizată ca un tablou k-dimensional prin intermediul
unei funcţii de indexare
I : V → L = {(ik−1 , ik−2 , . . . , i0 )/0 ≤ ij < nj , j = k − 1, k − 2, ...0}, unde nj este
mărimea celei de-a j-a dimensiuni, iar n = nk−1 ∗ nk−2 · · · ∗ n0 .
• Notăm cu Vik−1 ,ik−2 ,...,i0 nodul dat de I −1 (ik−1 , ik−2 , ..., i0 ).
• Nodul Vik−1 ,ik−2 ,...,ij ,...,i0 este adiacent cu nodul Vik−1 ,ik−2 ,...,ij +1,...,i0 , dacă ij + 1 ≤ nj .
• Nodul Vik−1 ,ik−2 ,...,ij ,...,i0 este adiacent cu nodul Vik−1 ,ik−2 ,...,ij −1,...,i0 , dacă ij − 1 ≥ 0.
Figura 12 : Plase
17/ 34
Plasa circulară
• Este o generalizare a topologiei de tip inel.

• Nodul Vik−1 ,ik−2 ,...,ij ,...,i0 este adiacent cu nodul Vik−1 ,ik−2 ,...,ij ⊕1,...,i0 , unde ⊕ este
adunarea modulo nj .
• Nodul Vik−1 ,ik−2 ,...,ij ,...,i0 este adiacent cu nodul Vik−1 ,ik−2 ,...,ij 1,...,i0 , unde este
scăderea modulo nj .
Figura 13 : Plasa circulară
18/ 34
Plasa de arbori
• Mulţimea nodurilor, V este partiţionată ı̂n două submulţimi M şi T
• Nodurile din M sunt organizate sub forma unei matrice.
• Conectarea nodurilor din M se realizează prin intermediul unor arbori binari formaţi
din noduri din mulţimea T , câte un arbore pentru fiecare linie şi fiecare coloană.
• Nodurile din M aparţinând unei linii/coloane constituie frunzele arborelui asociat
liniei/coloanei respective.
Figura 14 : Plasa de arbori
19/ 34
Hipercubul (Cubul cu k dimensiuni)
• Numărul n al nodurilor grafului ce reprezintă o astfel de topologie este 2k , unde k

este dimeniunea cubului.
• Fie ik−1 ik−2 . . . i0 reprezentarea binară a lui i ∈ {0, ..., n − 1} şi fie i (j) numărul a cărui
reprezentare binară este ik−1 ik−2 . . . ij+1 ĩj ij−1 · · · 0, unde ĩj = 1 − ij , 0 ≤ j < k.
• Nodul Vi este adiacent cu nodurile din mulţimea {Vi (j) ; 0 ≤ j < k}.
Figura 15 : Hipercub liniarizat
20/ 34
Hipercuburi cu 0, 1, 2 , 3 şi 4 dimensiun
Figura 16 : Hipercuburi cu 0, 1, 2 , 3 şi 4 dimensiuni
21/ 34
Amestecul perfect
• Fie ik−1 ik−2 . . . i0 reprezentarea binară a lui i ∈ {0, ..., n − 1}.

• Nodul Vi este conectat la nodurile Vi (0) , Vik−2 ik−3 ...i0 ik−1 si Vi0 ik−1 ik−2 ...i1 , 0 ≤ i < n,
• n, q, i şi i (0) sunt definite ca ı̂n cazul hipercubului..
000 001 010 011 100 101 110 111
Figura 17 : Amestec perfect
22/ 34
Criterii de evaluare a topologiilor regulate
• Distanţa = cel mai scurt drum ı̂ntre două unităţi de procesare.

• Diametrul = distanţa maximă ı̂ntre două unităţi de procesare.
• Lăţimea bisecţiei = numărul minim de linii de comunicaţii care pot fi ı̂ntrerupte
pentru a sparge reţeaua ı̂n două reţele de dimensiuni aproximativ egale.
• Costul = numărul de linii de comunicaţii.
23/ 34
Evaluarea a 8 topologii regulate, cu p unităţi de procesare
Topologia Diametrul Lăt, imea bisect, iei Costul
Graful complet 1 bp 2 /4c p(p − 1)/2

Steaua 2 p−1
Arborele binar 2blog(p + 1)/2)c 1 p−1
complet
Lanţul p−1 1 p−1
Inelul bp/2c 2 p
√ √ √
Plasa 2D 2( p − 1) p 2(p − p)
√
Plasa 2D ciclică 2b( p/2)c 4 2p
Hipercubul log p p/2 p log p/2
24/ 34
Graful oarecare
• Internet-ul.
• Web-ul.
Figura 18 : Graful oarecare
25/ 34
Arborele oarecare
• reţelele locale.
Figura 19 : Arborele oarecare
26/ 34
Modele de calcul paralel/distribuit

Taxonomia lui Flynn
• Formulată de Michael J. Flynn, ı̂n 1966. Criteriul de clasificare este concurenţa
instrucţiunilor şi a fluxurilor de date.
• Un calculator monoprocesor poate executa la un moment dat o singură instrucţiune,
ı̂n timp ce un sistem multiprocesor poate executa simultan mai multe instrucţiuni
asupra mai multor fluxuri de date.
• Taxonomia:
• SISD Single Instructuction / Single Data stream (o singură instrucţiune / un singur
flux de date). Exemplu: calculatoarele monoprocesor;
• SIMD Single Instructuction / Multiple Data streams (o singură instrucţiune / mai
multe fluxuri de date). Exemplu: calculatoarele vectoriaale, sistemele GPU;
• MISD Multiple Instructuctions / Single Data stream (mai multe instrucţiuni / un
singur flux de date). Exemplu: sitemele pipeline;
• MIMD Multiple Instructuctions / Multiple Data streams (mai multe instrucţiuni / mai
multe fluxuri de date). Exemplu: calculatoarele multiprocesor, clusterele, grid-urile,
norii de calcul (cloud).
• Tipuri de sisteme MIMD
• SPMD Single Program / Multiple Data streams (un singur program / mai multe
fluxuri de date);
• MPMD Multiple Program / Multiple Data streams (mai multe programe / mai multe
fluxuri de date).
27/ 34
Modele arhitecturale
• Modele bazate pe comunicarea prin memoria comună (Shared-Memory)

• Modele bazate pe comunicarea prin mesaje (Message-Passing)
28/ 34
Modelul Shared-Memory
• Un sistem Shared-Memory este compus din n unităţi de procesare p0 , p1 , . . . pn−1 şi
m regiştri de memorie, r0 , r1 , . . . rm−1 .
• Fiecare registru este caracterizat prin:
• valoarea care poate fi memorată ı̂n registru;
• operaţiile care pot fi efectuate asupra conţinutului registrului;
• valoarea returnată de fiecare operaţie ;
• valoarea aflată ı̂n registru după fiecare operaţie.
• Exemplu - registrul integer-valued read/write:
• Valorile v memorate de registrul v sunt numere ı̂ntregi.
• Operaţiile suportate sunt read(r,v) and write(r,v).
• Operaţia read(r,v) ı̂ntoarce valoarea v şi lasă conţinutul registrului neschimbat.
• Operaţia write(r,v) nu returnează nimic, dar schimbă conţinutul registrului r ,
ı̂nscriind acolo valoarea v .
• Evenimente:
• Evenimentele sunt paşi computaţionali, executaţi de unităţile de procesare .
• Un pas computaţional, executat de o unitate de procesare pi , este executat astfel:
• În funcţie de starea sa, pi selectează un registru rj şi una din operaţiile asociate acestui
registru.
• Execută operaţia asupra conţinutului lui rj .
• Îşi schimbă starea, ı̂n funcţie de starea curentă şi valoarea returnată de operaţia executată.
29/ 34
Modelul PRAM
• Este derivat din modelul Shared-Memory.
• Unităţile de procesare sunt procesoare simple.
• Cele p(n) procesoare P1 , . . . , Pp(n) comunică ı̂ntre ele prin intermediul regiştrilor de
memorie R1 , ..., Rm(n) .
• Procesoarele execută ı̂n mod sincron aceeaşi instrucţiune, sub control central.
• Deşi instrucţiunea este aceeaşi, regiştrii de memorie asupra cărora acţionează
procesoarele pot diferi de la un procesor la altul.
• Conform taxonomiei Flynn, maşina PRAM este un sistem SIMD.
Figura 20 : Maşina PRAM
30/ 34
Tipuri de maşini PRAM
• La un moment dat t, un procesor poate accesa un registru de memorie pentru citire

sau scriere.
• În funcţie de accesul concurent permis, maşinile PRAM pot fi de tipul
• EREW (Exclusive-Read,Exclusive-Write),
• CREW (Concurrent-Read,Exclusive-Write),
• CRCW (Concurrent-Read,Concurrent-Write).
• O maşină EREW-PRAM nu permite acces simultan la un registru de memorie.
Aceasta ı̂nseamnă că, la un moment dat, cel mult un procesor poate accesa un
registru de memorie.
• Ultimele două tipuri (CREW,CRCW) permit citiri simultane din acelaşi registru de
memorie. Diferenţierea derivă din accesul la scriere.
• Tipul CREW-PRAM defineşte o maşină ı̂n care un singur procesor poate accesa la
un moment dat un registru de memorie pentru scriere.
• O maşină CRCW-PRAM este caracterizată prin faptul că sunt permise accesări
concurente pentru scriere.
31/ 34
Modelul Message-Passing
• Un sistem Message-Passing este compus din n unităţi de procesare p0 , p1 , . . . pn−1 care
comunică ı̂ntre ele prin mesaje transmise pe canalele de comunicare care le conectează.
• Topologia de comunicare este reprezentată printr-un graf G = (v , E ), care asignează fiecărui
vârf vi o unitate de procesare pi . Fiecare muchie ek ∈ E reprezintă un canal de comunicare
directă ı̂ntre două unităţi de procesare pi şi pj .
• Fiecare unitate de procesare pi poate fi ı̂ntr-o stare din mulţimea de stări Qi . Fiecare stare
include două mulţimi de regiştri: (inbufi k , k = 1, . . . , d) şi (outbufi k , k = 1, . . . , d), unde d este
gradul vârfului vi asignat lui pi .
• Un registru inbufi k conţine mesajele pe care unitatea de procesare pi le-a primit de la
unitatea de procesare vecină pj , prin canalul de comunicare directă k. Un registru outbufi k
conţine mesajele pe care unitatea de procesare pi le-a transmis spre unitatea de procesare
vecină pj , prin canalul de comunicare directă k.
• Mulţimea de stări Qi conţine o submulţime de stări speciale, ı̂n care regiştrii inbufl nu
memorează nici un mesaj.
• Evenimentele sunt paşi computaţionali şi paşi de comunicare.
• În timpul unui pas computaţional, o unitate de procesare pi cites, te s, i apoi resetează regis, trii
inbufi k , k = 1, . . . , d s, i produce valori noi pentru outbufi k , k = 1, . . . , d, schimbându-s, i ı̂n
acelas, i timp starea internă.
• Evenimentul de comunicare ı̂nseamnă o operat, ie de transmisie, i.e. un mesaj memorat ı̂n
outbuf-ul unei unităt, i de procesare pi este transmis, prin canalul de comunicare directă, la
destinat, ia pj , unde va fi memorat ı̂n inbuf .
32/ 34
Modelul sistolic
• Este derivat din modelul

Message-Passing.
• Arhitecturile utilizate de modelul sistolic
au două proprietăţi foarte importante:
regularitatea şi interconexiunile locale.
• O arhitectură sistolică este
• compusă din celule computaţionale de
acelasi tip sau dintr-o mulţime
restransă de tipuri,
• interconectate regulat prin conexiuni
locale.
Y. Robert si D. Trystram
Problema algebrică a drumurilor
Figura 21 : Exemplu de arhitectură sistolică
33/ 34
Bibliografie
• V. Kumar, A. Grama A. Gupta & G Karypis, Introduction to Parallel Computing:

• H. Attiya, J. Welch, Distributed Computing: Fundamentals, Simulations and
Advanced Topics, John Wiley & Sons, Inc., 2004
• K. Berman, J. Paul, Algorithms: Sequential, Parallel, and Distributed, Thomson
Learning, Inc., 2005
• T. Mattson, B. Sanders, B. Massingill, Patterns for Parallel Programming,
Addison-Weslwy, 2005
34/ 34
Cuprins Parametri de performanţă a unui algoritm paralel/distribuit Comunicarea ı̂n sistemele de calcul paralel/distribuit

Performanţă, Comunicare
Mitică Craus
1/ 19
Cuprins
Parametri de performanţă a unui algoritm paralel/distribuit

Comunicarea ı̂n sistemele de calcul paralel/distribuit
Tipuri de comunicare
Comunicare prin ret, ele de interconectare cu topologie regulată
Difuzia unu la tot, i
Difuzia tot, i la tot, i
Comunicarea personalizată unu la tot, i
Comunicarea personalizată tot, i la tot, i
Comunicare prin ret, ele de interconectare cu topologie arbore oarecare
Comunicare grup la grup
2/ 19
Parametri de performanţă a unui algoritm paralel/distribuit
• Parametri de performanţă a unui algoritm paralel:

• timpul de execut, ie paralelă: Tp (n), p = numărul unităt, ilor de procesare, n =
dimensiunea problemei;
• timpul de execut, ie sequent, ială: Ts (n);
• factorul de ı̂ncarcare: L = n/p;
• accelerarea: S(n) = Ts (n)/Tp (n), Ts (n) = timpul de execut, ie al celui mai rapid
algoritm secvent, ial;
• eficient, a: E (n) = S(n)/p = Ts (n)/(pTp (n));
• costul: C (n) = Costul = pTp (n)
• Parametri de performanţă a unui algoritm distribuit:
• numărul de mesaje transmise prin ret, eaua de interconectare: M(n), p = numărul
unităt, ilor de procesare.
3/ 19
Tipuri de comunicare
• unu la unu.
• comunicări colective:
• unu la un grup, unu-la-toţi: broadcast, scatter;
• un grup la un grup, un grup la toţi, toţi la un grup, toţi la toţi;
• un grup la unu, toţi la unu: reduction, gather.
4/ 19
Difuzia unu la tot, i

Definit, ie: O unitatea de procesare trimite acelaşi mesaj M la toate celelalte.
Difuzia unu la tot, i pe un inel
Copyright
c V. Kumar, A. Grama A. Gupta & G Karypis, Introduction to Parallel Computing: Design and Analysis of Algorithms, Addison Wesley, 2003.
Figura 1 : Exemplu de difuzie unu la tot, i pe un inel
• Timpul de execuţie: T = (Ts + Tc m)dp/2e, unde

• Ts = timpul de iniţializare a transmisiei;
• Tc = timpul de transmisie a unui cuvânt;
• m = numărul de cuvinte care compun mesajul M; prin cuvănt se ı̂nţelege unitatea
lexicală care compune mesajul ( exemplu: octet, 2 octeţi, etc.);
• p = numărul de unităt, i de procesare.
5/ 19
Difuzia unu la tot, i pe o plasă circulară
Copyright
Figura 2 : Exemplu de difuzie unu la tot, i pe o plasă circulară
√
Timpul de execuţie: T = (Ts + Tc m)d p/2e.
6/ 19
Difuzia unu la tot, i pe un hipercub
Copyright
Figura 3 : Exemplu de difuzie unu la tot, i pe un hipercub
Timpul de execuţie: T = (Ts + Tc m) log p
7/ 19
Algoritmul de difuzie unu la tot, i pe un hipercub
• Notat, ii:
• H este un hipercub cu d dimensiuni.
• M este un mesaj care urmează a fi transmis tuturor unităt, ilor de procesare.
• i este identificatorul unităt, ii de procesare care executa algoritmul de difuzie
unu la tot, i pe hipercub.
• Premise:
• Init, ial, mesajul M se află ı̂n nodul 0 al hipercubului H.
difuzie unu la toti pe hipercub(H, d, i, M)

1 masca ← 2d − 1 /* init, ializeaza cu 1 toti bitii mastii */
2 for k ← d − 1 downto 0
3 do masca ← masca XOR 2k ; /* seteaza pe 0 al k-lea bit al mastii */
4 if (i AND masca) = 0
5 then /* daca ultimii k biti sunt 0 */
6 if (i AND 2k ) = 0
7 then destinatie ← i XOR 2k ;
8 trimite M la destinatie;
9 else sursa ← i XOR 2k ;
10 primeste M de la sursa.
8/ 19
Algoritmul generalizat de difuzie unu la tot, i pe un hipercub

• Notat, ii:
• M este un mesaj care urmează a fi transmis tuturor unităt, ilor de procesare.
• i este identificatorul unităt, ii de procesare care executa algoritmul de difuzie
unu la tot, i pe hipercub.
• Premise:
• Init, ial, mesajul M se află ı̂n nodul nodul s al hipercubului H.
difuzie unu la toti pe hipercub(H, d, i, s, M)

1 id virtual ← i XOR s;
2 masca ← 2d − 1 /* init, ializeaza cu 1 toti bitii mastii */
3 for k ← d − 1 downto 0
4 do masca ← masca XOR 2k ; /* seteaza pe 0 al k-lea bit al mastii */
5 if (id virtual AND masca) = 0
6 then /* daca ultimii k biti sunt 0 */
7 if (id virtual AND 2k ) = 0
8 then destinatie virtuala ← id virtual XOR 2k ;
9 trimite M la destinatie virtuala XOR s;
10 else sursa virtuala ← id virtual XOR 2k ;
11 primeste M de la sursa virtuala XOR s.
9/ 19
Difuzia tot, i la tot, i
Definit, ie: Fiecare unitatea de procesare i trimite un mesaj Mi la toate celelalte.

Difuzia tot, i la tot, i pe un inel
Copyright
Figura 4 : Exemplu de difuzie tot, i la tot, i pe un inel - paşii 2 şi 7
Timpul de execuţie: T = (Ts + Tc m)(p − 1)
10/ 19
Difuzia tot, i la tot, i pe un hipercub
Copyright
Figura 5 : Exemplu de difuzie tot, i la tot, i pe un hipercub
Timpul de execuţie: T = Ts log p + Tc m(p − 1) 11/ 19

Algoritmul de difuzie tot, i la tot, i pe un hipercub
• Notat, ii:
• i este identificatorul unităt, ii de procesare care executa algoritmul de difuzie unu la tot, i
pe hipercub.
• Mi este mesajul care urmează a fi transmis de unitatea de procesare id tuturor
unităt, ilor de procesare.
• Premise:
• Init, ial, fiecare unitate de procesare i det, ine un mesaj Mi care urmează a fi transmis
tuturor unităt, ilor de procesare plasate ı̂n nodurile hipercubului H.
difuzie toti la toti pe hipercub(H, d, i, Mi , mesaje)

1 mesaje colectate ← Mi ;
2 for k ← 0 to d − 1
3 do partener ← i XOR 2k ;
4 trimite mesaje colectate la partener ;
5 primeste mesaje de la partener ;
6 mesaje colectate ← mesaje colectate ∪ mesaje.
12/ 19
Comunicarea personalizată unu la tot, i

Definit, ie: O unitate de procesare i trimite un trimite câte un mesaj Mij la fiecare unitate
de procesare j.
Copyright
Figura 6 : Exemplu de comunicarea personalizată unu la tot, i pe un hipercub
Timpul de execuţie: T = Ts log p + Tc m(p − 1) 13/ 19

Comunicarea personalizată toţi la tot, i
Definit, ie: Fiecare unitate de procesare i trimite câte un trimite un mesaj Mij la fiecare
unitate de procesare j.
14/ 19
Difuzia unu la toţi pe un arbore
Premise : Iniţial, unitatea de procesare pr (rădăcina) deţine mesajul M, care urmează a fi

difuzat ı̂n arbore.
cod pr
difuzie unu la toti pe arbore(T , pr , M)
1 trimite M catre fii;
2 termina executia.
cod pi 6= pr
difuzie unu la toti pe arbore(T , pi , M)
1 asteapta primirea mesajului M de la parinte;
2 dupa primirea lui M trimite mesajul la fii;
3 termina executia.
15/ 19
Complexitatea
Teorema (1)
Numărul de paşi, după care toate unităţile de procesare termină execuţia algoritmului =
h (adâncimea arborelui T ).
Demonstraţie.
Inducţie.
Teorema (2)
Numărul de mesaje, care sunt transmise de toate unităţile de procesare, ı̂n timpul
execuţiei algoritmului = n − 1.
Demonstraţie.
Pe fiecare muchie este transmis câte un mesaj, de la părinte spre fii.
16/ 19
Difuzia toţi (frunze)la unu (rădăcină) pe un arbore

Premise : Iniţial, unitatea de procesare din frunza i deţine mesajul Mi , care urmează a fi
transmis spre rădăcină.
cod pi = frunza
difuzie toti la unu pe arbore(T , pi , Mi )
1 trimite Mi catre parinte;
2 termina executia.
cod pi = nod interior

difuzie toti la unu pe arbore(T , pi , Mi )
1 asteapta primirea valorilor Mi0 , Mi1 , . . . , Mik−1 de la fii;
2 dupa primire, calculeaza Mi ← f (Mi , Mi0 , Mi1 , . . . , Mik−1 );
3 trimite Mi catre parinte;
4 termina executia.
cod pr
difuzie toti la unu pe arbore(T , pr , Mr )
1 asteapta primirea valorilor Mr0 , Mr1 , . . . , Mrk−1 de la fii;
2 dupa primire, calculeaza Mr ← f (Mr , Mr0 , Mr1 , . . . , Mrk−1 );
3 termina executia.
17/ 19
Complexitatea
Teorema (3)
Numărul de paşi, după care toate unităţile de procesare termină execuţia algoritmului =
h( adâncimea arborelui T ).
Demonstraţie.
Inducţie.
Teorema (4)
Numărul de mesaje, care sunt transmise de toate unităţile de procesare, ı̂n timpul
execuţiei algoritmului = n − 1.
Demonstraţie.
Pe fiecare muchie este transmis câte un mesaj, de la fii către părinte.
18/ 19
Comunicare grup la grup
• Comunicarea ı̂ntre grupuri este similară cu comunicare ı̂ntre toate unităt, ile de
procesare ale sistemului.
• Deosebirile sunt următoarele:
• Pe parcursul execut, iei algoritmului de comunicare doar unităt, ile de procesare membre
ale grupurilor vor init, ia un transfer sau vor memora un mesaj.
• Celelalte unităt, i de procesare au rol de retransmisie a mesajelor (releu).
19/ 19
Cuprins Comprimarea (Reducerea) Calculul Prefixelor (Scan) Scurtcircuitarea (dublarea)

Algoritmi fundamentali
Mitică Craus
1/ 22
Cuprins
Comprimarea (Reducerea)
Algoritm recursiv de comprimare
Algoritm paralel de comprimare
Corectitudinea şi complexitatea
Reducerea numărului unităţilor de procesare
Comentarii
Calculul Prefixelor (Scan)
Algoritmul de calcul al prefixelor ı̂n cazul ı̂n care operatia ⊕ admite
element simetric
Algoritmul de calcul al prefixelor ı̂n cazul ı̂n care operatia ⊕ nu admite
element simetric
Comentarii
Scurtcircuitarea (dublarea)
Algoritm paralel de scurtcircuitare
Complexitatea
Aplicaţii ale scurtcircuitării: Calcul ranguri
Comentarii
2/ 22
Comprimarea (Reducerea)
• Fie M o mulţime de n = 2m elemente, M = {ai /i = 0, 1, . . . , n − 1} ⊆ Mr = mulţime

de referinţă.
• Mult, imea M urmează a fi procesată pentru a calcula valoarea a1 ⊕ · · · ⊕ an , unde ⊕
este o lege de compozit, ie asociativă definită pe Mr .
• Mult, imea de referint, ă Mr poate fi R, iar ⊕ poate fi +, min, max, etc.
3/ 22
Algoritm recursiv de comprimare
• Notat, ii:
• A[0..n − 1] este un tablou de dimensiune n = 2m .
• Prin (A, k, k + l − 1) se notează segmentul din tabloul A care ı̂ncepe pe poziţia k şi se
termină pe poziţia k + l − 1
• Premise:
• Datele de intrare sunt init, ial memorate ı̂n tabloul A[0..n − 1].
• Init, ial, k = 0 si l = n.
Comprim Recursiv(A, k, k + l − 1)
1 if l = 1
2 then return A[k]
3 else return Comprim Recursiv(A, k, k + l/2 − 1) ⊕ Comprim Recursiv(A, k + l/2, k + l − 1).
4/ 22
Algoritm paralel de comprimare
• Notat, ii:
• A[0..2n − 1] este un tablou de dimensiune 2n = 2m+1 .
• Premise:
• Datele de intrare sunt memorate ı̂n tabloul A[0..2n − 1], ı̂n locat, iile
A[n], A[n + 1], . . . , A[2n − 1].
Comprim Paralel(A, ⊕)
1 for k ← m − 1 down to 0
2 do for all j : 2k ≤ j ≤ 2k+1 − 1
3 do in parallel
4 A[j] ← A[2j] ⊕ A[2j + 1];
5/ 22
Exemplu de execuţie a algoritmului de comprimare
Figura 1 : Exemplu de execuţie a algoritmului de comprimare
6/ 22
Teorema (1)
La terminarea execut, iei algoritmului A[1] = a0 ⊕ a1 ⊕ . . . an−1 .
Teorema (2)
Complexitatea timp a algoritmului de comprimare (implementat pe o masina
CREW-PRAM sau pe o ahitectura VLSI de tip arbore binar) este O(log n).
Demonstraţie.
Adâncimea arborelui de calcul este log n.
Teorema (3)
Numarul unităt, ilor de procesare este p ≥ d n2 e
Demonstraţie.
In prima iteraţie sunt active d n2 e unităt, ilor de procesare. Apoi numărul lor scade pâna la 1.
7/ 22
Reducerea numărului unităţilor de procesare

n
• Se poate observa că ı̂n fiecare pas k, k = m − 1, m − 2 . . . , 0, sunt active d m−k
2
e
unităţi de procesar.e Aceasta sugerează faptul că este posibilă reducerea numărului
de unităţi de procesare, fără a afecta complexitatea algoritmului.
• Presupunând că p < d n2 e, se partiţionează mulţimea celor n elemente
a0 , a1 , . . . , an−1 ı̂n p submulţimi astfel:
• Primele p − 1 submulţimi contin k = d pn e elemente.
• Ultima submulţime conţine n − (p − 1)· d pn e (≤ d pn e elemente.
• Fiecărei submulţimi i se asociază o unitate de procesare. Unitatea de procesare
asociată unei submulţimi S = {ai0 , . . . , aik−1 } rezolvă problema determinarii valorii
ai0 ⊕ ... ⊕ aik−1 ı̂n d pn e − 1 unităţi de timp.
• Actionând ı̂n paralel, cele p unităţi de procesare reduc problema iniţială la o
problemă similară de dimensiune p, ı̂n d pn e − 1 unităţi de timp.
• În continuare, aplicând comprimarea asupra problemei rezultate, se obţine rezultatul
final ı̂n log p unităţi de timp.
• Rezultă un timp total de d pn e − 1 + log p unităţi. Dacă p = d log
n
n e, atunci
d logn n e − 1 + log p ' 2 log n − 1 − log log n ∈ O(log n),
8/ 22
Comentarii
• Comprimarea nu se reduce la operarea cu elementele unei mulţime de numere.

• a0 ⊕ a1 ⊕ . . . an−1 pot fi n fis, iere, care urmează a fi concatenate.
• Mai pot fi n instant, e ale unei tabele ale unei baze de date distribuite, care trebuie
unificate.
• În aceste situat, ii algoritmul este distribuit.
9/ 22
Calculul Prefixelor (Scan)
• Tehnica calculării prefixelor dezvoltă tehnica comprimării, ı̂n care parcurgerea

arborelui asociat execut, iei algoritmului se face dinspre frunze spre rădăcină.
• Algoritmii de calcul a prefixelor parcurg arborele de execut, ie ı̂n ambele sensuri.
• Calculul prefixelor constă ı̂n determinarea valorilor
a0 , a0 ⊕ a1 , . . . , a0 ⊕ a1 ⊕ · · · ⊕ an−1 , unde ⊕ este o operat, ie binară asociativă.
10/ 22
Algoritmul de calcul al prefixelor ı̂n cazul

ı̂n care operatia ⊕ admite element simetric
• Notat, ii:
• A[0..2n − 1] este un tablou de dimensiune 2n = 2m+1 .
• Premise:
• Datele de intrare sunt memorate ı̂n tabloul A[0..n − 1], ı̂n locat, iile
A[n], A[n + 1], . . . , A[2n − 1].
Calcul Prefixe ⊕ admite element neutru(A, ⊕)

1 / ∗ Comprimare ∗ /
3 do for all j : 2k ≤ j ≤ 2k+1 − 1
4 do in parallel A[j] ← A[2j] ⊕ A[2j + 1];
5 / ∗ Calcul prefixe ∗ /
6 B[1] ← A[1];
7 for k ← 1 to m
8 do for all j : 2k ≤ j ≤ 2k+1 − 1
9 do in parallel;
10 if bit0 (j) = 1
11 then B[j] ← B[(j − 1)/2];
12 else B[j] ← B[j/2] ⊕ (−A[j + 1]);
11/ 22
Exemplu de execuţie a algoritmului de calcul al prefixelor ı̂n cazul ı̂n care

operatia ⊕ admite element simetric
12/ 22
Algoritmul de calcul al prefixelor ı̂n cazul ı̂n care operatia ⊕ nu admite

element simetric
• Notat, ii: A[0..2n − 1] şi B[0..2n − 1] sunt tablouri de dimensiune 2n = 2m+1 .
• Premise: Datele de intrare sunt memorate ı̂n tabloul A[0..2n − 1], ı̂n locat, iile
A[n], A[n + 1], . . . , A[2n − 1]. La final,
B[n] = a0 , B[n + 1] = a0 ⊕ a1 , . . . , B[2n − 1] = a0 ⊕ a1 ⊕ · · · ⊕ an−1 .
Calcul Prefixe ⊕ nu admite element neutru(A, ⊕)
1 / ∗ Comprimare ∗ /
3 do for all j : 2k ≤ j ≤ 2k+1 − 1
4 do in parallel A[j] ← A[2j] ⊕ A[2j + 1];
5 / ∗ Calcul prefixe ∗ /
6 for k ← 0 to m
7 do for all j : 2k ≤ j ≤ 2k+1 − 1
8 do in parallel
9 if j = 2k
10 then B[j] ← A[j];
11 else if bit0 (j) = 1
12 then B[j] ← B[(j − 1)/2];
13 else B[j] ← B[(j − 2)/2] ⊕ (A[j]);
13/ 22
Teorema (4)
La terminarea execut, iei algoritmului,
B[n] = a0 , B[n + 1] = a0 ⊕ a1 , . . . , B[2n − 1] = a0 ⊕ a1 ⊕ · · · ⊕ an−1 .
Teorema (5)
Complexitatea timp a algoritmului paralel de calcul al prefixelor (implementat pe
o masina CREW-PRAM sau pe o ahitectura VLSI de tip arbore binar) este
O(log n).
Demonstraţie.
Adâncimea arborelui de calcul este log n.
Teorema (6)
Numarul unităt, ilor de procesare este d logn n e.
Demonstraţie.
Necesarul de unităt, ide procesare este acelas, i cu cel de la comprimare .
14/ 22
Comentarii
• Ca s, i ı̂n cazul comprimării, calculul prefixelor nu se reduce la operarea cu elementele

unei mulţime de numere.
• Compilatoarele folosesc masiv calculul prefixelor.
• Descopirirea patternurilor frecvente ı̂n colect, ii de date de dimensiuni foarte mari,
cont, ine ca task de bază calculul de prefixe.
• Regăsirea informat, iei este un alt domeniu de aplicare a calculului prefixelor.
• Algoritmii paraleli pot aduce preformanţă sporită.
• Recurent, ele sunt cel mai clar exemplu de aplicare a calculului prefixelor.
• Fie recurent, a xk = xk−1 ⊕ ak , k > 0, x0 = a0 .
• Daca ⊕ este un operator binar asociativ, atunci xk = a0 ⊕ a1 ⊕ . . . ak .
15/ 22
Scurtcircuitarea (dublarea)
• Fie L o listă simplu ı̂nlănţuită formată din n elemente.

• Fiecare element k ∈ L are asociat un număr valoare[k] şi un pointer pointer [k].
• Se presupune că fiecărui element k ∈ L ı̂i este asignată o unitate de procesare pk .
• Scurtcircuitarea se referă la indirectarea prin intermediul pointerilor, pentru a
accesa locaţii noi.
16/ 22
Algoritm paralel de scurtcircuitare
Scurtcircuitare paralela(L, valoare, ⊕)

1 for i ← 1 to log n
2 do for all k : k ∈ L
3 do in parallel
4 if pointer [k] 6= pointer [pointer [k]]
5 then valoare[k] ← valoare[k] ⊕ valoare[pointer [k]];
6 pointer [k] ← pointer [pointer [k]];
17/ 22
Complexitatea
Teorema (7)
Complexitatea timp a algoritmului paralel de scurtcircuitare, implementat pe o masina
CREW-PRAM, este O(log n).
18/ 22
Aplicaţii ale scurtcircuitării: Calcul ranguri
• Un exemplu tipic de utilizare a tehnicii scurtcircuitării ı̂l constituie calcularea

numerelor de ordine ale elementelor unei liste, faţă de sfârşitul acesteia.
• Pentru un element k ∈ L, rang [k] va conţine ı̂n final numărul i al elementor din lista
L care se afla ı̂n listă după elementul k, ı̂n ordinea dată de pointeri.
19/ 22
Algoritm paralel de calcul ranguri
Calcul Ranguri paralel(L, rang , +)

1 / ∗ Init, ializare vectori pointer s, i rang ∗ /for all k : k ∈ L
2 do in parallel
3 pointer [k] ← succesor (k) / ∗ succesor (k) = elementul care urmează lui k ı̂n lista L ∗ /
4 if pointer [k] 6= k
5 then rang [k] ← 1;
6 else rang [k] ← 0;
7 / ∗ Aplicarea tehnicii scurtcircuitării ∗ /
8 Scurtcircuitare paralela(L, rang , +)
20/ 22
Exemplu de execuţie a algoritmului de calcul ranguri
Figura 3 : Exemplu de execuţie a algoritmului de calcul ranguri
21/ 22
Comentarii
• Scurtcircuitarea nu se reduce la operarea cu elementele unei liste.

• Documentele web pot fi obiectul unor operaţii de scurtircuitare paralelă, atunci când
se doreşte clusterizarea acestora.
• Rutarea poate folosi tehnica scurtcircuitării paralele.
22/ 22
Introducere Algoritmul Muller-Preparata Algoritmul Impar-Par (Odd-Even Sort) Sortare bitonică Sortare rapidă pe hipercub Comentarii bibliografice

Sortare paralelă
Mitică Craus
1/ 42
Cuprins
Introducere
Algoritmul Muller-Preparata
Descriere
Pseudocod
Exemplu de execuţie
Corectitudinea
Complexitatea
Comentarii
Algoritmul Impar-Par (Odd-Even Sort)
Descriere
Pseudocod pentru algoritmul secvenţial
Pseudocod pentru un lanţ de unităţi de procesare
Complexitatea
Comentarii
Sortare bitonică
Descriere
Pseudocod
Exemplu de sortare a unei secvenţe bitone
Corectitudinea
Implementare
Complexitatea
Comentarii
Sortare rapidă pe hipercub
Descriere
Pseudocod
Complexitatea
Comentarii
Comentarii bibliografice
2/ 42
Introducere
• Există o vastă literatură de specialitate având ca subiect sortarea.

• Aceasta se explică prin faptul că sortarea apare ca substask ı̂n solut, iile algoritmice
ale multor probleme.
• Problema poate fi enunt, ată astfel:
Date fiind n elemente a0 , a1 , . . . , an−1 , dintr-o mulţime U peste care este definită o
relat, ie de ordine totală ” < ”, se dores, te renumerotarea lor astfel ı̂ncât
ai < aj , i, j ∈ {0, 1, . . . , n − 1}, i < j.
• Se presupune, pentru simplitate, că ai 6= aj , dacă i 6= j.
3/ 42
Algoritmul Muller-Preparata - descriere
• Autori: David E. Muller şi Franco P. Preparata. Anul publicării: 1975

• Algoritmul este compus din trei faze:
1. Determinarea poziţiilor relative pentru fiecare pereche {ai , aj }, i, j = 0, 1, . . . , n − 1:
• Notaţii: pozitie relativaaj (ai ) şi pozitie relativaai (aj ) desemnează poziţia lui ai ,
respectiv aj ı̂n secvenţa (ai , aj ) sortată crescător.
• Dacă ai < aj , atunci pozitie relativaaj (ai ) = 0 şi pozitie relativaai (aj ) = 1.
• Dacă ai > aj , atunci pozitie relativaaj (ai ) = 1 şi pozitie relativaai (aj ) = 0.
2. Calcularea pozitiilor finale ale elementelor ai , i = 0, 1, . . . , n − 1.

3. Plasarea elementelor aj pe pozitiile finale.
4/ 42
Algoritmul Muller-Preparata - pseudocod

• Notat, ii:
• A[0..n − 1] s, i P[0..n − 1] sunt două tablouri, fiecare de dimensiune n.
• R[0..2n − 2, 0..n − 1] este un tablou bidimensional de mărime (2n − 1)xn; R[j] desemnează coloana j.
• Premise:
• Datele de intrare sunt memorate ı̂n tabloul A[0..n − 1].
• Pozit, iile relative vor fi memorate ı̂n tabloul R, ı̂n liniile n − 1, n, . . . , 2n − 2.
• Pozit, iile finale vor fi ret, inute ı̂n tabloul P.
Sortare Paralela Muller Preparata(A, R, n)
1 for all i, j : 0 ≤ i, j ≤ n − 1
2 do in parallel/ ∗ calcularea pozit, iilor relative ∗ /
3 if A[i] < A[j]
4 then R[i + n − 1, j] ← 1
5 else R[i + n − 1, j] ← 0
6 for all j : 0 ≤ j ≤ n − 1
7 do in parallel/ ∗ calcularea pozit, iilor finale ∗ /
8 / ∗ Se calculează numărul elementelor care se află ı̂n faţa elementului aj ∗ /
9 Comprim Iterativ(R[j], +)
10 P[j] = R[0, j]
11 for all j : 0 ≤ j ≤ n − 1
12 do in parallel/ ∗ plasarea pe pozit, iile finale ∗ /
13 A[P[j]] = A[j]
5/ 42
Exemplu de execuţie a algoritmului Muller-Preparata

Tabloul R
Figura 1 : Exemplu de execuţie a algoritmului de sortare paralelă Muller-Preparata pentru secvenţa 2,6,3,8
6/ 42
Corectitudinea
Lema (1)
Poziţiile finale ale elementelor secvent, ei a0 , a1 , . . . , an−1 respectă relaţia de ordine ” < ”.
Demonstraţie.
În urma calculării numărului elementelor care se află ı̂n faţa unui element ai (COMPRIM ITERATIV
(R[j],+)), se obţine poziţia finală a acestuia, ı̂n concordanta cu relaţia de ordine ” < ”.
Teorema (1)
Algoritmul Muller-Preparata sortează corect o secvent, ă de elemente a0 , a1 , . . . , an−1
dintr-o mult, ime U peste care este definită o relaţie de ordine totală ” < ”.
Demonstraţie.
Consecint, ă imediată a lemei 1.
7/ 42
Complexitatea
Teorema (2)
Complexitatea timp a algoritmului de sortare paralelă Muller-Preparata, implementat pe
n2
o masina CREW-PRAM cu O( log n ) unităţi de procesare, este O(log n).
Demonstraţie.
1. Determinarea poziţiilor relative pentru fiecare pereche {ai , aj }, i, j = 0, 1, . . . , n − 1: dacă
maşina CREW-PRAM este compusă din n2 unităt, i de procesare, timpul paralel este O(1);
n2
dacă numărul unităt, ilor de procesare este d log n e, timpul paralel este O(log n) (tehnica este
aceeaşi cu cea de la comprimare).
2. Calcularea pozitiilor finale ale elementelor ai , i = 0, 1, . . . , n − 1: pentru fiecare i, sunt
necesare cel put, in d logn n e unităt, i de procesare, pentru a calcula pozit, ia finală a elementului
ai ı̂n timpul paralel O(log n) (vezi complexitatea algoritmului paralel de comprimare).
Rezultă un necesar de nd logn n e unităt, i de procesare pentru a calcula toate pozit, iile finale ı̂n
timpul paralel O(log n).
3. Plasarea elementelor aj pe pozitiile corecte: cu n unităt, i de procesare pentru se obţine
timpul paralel O(1).
8/ 42
Comentarii
• Relativ la algoritmul secvenţial, bazat pe metoda enumerării, care necesita O(n2 )

O(n2 )
timp, eficienţa algoritmului este E = n2
= O(1).
O( log n ) log n
• Totusi, algoritmul nu este optimal, deoarece cel mai rapid algoritm secvential are
timpul de executie de O(n log n).
9/ 42
Algoritmul Impar-Par (Odd-Even Sort) - descriere
• Este o versiune a algoritmului Bubble.

• Se desfăs, oară ı̂n faze.
• În fazele impare sunt sortate perechile {ai , ai+1 } cu i par.
• În fazele pare sunt sortate perechile {ai , ai+1 } cu i impar.
• Este paralelizabil.
10/ 42
Algoritmul Impar-Par secvenţial - pseudocod
• Notat, ii: A[0..n − 1] este un tablouri de dimensiune n.

• Premise: Datele de intrare sunt memorate ı̂n tabloul A[0..n − 1].
Sortare Secventiala Impar Par(A, n)

1 for faza ← 1 to n Compara si Interschimba(i, j)
2 do if faza este impara 1 if ai > aj
3 then for i ← 0 to 2b n2 c − 2 step 2 2 then temp ← ai
4 do compara si interschimba(i, i + 1) 3 ai ← aj
5 if faza este para 4 aj ← temp
6 then for i ← 1 to 2b n−12 c − 1 step 2 5
7 do compara si interschimba(i, i + 1)
11/ 42
Exemplu de execuţie a algoritmului Impar-Par
Figura 2 : Exemplu de execuţie a algoritmului de sortare Impar-Par pentru n = 8
12/ 42
Algoritmul Impar-Par paralel - pseudocod pentru un lanţ de unităţi de

procesare
• Premise: Init, ial, o unitate de procesare pi memorează elementul ai ı̂n registrul r .
Sortare Paralela Impar Par(pi , r , n)
1 for faza ← 1 to n
2 do if faza este impara si 0 ≤ i ≤ 2b n2 c − 1
3 then if i este par
4 then trimite lui pi+1 valoarea memorata in registrul r
5 primeste de la pi+1 o valoare v
6 r ← min(r , v )
7 else trimite lui pi−1 valoarea memorata in registrul r
8 primeste de la pi−1 o valoare v
9 r ← max(r , v )
10 if faza este para si 1 ≤ i ≤ 2b n−1
2 c
11 then if i este impar
12 then trimite lui pi+1 valoarea memorata in registrul r
13 primeste de la pi+1 o valoare v
14 r ← min(r , v )
15 else trimite lui pi−1 valoarea memorata in registrul r
16 primeste de la pi−1 o valoare v
17 r ← max(r , v )
13/ 42
Complexitatea
Teorema (3)
Complexitatea timp a algoritmului de sortare paralelă Impar-Par, implementat pe un lant,
de n unităţi de procesare, este O(n).
Demonstraţie.
Timpul paralel pentru fiecare fază este O(1). După n faze algoritmul se termină.
14/ 42
Comentarii
• Algoritmul de sortare paralelă Impar-Par este optimal pentru architecturã: Fiecare

unitate de procesare este solicitată O(n) timp
• Costul nu este optimal: (Numarul de unităt, i de procesare ) x (timpul paralel) =
nxn = O(n2 ). Timpul pentru cel mai rapid algoritm secvenţial este O(n log n).
• Algoritmul poate fi implementat şi pe o maşină CREW-PRAM.
Exerciţiu: Scrieţi un pseudocod pentru sortarea Impar-Par pe o astfel de maşină.
15/ 42
Algoritmul lui Batcher de sortare bitonică - descriere
• Autor: Batcher; Anul publicării: 1968.

• Operaţia de bază este sortarea unei secvenţe bitone.
• Esenţa problemei sortării unei secvenţe bitone este transformarea sortării unei
n
secvenţe de bitone lungime n ı̂n sortarea a doua secvent, e bitone de dimensiune 2.
• Pentru a sorta o secvent, ă de n elemente, prin tehnica sortării unei secvent, e bitone,
trebuie să dispunem de o secvent, ă bitonă formată din n elemente.
• Observaţii:
• Două elemente formează o secvent, ă bitonă.
• Orice secvent, ă nesortată este o concatenare de secvent, e bitone de lungime 2.
• Ideea transformării unei secvenţe oarecare ı̂n una bitonă: combinarea a două
n
secvent, e bitone de lungime 2 pentru a obţine o secvent, ă bitonă de lungime n.
• Algoritmul este paralelizabil.
16/ 42
Secvenţe bitone
• Secvenţa bitonă este o secvenţă de elemente [a0 , a1 , . . . , an−1 ] pentru care

• există i astfel ı̂ncât [a0 , a1 , . . . , ai ] este monoton crescătoare s, i [ai+1 , . . . , an−1 ] este
monoton descrescătoare sau
• există o permutare circulară astfel ı̂ncât să fie satisfacută condit, ia anterioară.
• Exemple:
• [1, 2, 4, 7, 6, 0]; ı̂ntâi cres, te s, i apoi descres, te; i = 3.
• [8, 9, 2, 1, 0, 4]: după o permutare circulară la stânga cu 4 poziţii rezultă
[0, 4, 8, 9, 2, 1]; i = 3.
• Fie S = [a0 , a1 , . . . , an−1 ] o secventă bitonă,
• S1 = [min{a0 , a n }, min{a1 , a n +1 }, . . . min{a n −1 , an−1 }] şi
2 2 2
• S2 = [max{a0 , a n }, max{a1 , a n +1 }, . . . max{a n −1 , an−1 }]
2 2 2
• Secvenţele S1 si S2 au proprietăţile următoare:
• Sunt bitone.
• Fiecare element din S1 este mai mic decit fiecare element din S2 .
17/ 42
Algoritmul lui Batcher de sortare bitonică - pseudocod

• Notaţii:
• A[0..n − 1] este un tablou unidimensional de dimensiune n.
• (A, i, d) defines, te segmentul A[i..i + d − 1] = A[i], ..., A[i + d − 1].
• s este un parametru binar care specifică ordinea crescătoare (s = 0) sau descrescătoare
(s = 1) a cheilor de sortare.
• COMPARA SI SCHIMBA(x, y , s) desemnează sortarea a două elemente x si y ordinea
indicată de parametrul s.
• Premise: Iniţial, A[0..n − 1] conţine secvenţa de sortat.
• Apel: SORTARE BATCHER(A, 0, n, 0) sau SORTARE BATCHER(A, 0, n, 1).
Sortare Batcher(A, i, d, s)
1 if d = 2
2 then (A[i], A[i + 1]) ← Compara si Schimba(A[i], A[i + 1], s)
3 else / ∗ sortare crescătoare a unei secvenţe S de lungime d2 ∗ /
4 Sortare Batcher(A, i, d2 , 0)
5 / ∗ sortare descrescătoare a secvenţei S 0 , care urmează lui S, de lungime d
2 ∗/
6 Sortare Batcher(A, i + d2 , d2 , 1)
7 / ∗ sortarea secvenţei bitone SS 0 , de lungime d ∗ /
8 Sortare Secventa Bitona(A, i, d, s)
18/ 42
Sortarea unei secvenţe bitone - pseudocod
• Premise: Iniţial, segmentul A[i..i + d − 1] conţine o secventă bitonă de lungime d;
Sortare Secventa Bitona(A, i, d, s)

1 if d = 2
2 then (A[i], A[i + 1]) ← Compara si Schimba(A[i], A[i + 1], s)
3 else / ∗ Construirea secvent, elor bitone S1 s, i S2 , de lungime d2 ∗ /
4 for all j : 0 ≤ j < d2
5 do in parallel
6 (A[i + j], A[i + j + d2 ]) ← Compara si Schimba(A[i + j], A[i + j + d2 ], s)
7 / ∗ sortarea secvenţei bitone S1 , de lungime d2 ∗ /
8 Sortare Secventa Bitona(A, i, d2 , s)
9 / ∗ sortarea secvenţei bitone S2 , de lungime d2 ∗ /
10 Sortare Secventa Bitona(A, i + d2 , d2 , s)
19/ 42
Exemplu de sortare a unei secvenţe bitone
Copyright 1994
c Benjamin/Cummings Publishing Co.
Figura 3 : Exemplu de sortare a unei secvenţe bitone
20/ 42
Corectitudinea
Lema (2)
Dacă algoritmul lui Batcher sortează orice secvent, ă de chei de sortare binare, atunci
sortează orice secvent, ă de chei de sortare numere reale oarecare.
Demonstraţie.
Fie f : R → R o funcţie monotonă. Astfel, f (ai ) ≤ f (aj ) dacă şi numai dacă ai ≤ aj . Evident,
dacă algoritmul lui Batcher transformă secvenţa [a1 , a2 , . . . , an ] ı̂n secvenţa [b1 , b2 , . . . , bn ], atunci
va transforma secvenţa [f (a1 ), f (a2 ), . . . , f (an )] ı̂n secvenţa [f (b1 ), f (b2 ), . . . , f (bn )]. Astfel, dacă
ı̂n secvenţa [b1 , b2 , . . . , bn ] există un indice i pentru care bi > bi+1 , atunci ı̂n secvenţa
[f (b1 ), f (b2 ), . . . , f (bn )] vom avea f (bi ) > f (bi+1 ). (
0 , dacă bj < bi
Fie acum f o funcţie monotonă definită astfel: f (bj ) =
1 , dacă bj ≥ bi
În aceste condiţii, secvenţa [f (b1 ), f (b2 ), . . . , f (bn )] va fi o secventă binară nesortată deoarece
f (bi ) = 1 şi f (bi+1 ) = 0. Rezultă că algoritmul lui Batcher eşuează ı̂n sortarea secvenţei binare
[f (a1 ), f (a2 ), . . . , f (an )]. Deci, dacă algoritmul lui Batcher eşuează ı̂n sortarea unei secvenţe de
chei de sortare numere reale oarecare, atunci există o secvenţa binară care nu va fi sortată ı̂n
urma aplicăriii algoritmului lui Batcher.
21/ 42
Corectitudinea -continuare
Teorema (4)
Algoritmul lui Batcher sorteaza cele n elemente ale secvent, ei memorate ı̂n tabloul A[0..n − 1], ı̂n
ordinea crescătoare (s = 0) respectiv descrescătoare (s = 1) a cheilor de sortare.
Demonstraţie.
Este suficient să demonstrăm corectitudinea procedurii SORTARE SECVENTA BITONA pentru cazul binar (Lema 2). Procedăm
prin inducţie după lungimea d a secvenţelor procesate.
Dacă d = 2, evident procedura SORTARE SECVENTA BITONA transformă secvenţa iniţială Sinit = A[i..i + d − 1] ı̂ntr-o secvenţă
sortată Sfin .
Vom demonstra că procedura SORTARE SECVENTA BITONA transformă o secvenţă binară Sinit de tipul 0r 1t 0v sau
1r 0t 1v (r + t + v = d) ı̂ntr-o secvenţă Sfin sortată ı̂n ordinea indicată de valoarea lui s, (∀)d ≥ 2
Pasul paralel 6 transformă secvenţa Sinit ı̂ntr-o secvenţă Stemp conform figurilor 2 şi 3.
1
Se observă că ı̂n toate cazurile, secvenţa rezultată Stemp , este formată din două sub-secvenţe bitone Stemp 2
şi Stemp , fiecare de
lungime d2 . O secvenţă este de tipul Sinit iar cealaltă secvenţă cont, ine numai cifre 0 sau numai cifre 1. Dacă s = 0, cheia
1
maximă din Stemp este mai mică sau egală cu cheia minimă din Stemp 2 1
. Dacă s = 1, cheia minimă din Stemp este mai mare sau
2
egală cu cheia maximă din Stemp .
Conform ipotezei de inducţie, procedura 1
SORTARE SECVENTA BITONA transformă secvenţele Stemp 2
şi Stemp ı̂n două secvenţe
1 şi S 2 , sortate crescător (d = 0) sau descrescător (s = 1). Dacă s = 0, cheia maximă din S 1 este mai mică sau egală cu
Sfin fin fin
2 deci secvenţa S 1 S 2 este crescătoare. Daca s = 1, cheia minimă din S 1 este mai mare sau egală cu
cheia minimă din Sfin fin fin fin
2 deci secvenţa S 1 S 2 este descrescătoare.
cheia maximă din Sfin fin fin
22/ 42
s p + q(p, q ≤ d2 ) Secvenţa iniţială Secvenţa rezultată
d d d d
0 ≤ d2 0 2 −p 1p 1q 0 2 −q 0 2 1q 0 2 −(p+q) 1p
d d
0 ≤ d2 02 0k 1p+q 0m 02 0k 1p+q 0m
d d
0 ≤ d2 0k 1p+q 0m 0 2 02 0k 1p+q 0m
d d d d
0 ≤ d2 1p 0 2 −p 0 2 −q 1q 02 1p 0 2 −(p+q) 1q
d d d −(p+q) d
0 ≤ d
2 12 1p 0 2 −(p+q) 1q p
1 02 1q 1 2
d d d d
0 ≤ d
2 1p 0 2 −(p+q) 1q 1 2 1p 0 2 −(p+q) 1q 1 2
d d d d d d
0 > d
2 0 2 −p 1p 1q 0 2 −q 0 2 −p 1(p+q)− 2 0 2 −q 1 2
d −p d −q d −q (p+q)− d d −p d
0 > d 1 0 2 0 2 1q
p 02 1 2 02 12
2
d d d d
1 ≤ d
2 0 2 −p 1p 1q 0 2 −q 1q 0 2 −(p+q) 1p 0 2
d d
1 ≤ d 0 2 0k 1p+q 0m 0k 1p+q 0m 0 2
2
d d
1 ≤ d 0k 1p+q 0m 0 2 0k 1p+q 0m 0 2
2
d d d d
1 ≤ d
2 1p 0 2 −p 0 2 −q 1q 1p 0 2 −(p+q) 1q 0 2
d d d d
1 ≤ d
2 12 1p 0 2 −(p+q) 1q 12 1p 0 2 −(p+q) 1q
d −(p+q) d d d
1 ≤ d
2
p
1 02 1q 1 2 12 1 0 2 −(p+q) 1q
p
d −p d −q d d −p (p+q)− d d
1 > d
2 0 2 1p 1q 0 2 12 02 1 2 0 2 −q
d d d d d d
1 > d
2 1p 0 2 −p 0 2 −q 1q 12 0 2 −q 1(p+q)− 2 0 2 −p
Figura 4 : Corectitudinea
23/ 42
s=0
0000111111 1110000000 - 0000000000 1110111111

0000000000 0011111000 - 0000000000 0011111000
0011111000 0000000000 - 0000000000 0011111000
1111110000 0000000011 - 0000000000 1111110011
1111111111 1100000111 - 1100000111 1111111111
1100000111 1111111111 - 1100000111 1111111111
0011111111 1111000000 - 0011000000 1111111111
1111111000 0000001111 - 0000001000 1111111111
s=1
0000111111 1110000000 - 1110111111 0000000000

0000000000 0011111100 - 0011111100 0000000000
0011111100 0000000000 - 0011111100 0000000000
1111110000 0000000111 - 1111110111 0000000000
1111111111 1111000111 - 1111111111 1111000111
1111000111 1111111111 - 1111111111 1111000111
0111111111 1110000000 - 1111111111 0110000000
1111100000 0011111111 - 1111111111 0011100000
Figura 5 : Corectitudinea
24/ 42
Implementarea algoritmului lui Batcher pe reţele de sortare

• Dacă se derecursivează algoritmul lui Batcher, se constată că sortarea unei secvent, e de
n = 2m elemente constă ı̂n m faze de sortare a unei secvent, e bitone: SSB0 , SSB1 , . . . , SSBm−1
• În faza SSBk , k ∈ {0, 1, . . . , m − 1}, se realizează sortarea secvent, elor bitone Si2d formate din
0 0
perechile de secvent, e consecutive Sid Si d de lungime d = 2k , Sid fiind sortată crescător s, i Si d
descrescator.
• Secvent, ele Si2d cu numărul de ordine i par sunt sortate crescător. Cele cu i impar sunt
sortate descrescător.
Copyright 1994
Figura 6 : Comparatori pentru sortarea a două elemente

25/ 42
Reţea de comparatori care transformă o secvenţă oarecare ı̂n una bitonă

Fazele 0, 1, . . . , m − 2
• Intrare: o secvenţă oarecare; Ieşire: o secvenţă bitonă.
Copyright 1994
Figura 7 : Reţea de comparatori care transformă o secvenţă oarecare ı̂n una bitonă (R1 ); n = 16
26/ 42
Reţea de sortare a unei secvenţe bitone - Faza m − 1

• Intrare: o secvenţă bitonă; Ieşire: o secvenţă sortată.
Copyright 1994
Figura 8 : Reţea de sortare a unei secvenţe bitone (R2 ); n = 16
27/ 42
Implementarea algoritmului lui Batcher pe hipercub

• Cubul binar multidimensional este o arhitectură ideală pentru implementarea
algoritmului lui Batcher.
• Reamintim:
• Dacă se derecursivează algoritmul lui Batcher, se constată că sortarea unei secvent, e de
n = 2m elemente constă ı̂n m faze de sortare a unei secvent, e bitone:
SSB0 , SSB1 , . . . , SSBm−1
• În faza SSBk , k ∈ {0, 1, . . . , m − 1}, se realizează sortarea secvent, elor bitone Si2d
0
formate din perechile de secvent, e consecutive Sid Si d de lungime d = 2k , Sid fiind
0d
sortată crescător s, i Si descrescator.
• Secvent, ele Si2d cu numărul de ordine i par sunt sortate crescător. Cele cu i impar sunt
sortate descrescător.
• Execut, ia fazei SSBk pe hipercub necesită utilizarea succesivă a dimensiunilor
Dk , Dk−1 , . . . , D1 , D0 .
• Planificarea utilizării dimensiunilor pentru o sortare completă poate fi reprezentată
astfel:
• SSB0 : D0
• SSB1 : D1 , D0
• SSB2 : D2 , D1 , D0
...
• SSBm−1 : Dm−1 , Dm−2 , . . . , D0
28/ 42
Planificarea dimensiunilor = Fazele sortării prin ret, ele de sortare Batcher
(a) (b)
Copyright 1994
Figura 9 : (a) Planificarea dimensiunilor (b)Fazele sortării prin ret, ele de sortare Batcher
29/ 42
Comunicarea pe hipercub ı̂n timpul ultimei faze a algoritmului lui Batcher

Fiecare linie continuă reprezintă o operaţie de interschimbare.
Copyright 1994
Figura 10 : Comunicarea ı̂n timpul ultimei faze a algoritmului lui Batcher

30/ 42
Complexitatea implementării pe o mas, ină CREW-PRAM
Teorema (4)
Complexitatea timp a algoritmului lui Batcher de sortare paralelă, implementat pe
mas, ină CREW-PRAM cu O(n) unităt, i de procesare este O(log2 n). Eficient, a
algoritmului este O( log1 n ).
Demonstraţie.
Timpul paralel pentru sortarea unei secvent, e bitone de lungime d < n este O(log d). După log n
O(n log n) 1
faze algoritmul se termină. Eficient, a este nO(log 2 n) = O( log n ).
31/ 42
Complexitatea implementării pe ret, ele de sortare
Teorema (5)
Complexitatea timp a algoritmului lui Batcher de sortare paralelă, implementat pe o
ret, ea de sortare cu O(n) intrări si ies, iri, este O(log2 n).
Demonstraţie.
Ret, eaua (R1 , R2 ) implementează algoritmul lui Batcher. Numărul de faze este log n. Fazele sunt
compuse din log d < log n paşi
32/ 42
Complexitatea implementării pe hipercub
Teorema (6)
Complexitatea timp a algoritmului lui Batcher de sortare paralelă, implementat pe un
hipercub cu O(n) unităţi de procesare este O(log2 n).
Demonstraţie.
Sortarea Batcher pe hipercub este congruentă cu sortarea Batcher pe reţele de sortare
33/ 42
Comentarii
• Algoritmul lui Batcher de sortare paralelă este din clasa timp O(log2 n). Numărul
de unităt, i de procesare este din clasa O(n). Comparativ cu algoritmii
Muller-Preparata şi Impar-Par are un cost mai bun.
• Totuşi, costul nu este optimal: (Numarul de unităt, i de procesare ) x (timpul
paralel) = n log2 n = O(n log2 n). Timpul pentru cel mai rapid algoritm secvenţial
este O(n log n).
34/ 42
Sortare rapidă pe hipercub - descriere
• Să ne amintim că un hipercub cu m dimensiuni este format din două hipercuburi cu
m − 1 dimensiuni.
• Numărul unităţilor de procesare, p, este mai mic decât numărul elementelor
secvenţei de sortat, n.
• Ideea este de a partiţiona secvenţa de sortat pe subcuburi şi apoi de a repeta repeta
recursiv această operaţie.
• Selectarea pivotului este problema cheie.
35/ 42
Sortare rapidă pe hipercub - pseudocod

• Notat, ii:
• A[0..n − 1] este un tablou de dimensiune n = 2m .
• Premise:
• Datele de intrare sunt partit, ionate ı̂ntre unităt, ile de procesare.
• Fiecare unitate de proceare(nod al hipercubului) memorează o parte Ai din secventa de
sortat, memorată iniţial ı̂n tabloul A[0..n − 1].
Sortare Rapida pe Hipercub(Ai , m, pi , pivot)
1 i ← eticheta unitatii de procesare
2 for k ← m − 1 downto 0
3 do / ∗ ∗ /
4 x ← pivot
5 partitioneaza Ai in Ai1 si Ai2 astfel incat Ai1 ≤ x ≤ Ai2
6 if al − k − lea bit este 0
7 then trimite Ai2 unitatii de procesare vecina pe dimensiunea k
8 Bi1 ← subsecventa primita de la vecinul de pe dimensiunea k
Ai ← Ai1 Bi1
S
9
10 else trimite Ai1 unitatii de procesare vecina pe dimensiunea k
11 Bi2 ← subsecventa primita de la vecinul de pe dimensiunea k
Ai ← Ai2 Bi2
S
12
13 Aplica lui Ai sortarea rapida secventiala
36/ 42
Exemplu de execuţie a algoritmului de sortare rapidă pe hipercub (m=3)
Copyright 1994
Figura 11 : Partiţionarea secvenţei de sortat ı̂n două blocuri. Se utilizează dimensiunea a treia (m − 1).
37/ 42
Exemplu de execuţie a algoritmului de sortare rapidă pe hipercub -

continuare
Copyright 1994
Figura 12 : Partiţionarea fiecărui bloc ı̂n două sub-blocuri. Se utilizează dimensiunea a doua (m − 2 = 1).
38/ 42
Exemplu de execuţie a algoritmului de sortare rapidă pe hipercub -

continuare
Copyright 1994
Figura 13 : Partiţionarea sub-blocurilor. Se utilizează prima dimensiune (m − 3 = 0).
39/ 42
Complexitatea
Teorema (7)
Dacă pivotul este ales astfel ı̂ncât să partit, ioneze secvent, a ı̂n două subsecvent, e de
dimensiuni aproximativ egale, atunci
n n n
Tp = O( log ) + O( log p) + O(log2 p)
p p p
.
40/ 42
Comentarii
• Selectarea unui pivot care să partit, ioneze secvent, a ı̂n două subsecvent, e de
dimensiuni aproximativ egale este dificilă.
41/ 42
• Capitolul sortare are la bază cartea

V. Kumar, A. Grama A. Gupta & G Karypis, Introduction to Parallel Computing:
s, i edit, ia mai veche
V. Kumar, A. Grama A. Gupta & G Karypis, Introduction to Parallel Computing:
Design and Analysis of Algorithms, Benjamin-Cummings, 1994
42/ 42
Cuprins Introducere Transpusa unei matrice Inmulţirea de matrice pătractice Comentarii bibliografice

Calcul matriceal
Mitică Craus
1/ 24
Cuprins
Introducere
Transpusa unei matrice
Descriere
Pseudocod
Implementare
Complexitatea
Inmulţirea de matrice pătractice
Descriere
Pseudocod
Implementare
Complexitatea
2/ 24
Introducere
• Calculul matricial se pretează extrem de bine la procesare paralelă.

• Natura regulată a matricelor constituie un atu de neegalat pentru abordări specifice
calculului paralel.
• Vom studia ı̂n această lecţie problemele transpusei unei matrice şi produsului de
matrice.
3/ 24
Transpusa unei matrice - formularea problemei
• Dată fiind matricea pătratică An×n = (ai,j )i,j=0,1...,n−1 , se cere să se calculeze
matricea AT T
nxn = (ai,j )i,j=0,1...,n−1 , pentru care
T
ai,j = aj,i , (∀)i, j = 0, 1 . . . , n − 1
.
• Fără calcule.
• Doar mişcări de elemente.
• Timpul secvenţial Ts (n) = O(n2 ).
4/ 24
Algoritmul secvenţial standard - pseudocod
• Notat, ii:
• A[0..n − 1, 0..n − 1] este un tablou bidimensional, de dimensiune nxn.
• Premise:
• Datele de intrare sunt memorate ı̂n tabloul A.
• Datele finale vor fi memorate ı̂n tabloul A.
Transpunere Matrice(A, n) Interschimba(A[i, j], A[j, i])

1 for i = 0 to n − 1 1 temp ← A[i, j]
2 do for j = i + 1 to n − 1 2 A[i, j] ← A[[j, i]
3 do Interschimba(A[i, j], A[j, i]) 3 A[j, i] ← temp
5/ 24
Exemplu de execuţie a algoritmului de transpunere a unei matrice pe o

plasă de unităţi de procesare
Figura 1 : Exemplu de execuţie a algoritmului de transpunere a unei matrice 4x4 pe o plasă de unităţi de procesare
6/ 24
Algoritmul recursiv - pseudocod
• Notat, ii:
• Premise:
• n = 2m .
• Datele de intrare sunt memorate ı̂n tabloul A.
• Matricea A este divizată ı̂n patru blocuri: stânga-sus, dreapta-sus, stânga-jos,
dreapta-jos.
• Datele finale vor fi memorate ı̂n tabloul A.
Transpunere Matrice Recursiv(A[0..n − 1, 0..n − 1])

1 / ∗ Interschimbarea blocurilor stânga-jos cu dreapta-sus ∗ /
2 for i = n2 to n − 1
3 do for j = 0 to n2 − 1
4 do Interschimba(A[i, j], A[i − n2 , j + n2 ], )
5 Transpunere Matrice Recursiv(A[0.. n2 − 1, 0.. n2 − 1])
6 Transpunere Matrice Recursiv(A[0.. n2 − 1, n2 ..n − 1])
7 Transpunere Matrice Recursiv(A[ n2 ..n − 1, 0.. n2 − 1])
8 Transpunere Matrice Recursiv(A[ n2 ..n − 1, n2 ..n − 1])
7/ 24
Exemplu de execuţie a algoritmului recursiv de transpunere a unei matrice
Figura 2 : Exemplu de execuţie a algoritmului recusrsiv de transpunere a unei matrice 8x8
8/ 24
Exemplu de execuţie a algoritmului recursiv de transpunere a unei matrice -

continuare
Figura 3 : Exemplu de execuţie a algoritmului recusrsiv de transpunere a unei matrice 8x8
9/ 24
Implementare pe hipercub
p
1 Hipercubul este divizat ı̂n 4 subcuburi cu 4 procesoare.
2 Sferturile de matrice (quadrant, ii) sunt mapate recursiv pe cele 4 subcuburi
astfel:
• cubul 00∗ cont, ine sfertul stânga-sus al matricei A;
• cubul 01∗ cont, ine sfertul dreapta-sus sfert al matricei A;
• cubul 10∗ cont, ine sfertul stânga-jos al matricei A;
• cubul 11∗ cont, ine sfertul dreapta-jos al matricei A.
3 Se interschimbă blocurile stânga-jos cu dreapta-sus.
4 Se repetă paşii 1-3 ı̂n fiecare subcub.
10/ 24
Algoritmul recursiv implementat pe hipercub - pseudocod

• Notat, ii:
• H este un hipercub cu m dimensiuni.
• i este indicele unităt, ii de procesare care executa algoritmul de transpunere a unei
matrice A.
• M este blocul care urmează a fi transmis de o unitate de procesare câtre partener.
• Premise:
• Init, ial, fiecare unitate de procesare pi det, ine un bloc Bi din matricea A, conform cu
regula de mapare, care urmează a fi transmis unei unităţi de procesare plasate ı̂ntr-un
nod al hipercubului H.
Transpunere Matrice pe Hipercub(H, m, i, Bi )
1 M ← Bi
2 for k ← m − 1 downto 0 step 2
3 do partener ← i xor 2k
4 if (i and 2k ) xor (i and 2k−1 ) = 1
5 then trimite M catre partener
6 else primeste M de la partener
7 partener ← i xor 2k−1
8 if (i and 2k ) xor (i and 2k−1 ) = 0
9 then trimite M catre partener
10 else primeste M de la partener
11 Bi ← M
2
12 Transpunere Matrice(Bi , np )
11/ 24
Exemplu de execuţie a algoritmului de transpunere a unei matrice pe

hipercub
Figura 4 : Exemplu de execuţie a algoritmului de transpunere pe hipercub a unei matrice 4x4
12/ 24
Complexitatea implementării pe hipercub algoritmului recursiv de

transpunere a unei matrice
Teorema (1)
Complexitatea timp a algoritmului recursiv de transpunere a unei matrice Anxn ,
2
implementat pe un hipercub cu p unităt, i de procesare este O( np log p). Eficient, a
algoritmului este O( log1 n ).
Demonstraţie.
n2
Divizarea recursivă se opreşte când dimensiunea blocului este p . Numărul de paşi de
interschimbare de blocuri este log4 p = log22 p ; fiecare pas de interschimbare se realizează pe două
dintre dimensiunile hipercubului (două muchii). Timpul de transfer al unui bloc de dimensiune
n2 n2 n2
p este O( p ). Transpunerea locală necesită O( p ) timp.
2
Rezultă că timpul total este O( np log p). Costul este O(n2 log p) - nu este optimal.
13/ 24
Inmulţirea de matrice pătractice - formularea problemei
• Date fiind matricele pătratice An×n = (ai,j )i,j=0,1...,n−1 şi Bn×n = (bi,j )i,j=0,1...,n−1 , se
cere să se calculeze matricea pătratică Cnxn = (ci,j )i,j=0,1...,n−1 , conform cu formula
n−1
ci,j = ∑ ai,k xbk,j , (∀)i, j = 0, 1 . . . , n − 1
k=0
.
• Timpul secvenţial Ts (n) = O(n3 ).
14/ 24
Algoritmul secvenţial standard - pseudocod
• Notat, ii:
• A[0..n − 1, 0..n − 1], B[0..n − 1, 0..n − 1] s, i C [0..n − 1, 0..n − 1] sunt tablouri
bidimensionale, de dimensiune nxn.
• Premise:
• Datele de intrare sunt memorate ı̂n tablourile A s, i B;
A[i, j] = ai,j , B[i, j] = bi,j , i, j = 0, 1, . . . , n − 1.
• Datele finale vor fi memorate ı̂n tabloul C .
Inmultire Matrice(A, B, n)
1 for i = 0 to n − 1
2 do for j = 0 to n − 1
3 do C [i, j] ← 0
4 for k = 0 to n − 1
5 do C [i, j] ← C [i, j] + A[i, k]xB[k, j]
6 return C
15/ 24
Algoritmul ı̂nmult, irii de blocuri- pseudocod
• Notat, ii:
• A[0..n − 1, 0..n − 1], B[0..n − 1, 0..n − 1] s, i C [0..n − 1, 0..n − 1] sunt tablouri
bidimensionale, de dimensiune nxn.
• Matricele A s, i B sunt divizate ı̂n blocuri Ai,k şi respectiv Bk,j , de dimensiuni qn × qn .
• INMULTIRE MATRICE(Ai,k , Bk,j , qn ) semnifică ı̂nmult, irea blocului Ai,k cu Bk,j şi
returnarea rezultatului Ai,k xBk,j .
• Premise:
• Datele de intrare sunt memorate ı̂n tablourile A s, i B.
• Datele finale vor fi memorate ı̂n tabloul C .
Inmultire Matrice Blocuri(A, B, n, q)

1 for i = 0 to q − 1
2 do for j = 0 to q − 1
3 do Ci,j ← 0
4 for k = 0 to q − 1
5 do Ci,j ← Ci,j + Inmultire Matrice(Ai,k , Bk,j , qn )
6 return C
16/ 24
Implementarea standard
• Arhitectura naturală este cea cu topologie de tip plasă, cu p = q 2 unităt, i de

procesare.
• Fiecare unitate de procesare pi,j dispune ı̂n memoria locală de blocul Ai,j s, i un bloc
Bi,j s, i calculează Ci,j .
• Pentru a calcula Ci,j , unitatea de procesare pi,j are nevoie de Ai,k s, i
Bk,j , k = 0, 1, . . . , q − 1.
• Pentru fiecare k, blocurile Ai,k s, i Bk,j sunt obt, inute printr-o difuzie tot, i-la-tot, i pe
linii s, i apoi pe coloane.
17/ 24
Implementarea lui Cannon
• Similar cu implementarea standard, dar cu consum mai mic de memorie.

• Fiecare bloc este procesat la momente diferite, ı̂n locuri diferite. Pentru aceasta
blocurile sunt deplasate ciclic.
√
• Sunt executaţi p − 1 paşi de ı̂nmulţiri şi adunari locale de blocuri, urmate de
deplasări ciclice la stânga (ı̂n A) şi ı̂n sus (ı̂n B).
• La final este executată o ı̂nmulţire şi o adunare locală de blocuri.
18/ 24
Algoritmul lui Cannon - pseudocod

• Notat, ii:
√ √
• P este o plasă formată din qxq = px p = p unităt, i de procesare.
• pi,j este unitatea de procesare care execută algoritmul de inmultire de blocuri.
• M1 este blocul care urmează a fi transmis de pi,j către pi,j 1 .
• M2 este blocul care urmează a fi transmis de pi,j către pi 1,j .
• M3 este blocul calculat de pi,j .
• ⊕ s, i semnifică adunarea şi scăderea modulo q.
• Premise: Init, ial, fiecare pi,j deţine ı̂n memoria locală blocurile Ai,j şi Bi,j .
• Rezultate: Fiecare unitate de procesare pi,j calculează blocul Ci,j .
Inmultire Matrice Cannon(Ai,j , Bi,j , n, q, pi,j )
1 M1 ← Ai,j ; M2 ← Bi,j
2 Aliniere Initiala(M1 , M2 , n, q, pi,j )
3 M3 ← 0 Aliniere Initiala(M1 , M2 , n, q, pi,j )
4 / ∗ q − 1 pas, i de ı̂nmulţiri şi adunari de blocuri /∗ 1 for k ← 1 to i
5 for k ← 0 to q − 2 2 do trimite M1 catre pi,j 1
6 do M3 = M3 + Inmultire Matrice(M1 , M2 , q) 3 primeste M1 de la pi,j⊕1
7 trimite M1 catre pi,j 1 4 for k ← 1 to j
8 primeste M1 de la pi,j⊕1 5 do trimite M2 catre pi 1,j
9 trimite M2 catre pi 1,j 6 primeste M2 de la pi⊕1,j
10 primeste M2 de la pi⊕1,j
11 Ci,j ← M3 + Inmultire Matrice(M1 , M2 , q)
12 return Ci,j
19/ 24
Exemplu de execuţie a algoritmului lui Cannon
Alinierea iniţială
Figura 5 : Exemplu de execuţie a algoritmului lui Cannon
20/ 24
A si B după alinierea iniţială Poziţiile blocurilor după prima deplasare
21/ 24
Poziţiile blocurilor după a II-a deplasare Poziţiile blocurilor dupa a III-a deplasare
22/ 24
Complexitatea algoritmului lui Cannon
Teorema (2)
3
Complexitatea timp a algoritmului lui Cannon este O( np ). Eficient, a algoritmului este
O(1).
Demonstraţie.
√
Numărul de transmisii s, i primiri de blocuri M1 efectuate de pi,j este i + q − 1 = i + p − 1.
√
Numărul de transmisii s, i primiri de blocuri M2 efectuate de pi,j este tot j + q − 1 = j + p − 1.
Se observă că pq−1,q−1 efectuează cele mai multe transmisii s, i primiri de blocuri,
√
q − 1 + q − 1 = 2(q − 1) = 2( p − 1). Rezultă pentru deplasările de blocuri o complexitate timp
2 √
de O( np p). Numărul ı̂nmult, irilor s, i adunărilor efectuate de o unitate de procesare este
√ 3
O(( √np )3 p)=O( np ); O(( √np )3 ) pentru fiecare ı̂nmult, ire s, i adunare de blocuri. Costul este
3
O(p)O( np ) = O(n3 ).
23/ 24
• Capitolul Calcul matricial are la bază cartea

V. Kumar, A. Grama A. Gupta & G Karypis, Introduction to Parallel Computing: Design
and Analysis of Algorithms, Addison Wesley, 2003
and Analysis of Algorithms, Benjamin-Cummings, 1994
24/ 24
Cuprins Introducere Sistem de ecuaţii liniare Comentarii bibliografice

Sisteme de ecuaţii liniare
Mitică Craus
1/ 12
Cuprins
Introducere
Sistem de ecuaţii liniare
Descriere
Pseudocod
Implementare
Complexitatea
2/ 12
Introducere
• Sistemele de ecut, ii liniare pot fi rezolvate prin tehnici de calcul paralel datorită
multiplelor operat, ii independente una de alta.
• Vom studia ı̂n această lecţie metoda lui Gauss de rezolvare a sistemelor de ecuat, ii
liniare.
3/ 12
Rezolvarea sistemelor de ecuaţii liniare prin metoda lui Gauss
• Se consideră un sistem format din n ecuat, ii liniare cu n necunoscute:
a0,0 x0 + a0,1 x1 + · · · + a0,n−1 xn−1 = b0

a1,0 x0 + a1,1 x1 + · · · + a1,n−1 xn−1 = b1
.........
an−1,0 x0 + an−1,1 x1 + · · · + an−1,n−1 xn−1 = bn−1
• Metoda lui Gauss constă ı̂n reducerea sistemului la forma triunghiulară

0 0
x0 + a0,1 x1 + · · · + a0,n−1 xn−1 = b00
0
x1 + · · · + a1,n−1 xn−1 = b10
.........
0
xn−1 = bn−1
• şi rezolvarea ecuaţiilor ı̂n ordine inversă ( ı̂ntâi ultima, apoi penultima şi la sfârşit
prima ecuaţie din sistem)
4/ 12
Algoritmul eliminării Gaussiene - varianta secvenţială

• Notat, ii:
• B[0..n − 1] este un tablou unidimensional, de dimensiune n.
• Premise:
• Coeficient, ii iniţiali ai,j , i, j = 0, 1, . . . , n − 1 sunt memorat, i ı̂n tabloul A.
0 , i, j = 0, 1, . . . , n − 1 vor fi memorati tot ı̂n tabloul A.
• Coeficient, ii ai,j ,
• Tabloul B va memora coeficient, ii iniţiali bi , i = 0, 1, . . . , n − 1 şi soluţia sistemului.
Eliminare Gaussiana(A, B, n)
1 for k ← 0 to n − 1 / ∗ bucla exterioară ∗ /
2 do
3 for j ← k + 1 to n − 1
A[k,j]
4 do A[k, j] ← A[k,k] / ∗ pasul de impărt, ire cu A[k, k] ∗ /
B[k]
5 B[k] ← A[k,k]
6 A[k, k] ← 1
7 for i ← k + 1 to n − 1
8 do for j ← k + 1 to n − 1
9 do A[i, j] ← A[i, j] − A[i, k]xA[k, j]/ ∗ pasul de eliminare ∗ /
10 B[i] ← B[i] − A[i, k]xB[k]
11 A[i, k] ← 0
5/ 12
Algoritmul eliminării Gaussiene - varianta paralelă

• Notat, ii:
• B[0..n − 1] este un tablou unidimensional, de dimensiune n.
• Premise:
• Coeficient, ii iniţiali ai,j , i, j = 0, 1, . . . , n − 1 sunt memorat, i ı̂n tabloul A.
0 , i, j = 0, 1, . . . , n − 1 vor fi memorati tot ı̂n tabloul A.
• Coeficient, ii ai,j ,
• Tabloul B va memora coeficient, ii iniţiali bi , i = 0, 1, . . . , n − 1 şi soluţia sistemului.
Eliminare Gaussiana Paralela(A, B, n)

1 for k ← 0 to n − 1 / ∗ bucla exterioară ∗ /
2 do
3 for j ← k + 1 to n − 1
A[k,j]
4 do A[k, j] ← A[k,k] / ∗ pasul de impărt, ire cu A[k, k] ∗ /
B[k]
5 B[k] ← A[k,k]
6 A[k, k] ← 1
7 for i ← k + 1 to n − 1
8 do in parallel
9 for j ← k + 1 to n − 1
10 do A[i, j] ← A[i, j] − A[i, k]xA[k, j]/ ∗ pasul de eliminare ∗ /
11 B[i] ← B[i] − A[i, k]xB[k]
12 A[i, k] ← 0
6/ 12
Implementare pe un sistem cu n unităţi de procesare

• Se consideră un sistem format din n unităţi de procesare, p0 , p1 , . . . , pn−1 .
• Fiecare unitate de procesare pi , i ∈ {0, 1, . . . , n − 1}, dispune, ı̂n memoria locală, de
coeficient, ii ecuatiei a-i-a (linia i a tabloului A plus B[i]).
• În prima fază, unitatea de procesare p0 execută pasul de imparţirea cu A[0, 0]:
A[0,j]
A[0, j] = A[0,0] , j = 0, . . . , n − 1. Apoi trimite A[0, j], j = 0, 1, . . . , n − 1 celorlalte unităţi
de procesare, după care, fiecare unitate de procesare pi , i = 1 . . . , n − 1 execută pasul
de eliminare: A[i, j] = A[i, j] − A[i, 0]xA[0, j], i, j = 1, . . . , n − 1 şi
A[i, 0] = 0, i = 1 . . . , n − 1.
• În faza a doua, p1 preia rolul lui p0 s, i execută imparţirea cu A[1, 1]:
A[1,j]
A[1, j] = A[1,1] , j = 1 . . . , n − 1. Apoi trimite A[1, j], j = 1 . . . , n − 1 unităţilor de
procesare p2 , . . . , pn−1 , după care, fiecare unitate de procesare pi , i = 2 . . . , n − 1
execută pasul de eliminare: A[i, j] = A[i, j] − A[i, 1]xA[1, j], i, j = 2, . . . , n − 1 şi
A[i, 1] = 0, i = 2, . . . , n − 1.
A[k,j]
• În faza k, pk execută imparţirea cu A[k, k]: A[k, j] =
A[k,k]
, j = k . . . , n − 1. Apoi
trimite A[k, j], j = k . . . , n − 1 unităţilor de procesare pk+1 , . . . , pn−1 , după care,
fiecare unitate de procesare pi , i = k + 1 . . . , n − 1 execută pasul de eliminare:
A[i, j] = A[i, j] − A[i, k]xA[k, j], i, j = k + 1, . . . , n − 1 şi A[i, k] = 0, i = k + 1, . . . , n − 1.
7/ 12
Exemplu de implementare pe un sistem cu 8 unităţi de procesare
Figura 1 : Pasul de imparţire cu A[3, 3]:

A[3,j]
A[3, j] = A[3,3] , j = 4, . . . 7, şi A[3, 3] = 1
8/ 12
Exemplu de implementare pe un sistem cu 8 unităţi de procesare -

continuare
Figura 2 : Broadcast linia 3: A[3, j], j = 4, . . . , 7
9/ 12
Exemplu de implementare pe un sistem cu 8 unităţi de procesare -

continuare
Figura 3 : Pasul de eliminare:

A[i, j] = A[i, j] − A[i, 3]xA[3, j], i, j = 4, . . . , 7, şi
A[i, 3] = 0, i = 4, . . . , 7
10/ 12
Complexitatea timp a implementării algoritmului eliminării Gaussiene pe un

lanţ de n unităţi de procesare
Teorema (1)
Complexitatea timp a implementării algoritmului eliminării Gaussiene pe un lanţ de n
unităţi de procesare este Θ(n2 ).
Demonstraţie.
Timpul consumat ı̂n iteraţia k este Θ(n − k − 1). Timpul total este ∑k=n−1
k=0 Θ(n − k − 1)
=Θ(n − 1) + Θ(n − 1) + · · · + Θ(0) = Θ(n2 ).
11/ 12
• Capitolul Sisteme de ecuaţii liniare are la bază cartea

and Analysis of Algorithms, Benjamin-Cummings, 1994
12/ 12
Cuprins Introducere Parcurgerea euleriană a unui arbore Colorarea arborilor

Algoritmi paraleli pe arbori
Mitică Craus
1/ 18
Cuprins
Introducere
Parcurgerea euleriană a unui arbore
Descriere
Transformarea unui arbore neorientat ı̂n arbore cu rădăcină
Numerotarea vârfurilor ı̂n preordine şi postordine
Calculul relaţiilor ”este un descendent al lui ” şi ”este un strămoş al lui ”
Calculul minimului (maximului) valorilor din subarborele cu rădăcina ı̂ntr-un nod
oarecare:
Colorarea arborilor
Colorarea arcelor
Colorarea vârfurilor
2/ 18
Introducere
• Arborii sunt obiectul unor calcule care deseori constituie taskuri ı̂n probleme de
grafuri.
• Sunt frecvente cazurile ı̂n care algoritmi polilogaritmici eficienţi sunt obţinuţi pe
baza unor calcule pe arbori.
• Problemele relative la arbori, abordate ı̂n acestă lecţie sunt:
1. Parcurgerea unui arbore ı̂n sens eulerian:
2. Aplicaţii ale parcurgerii euleriene:
2.1 Transformarea unui arbore neorientat ı̂n arbore cu rădăcină;
2.2 Numerotarea preordine si postordine a vârfurilor unui arbore;
2.3 Calculul relaţiilor ”este un descendent al lui ” şi ”este un strămoş al lui ”;
2.4 Calculul minimului (maximului) valorilor din subarborele cu rădăcina ı̂ntr-un nod oarecare.
3. Colorarea arborilor:
3.1 Colorarea arcelor;
3.2 Colorarea vârfurilor.
3/ 18
Parcurgerea euleriană a unui arbore - descriere
• Fie T = (V , E ) un arbore cu V = {1, 2, ..., n} şi E ⊆ V × V , |E | = n − 1 Algoritmul

orientat PRAM cel mai cunoscut pentru parcurgerea euleriană a unui arbore T este
cel al lui Tarjan şi Vishkin.
• Un arbore nu este graf eulerian; din acest motiv, este transformat, prin orientarea
muchiilor, ı̂nlocuind fiecare muchie {i, j} cu două arce (i, j) şi (j, i).
• Graful rezultat, T 0 = (V , E 0 ), este eulerian deoarece pentru orice vârf v gradul
interior este egal cu cel exterior.
• Fie Eiout = { (i, i0 ); (i, i1 ); .. (i, id−1 ) } mulţimea arcelor ce ies dintr-un vârf i. Fără a
restrânge generalitatea se poate presupune că i0 < i1 < · · · < id−1 . Altfel, se sortează
Eiout conform cu ordinea crescătoare a valorilor ij , j = 0, 1, . . . , d − 1.
• Se defineşte succesorul unui arc astfel:
succ((i, ik )) = (i, ik⊕1 ), (∀)k ∈ {0, 1, . . . , d − 1} unde ⊕ este adunarea modulo d.
• Mulţimea Eiout ı̂mpreună cu funcţia succ definesc o listă circulară asignată vârfului i.
Pentru simplitate, şi mulţimea arcelor ce ies din vârful i şi lista circulară se notează
tot cu Eiout .
4/ 18
Parcurgerea euleriană a unui arbore - pseudocod

• Notat, ii:
• A[1..2(n − 1)] este un tablou unidimensional, de dimensiune 2(n − 1).
• Tour Next[1..2(n − 1)] este un tablou unidimensional, de dimensiune 2(n − 1).
• Premise:
• Arborele este dat prin listele Eiout , i = 1, 2 . . . , n memorate ı̂ntr-un tablou A ı̂n ordinea
E1out , E2out , . . . , Enout .
• Elementul A[k] al tabloului A conţine perechea h(i, j), index(succ(i, j))i, unde
index(succ(i, j)) reprezintă indicele elementului ce conţine succ(i, j).
• A = ( h(1, i10 ), index(succ(1, i10 ))i; . . . ; h(1, i1d1 −1 ), index(succ(1, i1d1 −1 ))i;
h(2, i20 ), index(succ(2, i20 ))i; . . . ; h(2, i2d2 −1 ), index(succ(2, i2d2 −1 ))i;
. . . h(n, in 0 ), index(succ(n, in0 ))i; . . . ; h(n, indn −1 ), index(succ(n, indn −1 ))i;
• Rezultate:
• Lista euleriană LE va fi memorată ı̂n tabloul A.
• Elementul A[k] va conţine perechea h(i, j), Tour Next[(k]i
Parcurgere Euleriana Arbore(A, n)

1 for all k ∈ {1, 2, . . . , 2(n − 1)}
2 do in parallel
3 tour next[k] ← index(succ(j, i))/ ∗ k = index(i, j) ∗ /
4 for all k ∈ {1, 2, . . . , 2(n − 1)}
5 do in parallel
6 A[k] ← h(i, j), Tour Next[k]i
5/ 18
Parcurgerea euleriană a unui arbore - complexitatea
• Problema cheie este calcularea, pentru arcul (i, j), a valorii index(succ(j,i)).
• Dacă se copie tabloul A ı̂ntr-un tablou B şi apoi se sortează tabloul B ı̂n ordinea
crescătoare a valorilor lui j, atunci B[k] va conţine h(j, i), index(succ(j, i))i.
• Aceasta presupune o fază de preprocesare de complexitate timp ≥ O(log n).
• În aceste condiţii, algoritmulPARCURGERE EULERIANA ARBORE(A, n) are
complexitate timp O(1), pe o maşină PRAM cu O(n) unităţi de procesare.
6/ 18
Exemplu de parcurgere euleriană
Figura 1 : Exemplu de parcurgere euleriană pentru un arbore T , cu 7 vârfuri
7/ 18
Parcurgerea euleriană a unui arbore - arce directe şi indirecte
• Se numerotează elementele listei LE prin intermediul procedurii CALCUL RANGURI.

• Rangurile rezultate vor fi modificate astfel ı̂ncât să reprezinte distanţa unui arc faţă
de primul element al listei LE .
• Dintre doua arce (i, j) şi (j, i), cel de rang mai mic este marcat ca fiind arc direct iar
celalt invers.
• Sublistele rezultate vor fi numite
• LED = lista arcelor directe, respectiv
• LEI = lista arcelor inverse.
8/ 18
Exemplu de arce directe şi indirecte
Figura 2 : Exemplu de arce directe şi indirecte pentru arborele T
9/ 18
Transformarea unui arbore neorientat ı̂n arbore cu rădăcină
• Fie (r , j) primul arc din tabloul A. Arborele neorientat T va fi transformat ı̂n arbore
cu rădăcina r . Pentru fiecare vârf i 6= r se determină părinte(i) ı̂n modul următor:
1. Se numerotează elementele listei LE prin intermediul procedurii CALCUL RANGURI.
2. Rangurile rezultate vor fi modificate astfel incât să reprezinte distanţa unui arc faţă de
primul element al listei LE . Dintre două arce (i, j) şi (j, i) cel de rang mai mic este
marcat ca fiind arc direct iar cealalt invers.
3. Sublistele rezultate vor fi numite LED = lista arcelor directe, respectiv LEI = lista
arcelor inverse.
4. Pentru fiecare arc direct (i, j), părinte[j] ← i.
• Pentru simplificarea limbajului vom nota index(succ(i, j)) cu index(succ(A[k]), dacă
A[k] = h(i, j), index(succ(i, j))i.
10/ 18
Exemplu de transformare a unui arbore neorientat ı̂n arbore cu rădăcină
Figura 3 : Exemplu de transformare a arborelui neorientat T ı̂n arbore cu rădăcină
11/ 18
Numerotarea vârfurilor ı̂n preordine şi postordine
• Numerotarea vârfurilor ı̂n preordine (postordine) se poate face pornind de la sublista

arcelor directe (inverse): LED (LEI ).
• Aplicând procedura de calculare a rangurilor elementelor listei LED (LEI ), se obţine
numerotarea preordine (postordine) prin atribuirea
pre ordine[j] ← rang [i, j] + 1 (post ordine[j] ← rang [(j, i)]).
12/ 18
Exemplu de numerotare a vârfurilor ı̂n preordine şi postordine
Figura 4 : Exemplu de numerotare a vârfurilor arborelui T ı̂n preordine şi postordine
13/ 18
Calculul relaţiilor ”este un descendent al lui ” şi ”este un strămoş al lui ”
• Vârful j este un descendent al lui i dacă şi numai dacă

pre ordine[i] ≤ pre ordine[j] < pre ordine[i] + nd[i].
• Calculul valorilor nd[i] (numărul descendenţilor lui i), i = 1, ..., n, se poate face astfel:
for each i : 1 ≤ i ≤ n
do in parallel
nd[i] ← 12 {rang [(i, părinte[i])] − rang [(părinte[i], i)]} + 1
• Analog, se poate calcula relaţia ”este un strămoş al lui ”.
14/ 18
Exemplu de calculare a numărului de descenţi

d[4] = 21 {rang [(4, parinte[4])] − rang [(parinte[4], 4)]} + 1 = 12 {rang [(4, 1)] − rang [(1, 4)]} + 1 =
1
2 (12 − 1) + 1 = 6
Figura 5 : Exemplu de calculare a numărului de descenţi pentru vârful 4 al arborelui T

15/ 18
Calculul minimului (maximului) valorilor din subarborele cu rădăcina ı̂ntr-un

nod oarecare:
• Fie V un vector de dimensiune n ce conţine valorile asociate vârfurilor unui arbore

considerate ı̂n preordine.
• Valorile asociate descendenţilor lui i se află ı̂n segmentul
S = V [pre ordine[i]..pre ordine[i] + nd[i] − 1].
• Aplicând procedura SUM(S, min) se obţine valoarea minimă a valorilor din
subarborele cu rădăcina i.
16/ 18
Colorarea arcelor
• Culorile utilizate se noteazc̆u a 0,1,...,∆ − 1. Algoritmul se desfăşoară astfel:

1. Se transformă arborele T = (V , E ) ı̂ntr-un arbore cu rădăcină
2. Pentru fiecare vârf v se determină părintele s, i fii.
3. Pentru fiecare vârf v se colorează arcele (v , fiui (v )) cu culoarea i ≥ 1.
4. Pentru fiecare vârf v se calculează valoarea f (v ) = suma modulo ∆ a etichetelor
(culorilor arcelor) drumului de la rădăcină la v ; valoarea f (v ), se atribuie arcului
(părinte(v ), v ).
• Etichetarea obţinută este o colorare validă deoarece pentru orice x ∈ {0, 1, ..., ∆ − 1}
valorile x, x ⊕ 1, ..., x ⊕ (∆ − 1) sunt diferite. (⊕ = adunarea modulo ∆).
• Colorarea este optimă deoarece se utilizează cel mult ∆ culori.
• Paşii 1–4 necesită O(log n) timp paralel şi n procesoare (se utilizează primitive pe
arbori).
• Funcţia f se poate calcula prin tehnica dublării (scurtcircuitării) pe listele de
adiacenţă determinate de fii.
• Rezultă pentru ı̂ntregul algoritm T ∈ O(log n), iar p ∈ O(n).
17/ 18
Colorarea vârfurilor
• Prin tehnica dublării (scurtcircuitării) pe listele de adiacenţă determinate de fii, se

poate determina paritatea distanţelor vârfurilor faţă de rădăcină.
• Vârfurile situate la distanţă pară se colorează cu 0 şi celelalte cu 1.
• Evident, T ∈ O(log n) şi p ∈ O(n).
18/ 18
Cuprins Introducere Algoritmii HCS şi SV Algoritmul HCS modificat Implementare VLSI

Componente conexe
Mitică Craus
1/ 19
Cuprins
Introducere
Algoritmii HCS şi SV
Algoritmul HCS modificat
Descriere
Pseudocod
Implementare VLSI
Descriere
Pseudocod
Complexitatea
2/ 19
Introducere
• Determinarea componentelor conexe este o problemă importantă, cu numeroase

aplicaţii ı̂n procesarea imaginilor, rezolvarea unor probleme de optimizare
combinatorie pe grafuri.
• Problema componentelor conexe poate fi definită astfel:
Dată fiind matricea de adiacenţă A a unui graf G = (V , E ), unde V={1,2,...,n} şi
E ⊂ {{i, j}/(i, j) ∈ V × V }, |E | = m),
să se determine un vector C de lungime n, astfel ı̂ncât C [i] = C [j] = k, dacă i este ı̂n
aceeaşi componentă cu j, adică există un drum de la i la j ı̂n G .
• În esenţă, există doi algoritmi paraleli polilogaritmici: Hirschberg & Chandra &
Sarwate 1979 (HCS) şi Shiloach & Vishkin, 1982 (SV).
• Implementări ale algoritmului HCS au fost date de Chin, 1982; Vishkin, 1982;
Wyllie, 1979, iar ale algoritmului SV de Awerbuch şi Shiloach, 1983.
3/ 19
Algoritmii HCS şi SV

• Concepte utilizate:
• arbore cu rădăcină (rooted tree): digraf cu următoarele proprietăţi:
a. Graful neorientat care se obţine prin eliminarea orientării arcelor este un arbore.
b. Există un vârf r , astfel ı̂ncât, pentru orice alt vârf i, există un drum de la i la r . Vârful r este
numit rădăcină arborelui.
• stea cu rădăcină (rooted star): arbore cu rădăcină ı̂n care drumurile de la vârfuri la
rădăcină au lungimea 1.
• Următoarele sunt comune ambilor algoritmi:
• În fiecare pas, fiecare vârf i dispune de un pointer P[i] prin care indică un alt vârf j
(P[i] = j) sau nici unul (P[i] = 0).
/
• Mulţimea arcelor (i, P[i]) formează un digraf auxiliar, numit graful pointer.
• Iniţial, pentru fiecare vârf i, P[i] = 0/ (nu indică nici un alt vârf) şi, astfel, graful
pointer constă doar din vârfuri izolate.
• Graful pointer păstrează schimbările ce intervin ı̂n cursul algoritmului.
• Ambii algoritmi actualizează graful pointer de aşa manieră ı̂ncı̂t ı̂n fiecare pas acesta
conţine numai arbori cu rădăcină.
• Mulţimea vârfurilor unui arbore cu rădăcină va fi numită supervârf. Totuşi, uneori,
supervârful va fi ı̂nţeles ca arborele ı̂n ansamblu.
• Pe măsură ce execuţia algoritmului avansează, numărul supervârfurilor (arborilor)
descreşte.
• Aceasta se realizează prin operaţii de agăţare (conectare, hooking) executate simultan.
4/ 19
Algoritmii HCS şi SV - continuare
• O operaţie de agăţare constă ı̂n conectarea unei rădăcini i la un vârf j al unui alt
arbore. P[i] devine j şi astfel i este agaţat de vârful j. În cazul algoritmului HCS j
este tot radăcină.
• Fiecare conectare este realizată numai după ce algoritmul identifică o muchie ce
leagă un vârf din supervârful lui i cu un vârf al supervârfului lui j.
• O asemenea muchie se numeşte muchie de bază. Colecţia muchiilor de bază
formează o pădure de arbori parţiali (spanning forest) a grafului de intrare.
• Arborii asociaţi unui supervârf sunt obiectul unei operaţii de scurtcircuitare realizate
aplicând tehnica dublării:
for each i : i ∈ S {supervârf}
do in parallel if P[P[i]] 6= 0/ then P[i] ← P[P[i]]
• Operaţia de scurtcircuitare ı̂njumătăţeşte adâncimea arborelui.
• Scurtcircuitarea nu introduce circuite ı̂n graful pointer.
• Agăţările sunt calculate astfel ı̂ncât să nu introducă circuite ı̂n graful pointer.
5/ 19
Algoritmii HCS şi SV - continuare
• Fiecare muchie {k, l} din graful iniţial induce o muchie ce conectează supervârful ce
conţine k la supervı̂rful lui l.
• Graful format din mulţimea supervârfurilor şi mulţimea muchiilor induse se numeşte
graful supervârfurilor.
• Fiecare din cei doi algoritmi sfârşesc cu stele cu rădăcină ı̂n graful pointer, existând o
corespondenţă biunivocă ı̂ntre mulţimea stelelor şi mulţimea componentelor conexe.
6/ 19
Algoritmul HCS modificat

• Algoritmul HCS execută O(log n) iteraţii. La ı̂nceputul unei iteraţii, fiecare supervârf
este reprezentat de o stea ı̂n graful pointer.
• Fiecare rădăcină este agaţată de o rădăcină minimală care ı̂i este adiacentă ı̂n graful
supervârfurilor.
• Stelele astfel agăţate formează un arbore ı̂n care rădăcina uneia din ele devine
rădăcina noului arbore.
• Iteraţia sfârşeşte cu O(log n) scurtcircuitări.
• Pentru a evita circuitele de lungime 2 care pot apare ı̂n graful pointer, se poate
proceda ı̂n felul următor:
• Dacă două rădăcini se agaţă reciproc, este eliminat arcul obţinut prin agăţarea
rădăcinii cu numărul de ordine mai mic de rădacina cu numărul de ordine mai mare.
• Aceasta permite evitarea utilizarii unui vector auxiliar pentru memorarea tabloului P
inainte de scurtcircuitare.
• Dacă graful pointer nu se modifică pe parcursul unei iteraţii, atunci el nu se va mai
modifica nici ı̂n iteraţiile urmatoare, deci au fost obţinute componentele conexe.
• Pe baza acestei observaţii se poate reduce numărul iteraţiilor.
• Se obţine astfel o dependenţă de configuraţia de intrare a comportării algoritmului
deci o manifestare inteligentă a acestuia.
• Pentru configuraţia cea mai defavorabilă vor fi necesare tot log n iteraţii, dar pentru
configuraţia medie numărul acestora va fi mult mai mic.
7/ 19
Algoritm pentru componente conexe - pseudocod

Componente Conexe(G )
1 for eachi : 1 ≤ i ≤ n
2 do in parallel SV [i] ← i
3 repeat
4 ∗ Pasul 1: Execuţia operaţiilor de agăţare ∗ /
5 for each i : 1 ≤ i ≤ n
Notat, ii: 6 do in parallel if {SV [j] / A[i, j] = 1, SV [j] 6= SV [i]} 6= 0/
• A[1..n; 1..n]] este 7 then P[i] ← min {SV [j] / A[i, j] = 1, SV [j] 6= SV [i]}
1≤j≤n
un tablou pătratic
8 else P[i] ← SV [i]
de dimensiune
nxn.
10 do in parallel if {P[j] / SV [j] = i, P[j] 6= i} 6= 0/
• SV [1..n], P[1..n] 11 then P[i] ← min {P[j] / SV [j] = i, P[j] 6= i}
sunt tablouri de 1≤j≤n
dimensiune n. 12 else P[i] ← SV [i]
13 / ∗ Pasul 2: Eliminarea circuitelor de lungime 2 şi Execuţia a log n operaţii de scurtcircuitare ∗ /
Premise: 14 for each i : 1 ≤ i ≤ n
• Graful G este dat 15 do in parallel if P[P[i]] = i and i < P[i]
prin matricea de 16 then P[i] ← i
adiacenţă 17 for k ← 1 to log n
memorată ı̂n 18 do for each i : 1 ≤ i ≤ n
tabloul A. 19 do in parallel P[i] ← P[P[i]]
20 / ∗ Pasul 3: Actualizarea mulţimii supervârfurilor ∗ /
• P conţine graful 21 for each i : 1 ≤ i ≤ n
pointer iar SV 22 do in parallel if SV [i] = P[i]
memorează graful 23 then SV [i] ← 0
supervârfurilor. 24 else SV [i] ← 1
25 Stare Graf Pointer ← max{SV [i]/ i = 1, n}
27 do in parallel SV [i] ← P[i]
28 until Stare Graf Pointer = 0
8/ 19
Figura 1 : Exemplu de execuţie pentru un graf cu 9 vârfuri
9/ 19
Corectitudinea
Lema (1)
Prin execuţia de operaţii de agăţare nu se produc circuite de lungime l > 2 ı̂n graful
pointer.
Demonstraţie.
Presupunem că ı̂n urma unei agăţări, ı̂n graful pointer se produce un circuit C de lungime l > 2.
Fie acesta (i1 , i2 , . . . , il , i1 ). Pentru secvenţa (ij , ij+1 , ij+2 ) ⊂ C rezultă ij > ij+2 (altfel ij+1 ar fi fost
agăţat de ij şi nu de ij+2 ).
In consecinţă:
a) l = 2k : i1 > i3 > . . . i2k−1 > i1 ; absurd.
b) l = 2k + 1 : i1 > i3 > · · · > i2k−1 > i2k+1 > i2 > i4 > · · · > i2k > i1 absurd.
Deci, presupunerea existenţei unui circuit C de lungime l > 2 este falsă.
Lema (2)
Un număr de log n scurtcircuitări sunt suficiente pentru a reduce un arbore cu rădăcină la
o stea cu rădăcină.
Demonstraţie.
Operaţiile de scurtcircuitare injumătăţesc adâncimea unui arbore cu rădăcină. Deci dupa log n
scutcircuitări adâncimea unui arbore devine 1.
10/ 19
Corectitudinea - continuare
Lema (3)
Înaintea execuţiei operaţiilor de scurtcircuitare ı̂n algoritmul COMPONENTE CONEXE,
graful pointer este o pădure de arbori cu rădăcină.
Demonstraţie.
Procedăm prin inducţie după numărul de ordine i al iteraţiei (paşii 1-3). La ı̂nceputul iteraţiei 1
graful pointer conţine doar vârfuri izolate. Astfel, fiecare vârf are gradul exterior 0. Operaţia de
agătare a unui vârf produce creşterea cu o unitate a gradului exterior al acestuia. Prin urmare
gradele exterioare ale vârfurilor devin 1. Din Lema 1 rezultă ca prin agăţări nu se produc circuite
de lungime l > 2. La inceputul pasului 2 se elimină circuitele de lungime 2. Deci graful pointer
devine o pădure de arbori cu rădăcină. Cele log n scurtcircuitări efectuate ı̂n iteraţia 1, reduc
graful pointer la o mulţime de stele cu rădăcină (Lema 2). Deci, la inceputul iteraţiei, 2 graful
pointer conţine doar stele cu rădacină.
Presupunem acum că, la ı̂nceputul iteraţiei i, graful pointer conţine doar stele cu rădacină.
Astfel, fiecare vârf are gradul exterior 1. Operaţia de agătare a unei rădăcini nu produce
schimbarea gradului exterior al acesteia. Prin urmare gradele exterioare ale vârfurilor rămân 1.
Din Lema 1 rezultă ca prin agăţări nu se produc circuite de lungime l > 2. La inceputul pasului 2
al iteraţiei i se elimină circuitele de lungime 2. În consecintţă, graful pointer devine o pădure de
arbori cu radăcină. Ce log n scurtcircuitări efectuate ı̂n iteraţia i, reduc graful pointer la o
mulţime de stele cu rădăcină (Lema 2). Deci, la inceputul iteraţie i + 1 ,graful pointer conţine
doar stele cu rădacină.
11/ 19
Corectitudinea - continuare
Teorema (1)
Algoritmul COMPONENTE CONEXE calculează componentele conexe ale unui graf G .
Demonstraţie.
Conceptual, intrarea ı̂ntr-o iteraţie următoare a algoritmului poate fi gândită ca fiind graful
supervârfurilor rezultate din iteraţia curentă. Într-un astfel de graf există un arc ı̂ntre
supervârfurile i şi j dacă există două vârfuri k şi l, astfel ı̂ncât SV [k] = i şi SV [l] = j şi A[k, l] = 1.
O iteraţie (formată din paşii 1-3 ai algoritmului COMPONENTE CONEXE) va reduce, de cel
puţin două ori, numărul de supervârfuri aflate ı̂n aceeaşi componetă conexă. Aceasta ı̂nseamnă
că după un număr finit de paşi graful supervârfurilor nu va mai suferi moficări, supervârfurile
devenind identice cu componentele conexe. Numărul maxim de iteraţii pentru a aduna vârfurile
unei componente conexe ı̂ntr-un singur supervârf este evident log n
12/ 19
Complexitatea
Teorema (2)
Implementat pe o maşină PRAM-CREW, algoritmul COMPONENTE CONEXE
2
utilizează O(n2 / logn) unităţi
de procesare şi necesită O(log n) timp. Eficienţa
n+m
algoritmului este O n2 log n
.
Demonstraţie.
Evident, O(n2 ) unităţi de procesare sunt suficiente pentru execuţia tuturor paşilor paraleli ai
algoritmului COMPONENTE CONEXE. Deoarece cele O(n2 ) unităţi de procesare sunt necesare
ı̂n pasul 1, pentru calcularea celor n valori minime, dacă se foloseşte tehnica prefixelor pentru a
rezolva problema, numărul procesoarelor poate fi redus la O(n2 / log n). Algoritmul execută cel
mult log n iteraţii şi necesită O(log n) timp paralel ı̂n fiecare iteraţie. Deci, timpul paralel necesar
2
execuţiei algoritmului COMPONENTE CONEXE esteO(log n).
Ts O(n+m) n+m
Eficienţa E = p·T (p) = O(n2 / log n)·O(log2 n)
=O n2 log n
unde Ts este timpul secvenţial şi T (p) =
timpul paralel corespunzător execuţiei algoritmului COMPONENTE CONEXE pe o maşină
PRAM-CREW cu p unităţi de procesare.
13/ 19
Implementare VLSI - Descriere

• O implementare VLSI optimală a algoritmului COMPONENTE CONEXE se poate
obţine utilizând o arhitectură de tip plase locale conectate prin arbori (tree connected
local meshes) [D. Carison, A Fast Area-Optimal Algoritm for the Conected
Components Problem, ICCD´ 87, New York, oct. 5-8, 1987, pages 12-15] .
• Algoritmul COMPONENTE CONEXE VLSI presupune că graful este dat prin
matricea de adiacenţă.
• Procesarea se desfăşoară ı̂n etape, caracterizate prin reuniuni de submulţimi de
vârfuri situate ı̂n aceeaşi componentă conexă.
• O submulţime corespunde unui supervârf ı̂n algoritmul COMPONENTE CONEXE.
• În fiecare etapă numărul supervârfurilor descreşte de cel puţin două ori.
• Operaţiile de bază efectuate de algoritm sunt următoarele:
O1 Pentru fiecare linie (coloană), trimite un item de date tuturor procesoarelor din linia
(coloana) respectivă.
O2 Pentru fiecare linie (coloana), calculează minumul valorilor reţinute ı̂n procesoarele din
linia (coloana) respectivă;
• Eficienţa este obţinută prin execuţia operaţiilor O1 şi O2 ı̂n paralel pe mai multe linii
şi, respectiv, coloane.
• Arhitectura plasa de arbori (mesh of trees) poate face aceasta datorită existenţei ı̂n
componenţa sa a unui arbore pentru fiecare linie (coloana).
14/ 19
Descriere - continuare
• Arhitectura plase locale conectate prin arbori nu conţine un arbore separat pentru
fiecare linie (coloană), dar poate partaja un arbore pentru mai multe linii (coloane)
astfel ı̂ncât operaţiile O1 şi O2 să poată fi executate ı̂n timp logaritmic.
• Ideea de bază este de a permite pomparea valorilor din procesoarele liniilor
(coloanelor) ı̂n arborii cu frunzele = procesoarele (patratele albe) de interfaţare ale
plaselor locale (local meshes).
• De exemplu, pentru a calcula valorile minime pentru fiecare linie de procesoare din
reţeaua globală, se lucrează ı̂n paralel pe fiecare plasă locală.
• O linie de plase locale conţine un bloc format din blog nc linii globale, şi dispune de
un arbore conectat la plase prin procesoarele de interfaţare.
15/ 19
Descriere - continuare
• Întı̂i se calculează valorile minime ce corespund porţiunilor din cele blog nc linii
globale, conţinute ı̂n plasele locale.
• Apoi cele dn/blog nce minime locale dintr-o linie globală sunt combinate prin
intermediul arborelui corespunzător plaselor locale care conţin linia respectivă.
• Prin pomparea ı̂n arborele asociat liniei de plase locale, mulţimi succesive de minime
locale pot fi combinate pentru obţinerea ı̂n secvenţă a valorilor minime
corespunzătoare liniilor reţelei globale, ı̂n timp paralel de complexitate O(log n).
• Aceasta se poate face deoarece plasele locale au dimensiuni blog nc × blog nc iar
arborele corespunzător unei linii de plaselor locale are adâncime blog nc.
• Minimul global al unei linii poate fi transmis ı̂napoi procesoarelor din plasele locale ı̂n
timp O(log n).
16/ 19
Exemplu de implementare VLSI pentriu algoritmul

COMPONENTE CONEXE
Figura 2 : Exemplu pentru algoritmul COMPONENTE CONEXE VLSI ı̂n cazul n = 12

17/ 19
Pseudocod
Notat,ii:
• A[1..n; 1..n]] este un tablou pătratic de dimensiune nxn.
Componente Conexe Vlsi Pasii 2 3(G )
• SV [1..n], P[1..n] sunt tablouri de dimensiune n. 1 / ∗ Pasul 2 ∗ /
Premise: 2 / ∗ Eliminarea circuitelor de lungime 2 ∗ /
3 for each j : 1 ≤ j ≤ n
•Iniţial procesoarele conţin ı̂n regiştrii de memorie matricea de 4 do in parallel pj,j transmite P[j] tuturor procesoarelor din coloana j
adiacenţă A[1..n, 1..n]. 5 for each i : 1 ≤ i ≤ n
•Vectorii SV şi P vor fi memoraţi ı̂n regiştrii procesoarelor de pe 6 do in parallel
diagonala principală. 7 pi,i cere lui pj,j , j = P[i], valoarea lui P[j]
Componente Conexe Vlsi(G ) 8 P2[i] ← P[j]
1 / ∗ Iniţializarea tabloului SV ∗ / 9 for each i : 1 ≤ i ≤ n
2 for eachi : 1 ≤ i ≤ n 10 do in parallel if P2[i] = i and i < P[i]
3 do in parallel SV [i] ← i 11 then P[i] ← i
4 repeat 12 / ∗ Execuţia a log n operaţii de scurtcircuitare ∗ /
5 / ∗ Pasul 1: Execuţia operaţiilor de agăţare ∗ / 13 / ∗ P[i] = P[P[i]] ∗ /
6 for each j : 1 ≤ j ≤ n 14 k ← 0
7 do in parallel pj,j transmite SV [j] tuturor procesoarelor din coloana j 15 while k ≤ log n
16 do for each j : 1 ≤ j ≤ n
17 do in parallel pj,j transmite P[j] tuturor procesoarelor din coloana j
9 do in parallel if {SV [j] / A[i, j] = 1, SV [j] 6= SV [i]} 6= 0/
10 then P[i] ← min {SV [j] / A[i, j] = 1, SV [j] 6= SV [i]} 18 for each i : 1 ≤ i ≤ n
1≤j≤n 19 do in parallel
11 else P[i] ← SV [i] 20 pi,i cere lui pi,j , j = P[i], valoarea lui P[j]
12 for each j : 1 ≤ j ≤ n 21 P[i] ← P[j]
13 do in parallel pj,j transmite P[j] şi SV [j] tuturor procesoarelor 22 k ← k +1
14 din coloana j 23 / ∗ Pasul 3 ∗ /
15 for each i : 1 ≤ i ≤ n 24 / ∗ Actualizarea mulţimii supervârfurilor ∗ /
16 do in parallel if {P[j] / SV [j] = i, P[j] 6= i} 6= 0/ 25 for each i : 1 ≤ i ≤ n
17 then B[i] ← min {P[j] / SV [j] = i, P[j] 6= i} 26 do in parallel if SV [i] = P[i]
1≤j≤n 27 then SV [i] ← 0
18 else B[i] ← SV [i] 28 else SV [i] ← 1
19 for each i : 1 ≤ i ≤ n 29 Stare Graf Pointer ← max{SV [i]/ i = 1, n}
20 do in parallel P[i] ← B[i] 30 for each i : 1 ≤ i ≤ n
21 Componente Conexe Vlsi Pasii 2 3(G) 31 do in parallel SV [i] ← P[i]
22 transmite Stare Graf Pointer tuturor procesoarelor
23 until Stare-Graf-Pointer = 0
18/ 19
Complexitatea
Teorema (3)
Algoritmul COMPONENTE CONEXE VLSI rezolvă problema componentelor conexe ı̂n
timpul paralel T = O(log3 n) pe o arhitectură de tip plase locale conectate prin arbori.
Demonstraţie.
Timpul de execuţie al acestui algoritm este O(log n)· T(CC) unde T(CC) este timpul execuţiei
algoritmului COMPONENTE CONEXE.
Observaţie: Remarcabil pentru asemenea arhitecturi este faptul că aria chip-ului
A = O(n2 ).
19/ 19
Cuprins Arbori parţiali oarecare Algoritm pentru arbori parţiali oarecare

Arbori parţiali oarecare
Mitică Craus
1/ 5
Cuprins

Algoritm pentru arbori parţiali oarecare
2/ 5
• Dat fiind un graf G = (V , E ), V = {1, 2, . . . , n}, problema arborilor parţiali constă ı̂n
determinarea unei păduri de arbori parţiali in G .
• Algoritmii de construcţie a unei păduri de arbori parţiali au la bază algoritmi pentru
determinarea componentelor conexe.
• Astfel, dacă se adaugă algoritmului HCS o procedură de identificare şi reţinere ı̂n
cursul unei operaţii de agăţare a muchiilor de bază, algoritmul obţinut rezolvă
problema arborilor parţiali.
3/ 5
Algoritm pentru arbori parţiali oarecare - pseudocod

Arbori Partiali(G )
1 for eachi : 1 ≤ i ≤ n
2 do in parallel SV [i] ← i
3 repeat
4 ∗ Pasul 1: Execuţia operaţiilor de agăţare şi calcul muchii de bază ∗ /
6 do in parallel if {SV [j] / A[i, j] = 1, SV [j] 6= SV [i]} 6= 0/
7 then P[i] ← min {SV [j] / A[i, j] = 1, SV [j] 6= SV [i]}
1≤j≤n
9 T [i] ← min {j/A[i, j] = 1, SV [j] = P[i]}
Notat, ii: 1≤j≤n
• A[1..n], SV [1..n], P[1..n] sunt 11 do in parallel if {P[j] / SV [j] = i, P[j] 6= i} 6= 0/
tablouri de dimensiune n. 12 then P[i] ← min {P[j] / SV [j] = i, P[j] 6= i}
1≤j≤n
Premise:
• Graful G este dat prin matricea 14 k ← min {j/SV [j] = i, SV [T [j]] = P[i]}
de adiacenţă memorată ı̂n 1≤j≤n
tabloul A. 15 T [i] ← T [k]
16 S[i] ← k
• P conţine graful pointer iar SV 17 if SV [S[i]] = SV [T [i]]
memorează graful 18 then S[i] ← 0
supervârfurilor. 19 / ∗ Eliminarea dublurilor din mulţimea muchiilor de bază ∗ /
21 do in parallel if S[i] = T [T [i]] and SV [i] < SV [T [i]]
22 then S[i] ← 0
23 / ∗ Includerea muchiilor de bază ı̂n pădurea de arbori parţiali ∗ /
25 do in parallel if SV [i] = i and S[i] 6= 0
26 then F ← F ∪ {S[i], T [i]}
27 Arbori Partiali Pasii 2 3(G)
28 until Stare-Graf-Pointer = 0
4/ 5
Algoritm pentru arbori parţiali oarecare - pseudocod (continuare)
Arbori Partiali Pasii 2 3(G )

1 / ∗ Pasul 2 ∗ /
2 / ∗ Pasul 2.1: Eliminarea circuitelor de lungime 2 ∗ /
4 do in parallel if P[P[i]] = i and i < P[i]
5 then P[i] ← i
6 / ∗ Pasul 2.2: Execuţia a log n operaţii de scurtcircuitare ∗ /
7 k ←0
8 while k ≤ log n
9 do for each i : 1 ≤ i ≤ n
10 do in parallel P[i] ← P[P[i]]
11 k ← k +1
12 / ∗ Pasul 3: Actualizarea mulţimii supervârfurilor ∗ /
14 do in parallel if SV [i] = P[i]
15 then SV [i] ← 0
16 else SV [i] ← 1
17 Stare-Graf-Pointer ← max{SV [i]/ i = 1, n}
19 do in parallel SV [i] ← P[i]
5/ 5
Cuprins Transformata Fourier discretă Algoritm Algoritm ı̂mbunătăţit Algoritmul Cooley-Tukey Comentarii bibliografice

Transformata Fourier discretă
Mitică Craus
1/ 17
Cuprins
Transformata Fourier discretă

Descriere
Algoritm
Descriere
Pseudocod
Algoritm ı̂mbunătăţit
Descriere
Pseudocod
Algoritmul Cooley-Tukey
Pseudocod
Implementare pe hipercub sau fluture
2/ 17
Transformata Fourier discretă - descriere
• Notăm cu f (t) funcţia care descrie semnalul ı̂n domeniul timp şi cu F (ν) funcţia
care descrie semnalul ı̂n domeniul frecvenţei.
• Se poate trece dintr-o descriere ı̂n alta prin transformata Fourier.
• Trecerea din domeniul timp ı̂n domeniul frecvenţă se face prin transformata Fourier
directă: Z +∞
F (ν) = F [f (t)] = f (t)e −2πiνt dt, (1)
−∞
iar trecerea de la domeniul frecvenţă la domeniul timp se face prin transformata
Fourier inversă: Z +∞
f (t) = F −1 [F (ν)] = F (ν)e 2πiνt dν. (2)
−∞
3/ 17
Transformata Fourier discretă - descriere (continuare)
• Transformata Fourier discretă se obţine când se consideră f (t) măsurată ı̂ntr-un

număr finit de puncte: t0 , . . . , tn−1 cu tj = jT , unde T este perioada de timp la care
se fac măsurătorile.
• Notând xk = f (tk ), pentru k = 0, . . . , n − 1, transformata Fourier discretă directă este
dată de relaţia:
n−1 j n−1 −2πijk
F [f (t)] = ∑ xk e −2πi nT kT T = T ∑ xk e n . (3)
k=0 k=0
• Notăm:
n−1 −2πijk
yj = ∑ xk e n . (4)
k=0
• Transformata Fourier discretă inversă este dată de relaţia:
n−1 2πijk 1 1 n−1 2πijk

xk = ∑ yj Te n = ∑ yj e n (5)
j=0 nT n j=0
4/ 17
• Dacă se consideră polinomul de variabilă z:
X (z) = x0 + x1 z + · · · xn−1 z n−1 (6)
şi rădăcinile de ordinul n ale unităţii:

2πij
ωj = e n , j = 0, 1, . . . , n − 1, (7)
obţinem
yn−j = X (ωj ), j = 0, 1, . . . , n − 1, (8)
unde am considerat yn = y0 .
5/ 17
Rădăcinile de ordinul n ale unităţii satisfac următoarele proprietăţi:

Lema (1)
Dacă n este par, n = 2m, şi j < m, atunci −ωj = ωj+m .
Demonstraţie.
2πi(j+m) 2πij 2πim 2πij 2πi2m
2
Avem ωj+m = (e 2m )2 = (e 2m )2 (e 2m )2 = (e 2m )2 e 2m = ωj2 . Deoarece ωj şi
ωj+m sunt distincte, rezultă ωj = −ωj+m .
Lema (1)
Dacă n este par, n = 2m, şi 1 ≤ j < m, atunci ωj2 este de asemenea o rădăcină 6= 1.
Demonstraţie.
Deoarece ωjn = 1 rezultă (ωj2 )n = 1. Pe de altă parte,
2πij 2πi(j+j)
ωj2 = (e n )2 =e n = ωj+j 6= 1 pentru că 2 ≤ j + j ≤ n − 2.
6/ 17
Algoritm pentru transformata Fourier discretă - descriere

• Reamintim că determinarea valorii unui polinom ı̂ntr-un punct se poate realiza prin n
ı̂nmulţiri şi n adunări, utilizând schema lui Horner, şi numărul acestor operaţii este
optim. Prin urmare, calculul direct al celor n componente ale transformatei Fourier
necesită timpul O(n2 ).
• Utilizând strategia divide-et-impera, se poate obţine un algoritm care necesită
O(n log n) timp. Numim calculul dat de acest algoritm transformata Fourier rapidă
şi-l notăm FFT (Fast Fourier Transform).
• Considerăm cazul n = 2r .
• Utilizăm proprietăţile de mai sus ale rădăcinilor unităţii pentru a despărţi suma din
definiţia lui X (ωj ) ı̂n două subsume: suma coeficienţilor pari şi suma coeficienţilor
impari.
• Avem:
n −1 n −1
2 2
X (ωj ) = ∑ x2m ωj2m + ∑ x2m+1 ωj2m+1
m=0 m=0 (9)
n −1 n −1
2 2
= ∑ x2m ωj2m + ωj ∑ x2m+1 ωj2m
m=0 m=0
7/ 17
Algoritm pentru transformata Fourier discretă - descriere (continuare)

• Expresia anterioară corespunde scrierii polinomului f (t) sub forma:
X (z) = (x0 +x2 z 2 +· · ·+xn−2 z n−2 )+z(x1 +x3 z 2 +· · ·+xn−1 z n−2 ) = X 1(z)+zX 2(z),
(10)
unde X 1(z) şi X 2(z) sunt polinoame de grad n − 2, i.e., de grad mai mic cu 1 decât
cel al lui X (z).
• Evaluarea acestor polinoame se za face numai ı̂n punctele
ωm , m = 0, 1, . . . , n
2 −1 = 2
r −1 − 1.
• Considerăm listele de numere x0 , x2 , x4 , . . . , x2r −2 , respectiz x1 , x3 , x5 , . . . , x2r −1 .

Seriile Fourier ale acestor liste constau din valorile polinoamelor:
n
X 0 (z) = x0 + x2 z + x4 z 2 + · · · + xn−2 z 2 −1 (11)
şi
n
X 00 (z) = x1 + x3 z + x5 z 2 + · · · + xn−1 z 2 −1 (12)
pentru rădăcinile de ordinul n 2 ale unităţii.
• Notăm cu ωj0 , j = 0, 1, . . . , n − 1 aceste rădăcini.
2
• Se pune problema dacă putem calcula X (ωj ), utilizând X 0 (ωj0 ) şi X 00 (ωj0 ).
8/ 17
Algoritm pentru transformata Fourier discretă - descriere (continuare)
• Pentru j < n avem:

2
2πij2m 2πijm
m
ωj2m = e 2r =e 2r −1 = ωj0 (13)
iar pentru j ≥ n
2 are loc:
2πi(j− n 2πi(j− n
2 )m
2 )2m m
ωj2m = −ωj−
2m
n = −e 2r =e 2r −1 = ω 0 j− n (14)
2 2
• Aceste relaţii arată că valorile X (ωj ) pot fi calculate dacă se cunosc X (ωj0 ) şi
X 00 (ωj0 ):
n
X (ωj ) = X 0 (ωj0 ) + ωj X 00 (ωj0 ), dacă j < (15)
2
şi
n
X (ωj ) = X 0 (ωj−n
0
) + ωj X 00 (ωj−n
0
), dacă j ≥ (16)
2
9/ 17
Algoritm pentru transformata Fourier discretă - pseudocod

Notat, ii:
• X este polinomul cu coeficienţii x0 , x1 , . . . , xn−1 .
• Ω[0..n − 1] = (ω0 , ω1 , . . . , ωn−1 ) este un tablou de dimenisune n.
• Ω0 [0..d n2 e − 1] = (ω00 , ω10 , . . . , ωd0 n e−1 ) este un tablou de dimenisune d n2 e.
2
Premise:
• Ω conţine rădăcinile de ordinul n ale unităţii.
• Ω0 conţine rădăcinile de ordinul d n2 e ale unităţii.
FFT Recursiv 1(X , n, Ω)
1 if n = 1
2 then X (ω0 ) ← x0
n
3 else X 0 ← x0 + x2 z + · · · + xn−2 z 2 −1
n
4 X 00 ← x1 + x3 z + · · · + xn−1 z 2 −1
5 FFT Recursiv 1(X , 2 , Ω ) 0 n 0
6 FFT Recursiv 1(X 00 , n2 , Ω0 )
7 for j ← 0 to n2 − 1
8 do X (ωj ) ← X 0 (ωj0 ) + ωj X 00 (ωj0 )
9 for j ← n2 to n − 1
10 do X (ωj ) ← X 0 (ωj−0 00 0
n ) + ωj X (ωj− n )
2 2
10/ 17
Algoritm ı̂mbunătăţit pentru transformata Fourier discretă - descriere
• În algoritmul de mai sus există dezavantajul că trebuie calculate atât rădăcinile
unităţii de ordinul n, cât şi cele de ordinul n
2.
• Acest dezavantaj poate fi eliminat dacă se schimbă instanţa problemei.
• Plecând de la observaţia că dacă se cunoaşte o rădăcină primitivă de ordinul n a lui
1, să zicem ω 6= 1, atunci celelalte rădăcini sunt puteri ale lui ω.
• Deci putem lua ωj = ω j .
• Instanţa problemei se modifică ı̂n felul următor: ı̂n loc să considerăm dat numai
polinomul X , presupunem date polinomul X de grad n − 1 şi o rădăcină primitivă de
ordinul n a unităţii.
• Ieşirea constă ı̂n determinarea valorilor X (ω 0 ), X (ω 1 ), X (ω 2 ), . . . , X (ω n−1 ).
• De asemenea, se ţine cont de faptul că dacă ω este o rădăcină primitivă de ordinul n
a unităţii, atunci ω 2 este o rădăcină primitivă de ordinul n
2 a unităţii.
11/ 17
Algoritm ı̂mbunătăţit pentru transformata Fourier discretă - pseudocod
Notat, ii:
• X este polinomul cu coeficienţii x0 , x1 , . . . , xn−1 .
• ω este o rădăcină de ordinul n a unităţii.
FFT Recursiv 2(X , n, ω)
1 if n = 1
2 then X (ω 0 ) ← x0
n
3 else X 0 ← x0 + x2 z + · · · + xn−2 z 2 −1
n
4 X 00 ← x1 + x3 z + · · · + xn−1 z 2 −1
5 FFT Recursiv 2(X , 2 , ω )0 n 2
6 FFT Recursiv 2(X 00 , n2 , ω 2 )

7 for j ← 0 to n − 1
n mod n2 )
8 do X (ω j ) ← X 0 (ω 2(j mod 2 ) ) + ω j X 00 (ω 2(j )
12/ 17
Figura 1 : Exemplu de execuţie pentru n = 8

13/ 17
Algoritmul Cooley-Tukey - pseudocod

Notat, ii:
• X [0..n − 1] = (x0 , x1 , . . . , xn−1 ) şi Y [0..n − 1] = (y0 , y1 , . . . , yn−1 ) sunt tablouri de dimenisune n.
• ω este o rădăcină de ordinul n a unităţii.
Premise:
• Init, ial, X conţine valorile xk = f (tk ), k = 0, . . . , n − 1.
Rezultate:
−2πijk
• Y va conţine valorile yj = ∑n−1
k=0 xk e
n , k = 0, . . . , n − 1.
FFT Iterativ(X , n, ω, Y )
1 r ← log n
2 for j ← 0 to n − 1
3 do T [j] ← X [j]
4 for m ← 0 to r − 1
5 do for j ← 0 to n − 1
6 do S[j] ← T [j]
7 for j ← 0 to n − 1
8 do in parallel
9 / ∗ Fie b0 b1 . . . br −1 reprezenatarea binară a lui j ∗ /
10 k = (b0 . . . bm−1 0bm+1 . . . br −1 )
11 l = (b0 . . . bm−1 1bm+1 . . . br −1 )
12 T [j] = S[k] + ω (bm bm−1 ...b0 0...0) S[l]
13 for j ← 0 to n − 1
14 do Y [j] ← T [j]
14/ 17
Figura 2 : Exemplu de execuţie pentru n = 8

15/ 17
Implementare pe hipercub sau fluture
X Y
Figura 3 : Implementare pe hipercub sau fluture - exemplu pentru n = 8
16/ 17
Capitolul Transformata Fourier discretă are la bază cărţile

1. D. Lucanu & M. Craus, Proiectarea algoritmilor, Editura Polirom, 2008;
2. V. Kumar, A. Grama A. Gupta & G Karypis, Introduction to Parallel Computing: Design
and Analysis of Algorithms, Benjamin-Cummings, 1994.
17/ 17
Introducere Alegerea liderului ı̂n reţele cu topologie de comuncare inel Alegerea liderului ı̂n reţele cu topologie de comunicare graf oarecare

Alegerea liderului
Mitică Craus
Univeristatea Tehnică ”Gheorghe Asachi” din Ias, i
1/ 28
Alegerea liderului
Introducere
Alegerea liderului ı̂n reţele cu topologie de comuncare inel
Aspecte generale
Algoritm sincron de alegere a liderului ı̂n inele etichetate uniforme
Descriere
Pseudocod
Corectitudinea
Complexitatea
Algoritm sincron de alegere a liderului ı̂n inele etichetate neuniforme
Descriere
Algoritm asincron de alegere a liderului ı̂n inele etichetate uniforme
Descriere
Pseudocod
Corectitudinea
Complexitatea
Alegerea liderului ı̂n reţele cu topologie de comunicare graf oarecare
Algoritmul FloodMax sincron
Descriere
Pseudocod
Complexitatea
2/ 28
Introducere
• Problemă fundamentală: ı̂n sistemele distribuite este frecvent nevoie de un

coordonator.
• Aplicaţii diverse:
• defecţiuni ale componentelor unui sistem distribuit (de exemplu: alegerea unui nou
server coordonator pentru continuarea funcţionării unui serviciu);
• excludere mutuală ı̂n sisteme bazate pe comunicarea prin mesaje;
• reţele mobile – alegerea unui alt lider când liderul cunoscut părăseşte reţeaua.
• Topologii de comunicare:
• inelul;
• graful.
3/ 28
Alegerea liderului ı̂n reţele cu topologie de comuncare inel - aspecte generale
• Fiecare nod al inelului este asociat unei unităt, i

de procesare.
• Se stabilec sensuri ı̂n inel. De exemplul stânga şi
dreapta unui nod este fixată din perspectiva
aşezării nodului cu ”faţa” la centru.
• Legăturile ı̂ntre noduri pot fi bidirect, ionale.
4/ 28
Aspecte generale - continuare
• Inel anonim:
• Unităt, ile de procesare nu au indentificatori.
• Au mecanisme identice pentru schimbarea
stărilor, adică funct, iile de tranzit, ie de stare sunt
identice.
• Sunt exprimate ı̂n termeni de stânga s, i dreapta.
• Inel etichetat:
• Fiecare unitate de procesare
pi , i ∈ {0, 1, . . . , n − 1} are asociat un
identificator unic idi
• Funct, iile de tranzit, ie de stare sunt diferite.
• Sunt identificate prin id-urile lor.
5/ 28
• Inel uniform:
• Unităt, ile de procesare au identificatori unici.
• Numarul nodurilor inelului (n) nu este cunoscut de către unităt, ile de procesare.
• Mecanismele de schimbare a stărilor nu depind de n (Funct, iile de tranzit, ie de stare nu
au variabila n ca parametru).
• Inel neuniform:
• Unităt, ile de procesare au identificatori unici.
• Numarul nodurilor inelului (n) este cunoscut de către unităt, ile de procesare.
• Mecanismele de schimbare a stărilor depind de n (Funct, iile de tranzit, ie de stare au
variabila n ca parametru).
6/ 28
• Algoritmii de alegere a liderului depind de:

• Tipul inelului: anonim sau etichetat;
• Numărul nodurilor inelului: cunoscut sau necunoscut;
• Tipul de ceas: global (execuţie sincronă) sau local (execuţie asincronă).
7/ 28
Alegerea liderului ı̂n inele anonime
• Inele anonime sincrone:

• Ceasul este global.
• Unităt, ile de procesare execută acelaşi program.
• La un moment dat, unităt, ile de procesare
efectuează aceeas, i operaţie (execută aceeas, i
instruct, iune)
• Unităt, ile de procesare au aceeaşi evoluţie,
deoarece sunt identice.
• La final, toate unităt, ile de procesare sunt lideri.
• Inele anonime asincrone:
• Ceasul este local.
• Unităt, ile de procesare au aceeaşi evoluţie,
deoarece sunt identice.
• La final, toate unităt, ile de procesare sunt lideri.
8/ 28
Alegerea liderului ı̂n inele etichetate
• Unitatea de procesare cu cel mai mare/mic

identificator (id) este aleasă lider
9/ 28
Algoritm sincron de alegere a liderului ı̂n inele etichetate uniforme -

descriere
• Startul nu este sincronizat. Aceasta ı̂nseamnă că unităt, ile de procesare se ”trezesc”
spontan sau după primirea unui mesaj, adică ı̂ncep execuţia programului de alegerea
a liderului ı̂n momente diferite.
• La trezire, dacă nu a primit nici un mesaj, unitatea de procesare devine participant;
dacă a primit un mesaj, devine releu.
• Atunci când o unitate de procesare cu rol de participant primes, te un mesaj de la pi ,
dacă id-ul primit este mai mare decât identificatorul cel mai mic cunoscut (inclusiv
propriul identificator), ı̂l ignoră; altfel, ı̂l reţine 2id − 1 runde.
• Atunci când o unitate de procesare cu rol de releu primes, te un mesaj de la pi , dacă
id-ul primit este mai mare decât identificatorul cel mai mic cunoscut (fără propriul
identificator), ı̂l ignoră; altfel, ı̂l retransmite imediat.
10/ 28
Algoritm sincron de alegere a liderului ı̂n inele etichetate uniforme

Pseudocod pentru unitatea de procesare pi
ASAL IEU(Si , Ri , Wi , n, starei , statuti , idi , pi )
1 while true
2 do if starei = adormit
• Notat, ii: 3 then if Ri = 0/
4 then starei ← participant
• Ri memorează mesajele 5 min ← idi
recepţionate de unitatea de 6 memoreaza (idi , 1) in Si
procesare pi . 7 else starei ← releu
• Si memorează mesajele care 8 min ← ∞
urmează a fi trimise de către 9 for each (m, h) in Ri
unitatea de procesare pi . 10 do if h 6= 3
• Wi memorează mesajele 11 then if m < min
ı̂ntârziate (ı̂n as, teptare). 12 then min ← m
• starei reprezintă starea curentă 13 if starei = releu and h = 1
a unităt, ii de procesare pi 14 then memoreaza (m, 1) in Si
(adormit, participant sau 15 else memoreaza (m, 2) impreuna cu numarul rundei in Wi
releu). 16 else if m = id
• statuti memorează starea finală 17 then statuti ← lider
a unităt, ii de procesare pi (lider 18 memoreaza (m, 3) in Si
sau non lider ), 19 else if statuti = lider
• h reprezintă faza ı̂n care se află 20 then break/ ∗ termină execut, ia algoritmului ∗ /
mesajul m. 21 else statuti ← non lider
22 memoreaza (m, 3) in Si
• Premise: 23 for each (m, 2) in Wi
• Init, ial Si = Ri = Wi = 0/ s, i 24 do if (m, 2) a fost primit in urma cu 2m − 1 runde
25 then sterge (m, 2) din Wi si memoreaza in Si
starei = adormit, 26 trimite Si spre stanga
statuti = nedefinit. 27 if statuti = non lider
28 then break/ ∗ termină execut, ia algoritmului ∗ /
11/ 28
Corectitudinea
Teorema (1)
Doar unitatea de procesare cu cel ai mic id primeşte inapoi propriul id.
Demonstraţie.
Fie pi unitatea de procesare participantă cu cel mai mic identificator (idi ). Cel put, in o unitate de
procesare are statut de participant. Evident, nici o unitate de procesare nu poate ”ı̂nghiţi”
(aruncă la cos, , fără a-l transmite mai departe) mesajul idi . Mai mult, mesajul idi . este ı̂ntârziat,
ı̂n fiecare unitate de procesare, cel mult 2idi runde. Să presupunem că există o unitate de
procesare pj , j 6= i, care primeşte ı̂napoi propriul identificator, idj . Rezulă că idj trece prin toate
unităţile de procesare din inel, inclusiv prin pi . Dar idi < idj şi pi este o unitate de procesare
participantă, care nu va retransmite idj . Contradict, ie.
12/ 28
Complexitatea
Mesajele care circulă prin inel pot fi clasificate ı̂n trei categorii:
1. mesaje ı̂n faza I (h = 1);
2. mesaje ı̂n faza II (h = 2) trimise ı̂nainte de intrarea mesajului liderului ı̂n faza II;
3. mesaje ı̂n faza II (h = 2) trimise după intrarea mesajului liderului ı̂n faza II.
4. mesaje ı̂n faza III (h = 3) trimise după ce a fost decis liderul.
Lema (1)
Numărul de mesaje din prima categorie este cel mult n.
Demonstraţie.
Este suficient să demonstrăm că fiecare unitate de procesare retransmite cel mult un mesaj din
prima categorie. Să presupunem că există o unitate de procesare pi care retransmite două mesaje
din prima categorie, idj primit de la pj şi idk de la pk . Fără a restrânge generalitatea, presupunem
că pj este mai aproape de pi decât pk . Dacă idk ajunge ı̂n pj după ce pj se ”trezeşte” şi trimite
pj , idk trece ı̂n faza II şi va fi ı̂ntârziat ı̂n fiecare unitate de procesare participantă 2idk runde;
altfel pj nu participă şi nu trimite identificatorul idj . Prin urmare, fie idk ajunge ı̂n pi ı̂n faza II,
fie idj nu este trimis de pj s, i prin urmare nu este primit de pi . Contradict, ie.
13/ 28
Complexitatea - continuare
Lema (2)
Fie r prima rundă ı̂n care se ”trezes, te” măcar o unitate de procesare s, i ı̂ncepe execut, ia
algoritmului. Fie pi una dintre acestea. Dacă unitatea de procesare pj este la distant, ă d
fat, ă de pi , atunci pj primes, te un mesaj din prima categorie cel mult ı̂n runda r + d.
Demonstraţie.
Induct, ie după d. Pentru d = 1 este evident că vecinul lui pi primes, te mesajul idi (din categoria 1)
ı̂n runda r + 1. Să presupunem că unitatea de procesare pk situată la distant, a d − 1 fat, ă de pi
primes, te un mesaj din prima categorie, cel mult ı̂n runda r + d − 1. Dacă aceasta este ” trezită”,
a trimis deja la vecinul pj un mesaj din prima categorie; altfel, ı̂nseamnă că pk are statut de releu
s, i va retransmite ı̂n runda r + d către pj mesajul de categoria 1, primit anterior.
14/ 28
Lema (3)
Numărul de mesaje din categoria a doua este cel mult n.
Demonstraţie.
Din Lema 1 rezultă că fiecare unitate de procesare retransmite cel mult un mesaj din prima
categorie, adică pe o muchie este transmis cel mult un mesaj din prima categorie. Din Lema 2
rezultă ca ı̂n runda r + n pe fiecare muchie a fost trimis un mesaj din categoria 1. Rezultă că
după runda r + n nu va mai fi transmis nici un mesaj din categoria 1. Din Lema 2 rezultă că
mesajul liderului intră in faza a II-a după cel mult r + n runde, adică nu mai târziun de a n-a
rundă care urmează trezirii primei unităt, i de procesare. Rezultă că mesajele din categoria 2
circulă cel mult n runde. Un mesaj m aflat ı̂n faza a II-a este ı̂ntârziat 2m − 1 runde, după care
este retransmis. Prin urmare, un mesaj m circulă cu statutul ”categoria 2” cel mult de 2nm ori.
Deoarece mesajul care conţine cel mai mic identificator circulă de cele mai multe ori, rezultă că
numarul maxim de mesaje se obţine atunci când unităţile de procesare participante au
identificatorii 0, 1, . . . , n − 1. Dacă ţimem cont că mesajul liderului nu poate face parte din
categoria 2, rezultă că numărul mesajelor din categoria 2 este ∑n−1 n
i=1 2i ≤ n
15/ 28
Lema (4)
Nici un mesaj nu este retransmis după ce liderul pi primes, te propriul identificator idi .
Demonstraţie.
Toate mesajele care urmează lui idi sunt ”ı̂nghit, ite”.
16/ 28
Lema (5)
Numărul de mesaje din categoria a treia este cel mult 2n.
Demonstraţie.
Fie pi liderul şi pj o unitate de procesare cu statut de participant. Din Teorema 1 rezultă că
idi < idj . Din Lema 4 rezultă că nici un mesaj nu este retransmis după ce pi primes, te ı̂napoi
propriul identificator idi . Deoarece idi este ı̂ntârziat cel mult 2idi runde ı̂n fiecare unitate de
procesare, sunt necesare cel mult n2idi runde pentru ca pi să primească ı̂napoi propriul
identificator idi . Aşadar, mesajele din categoria a treia sunt transmise de-a lungul a cel mult n2idi
runde. În timpul acestor runde, idj este retransmis cel mult de id1 j n2idi = idjn−idi ori. Astfel,
2 2
numărul mesajelor din categoria 3 este cel mult ∑n−1 n
j=0 2idj −idi . Pe baza faptului că numărul maxim
de mesaje se obţine atunci când unităţile de procesare participante au identificatorii 0, 1, . . . , n − 1
(Lema 3) se deduce că ∑n−1 n n−1 n
j=0 idj −idi = ∑k=0 2k < 2n.
2
17/ 28
Lema (6)
Numărul de mesaje din categoria a patra este n.
Demonstraţie.
Fiecare unitatea de procesare transmite mai departe mesajul liderului (h = 3), prin care acesta se
declară câs, tigător.
18/ 28
Teorema (2)
Numărul de mesaje circulate prin algoritmul sincron de alegere a liderului ı̂n inele
etichetate uniformeste cel mult 5n.
Demonstraţie.
Consecinţă imediată a lemelor 1,3,5 şi 6.
19/ 28
Algoritm sincron de alegere a liderului ı̂n inele etichetate neuniforme -

descriere
• Algoritmul se desfăs, oară ı̂n faze. Fiecare fază este compusă din n runde.
• Startul este sincronizat. Aceasta ı̂nseamnă că toate unităt, ile de procesare se
”trezesc” simultan, adică ı̂ncep execuţia programului de alegerea a liderului ı̂n acelaşi
moment.
• Unitatea de procesare cu cel mai mic identificator este aleasă lider.
• În fiecare rundă, fiecare unitate de procesare efectuează următoarele operaţii:
• analizează mesajele primite pe canalele din stânga şi din dreapta;
• ı̂şi schimbă starea ı̂n funct, ie de starea curentă s, i de mesajele primite; dacă nu a primit
niciun mesaj, ı̂şi schimbă starea doar ı̂n funct, ie de starea curentă;
• transmite mesaje la vecini, dacă are ceva de transmis.
• În faza i, dacă nimeni nu este ales, atunci unitatea de procesare cu id-ul i se
autodeclară lider şi transmite la vecini un mesaj prin care se declară lider; celelalte
unităţi de procesare retransmit mesajul primit.
20/ 28
Algoritmul asincron LCR (LeLann, Chang si Roberts) - descriere
• Se consideră că unităţile de procesare ”stau cu faţa” spre centrul inelului.

• Fiecare unitate de procesare pi transmite identificatorul său (idi ) vecinului din
stânga.
• Apoi, aşteaptă răspuns de la vecinul din dreapta
• Dacă identificatorul recepţionat este mai mare decât propriul identificator, transmite
identificatorul primit spre stânga.
• Dacă identificatorul primit e mai mic decat propriul identificator, ignoră (”inghite”)
mesajul.
• Dacă identificatorul recepţionat este propriul identificator, unitatea respectivă se
declară lider şi transmite ı̂n inel un mesaj de terminare.
• Dacă o unitate de procesare primes, te mesaj de terminare, termina ca non-lider.
21/ 28
Algoritmul LCR - exemplu de execuţie
22/ 28
Algoritmul LCR
LCR LE(pi , starei , statuti )

1 starei ← trezit
• Notat, ii: 2 trimite < ”id nou”, idi > spre stanga
• idi reprezintă identificatorul unităt, ii 3 while true
de procesare pi . 4 do switch
• starei memorează starea curentă a 5 case primeste < ”id nou”, id > dinspre dreapta :
unităt, ii de procesare pi (adormit, 6 if id = idi
trezit). 7 then statuti ← lider
• statuti memorează starea finală a 8 trimite < ”lider ”, id > spre stanga
9 if id > idi
unităt, ii de procesare pi (lider sau 10 then trimite < ”id nou”, id > spre stanga
non lider ) 11 case primeste < ”lider ”, id > dinspre dreapta :
12 if id 6= idi
• Premise: 13 then statuti ← non lider
• Init, ial starei = adormit s, i 14 trimite < ”lider ”, id > spre stanga
15 break/ ∗ termină execut, ia algoritmului ∗ /
statuti = necunoscut.
23/ 28
Corectitudinea
Teorema (3)
Doar unitatea de procesare cu cel mai mare id primeşte primeşte inapoi propriul id.
Demonstraţie.
Doar mesajul unităţii de procesare cu cel mai mare id nu va fi ”inghiţit” (aruncat la coş).
24/ 28
Complexitatea
Teorema (4)
Numărul de mesaje care circulă prin inel este cel mult n2 .
Demonstraţie.
Cazul cel mai nefavorabil este acela ı̂n care unităţile de procesare au identificatori din mulţimea
{0, 1, . . . , n − 1} şi sunt plasate pe inel ı̂n ordinea n − 1, n − 2, . . . , 0. În această situat, ie, mesajul
idi = i al unităt, ii de procesare pi este retransmis exact de i + 1 ori. Astfel, numărul mesajelor care
circulă prin inel (inclusiv mesajul de terminare) este n + ∑n−1 i=0 (i + 1) = O(n ).
2
25/ 28
Algoritmul FloodMax sincron - descriere
• Graful G = (V , E ) este conex. Unităt, ile de procesare cunosc diametrul= d.

• Fiecare unitate de procesare conţine o ı̂nregistrare a identificatorului maxim
cunoscut; iniţial acesta este propriul identificator.
• La fiecare rundă, fiecare unitate de procesare trimite acest maxim vecinilor.
• După d runde, dacă maximul cunoscut este propriul identificator, atunci unitatea de
procesare se declară lider ; altfel se consideră non-lider.
26/ 28
Algoritmul FloodMax sincron

• Notat, ii:
• idi reprezintă identificatorul unităt, ii
de procesare pi . FloodMax LE(G , d, pi , max idi , statuti )
• Ri memorează mesajele recepţionate 1 for runda ← 1 to d
de unitatea de procesare pi ı̂ntr-o 2 do for each (m) in Ri
rundă. 3 do if max idi < m
• max idi memorează cel mai mare 4 then max idi ← m
identificator cunoscut de pi .. 5 trimite max idi vecinilor
• statuti memorează starea finală a 6 if max idi = idi
unităt, ii de procesare pi (lider sau 7 then statuti ← lider
non lider ). 8 else statuti ← non − lider
• Premise:
• Init, ial max idi = idi s, i
statuti = necunoscut.
27/ 28
Complexitatea
Teorema (5)
Numărul de mesaje circulă prin graf este 2d|E |.
Demonstraţie.
Într-o rundă, pe fiecare muchie circulă două mesaje. Numărul rundelor este d.
28/ 28
Introducere Excluderea mutuală cu regiştri binari test&set Excluderea mutuală cu regiştri read-modify-write Excludere mutuală cu regiştri cu valori mărginite
Excluderea mutuală ı̂n sisteme ”shared-memory”
Mitică Craus
1/ 14
Cuprins
Introducere
Excluderea mutuală cu regiştri binari test&set
Descriere
Pseudocod
Excluderea mutuală cu regiştri read-modify-write
Descriere
Pseudocod
Excludere mutuală cu regiştri cu valori mărginite
Excludere mutuală cu regiştri cu valori mărginite, pentru două
unităţi de procesare, cu flămânzire
Descriere
Pseudocod
Excludere mutuală cu regiştri cu valori mărginite, pentru două
unităţi de procesare, fără flămânzire
Descriere
Pseudocod
2/ 14
Introducere
• Problemă fundamentală: ı̂n sistemele distribuite este frecvent nevoie de a arbitra

accesul concurent la o resursă.
• Problema excluderii mutuale apare la un grup de unităţi de procesare care periodic
accesează anumite resurse care nu pot fi utilizate simultan de mai mult de o singură unitate
de procesare (de exemplu o imprimantă).
• Fiecare unitate de procesare poate dori să execute un segment de cod numit secţiune critică,
astfel ı̂ncât, la orice moment, cel mult o unitate de procesare este ı̂n secţiunea critică
(excluderea mutuală).
• Dacă una sau mai multe unităţi de procesare ı̂ncearcă să intre ı̂n secţiunea critică, atunci
una dintre ele va reuşi ı̂n cele din urmă, atâta timp cât nici o unitate de procesare nu stă la
infinit ı̂n secţiunea critică.
• Proprietatea de mai sus nu dă nici o garanţie de reuşită, deoarece o unitate de procesare
poate ı̂ncerca să intre ı̂n secţiunea critică şi totuşi să nu reuşească, aceasta fiind ignorată
mereu de alte unităţi de procesare.
• O proprietate mai puternică, care elimină blocarea (deadlock), este făra flămânzire (no
lockout sau no starvation): Dacă o unitate de procesare doreşte să intre ı̂n secţiunea critică,
aceasta va reuşi ı̂n cele din urmă, atâta timp cât nici o unitate de procesare nu ramâne la
infinit ı̂n secţiunea critică.
3/ 14
Introducere - continuare
• Programul unei unităti de procesare este ı̂mpărţit ı̂n următoarele secţiuni:

Entry: codul executat la pregatirea pentru intrarea ı̂n secţiunea critică;
Critical: codul care trebuie protejat de execuţie concurentă;
Exit: codul executat după părăsirea secţiunii critice;
Remainder: restul codului.
4/ 14
Excluderea mutuală cu regiştri binari test&set - descriere
Un registru test&set memorează valori binare şi suportă două operaţii atomice, test&set
şi reset, definite astfel:
Notat, ii:
• r este un registru test&set.
Test&Set(r )
1 temp ← r
2 r ←1
3 return temp
Reset(r )
1 r ←0
5/ 14
Excluderea mutuală cu regiştri binari test&set - descriere (continuare)
• Se presupune că valoarea iniţială a registrului r este 0.

• În secţiunea de intrare, unitatea de procesare pi testează r ı̂n mod repetat r , pâna
când testul returnează 0; după ultimul test r va cont, ine 1
• Orice test ulterior va returna 1, ceea ce interzice oricărei alte unităt, i de procesare să
intre ı̂n sect, iunea critică.
• În sect, iunea de ies, ire, pi reseteaza r = 0, astfel ı̂ncât una dintre unităt, ile de
procesare, care as, teaptă ı̂n sect, iunea de intrare, să poată intra ı̂n sect, iunea critică.
• Excluderea mutuala realizată prin acest algoritm este fără blocaj (no deadlock), dar
cu flămânzire (lockout).
6/ 14
Excluderea mutuală cu regiştri binari test&set - pseudocod
Notat, ii:
• r este un registru test&set.
Premise: Iniţial, r = 0
Pseudocod pentru unitatea de procesare pi , i ∈ {0, 1, . . . , n − 1}
hEntry i /* pi are nevoie de resursa critică*/
Entry(r )
1 asteapta pana cand Test&Set(r ) = 0
hCriticali /* pi intră ı̂n secţiunea critică*/

hExiti /* pi părăses, te secţiunea critică*/
Exit(r )
1 Reset(r )
hRemainder i /* pi nu are nevoie de resursa critică*/
7/ 14
Excluderea mutuală cu regiştri read-modify-write - descriere

• Un registru r , de tipul read-modify-write, are următoarele proprietăt, i:
• Valorile v memorate de registrul r sunt numere ı̂ntregi.
• Operaţia suportată este RMW (r , f ), unde f este o funct, ie definită pe Z cu valori ı̂n Z,
adică f : Z ← Z.
• Operaţia RMW (r , f ) este atomică, ı̂ntoarce valoarea v memorată ı̂n registrul r şi
schimbă conţinutul lui r , ı̂nscriind acolo valoarea f (v ).
• Operat, ia test&set este un caz particular al operat, iei RMW , ı̂n care f (r ) = 1, pentru
orice valoare a lui r .
RMW(r , f )
1 v ←r
2 r ← f (v )
3 return v
• Unităt, ile de procesare sunt organizate ı̂ntr-o coadă de tip FIFO

• Numai unitatea de procesare de la ı̂nceputul cozii poate intra ı̂n sectiunea critică şi
rămâne la inceputul cozii până părăseşte secţiunea criticâ, nepermiţând ı̂n acest fel
celorlalte unităţi de procesare să intre ı̂n secţiunea critică.
• Excluderea mutuala realizată prin acest algoritm este fără blocaj (no deadlock) şi
fără flămânzire (no lockout).
8/ 14
Excluderea mutuală cu regiştri read-modify-write - descriere (continuare)
• Fiecare unitate de procesare dispune de două variabile locale, pozitie şi coada.
• Algoritmul utilizează un registru r de tip read-modify-write, care memorează o
structură formată din două câmpuri: primul s, i ultimul.
• r .primul s, i r .ultimul conţin “bilete” pentru prima s, i respectiv pentru ultima unitate
de procesare din coadă.
• Atunci când o unitate de procesare ajunge ı̂n sectiunea de intrare, se ”as, ează” la
coada, prin asignarea valoarii lui r unei variabile locale s, i prin incrementarea lui
r .ultimul. Toate acestea sunt realizate printr-o singură operatie, indivizibilă.
• Valoarea curentă a lui r .ultimul ı̂ndeplines, te rolul de ”bilet” pentru unitatea de
procesare.
• O unitate de procesare asteaptă ı̂n sect, iuneade intrare pâna devine prima din coadă,
adică până când r .primul este egal cu biletul său. În acest moment, unitatea de
procesare intră ı̂n sect, iunea critică.
• După părăsirea sect, iunii critice, unitatea de procesare se autoelimină din coadă prin
incrementrea lui r .primul, permit, ând ı̂n acest fel urmatoarei unităt, i de procesare din
coadă să intre ı̂n sect, iunea critică.
9/ 14
Excluderea mutuală cu regiştri read-modify-write - pseudocod

Notat, ii:
• r este un registru de tipul read-modify-write
Premise: Iniţial, r = (0, 0)
Pseudocod pentru unitatea de procesare pi , i ∈ {0, 1, . . . , n − 1}
hEntry i /* pi are nevoie de resursa critică*/
Entry(r )
1 pozitie ← RMW (r , hr .primul, r .ultimul + 1i)/ ∗ se ”aşează” la coadă ∗ /
2 repeat
3 coada ← RMW (r , r ) / ∗ ”citeste” coada ∗ /
4 until coada.primul = pozitie.ultimul/ ∗ până ajunge prima ∗ /
hCriticali /* pi intră ı̂n secţiunea critică*/

hExiti /* pi părăses, te secţiunea critică*/
Exit(r )
1 RMW(r , hr .primul + 1, r .ultimuli)
hRemainder i /* pi nu are nevoie de resursa critică*/
10/ 14
Excludere mutuală cu regiştri cu valori mărginite, pentru două unităţi de

procesare, cu flămânzire - descriere
• Fiecare unitate de procesare pi dispune de o variabila booleană vreau[i] partajată, a

carei valoare este 1, dacă pi este interesată să intre ı̂n sectiunea critică şi 0 ı̂n caz
contrar.
• Algoritmul este asimetric:
• p0 intră ı̂n secţiunea critică fără să ţină seama de ı̂ncercările lui p1 de a face acelaşi
lucru.;
• p1 intră ı̂n secţiunea critică numai dacă p0 nu este interesat de aceasta.
• Acest algoritm utilizează un mecanism cu fanioane pentru coordonarea unitaţilor de
procesare care ı̂şi dispută secţiunea critică:
• pi ridică un fanion (prin setarea vreau[i] ← 1) şi apoi urmăreşte fanionul celeilalte
unităţi de procesare (prin citirea lui vreau[1 − i]).
• Cel puţin una dintre unităţile de procesare observă fanionul ridicat al celeilalte unităţi
de procesare şi evită intrarea ı̂n secţiunea critică (excludere mutuală).
• Dacă p0 este interesată continuu să intre ı̂n secţiunea critică, este posibil ca p1 să
nu intre niciodată ı̂n secţiunea critică, având ı̂n vedere faptul că aceasta cedează de
fiecare dată (lockout).
11/ 14

procesare, cu flămânzire - pseudocod
Pseudocod pentru unitatea de procesare p1

Premise: Iniţial, vreau[0] = vreau[1] = 0
Pseudocod pentru unitatea de procesare p0 hEntry i /* p1 are nevoie de resursa critică*/
Entry(vreau)
hEntry i /* p0 are nevoie de resursa critică*/ 1 vreau[1] ← 0
Entry(vreau) 2 asteapta pana cand vreau[0] = 0
1 vreau[0] ← 1 3 vreau[1] ← 1
2 asteapta pana cand vreau[1] = 0 4 if vreau[0] = 1
5 then go to linia 1
hCriticali /* p0 intră ı̂n secţiunea critică*/
hExiti /* p0 părăses, te secţiunea critică*/
Exit(r ) hExiti /* p1 părăses, te secţiunea critică*/
1 vreau[0] ← 0 Exit(r )
1 vreau[1] ← 0
hRemainder i /*
p0 nu are nevoie de resursa critică*/ hRemainder i /*
p1 nu are nevoie de resursa critică*/
12/ 14

procesare, fără flămânzire - descriere
• Pentru a obţine no lockout se modifică algoritmul precedent, astfel ı̂ncât p0 să nu
mai fie prioritară continuu.
• Fiecare unitate de procesare va acorda prioritate celeilalte, după ce iese din sect, iunea
critică.
• O variabilă partajata prioritate cont, ine identificatorul (indicele) unităt, ii de procesare
care este prioritară momentan; prioritate este initializată cu 0, adică, iniţial p0 este
prioritară.
• Variabila prioritate este citită s, i modificată de ambele unităt, i de procesare.
• Unitatea de procesare prioritară joacă rolul lui p0 din algoritmul precedent; prin
urmare, aceasta va intra ı̂n sect, iunea critică.
• La ies, ire, va da prioritate celeilalte unităt, i de procesare, s, i va juca rolul lui p1 din
algoritmul precedent. Aceasta asigura proprietatea no lockout.
• Algoritmul modificat indeplineşte condiţiile de excludere mutuală ı̂n aceeaşi manieră
ca şi primul algoritm.
• O unitate de procesare ridică un fanion şi apoi inspectează fanionul celeilalte unităţi de
procesare;
• Cel puţin una dintre unităt, ile de procesare observă că fanionul celeilalte unitati de
procesare este ridicat s, i evită să intre ı̂n sect, iunea critică.
13/ 14

procesare, fără flămânzire - pseudocod
Premise: Iniţial, vreau[0] = vreau[1] = 0
hEntry i /* p1 are nevoie de resursa critică*/
hEntry i /* p0 are nevoie de resursa critică*/
Entry(vreau)
Entry(vreau, prioritate)
1 vreau[1] ← 0
1 vreau[0] ← 0
2 asteapta pana cand vreau[0] = 0 sau
2 asteapta pana cand vreau[1] = 0 sau
3 prioritate = 1
3 prioritate = 0
4 vreau[1] ← 1
4 vreau[0] ← 1
5 if prioritate = 0
5 if prioritate = 1
6 then if vreau[0] = 1
6 then if vreau[1] = 1
8 else asteapta pana cand vreau[0] = 0
8 else asteapta pana cand vreau[1] = 0
Exit(r )
Exit(r )
1 vreau[1] = 0
1 vreau[0] ← 0
2 prioritate ← 0
2 prioritate ← 1
hRemainder i /*
hRemainder i /*
14/ 14
Introducere Echilibrarea statică Echilibrarea dinamică Bibliografie
Echilibrarea ı̂ncărcării
Mitică Craus
1/ 16
Cuprins
Introducere
Echilibrarea statică
Tipuri de echilibrare statică a ı̂ncărcării
Dezavantaje
Echilibrarea dinamică
Tipuri de echilibrare dinamică a ı̂ncărcări
Echilibrarea dinamică centralizată
Echilibrarea dinamică descentralizată
Echilibrarea dinamică prin metoda metoda iniţializării transferurilor de
task-uri de către transmiţător
Bibliografie
2/ 16
Introducere
• Într-o execuţie paralelă, fiecare unitate de procesare primeşte un grup de sarcini

(task-uri).
• Pentru a creşte eficienţa procesării paralele ar trebui ca execuţia grupurilor de
task-uri să se termine aproximativ simultan.
• Echilibrarea statică:
• In literatura de specialitate este denumită problema mapării (Bokhari, 1981) sau
problema planificării (scheduling problem).
• Task-urile sunt alocate unităţilor de procesare ı̂nainte de startarea aplicaţiilor.
• Se bazează ı̂ndeosebi pe estimarea volumului de lucru şi pe partiţionarea acestuia ı̂n
segmente alocate fiecărui task ı̂n parte. Această estimare are foarte puţine şanse să fie
exactă.
• Echilibrarea dinamică:
• Task-urile sunt alocate unităţilor de procesare ı̂n timpul rulării aplicaţiilor.
• Unităţile de procesare se pot “evalua” ı̂ntre ele şi apoi pot redistribui sarcini.
3/ 16
Tipuri de echilibrare statică a ı̂ncărcării
• Round robin: Sunt transmite task-uri ı̂n ordinea secvenţială a unităţilor de procesare,
revenind la prima atunci când tuturor unităţilor de procesare li s-a acordat un task.
• Selecţia aleatorie: Sunt selectate unităţi de procesare la ı̂ntâmplare şi li se acordă
task-uri.
• Bisecţia recursivă: Problema este divizată ı̂n mod recursiv ı̂n subprobleme de efort
computaţional egal, minimizându-se ı̂n acelaşi timp transmiterea de mesaje.
• Tehnici bazate pe algoritmi genetici.
• Pentru unităţile de procesare interconectate cu o reţea de legături statice, task-urile
comunicante trebuie executate pe unităţi de procesare cu căi directe de comunicaţie
pentru a reduce ı̂ntârzierile; aceasta este un element esenţial al problemei mapării”
”
pentru astfel de sisteme.
• În general, maparea este o problemă din clasa problemelor NP-dificile, pentru care
nu există un algoritm de rezolvare cu un timp de execuţie polinomial. De aceea, de
multe ori se folosesc metode euristice pentru selecţia unităţilor de procesare.
4/ 16
Dezavantaje
• Este foarte dificil de estimat cu acurateţe timpii de execuţie ale diverselor părţi ale
unui program, fără executarea efectivă a acestora.
• Planificarea este de la ı̂nceput inexactă.
• Unele sisteme pot avea ı̂ntârzieri ı̂n comunicaţii care variază ı̂n funcţie de diverse
circumstanţe.
• Integrarea ı̂ntârzierilor variabile ı̂n echilibrarea statică a ı̂ncărcării poate fi foarte dificilă.
• Unii algoritmi au un număr de paşi care nu poate fi calculat ı̂n prealabil (de
exemplu, algoritmii bazaţi pe backtracking).
5/ 16
Tipuri de echilibrare dinamică a ı̂ncărcării
• Echilibrare centralizată: există o structură clară master-slave; sarcinile sunt

distribuite de către unitatea de procesare master.
• Echilibrare descentralizată: unităţile de procesare interactionează ı̂ntre ele şi pot face
schimb de task-uri conform cu nivelul de ı̂ncărcare.
• Sarcinile sunt transferate prin metoda iniţializării de către receptor
(receiver-initiated): unitatea de procesare subı̂ncărcată trimite cereri de task-uri la
celelalte unităţi de procesare.
• Transferurile sunt efectuate prin metoda initializării de către transmiţător: unitatea
de procesare supraı̂ncarcată trimite cereri de transfer.
6/ 16
Echilibrarea dinamică centralizată - Descriere
• Unitatea de procesare master dispune de colecţia de task-uri care urmează a fi

executate.
• Task-urile sunt trimise procesoarelor slave.
• Atunci când o unitate de procesare slave termină un task, cere un altul de la
unitatea de procesare master.
• Mecanismul este numit “work pool”.
7/ 16
Echilibrarea dinamică centralizată - Cum şi când se aplică?
• Task-urile sunt cunoscute ı̂n prealabil, sunt sensibil diferite.

• Este cazul problemelor rezolvabile prin metoda divide-and-conquer.
• Sunt trimise spre execuţie ı̂ntâi task-urile care durează mai mult şi folosesc multă
memorie.
• Dacă un task consumator intensiv de resurse (“mare”) este trimis mai târziu, task-urile
mai “mici” pot fi terminate de către unitătile de procesare slave, care vor sta apoi
inactive ı̂n aşteptarea terminării task-ului mai “mare”.
• Numărul de task-uri se modifică ı̂n timpul execuţiei.
• În unele aplicaţii, execuţia unui task poate genera noi task-uri, deşi ı̂n final numărul
task-urilor trebuie să se reducă la 0, semnalizând terminarea procesului de calcul.
• Dacă task-urile sunt la fel de de importante, poate fi folosită o coadă simplă FIFO.
• Dacă unele task-uri sunt mai importante decât altele (de exemplu, pot conduce mai
repede către o soluţie), va fi implementată o coadă cu priorităţi.
• Unitatea de procesare master poate deţine şi alte informaţii, cum ar fi soluţia optimă
curentă.
• Este cazul problemelor rezolvabile prin metoda greedy sau metoda programării
dinamice.
• Task-urile vor fi trimise spre execuţie ı̂n ordinea dictată de soluţia optimă.
8/ 16
Echilibrarea dinamică descentralizată - 5 faze

• Evaluarea ı̂ncărcării:
• Metode analitice de evaluare: metodele de acest tip “reacţionează” ı̂n timp real la
schimbări, dar nu sunt precise.
• Metode empirice: sunt precise dar nu pot anticipa schimbările.
• Metode hibride: sunt combinaţii ı̂ntre cele doua metode; s-au dovedit a fi cele mai
eficiente.
• Determinarea eficienţei redistriburii task-urilor:
• Transferul de task-uri ı̂ntre unităţile de procesare poate avea un cost destul de mare.
• Este bine sa se estimeze de la ı̂nceput dacă transferul de task-uri va micşora timpul
total de procesare.
• Calculul vectorilor de transfer:
• Metoda difuziei caldurii.
• Metoda gradientului.
• Metode ierarhice: divizarea recursiva si reechilibrarea grupului de unităţi de procesare.
• Metode specifice domeniului: metoda fâşiei.
• Selecţia task-urilor pentru transfer:
• Căutari exhaustive: consumatoare de resurse.
• Primul potrivit (first fit): metodele de acest tip nu sunt optimale.
• Schimbul efectiv de task-uri:
• Task-urile trebuie conservate perfect ı̂n timpul transferului.
• Trebuie avut ı̂n vedere şi un eşec al transferului din cauza lipsei de memorie pe maşina
destinaţie.
• Se poate face sincron şi asincron.
9/ 16
Echilibrarea dinamică prin metoda metoda iniţializării transferurilor de

task-uri de către transmiţător
Algoritmul SID (Sender Initiated Diffusion)
• Propus de Willebeek.
• Se presupune că ı̂ncărcările sunt infinit divizibile; ı̂ncărcarea unei unităţi de procesare
se poate reprezenta printr-un număr real.
• Presupunerea este aplicabilă ı̂n programele paralele care exploatează o granularitate
foarte fină.
• Pentru a fi extins ı̂n cazurile granularităţilor medii sau mari, algoritmul trebuie să poată
gestiona task-uri indivizibile, deci să reprezinte ı̂ncărcarea unui procesor printr-un
număr ı̂ntreg nenegativ.
10/ 16
Algoritmul SID (Sender Initiated Diffusion) - Schema de funcţionare
• Fiecare unitate de procesare ı̂şi trimite informaţiile despre ı̂ncărcare către toţi vecinii
şi primeşte de asemenea informaţiile despre vecini.
• Fiecare unitate de procesare calculează ı̂ncărcarea medie a domeniului său, incluzând
ı̂ncărcările vecinilor şi cea proprie.
• Fie wi (t) numărul unităţilor de ı̂ncărcare ale unităţii de procesare i la momentul t.
Fiecare unitate de procesare memorează o estimare a ı̂ncărcării fiecărei unitate de
procesare vecină.
• Fie wij (t) estimarea ı̂ncărcării unităţii de procesare j păstrată ı̂n memoria unităţii de
procesare i la momentul t.
• Dacă unităţile de procesare i şi j nu sunt conectate direct, estimarea wij (t) = 0.
• Altfel, dacă unităţile de procesare i şi j sunt vecine, estimarea ı̂ncărcării se defineşte
astfel:
wij (t) = wj (τij (t))
unde τij este o variabilă ı̂ntreagă care satisface relaţia 0 ≤ τij (t) ≤ t.
11/ 16

(continuare)
• Fie wii (t) ı̂ncărcarea unităţii de procesare i la momentul t, ceea ce ı̂nseamnă că
fiecare unitate de procesare ı̂şi poate preciza propria ı̂ncărcare la momentul t.
• Există o mulţime de momente de timp, T , numită mulţimea timpilor de echilibrare a
ı̂ncărcării, la care fiecare unitate de procesare i ı̂şi compară ı̂ncărcarea proprie cu
estimarea memorată a ı̂ncărcării vecinilor.
• Media estimată a ı̂ncărcării procesorului i şi a vecinilor săi este memorată de
variabila wi (t).
• Definim (aij ) = matricea de adiacenţă la care se adaugă matricea unitate:
(aij0 ) = In + (aij )
• Media estimată a ı̂ncărcării domeniului unităţii de procesare i este calculată astfel:
 
wi1 (t)
0 . . . a0 ) 
(ai1 ... 
in
win (t)
w i (t) =  
1
0 . . . a0 )  . . . 
(ai1 in
1
12/ 16

(continuare)
• Dupa ce unitatea de procesare i şi-a calculat media de ı̂ncărcare locală, w i (t),

aceasta calculează şi deficitul dii (t) = w i (t) − wi (t, pentru a determina dacă este
supraı̂ncărcat sau nu.
• Dacă este supraı̂ncărcat, dii (t) < 0
• Dacă este subı̂ncărcat, dii (t) ≥ 0
• O unitate de procesare supraı̂ncărcată repartizează excesul de ı̂ncărcare vecinilor
subı̂ncărcaţi.
• Pentru a evalua corect acest exces, este calculată o nouă pondere pentru toţi vecinii
deficitari: (
dij (t) , dacă dij (t) > 0
dij+ =
0 , altfel
13/ 16

(continuare)
• Cantitatea totală de deficit este:

n
dt = ∑ dij+ (t)
j=1
• Porţiunea din excesul unităţii de procesare i care este atribuită vecinului j este:
dij+ (t)
(
dt , dacă dij (t) < 0
Pij =
0 , altfel
• În momentul t este transferată o cantitate nenegativă de ı̂ncărcare, sij (t), de la i la j:
σij (t) = b−Pij (t) · dij (t)c
• Algoritmul se termină atunci când nimeni nu mai dispunde de volum de lucru de

transferat.
14/ 16
Algoritmul SID (Sender Initiated Diffusion) - Exemplu de execuţie
15/ 16
Bibilografie
1. J. Watts, “A Practical Approach to Dynamic Load Balancing”, Masters Thesis,

California Institute of Technology, 1995, USA
2. R. Diekmann, B. Monien, R. Preis, “Load Balancing Strategies for Distributed
Memory Machines”, Technical Report, University of Paderborn, 1997, Germany
3. A.Cortés, A. Ripoll, M.A. Senar, F.Cedó and E. Luque, “On the convergence of SID
and DASUD load-balancing algorithms”, Technical Report, Universitat Autonoma de
Barcelona, 1998, Spain
4. B. Godfrey, K. Lakshminarayanan, S. Surana, R. Karp and I. Stoica, ”Load
Balancing in Dynamic Structured P2P Systems”, IEEE INFOCOM, 2004
16/ 16
Introducere Euristici care asignează pe rând task-urile Euristici care consideră toate task-urile ı̂n procesul de mapare Compararea principalelor euristici de map
Maparea task-urilor ı̂n sisteme distribuite eterogene
Mitică Craus
1/ 24
Maparea task-urilor
Introducere
Matricea ETC (Expected Time to Compute)
Euristici care asignează pe rând task-urile
Algoritmul Oportunistic Load Balancing - OLB
Algoritmul Minimum Execution Time - MET
Algoritmul Minimum Completion Time - MCT
Algoritmul de alternare (Switching Algorithm)
Algoritmul k-Percent Best - KPB
Euristici care consideră toate task-urile ı̂n procesul de mapare
Algoritmul Min-Min
Algoritmul Max-Min
Algoritmul Duplex
Algoritmul Genetic - GA
Algoritmul Simulated Annealing - SA
Algoritmul Genetic Simulated Annealing - GSA
Algoritmul A*
Compararea principalelor euristici de mapare a task-urilor
2/ 24
Introducere
• Maparea task-urilor presupune asignarea task-urilor la unităţi de procesare şi

ordonarea lor pentru execuţie la unităţile respective.
• În practică, problema mapării task-urilor este rezolvată prin aplicarea euristicilor de
mapare, respectiv, prin metode bazate pe experienţă folosite ı̂n rezolvarea
problemelor unde o căutare exhaustivă a soluţiei optime nu este posibilă.
• Indicatorii cei mai utilizaţi ı̂n determinarea eficienţei unei euristici de mapare sunt:
• Makespan-ul - timpul ı̂n care toate unităţile de procesare termină de executat task-urile
asignate;
• Dezechilibrul ı̂ncărcării - diferenţa dintre unitatea de procesare cea mai ı̂ncărcată şi cea
mai putin ı̂ncărcată;
• Durata algoritmului - timpul ı̂n care se face asignarea task-urilor.
• O euristică de mapare este considerată a fi eficientă dacă obţine ı̂n cel mai scurt
timp o soluţie care are un makespan minim şi o ı̂ncărcare bine echilibrată.
3/ 24
Matricea ETC (Expected Time to Compute)
• Euristicile de mapare folosesc estimări ale timpilor de execuţie a fiecărui task la

fiecare unitate de procesare.
• Timpii sunt reţinuţi ı̂ntr-o matrice ETC (Expected Time to Compute), unde fiecare
rând al matricii reprezintă un task, iar fiecare coloană o unitate de procesare.
• Matricea ETC poate fi de trei tipuri: consistentă, inconsistentă sau semi-consistentă.
• Dacă există o relaţie de ordine astfel ı̂ncât toţi timpii de execuţie a task-urilor la un
procesor sunt fie toţi mai mari sau toţi mai mici decât timpii de execuţie la un alt
procesor, atunci matricea este considerată a fi consistentă.
• Dacă nu se poate stabili o astfel de relaţie de ordine, atunci matricea este
inconsistentă, iar daca există o submatrice consistentă ı̂ntr-o astfel de matrice,
atunci matricea ETC este semi-consistentă.
4/ 24
Matricea ETC (Expected Time to Compute) - continuare
Tabela 1 : Exemplu de matrice ETC Tabela 2 : Exemplu de matrice ETC

consistentă (ETCi1 < ETCi3 < ETCi2 , semi-consistentă (ETCi1 < ETCi3
∀i ∈ {1, . . . , n}) ∀i ∈ {1, . . . , n})
P1 P2 P3 P1 P2 P3
T1 1.9 5.9 2.3 T1 1.9 2.3 5.9
T2 5.1 7.9 5.4 T2 5.1 7.9 5.4
T3 2.1 3.1 2.8 T3 2.1 3.1 2.8
T4 2.3 4.4 4.3 T4 2.3 4.4 4.3
T5 1.1 3.5 1.5 T5 1.1 1.5 3.5
T6 7.4 7.6 7.5 T6 7.4 7.6 7.5
T7 5.9 6.7 6.4 T7 6.4 5.9 6.7
T8 2.6 3.9 3.8 T8 2.6 3.9 3.8
5/ 24
Matricea ETC (Expected Time to Compute) - continuare (2)
10 T1
3.1
2.6 T2
Tabela 3 : Exemplu de matrice ETC
unităţi de timp
T3
inconsistentă
5.9 T4
P1 P2 P3 T5
5 5.4
T1 2.3 5.9 1.9 T6
7.4
T2 5.4 7.9 5.1 1.5 T7
T3 3.1 2.8 2.1 T8
2.3 2.3
T4 4.4 2.3 4.3
T5 3.5 1.5 1.1 0
P1 P2 P3
T6 7.5 7.6 7.4
T7 6.4 5.9 6.7 unităţi de procesare
T8 3.9 3.8 2.6
Figura 1 : O posibilă mapare pentru matricea ETC
alăturată
6/ 24
Euristici care asignează pe rând task-urile
• Cea mai simplă modalitate de a mapa task-urile este de a le asigna ı̂ntr-o anumită
ordine ţinând cont doar de task-urile care au fost asignate deja.
• Cele mai importante metode de mapare din această categorie sunt:
• Algoritmul Oportunistic Load Balancing - OLB
• Algoritmul Minimum Execution Time - MET
• Algoritmul Minimum Completion Time - MCT
• Algoritmul de alternare (Switching Algorithm)
• Algoritmul k-Percent Best - KPB
• Majoritatea acestor algoritmi de mapare au complexitatea timp O(nm), unde n
reprezintă numărul de task-uri, iar m numărul de unităţi de procesare.
7/ 24
Algoritmul Oportunistic Load Balancing - OLB

• Fiecare task este asignat la următorul procesor disponibil, iar dacă sunt mai multe
unităţi de procesare disponibile, atunci se alege una aleatoriu.
• Avantajul este simplitatea abordării, iar dezavantajul major ı̂l constituie
neconsiderarea estimării timpului de execuţie a task-ului care urmează să fie asignat.
• Acest lucru poate duce la asignarea task-ului respectiv la o unitate de procesare
care, ı̂n ciuda faptului că este mai puţin ocupată la momentul respectiv, va executa
task-ul ı̂ntr-un timp mult mai mare comparativ cu celelalte unităţi.
• Complexitatea
• Complexitatea timp a acestui algoritm reprezintă complexitatea parcurgerii tuturor
task-urilor O(n), ı̂nmulţită cu complexitatea dată de determinarea la fiecare pas a
disponibilităţii minime a unităţilor de procesare.
• Determinarea minimului se rezumă la determinarea valorii minime dintr-un vector de m
elemente, având complexitatea O(m).
• Deoarece la fiecare iteraţie un singur task este asignat, doar o singură valoare a
disponibilităţii unităţii de procesare se modifică, rezultând complexitatea timp de O(1).
• În concluzie, euristica OLB are complexitatea timp O(n) · (O(1) + O(m)), care este
egală cu O(nm).
8/ 24
Algoritmul Minimum Execution Time - MET
• Fiecare task este asignat unităţii de procesare care are un timp minim estimat de
execuţie pentru task-ul respectiv, ignorând disponibilitatea unităţii.
• Dezavantajul constă ı̂n faptul că această metodă poate cauza dezechilibrări
semnificative ale ı̂ncărcării.
• Dacă există un grup de unităţi de procesare care execută toate task-urile ı̂ntr-un
timp mai scurt decât celelalte unităţi de procesare, atunci toate task-urile vor fi
asignate la unităţile din grupul respectiv; ceea ce ı̂nseamnă că celelalte unităţi de
procesare vor fi neutilizate.
• Complexitatea - este aceeaşi ca la algoritmul precedent (O(nm)) cu observaţia că,
pentru fiecare task, algoritmul MET calculează timpul minim de execuţie (care se
determină tot ı̂n O(m)).
9/ 24
Algoritmul Minimum Completion Time - MCT
• Fiecare task este asignat unităţii de procesare care are un timp minim estimat de
terminare a execuţiei pentru task-ul respectiv.
• Avantajul este combinarea precedentelor două metode prin evitarea situaţiilor ı̂n care
acestea dau rezultate nesatisfăcătoare.
• Dezavantajul constă ı̂n faptul că, ı̂n unele situaţii, task-urile sunt asignate la unităţi
de procesare care nu au un timp minim de execuţie.
• Complexitatea - este aceeaşi ca la algoritmii precedenţi (O(nm)) deoarece
complexitatea pentru determinarea timpului minim de terminare a execuţiei este
suma dintre calcularea timpului de terminare a execuţiei (O(1)) şi determinarea
minimului (O(m)), care este tot O(m).
10/ 24
Algoritmul de alternare (Switching Algorithm)
• Într-o manieră ciclică sunt alternate precedentele două metode de echilibrare a

ı̂ncărcării pentru a beneficia de părţile bune ale celor două metode.
• Pentru ı̂nceput este utilizat algoritmul MET, iar când dezechilibrarea ajunge prea
mare este folosit algoritmul MCT pentru a echilibra ı̂ncărcarea, după care se revine
la MET.
• Complexitatea - este dată de complexităţile algoritmilor MET şi MCT, şi este, de
asemenea, egală cu O(nm).
11/ 24
Algoritmul k-Percent Best - KPB

• În asignarea task-urilor este considerat doar un subset de unităţi de procesare, format
din cele mai bune k% unităţi ı̂n funcţie de timpul de execuţie al task-ului respectiv.
• Ideea acestui algoritm este de a asigna task-uri unităţilor de procesare celor mai
potrivite, având ı̂n vedere o eventuală sosire a unor task-uri care s-ar potrivi mai bine
doar anumitor unităţi.
• Algoritmul este următorul:
100
1. Generarea unei valori k aleatoare, unde ≤ k ≤ 100;
m
km
2. Selectarea primelor procesoare ı̂n funcţie de timpul minim de execuţie pentru
100
task-ul selectat;
3. Asignarea task-ului la unitatea de procesare cu cel mai bun timp de terminare a
execuţiei din subsetul selectat anterior.
• Complexitatea
• Determinarea complexităţii depinde de modalitatea de implementare a Pasului 2.
• Dacă cele mai bune k unităţi de procesare sunt determinate prin utilizarea unui
algoritm de sortare (de exemplu, Merge-Sort), atunci complexitatea pentru maparea
unui task este O(m · log m).
• Astfel, complexitatea timp a algoritmului k-Percent Best este O(nm · log m).
12/ 24
Euristici care consideră toate task-urile ı̂n procesul de mapare
• Algoritmul Min-Min
• Algoritmul Max-Min
• Algoritmul Duplex
• Algoritmul Genetic - GA
• Algoritmul Simulated Annealing - SA
• Algoritmul Genetic Simulated Annealing - GSA
• Algoritmul A*
13/ 24
Algoritmul Min-Min
• Task-urile sunt asignate astfel ı̂ncât modificarea disponibilităţilor unităţilor de
procesare să fie minimă.
• Algoritmul este bazat pe metoda MCT şi consta ı̂n:
1. Calcularea timpilor estimaţi de terminare a execuţiei fiecărui task la fiecare unitate de
procesare;
2. Determinarea timpului minim pentru fiecare task;
3. Asignarea task-ului cu timpul minim din setul de task-uri la unitatea de procesare
corespunzătoare;
4. Înlăturarea din lista de task-uri de mapat a task-ului asignat şi repetarea paşilor până
când nu mai sunt task-uri de asignat.
• Euristica Min-Min asignează ı̂ntâi task-urile cu cel mai mic timp de execuţie la
unităţile de procesare care vor executa cel mai rapid task-urile.
• Complexitatea
• Fiecare iteraţie a algoritmului are complexitatea O(nm), care este dată de calcularea
timpilor estimaţi de terminare a execuţiei fiecărui task la fiecare unitate de procesare.
• Întrucât la fiecare iteraţie este asignat un task, complexitatea timp a algoritmului este
O(n) · O(nm), şi anume O(n2 m).
14/ 24
Algoritmul Max-Min
• Acest algoritm este similar cu cel precedent cu menţiunea că la pasul al 3-lea este
asignat task-ul cu timpul maxim de terminare a execuţiei şi nu cu cel minim.
• Max-Min oferă rezultate mai bune decât Min-Min dacă avem task-uri cu timpi de
execuţie mai mari, deoarece, ı̂n cazul Min-Min, s-ar executa ı̂ntâi task-urile cu timpi
mai mici, iar când se execută cele cu timpi mari se poate ca unele unităţi de
procesare să stea ı̂n aşteptare mai mult ceea ce ar duce la o creştere a makesan-ului.
• Complexitatea - analog cu algoritmul Min-Min, complexitatea timp a algoritmului
Max-Min este O(n2 m).
15/ 24
Algoritmul Duplex
• Întrucât ı̂n anumite situaţii algoritmul Min-Min produce soluţii mai bune, iar ı̂n altele
algoritmul Max-Min oferă rezultate mai satisfăcătoare, euristica Duplex utilizează cei
doi algoritmi şi alege soluţia cea mai bună dintre cele două.
• Dezavantajul constă ı̂n dublarea timpului de execuţie al algoritmului.
• Complexitatea - complexitatea timp este egală cu suma complexităţilor algoritmilor
Min-Min şi Max-Min şi este tot O(n2 m).
16/ 24
Algoritmul Genetic - GA
• Algoritmii Genetici sunt folosiţi pentru căutarea ı̂n spaţiul soluţiilor, atunci când
acesta este foarte mare.
• Paşii unui algoritm genetic sunt următorii:
1. Generarea populaţiei iniţiale;
2. Evaluarea populaţiei;
3. Atâta timp cât nu este satisfăcută condiţia de oprire se urmează paşii:
3.1 Selectarea cromozomilor;
3.2 Aplicarea operatorului de ı̂ncrucişare;
3.3 Aplicarea operatorului de mutaţie;
3.4 Evaluarea cromozomilor şi determinarea noii populaţii.
17/ 24
Algoritmul Genetic - GA - continuare
• Algoritmii Genetici pot fi optimizaţi pentru a converge mai rapid către o soluţie
bună prin implementarea unor operatori de ı̂ncrucişare şi mutaţie orientaţi spre
ı̂mbunătăţirea soluţiei candidate.
• De asemenea, se poate obţine, ı̂ntr-un timp relativ mic, o soluţie acceptabilă dacă
un cromozom din populaţia iniţială este iniţializat cu soluţia obţinută prin execuţia
unei euristici de mapare mai ineficiente dar mult mai rapidă, cum ar fi: Min-Min,
Max-Min sau Duplex.
P1 P1 P1 P2 P2 P3 P2 P3
1 2 3 4 5 6 7 8
Figura 2 : Reprezentarea cromozomului algoritmului genetic pentru soluţia din Fig. 1
18/ 24
Algoritmul Simulated Annealing - SA
• Această tehnică iterativă consideră doar o singură soluţie posibilă pentru fiecare task
ı̂n parte, soluţia având aceeaşi reprezentare ca şi ı̂n cazul algoritmilor genetici.
• Algoritmul SA permite acceptarea unor soluţii mai puţin bune pentru a obţine un
spaţiu mai bun al soluţiilor, cu o probabilitate bazată pe o temperatură a sistemului
care descreşte la fiecare iteraţie cu o rată de răcire.
• Chiar dacă ı̂n general, acest algoritm este mai rapid decât GA, soluţiile găsite sunt
mai slabe decât Min-Min şi GA.
19/ 24
Algoritmul Simulated Annealing - SA - continuare
• Algoritmul Simulated Annealing este următorul:

1. Generarea unei soluţii iniţiale aleatoare;
2. Calcularea temperaturii sistemului pentru soluţia generată (makespan-ul soluţiei
iniţiale);
3. Temperatura veche ← temperatura sistemului;
4. Atâta timp cât temperatura sistemului nu a ajuns la o valoare limită:
4.1 Aplicarea operatorului de mutaţie: asignarea aleatorie a unui task la o unitate de procesare;
4.2 Temperatura noua ← makespan solutie noua;
4.3 Deciderea asupra acceptării noii soluţii: soluţia este acceptată dacă noul makespan este mai
bun (mai mic) decât vechiul sau dacă o valoare aleatoare din intervalul [0, 1) este mai mică
1
decât temperatura veche−temperatura noua
1+e temperatura sistemului
4.4 Temperatura sistemului ← temperatura sistemului ∗ rata de racire;
4.5 Dacă soluţia nouă este acceptată, atunci Temperatura veche ← temperatura noua.
20/ 24
Algoritmul Genetic Simulated Annealing - GSA
• Acest algoritm foloseşte tehnica GA, doar că ı̂n cazul procesului de selecţie GSA
foloseşte temperatura sistemului pentru acceptarea sau refuzarea unui cromozom
nou.
21/ 24
Algoritmul A*
• A* este o modalitate de căutare bazată pe arbori.

• Un nod din arbore reprezintă mapări parţiale (un subset de task-uri asignate la
unităţi de procesare), iar nodul rădăcină este soluţia nulă.
• Fiecare nod părinte are cu un task mai puţin faţă de fiecare copil al său.
• Un nod generează câte un nod copil pentru fiecare mapare posibilă a unui task.
După ce părintele a generat nodurile copii, acesta devine inactiv.
• Fiecare nod are asociat un cost care reprezintă suma dintre timpul total de execuţie
a task-urilor din soluţia parţială (makespan-ul) şi estimarea diferenţei dintre
makespan-ul soluţiei parţiale şi makespan-ul soluţiei complete care include soluţia
parţială respectivă.
• Algoritmul foloseşte metoda branch-and-bound cu cost minim.
22/ 24
Compararea principalelor euristici de mapare a task-urilor

Figura 3 : Comparaţia makespan-ului şi a dezechilibrării ı̂ncărcării pentru 12 euristici al căror
scop a fost maparea a 500 de task-uri la 20 de unităţi de procesare
23/ 24
Bibliografie
Adrian Alexandrescu, Mitică Craus (prof. coord.). Applications of Artificial
Intelligence in Heterogeneous Computing Systems. Teză de doctorat, 2012.
Frederic Magoules, Jie Pan, Kiat-An Tan and Abhinit Kumar. Introduction to grid
computing. CRC Press, Inc., Boca Raton, FL, USA, 2009.
E. Ilavarasan and P. Thambidurai. Low Complexity Performance Effective Task
Scheduling Algorithm for Heterogeneous Computing Environments. Journal of
Computer Sciences, no. 3, pg. 94–103, 2007.
Tracy D. Braun, Howard Jay Siegel, Noah Beck, Lasislau L. Bölöni, Muthucumara
Maheswaran, Albert I. Reuther, James P. Robertson, Mitchell D. Theys, Bin Yao,
Debra Hensgen and Richard F. Freund. A comparison of eleven static heuristics for
mapping a class of independent tasks onto heterogeneous distributed computing
systems. J. Parallel Distrib. Comput., vol. 61, pg. 810–837, 2001.
Muthucumaru Maheswaran, Shoukat Ali, Howard Jay Siegel, Debra Hensgen and
Richard F. Freund. Dynamic mapping of a class of independent tasks onto
heterogeneous computing systems. J. Parallel Distrib. Comput., vol. 59, pg.
107–131, 1999.
24/ 24

Alpd CURS

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Alpd CURS

Încărcat de

Drepturi de autor:

Formate disponibile

Cuprins Stadiul actual Despre curs De ce paralelism? De ce distribuiţie?

Algoritmi paraleli şi distribuiţi

Universitatea Tehnică ”Gheorghe Asachi” din Iaşi

Viitorul este paralel!

Evaluarea finală: examen

• Arhitecturi de calcul paralel/distribuit

Integrare şi conectivitate

• Legea lui Moore: Gradul de integrare creşte

• 2011: 2,600,000,000 C/CI. 1971 1990 2011

Figura 1 : Legea lui Moore

Conectivitate tot mai performantă

• V. Kumar, A. Grama A. Gupta & G Karypis, Introduction to Parallel Computing:

Algoritmi paraleli şi distribuiţi

Universitatea Tehnică ”Gheorghe Asachi” din Iaşi

Sisteme abstracte de calcul paralel/distribuit

• Un sistem abstract de calcul paralel/distribuit (SACP/D) este un ansamblu de

• O arhitectură paralelă/distribuită este o implementare a unui SACP/D. Aceasta

Modelul de comunicare bazat pe reţele de interconectare

Modelul de comunicare bazat pe memorie partajată

Figura 1 : Modelul de comunicare bazat pe memorie partajată

Modelul de comunicare bazat pe reţele de interconectare

Figura 2 : Modelul de comunicare bazat pe reţele de interconectare

Figura 3 : Graful complet

• Mulţimea nodurilor V este organizată sub forma unui tablou unidimensional de

• Mulţimea nodurilor V este indexată prin intermediul unei funcţii

• Mulţimea nodurilor, V , este indexată prin intermediul unei funcţii

Arborele binar complet

Figura 7 : Arborele binar complet

Figura 9 : Arborele gras

• Arbore cu mai multe rădăcini!

• Tot arbore cu mai multe rădăcini!

Figura 11 : Topologia Banyan

• Este o generalizare a topologiei de tip inel.

Figura 13 : Plasa circulară

Figura 14 : Plasa de arbori

Hipercubul (Cubul cu k dimensiuni)

• Numărul n al nodurilor grafului ce reprezintă o astfel de topologie este 2k , unde k

Figura 15 : Hipercub liniarizat

Hipercuburi cu 0, 1, 2 , 3 şi 4 dimensiun

Figura 16 : Hipercuburi cu 0, 1, 2 , 3 şi 4 dimensiuni

• Fie ik−1 ik−2 . . . i0 reprezentarea binară a lui i ∈ {0, ..., n − 1}.

000 001 010 011 100 101 110 111

Figura 17 : Amestec perfect

Criterii de evaluare a topologiilor regulate

• Distanţa = cel mai scurt drum ı̂ntre două unităţi de procesare.

Evaluarea a 8 topologii regulate, cu p unităţi de procesare

Topologia Diametrul Lăt, imea bisect, iei Costul

Graful complet 1 bp 2 /4c p(p − 1)/2

Figura 18 : Graful oarecare

Figura 19 : Arborele oarecare

Modele de calcul paralel/distribuit

• Modele bazate pe comunicarea prin memoria comună (Shared-Memory)

Figura 20 : Maşina PRAM

Tipuri de maşini PRAM

• La un moment dat t, un procesor poate accesa un registru de memorie pentru citire

• Este derivat din modelul

Figura 21 : Exemplu de arhitectură sistolică

• V. Kumar, A. Grama A. Gupta & G Karypis, Introduction to Parallel Computing:

Algoritmi paraleli şi distribuiţi

Universitatea Tehnică ”Gheorghe Asachi” din Iaşi

Parametri de performanţă a unui algoritm paralel/distribuit

Parametri de performanţă a unui algoritm paralel/distribuit

• Parametri de performanţă a unui algoritm paralel: