Curs SM

STRUCTURI MULTIPROCESOR
iacob55@yahoo.com
EF 202
Cuprins
Noiuni introductive despre calculatoarele paralele
Masini paralele si modele de programare
Clasificarea calculatoarelor paralele
Tipuri de calculatoare paralele
Performane ale calculatoarelor paralele
Programe paralele
Retele de interconectare
Proprietati ale retelelor de interconectare
Retele statice
Retele dinamice
Retele pe un cip
Retele de sortare
Retele dictionar si de cautare
Multiprocesoare
Organizare generala
Modele de consistenta pentru memoria partajata
Coerenta memoriilor cache
Proiectarea multiprocesoarelor cu supraveghere
Multiprocesoare cu acces uniform la memorie (UMA)
Organizare generala
Specificaia multiprocesor Intel
Sistem multiprocesor cu microprocesoare Intel Pentium
Gestionarea procesoarelor multiple in arhitecturile Intel 64 si IA-32
Multiprocesoare UMA bazate pe comutatoare gril
Multiprocesoare UMA bazate pe reele de comutatoare cu mai multe trepte
Cipuri cu procesoare multiple

SMT (simultaneous multithreading)
Arhitectura Hirata
Modelele Tullsen
Hyperthreading Technology (Intel)
CMP (chip multiprocessors) / multi-core
Hydra
Piranha
Arhitecturi tera-scalare
Proiectul Teraflop (Intel)
Procesor multicore comercial: Intel Core i7-2600
Proiectul Cell
Microblaze
Arhitecturi GPU
Multi-core DSP
Exemplu de multicore DSP: Texas Instruments TMS320C6678
MPSoC (Multiprocessor Systems on Chip)
Istoric MPSoC
Topologii si interconectari MPSoC
Sincronizarea proceselor in MPSoC
Multiprocesoare cu acces neuniform la memorie (NUMA)

Multiprocesoare NC-NUMA
Multiprocesoare COMA
Multiprocesoare CC-NUMA
Programarea multiprocesoarelor
Exploatarea concurentei la multiprocesoare
Thread-uri in Windows
Sincronizarea proceselor si thread-urilor
Excludere mutuala
Utilizarea sistemului de intreruperi
Instructiunea TestAndSet
Primitiva Fetch&Add
Semafoare
Sincronizarea thread-urilor in Windows
Detectarea paralelismului in programe
OpenMP
Multicalculatoare
Organizare general
Transferul de mesaje la multicalculatoare
Arhitecturi de routere
Proiectarea unui router pentru topologie 2D
Procesoare masiv paralele (MPP): sistemele IBM SP, Blue Gene/L
Sisteme cu transputere
Clustere de statii de lucru
Programarea multicalculatoarelor
Occam
Aplicatii paralele pe hipercub
MPI
PVM
Sisteme SIMD
Procesoare matriciale
Procesoare vectoriale
Sisteme sistolice VLSI
Modul de notare:
Laborator:
Teme de casa:
Examen:
25 puncte
25 puncte
50 puncte
-pentru intrarea in examen este obligatoriu obtinerea unui punctaj de minim 25 puncte;
-pentru promovarea examenului este necesar sa se obtina minim 25 de puncte la
examen.
http://acs.pub.ro/system/files/Decizie_CF_iunie_2013.pdf
1) Articolul 16. (1) din Regulamentul privind organizarea i desfurarea procesului de
nvmnt universitar de licen n Universitatea POLITEHNICA din Bucureti, 2013,
se completeaza cu:
Condiiile de promovare votate in Consiliul Facultii de Automatic i Calculatoare
sunt urmtoarele:
Minim 50% (minim nota 5) din punctajul acordat pentru activitile de pe parcursul
semestrului;
Minim 50% (minim nota 5) din punctajul acordat pentru examen, care poate fi compus
din parial - lucrare de degrevare - i examen final sau numai examen final.
NOIUNI INTRODUCTIVE DESPRE

CALCULATOARELE PARALELE
1. MASINI PARALELE SI MODELE DE PROGRAMARE
2. CLASIFICAREA CALCULATOARELOR PARALELE
3. TIPURI DE CALCULATOARE PARALELE
4. PERFORMANE ALE CALCULATOARELOR PARALELE
5. PROGRAME PARALELE
1. MASINI PARALELE SI MODELE DE PROGRAMARE
Calculator paralel = colectie de elemente de prelucrare

care comunica si coopereaza pentru rezolvarea rapida a unor
probleme complexe.
Comunicatie si cooperare: esentiale intr-o arhitectura paralela!
=> arhitectura comunicatiei
Cadrul de organizare intr-o masina paralela:
O arhitectura paralela generala:
Exemplu de aplicatie paralela: calcularea sumei

n 1
f ( A[i ])
i 0
Solutia generala:
n/p taskuri
p procesoare (procese).
Se disting doua seturi de date:

-partajate: valorile A[i] si suma finala;
-private: evalurile individuale de functii si sumele partiale
1) Modelul 1 de programare: spatiu partajat de adrese.

Programul = colectie de fire de executie, fiecare avand un set de
variabile private, iar impreuna partajeaza un alt set de variabile.
Comunicatia intre firele de executie: prin citirea/scrierea variabilelor
partajate.
Coordonarea firelor de executie prin operatii de sincronizare:

indicatori (flags), zavoare (locks), semafoare.
Masina paralela corespunzatoare modelului 1: masina cu memorie partajata

(sistemele multiprocesor, in primul rand sistemele multiprocesor simetrice sau SMPSymmetric Multiprocessors).
Exemple: sisteme de la Sun, DEC, Intel (Millennium), SGI Origin.
Variante ale acestui model:

a) masina cu memorie partajata distribuita (logic partajata, dar fizic distribuita.
Exemplu: SGI Origin (scalabila la cateva sute de procesoare).
b) masina cu spatiu partajat de adrese (memoriile cache inlocuite cu memorii

locale). Exemplu: Cray T3E.
O posibila solutie pentru rezolvarea problemei:
Este necesara sincronizarea threadurilor pentru accesul la variabilele partajate !

Exemplu: prin excludere mutuala, folosind operatia de zavorare (lock):
2) Modelul 2 de programare: transfer de mesaje.

Programul = colectie de procese, fiecare cu thread de control si spatiu
local de adrese, variabile locale.
Comunicatia intre procese: prin transfer explicit de date (perechi de
operatii corespunzatoare send si receive la procesele sursa si respectiv
destinatie). Datele partajate din punct de vedere logic sunt partitionate intre toate
procesele.
=> asemanare cu programarea distribuita!
Exista biblioteci standard (exemple: MPI si PVM).
Masina corespunzatoare modelului 2 este multicalculatorul (sistem cu

memorie distribuita):
Exemple: Cray T3E (poate fi incadrat si in aceasta categorie), IBM SP2, NOW,
Millenium.
O posibila solutie a problemei in cadrul modelului in transfer de mesaje

(simplificand, se calculeaza suma s = f(A[1]) + f(A[2]) ):
Procesor 1
xlocal = f(A[1])
send xlocal, proc2
receive xremote, proc2
s = xlocal + xremote
Procesor 2
xlocal = f(A[2])
send xlocal, proc1
Procesor 1
xlocal = f(A[1])
send xlocal, proc2
Procesor 2
xlocal = f(A[2])
send xlocal, proc1
sau:
3) Modelul 3 de programare: paralelism al datelor.

Thread singular secvential de control controleaza un set de operatii paralele aplicate
intregii structuri de date, sau numai unui singur subset.
Comunicatia: implicita, in modul de deplasare a datelor.
Eficienta numai pentru anumite probleme (exemplu: prelucrari de tablouri)!
Masina corespunzatoare modelului 3: sistem SIMD - Single Instruction

Multiple Data (numar mare de procesoare elementare comandate de un singur procesor
de control, executand aceeasi instructiune, posibil anumite procesoare inactive la
anumite momente de timp - la executia anumitor instructiuni).
Exemple: CM2, MASPAR, sistemele sistolice VLSI

Varianta: masina vectoriala (un singur procesor cu unitati functionale multiple,
toate efectuand aceeasi operatie in acelasi moment de timp).
4) Modelul 4 de masina: cluster de SMP-uri sau CLUMP (mai multe SMP-uri

conectate intr-o retea).
Fiecare SMP: sistem cu memorie partajata!
Comunicatia intre SMP-uri: prin transfer de mesaje.
Exemple: Millennium, IBM SPx, ASCI Red (Intel).
Model de programare: se utilizeaza transferul de mesaje, chiar in interiorul SMP-urilor!
Modele teoretice de calculatoare paralele

Modelul RAM (Random Access Machine) de calculator secvential (Sheperdson si
Sturgis):
Modelul PRAM (Parallel RAM) pentru un calculator paralel cu cost suplimentar nul de
sincronizare si acces la memorie (Fortune si Wylie):
Optiunile de acces concurent al procesoarelor la memoria partajata:

-ER (Exclusiv Read): intr-un ciclu cel mult un procesor poate
sa citeasca dintr-o locatie de memorie;
-EW (Exclusiv Write): intr-un ciclu cel mult un procesor
poate sa scrie intr-o locatie de memorie;
-CR (Concurrent Read): mai multe procesoare pot sa citeasca
din aceeasi locatie de memorie in acelasi ciclu;
-CW (Concurrent Write): mai multe procesoare pot sa scrie in
aceeasi locatie de memorie in acelasi ciclu.
Variante ale modelului PRAM:

-EREW-PRAM: este cel mai restrictiv;
-CREW-PRAM: conflictele de scriere sunt evitate prin excludere mutuala;
-ERCW-PRAM;
-CRCW-PRAM: este cel mai puternic model.
Rezolvarea conflictelor de scriere:

-COMMON-PRAM: toate operatiile de scriere memoreaza aceeasi valoare la
locatia accesata simultan;
-ARBITRARY-PRAM: se memoreaza una din valori (oricare), iar celelalte
sunt ignorate;
-MINIMUM-PRAM: se memoreaza valoarea scrisa de procesorul cu indexul
cel mai mic;
-PRIORITY-PRAM: se memoreaza o valoare obtinuta prin aplicarea unei
functii asociative (exemplu: insumare) tuturor valorilor cu care se acceseaza locatia de
memorie.
Algoritm secvential pentru inmultire de matrici
for (i=0; i<n; i++)

for (j=0; j<n; j++) {
c[i][j]=0;
for (k=0; k<n; k++)
c[i][j]+=a[i][k]*b[k][j];
}
Algoritmul necesita timpul de executie Ts = O(n3).
Algoritm CRCW-PRAM cu n3 procesoare pentru inmultire de matrici

-conflictele de scriere se rezolva cu modelul PRIORITY-PRAM folosind
operatorul de insumare;
-matricile a, b, c sunt in memoria partajata;
-cele n3 procesoare sunt plasate intr-un tablou 3D.
Algoritmul se executa in doua etape:
Etapa 1: fiecare procesor Pi,j,k calculeaza in paralel produsul a[i][k]*b[k][j].

Etapa 2: se face scrierea concurenta a procesoarelor Pi,j,0 ; Pi,j,1 ; Pi,j,2 ; .... ;
Pi,j,n-1 in locatia c[i][j] a termenilor a[i][0]*b[0][j], a[i][1]*b[1][j], a[i][2]*b[2][j], ...
, a[i][n-1]*b[n-1][j], care astfel se insumeaza.
Algoritmul paralel:
forall (0<= i<n)
forall (0<= j<n)
forall (0<=k<n) {
c[i][j]=0.0;
c[i][j] =a[i][k]*b[k][j];
}
Timpul de executie paralela Tp = O(1) => accelerarea S = O(n3) si eficienta E = 1.
Algoritm CREW-PRAM cu n3 procesoare pentru inmultire de matrici
Procesoarele ~ tablou 3D tablou suplimentar v cu n*n*n elemente in

memoria partajata in locul matricii c.
Etape:
Etapa 1: fiecare procesor Pi,j,k calculeaza in paralel produsul a[i][k]*b[k][j] si
inscrie rezultatul in v[i][j][k].
Etapa 2: reducerea prin insumarea a n elemente ale fiecarui vector din tabloul
2D v[i][j] (in total n2 vectori), folosind n procesoare pentru fiecare vector: Pi,j,0; Pi,j,1;
Pi,j,2; .... ; Pi,j,n-1, obtinand rezultatul in v[i][j][0].
Algoritmul:
forall (0<= i<n)
forall (0<= j<n)
forall (0<=k<n) {
v[i][j][k] =a[i][k]*b[k][j];
for (m=0; m<log2n; m++)
if (k % 2m+1 ==0)
v[i][j][k]+=v[i][j][k+2m];
}
Fiecare procesor executa un pas de calcul si log2n pasi pentru reducerea paralela
=> timpul de executie este:
Tp = 1 + log2n = O(log2n)
fiind cuprins intre O(n3) in cadrul algoritmului secvential si O(1) in algoritmul CRCW.
Accelerarea si eficienta:
S = O(n3/log2n)
E = O(1/log2n)
Operatia de reducere paralela (exemplu pentru 16 procesoare si 4 pasi):
2. CLASIFICAREA CALCULATOARELOR PARALELE

-SIMD (Single Instruction Multiple Data):
-Procesoare matriciale;
-Procesoare vectoriale;
-Procesoare sistolice VLSI.
-MIMD (Multiple Instruction Multiple Data):
-Multiprocesoare (MIMD cu memorie partajat):
-UMA (Uniform Memory Access):
-UMA cu magistrale;
-UMA cu comutatoare.
-NUMA (Non-Uniform Memory Access):
-CC-NUMA (Cache Coherent NUMA);
-NC-NUMA (Non Coherent NUMA).
-COMA (Cache Only Memory Access).
-Multicalculatoare (MIMD cu transfer de mesaje):
-MPP (Massively Parallel Processors):
-MPP cu gril;
-MPP hipercub.
-COW (Cluster Of Workstations).
3. TIPURI DE CALCULATOARE PARALELE
Calculatoare n band de asamblare

Calculatoare de masive
Sisteme multiprocesor
Calculatoare n flux de date
CMP
Calculatoare n band de asamblare
Execuia instruciunilor ntr-un calculator secveial.
Procesor n band de asamblare
Execuia instruciunilor ntr-un calculator n band de asamblare.
Structura funcional a unui calculator n band de asamblare.
Calculatoare de masive
(array processors)
Structura funcional a unui calculator de masive.
Structura funcional a unui sistem multiprocesor.
Calculatoare n flux de date

Exemplu: se consider calcularea expresiei: z = ( x + y ) * 2
Graful i abloanele n flux de date.
Mecanismul de execuie al unui program n flux de date.
CMP
CMP (Chip Multiprocessors) => TLP (thread-level parallelism) prin
rularea unor secvente complet separate de instructiuni pe procesoare separate.
Utilizeaza core-uri relativ simple pentru thread singular, dar executa thread-uri
multiple in paralel pe core-uri multiple.
simplitatea proiectului;
frecventa mai mare a ceasului;
scaderea timpului consumat cu validarea proiectului.
Scurt istoric CMP
Primul multicore de scop general: 2005 Intel Duo (doua nuclee Pentium M pe
un singur cip).
AMD Opteron dual-core: memorii cache L2 separate, dar o interfata comuna la
controllerul de memorie si la HyperTransport.
Niagara SPARC: opt nuclee simetrice multithread cu patru procesoare logice
fiecare.
Prima arhitectura CMP: L. Hammond, B. A. Nayfeh, and K. Olukotun, A
single-chip multiprocessor,, Computer, vol. 30, no. 9, pp. 7985, Sep. 1997:
(RDRAM = Rambus DRAM)

Exemplu: se consider un sistem simplu pentru calcularea convoluiilor, utiliznd o
reea liniar de elemente de prelucrare:
y(i) = w1*x(i)+ w2*x(i+1)+w3*x(i+2)+w4*x(i+3)
Reea liniar pentru calcularea convoluiilor.
4. PERFORMANE ALE CALCULATOARELOR

PARALELE
Masuratori de performanta
Factorul ctig de vitez
Principiul mediei armonice ponderate
Legea lui Amdahl
Limitri ale calculului paralel
Masuratori de performanta
Gradul de paralelism DOP (degree of parallelism) = numarul de procesoare

dintr-un calculator paralel utilizate pe un anumit interval de timp.
Profilul paralelismului = graficul DOP in functie de timp (pentru un anumit

program). Depinde de:
-structura algoritmului;
-optimizarea programului;
-utilizarea resurselor;
-conditiile de rulare.
Se considera un sistem paralel cu n procesoare identice.
Volumul de lucru W (work)

Notatii:
= capacitatea de calcul pentru un procesor, aproximata cu rata MIPS (million

instructions per second):
IC
f IC
f
Rata MIPS
6
6
6
T
10
CPI
10
C
10
unde
IC : numar instructiuni pentru program (instruction count);
T : timp de executie pentru program in secunde;
f : frecventa ceasului in Hz, egala cu 1/ ( perioada ceasului in secunde);
CPI : cicluri per instructiune (perioade de ceas necesare pentru executia unei
instructiuni);
C : numar de cicluri necesare pentru executia unui program.
Au fost utilizate relatiile:
C
CPI
IC
T C
C
CPI
I C CPI I C
f
f
Aproximarea cu rata MIPS sau rata Mflops nu tine seama de penalizarile cauzate de
accesul la memorie, latenta comunicatiei, overhead-ul sistemului.
Volumul de lucru este proportional cu aria de sub graficul profilului:

t2
W DOP (t )dt
t1
iar in cazul discret:

n
W i ti
i 1
unde ti = timpul total cat DOP = i, iar
t
i 1
t 2 t1
(timpul total scurs).
Paralelism mediu
Paralelismul mediu A (average paralellism):
t
1 2
A
DOP (t )dt
t 2 t1 t1
n
n
A i ti / ti
i 1
i 1
Aplicatie. Sa se determine paralelismul mediu pentru un algoritm de tip

divide-and conquer avand urmatorul profil al paralelismului.
Solutie
A = DOPi*ti / ti =
(1x5+2x3+3x4+4x6+5x2+6x2+8x3)/(5+3+4+6+2+2+3)=93/25=3.72
Factorul ctig de vitez

Definitie. Factorul ctig de vitez sau accelerare notat S (speedup) pentru
un calculator paralel este raportul dintre timpii necesari pentru rezolvarea aceleiai
probleme pe un sistem monoprocesor i respectiv pe sistemul paralel.
log2n < S < n/ln n
log2n supoziia lui Minsky.
Limita superioar n/ln n :

-o problem se rezolva pe un monoprocesor n unitatea de timp, T1=1;
- fi probabilitatea de a asigna aceeai problem la i procesoare, cu o ncrcare medie
di=1/i per procesor;
-se presupun probabiliti egale pentru fiecare mod de operare utiliznd i procesoare,
(fi=1/n pentru n moduri de operare, i=1,2,3,,n);
-timpul mediu necesar pentru rezolvarea problemei pe un sistem cu n procesoare :

n
Tn
i 1
i
f i d i i 1
n
-ctigul mediu de vitez S :
T1
n
n
n
1 ln n
Tn
i 1 i
Cazul ideal. Distributia de probabilitate este:

{0, 0, ... , 0, 1}
deci fi=0 pentru in si fn=1.

Incarcarile sunt di=1/i, deci dn=1/n.
Rezulta aplicand relatia precedenta ca:
Tn = fn dn = 11/n = 1/n
iar
S = T1/Tn = n
-volumul de lucru cu DOP =i:

n
W Wi
Wi i ti
i 1
-timpul de executie al volumului Wi pe un uniprocesor:
t i (1)
Wi
- timpul de executie al volumului Wi pe k procesoare:
ti (k )
Wi
k
k i
-intr-un sistem cu numar infinit de procesoare:
t i ( )
Wi
i
1 i n
-timpul de raspuns:
n
Wi
i 1
T (1) ti (1)
i 1
n
Wi
i 1 i
T ( ) t i ( )
i 1
=> factorul asimptotic de accelerare S :

n
T (1)
S
T ( )
W
i 1
n
Wi
i 1 i
i t
i 1
n
i ti
i
i 1
i t
i 1
n
t
i 1
=> S=A, dar aceasta numai in cazul ideal. In gerneral, S A (daca se

considera latenta comunicatie si alte overhead-uri).
Performanta medie aritmetica

-se noteaza cu Ri ratele de executie ale programelor i = 1, 2, 3, ... , n. Rata
medie aritmetica de executie:
n
Ra
R
i 1
n
(s-a presupus ponderea 1/n pentru fiecare din cele n programe).
-daca programele au ponderi cu o distributie oarecare = { fi | i = 1, 2, ..., n}:

n
R f i Ri
*
a
i 1
Performanta medie geometrica

-rata de executie medie geometrica:
n
Rg Ri1/ n
i 1
-iar pentru o distributie a ponderilor = { fi | i = 1, 2, ..., n}:

n
Rg* Ri f i
i 1
Rata de executie medie armonica

-timpul mediu de executie per instructiune pentru programul i:
1
Ti
Ri
-timpul mediu (aritmetic) de executie per instructiune:
1 n
1 n 1
Ta Ti
n i 1
n i 1 Ri
=> rata de executie medie armonica este inversul timpului mediu:
Rh
n
n
i 1
1
Ri
=> rata de executie medie armonica ponderata pentru o distributie oarecare de

ponderi = { fi | i = 1, 2, ..., n}:
1
*
Rh
i 1
fi
Ri
Principiul mediei armonice ponderate

Fie Tn timpul necesar execuiei a m taskuri de n tipuri diferite, fiecare tip
constnd din mi taskuri, necesitnd ti secunde:
n
m mi
Tn mi ti
i 1
i 1
Rata de execuie R (numrul de evenimente sau operaii n unitatea de timp):
m
R
Tn
*
h
1
n
n
mi
mi ti
ti
i 1
i 1 m
mi
fi
m
Se definesc fi ca fracia de rezultate generate la rata Ri i ti=1/Ri ca timpul necesar

pentru generarea unui rezultat
mi
fi
;
m
Rata globala a masinii:
Rh*
1;
1
n
i 1
f i ti
1
n
i 1
fi
Ri
1
Ri
ti
Legea lui Amdahl

caz particular al principiului mediei armonice ponderate.
Pentru un sistem de calcul se consider dou rate de execuie:
-rata de execuie superioar (sau paralel) RH;
-rata de execuie inferioar (sau serial) RL.
Dac f reprezint fracia rezultatelor generate cu rata RH i 1-f este fracia rezultatelor
generate cu rata RL, ecuaia mediei armonice ponderate devine:
R( f )
f
RH
1
1 f
RL
Aplicatie. Un sistem multiprocesor este capabil de o rata maxima de executie

de 100 MFLOPS. Codul scalar este prelucrat cu o rata de 1 MFLOPS. Care este
performanta masinii daca 10% din cod este secvential si 90% este paralel ?
Solutie
Deoarece se considera numai doua rate de executie (secvential si paralel) se va utiliza
legea lui Amdahl, in care:
RH = 100
RL = 1
f = 0.9
1f = 0.1
1
1
R
9.17 MFLOPS
f
1 f
0.9 0.1
RH
RL
100 1
Factorul de accelerare medie armonica

Se presupune executia unui program (sau o incarcare cu mai multe programe)
pe un sistem cu n procesoare. In diferite intervale de timp sistemul poate utiliza i=1, 2,
..., n procesoare (modul i cu i procesoare).
-timpul secvential pe un uniprocesor cu R1 = 1:
1
T1
1
R1
-timpul de executie cu i procesoare cu Ri = i, in cazul ideal:
Ti
1
1
Ri
i
Programul este executat in n moduri de functionare cu o distributie a ponderilor

= { fi | i = 1, 2, ..., n}.
=> factorul de accelerare medie armonica:
T1
S *
T
*
h
fi
i 1 Ri
unde T* = 1/Rh* este timpul mediu armonic de executie pentru cele n moduri de
executie.
Se presupune Ri = i, = (1-f, 0, 0, ..., 0, f). In ecuatia pentru Sh* se inlocuieste

R1 = 1 si Rn = n:
1
n
S
1 f f 1 f f n(1 f ) f
R1 Rn
1
n
*
h
Consecinta: Sh* 1/(1-f) pe masura ce n .
Eficienta, utilizarea si calitatea

Se noteaza:
O(n) = numarul de operatii unitare executate intr-un sistem cu n procesoare.
T(n) = timp de executie (unitati de timp) in general O(n) > T(n).
T(1) = O(1) intr-un uniprocesor.
Se definesc:
-factorul de accelerare:
S ( n)
T (1)
T ( n)
E ( n)
S ( n)
T (1)
n
n T ( n)
-eficienta:
Deoarece 1S(n) n => 1/nE(n) 1.

-redundanta:
O ( n)
R ( n)
O(1)
Evident 1R(n) n.
-utilizarea:
U ( n) R ( n) E ( n)
O ( n)
n T ( n)
Sunt interesante urmatoarele relatii:

1/nE(n) U(n) 1
1R(n) 1/E(n) n
-calitatea paralelismului:
S ( n) E ( n)
T 3 (1)
Q ( n)
R ( n)
n T 2 ( n) O ( n)
deoarece E(n) 1, 1R(n) n => Q(n) este limitat superior de S(n).
Aplicatie. Se considera o incarcare O(1)=T(1)=n3, O(n)=n3+n2log2n,

T(n)=4n3/(n+3), unde n = numar de procesoare. Sa se determine accelerarea, eficienta,
redundanta, utilizarea si factorul de calitate. Apoi sa se reprezinte grafic.
Solutie
Substituind in relatiile:
Se observa relatiile: 1/n E(n) U(n) 1 si 0 Q(n) S(n) n. Accelerarea ideala

corespunde cazului ideal cu eficienta 100%.
Limitri ale calculului paralel

variabile:
-ts = timpul de sincronizare;
-t = timpul mediu de execuie a unui task (granularitatea taskurilor);
-to = overhead-ul taskurilor cauzat de execuia paralel;
-N = numrul de taskuri executate ntre dou puncte de sincronizare;
-n = numrul de procesoare.
Execuia secvenial a celor N taskuri, fiecare necesitnd un timp t are loc ntr-un
timp total T1 = N t.
ntr-un sistem paralel:
-fiecare task necesit (t+to) uniti de timp, n loc de t.
-N taskuri pe n procesoare numr pai paraleli (raportul celular) = N/n.
Timpul de execuie paralel:
TN , n
N
t s (t to )
n
Factorul de accelerare:
S N ,n
T1
TN ,n
Nt
1
to
N
N
t s (t to )
(1 )
ts n
t
n
Nt
N
Mrirea factorului de accelerare:

-efectul sincronizrii ts/(Nt):
-scderea timpului de sincronizare ts;
-creterea produsului Nt (nsemnnd intervale mai largi ntre sincronizri).
-efectul de overhead to/t,:
-scderea timpului de overhead to;
-creterea granularitii t.
-numrul de pai de calcul N/n :
-utiliznd mai multe procesoare;
-numr de taskuri multiplu al numrului de procesoare.
Eficiena sistemului multiprocesor se definete prin relaia:
E N ,n
S N ,n
n
Limitrile calculului paralel trecerea la limit n relaiile pentru creterea de vitez

SN,n i eficiena EN,n. Rezultatele n tabela:
TOP 500 iunie 2013 (Rmax si Rpeak in TFlops, Power in KW pentru intregul sistem).
5. PROGRAME PARALELE
Cateva exemple de aplicatii complexe ale calculatoarelor paralele:

-simularea curentilor oceanici (structura regulata si calcule stiintifice);
-simularea evolutiei galaxiei (structura neregulata si calcule stiintifice);
-generarea scenelor prin metoda Ray Tracing (aplicatie de grafica pe
calculator cu structura neregulata);
-Data Mining (structura neregulata).
Simularea curentilor oceanici

Forte fizice: efectele atmosferice, vantul si frecarea cu fundul oceanului
=> sisteme complexe de ecuatii.
Problema continua in spatiu (intinderea oceanului) si in timp (se face studiul pe un

interval mare de timp) => discretizarea problemei dupa ambele dimensiuni.
Discretizarea spatiului: grid de puncte egal distantate, fiecare punct avand valori pentru
marimile de interes ( presiune, viteza, etc). Se utilizeaza un set de griduri
bidimensionale (sectiuni orizontale prin volumul oceanului).
Timpul discretizat: serie finita de pasi.

Solutia depinde de rezolutia aleasa in ambele dimensiuni (spatiu
si timp). Exemplu: o zona din ocean de 2000x2000 km2 un grid de
100x100 este insuficient (distanta dintre doua puncte 20 km, iar pentru
simularea pe 5 ani, cu un pas de timp de 8 ore => 5500 pasi de timp).
Problema prezinta un paralelism intrinsec (calculele si
actualizarea valorilor diferitelor puncte din spatiu se pot face in paralel).
Astfel, de exemplu se poate asigna cate un grid unui procesor, calculele
realizandu-se in paralel.
Simularea evolutiei galaxiei

Studiul evolutiei in timp a stelelor intr-un sistem de galaxii (probleme de
coliziune a galaxiilor, gruparea stelelor in galaxii).
Se simuleaza deplasarea a n corpuri, fiecare corp fiind sub influenta tuturor
celorlalte corpuri (problema n-body). Timpul discretizat, mai multi pasi de timp. Pentru
fiecare pas se calculeaza fortele gravitationale exercitate, actualizand pozitia, viteza si
alti parametri pentru fiecare corp.
n corpuri => complexitate O(n2), dar prin algoritmi ierarhici => complexitate
O(n log n).
Algoritmii ierarhici se bazeaza pe faptul ca forta de interactiune scade cu
distanta (~1/r2), deci influentele corpurilor foarte indepartate pot fi calculate prin
gruparea acestora si considerarea grupului ca un singur corp in centrul de masa, fara
pierdere de precizie.
Algoritmii ierarhici: forta de interactiune scade cu distanta (~1/r2).

=> influentele corpurilor foarte indepartate -> prin gruparea acestora!
=> cu cat stelele sunt mai indepartate de steaua curenta cu atat grupurile de
aproximare pot fi mai mari.
Algoritmul utilizat: Barnes-Hut.
Caracteristici:
1) Distributia de stele neregulata (galaxiile mai dense in anumite zone si mai
imprastiate in altele).
2) Distributia se modifica in timp (evolutia in timp).
=> structura neregulata si dinamica a sistemului de galaxii
(implementare dificila pe un sistem paralel).
Paralelizarea programelor
Algoritm secvential pentru rezolvarea unei probleme => programul paralel.
Este necesar:
-sa se identifice activitatile (incluzand calcule, accesul la date si operatii de
I/E) care pot fi efectuate in paralel;
-sa se imparta activitatea si eventual si datele intre procese;
-sa se gestioneze accesul datelor, comunicatia si sincronizarea;
Scop: micsorarea timpului de calcul => factorul de accelerare S=T(1)/T(n).
Pasii pentru crearea unui program paralel:
1. Descompunerea: spargerea calculului (algoritmului) intr-o colectie de

taskuri -> distribuite procesoarelor.
Exemplu. Program cu doua etape:
1) se calculeaza in mod independent n2 valori (tablou nxn);
2) se insumeaza cele n2 rezultate.
Sistem cu p procesoare: n2/p calcule fiecarui procesor(in paralel), apoi
rezultatele insumate secvential intr-o variabila globala.
Timpul total in acest caz este n2/p+n2 (fata de 2n2 unitati de timp in cazul
secvential). Factorul de accelerare obtinut este:
(limita 2).
Imbunatatirea algoritmului: in etapa a doua fiecare procesor face o suma locala

a rezultatelor obtinute, iar apoi aceasta suma este adunata la rezultatul final (variabila
globala).
Timpul: n2/p+n2/p+p=2n2/p+p.
Factorul de accelerare in acest caz se obtine:
(pentru n mare, limita apropiata de p).
Profilul concurentei: numarul de operatii (sau taskuri) disponibile pentru

executie concurenta la un moment dat.
Aria de sub grafic = volumul total de prelucrare (timp uniprocesor).

Limita orizontala din grafic = timpul cel mai scurt de executie a aplicatiei (presupunand
un numar infinit de procesoare). Factorul de accelerare:
2. Asignarea: mecanism de distribuire a taskurilor la procese (exemplu:

algoritm Barnes-Hut -> care procese calculeaza fortele de interactiune pentru care
stele).
Scop principal: echilibru de incarcare intre procese (reduce comunicatia intre
procese si costul gestionarii).
Asignarea poate sa fie:
-statica (predeterminata): asignarea este complet determinata la inceputul
programului, sau dupa introducerea datelor initiale si nu se modifica in timpul executiei
aplicatiei;
-dinamica: asignarea lucrului la procese se determina in timpul executiei,
eventual ca reactie la un dezechilibru de incarcare.
3. Orchestrarea: determinata de arhitectura si modelul de programare (chiar si

de limbajul de programare).
Mecanisme:
-accesare date;
-comunicatie intre procese;
-sincronizare;
-planificarea taskurilor asignate unui proces (ordinea in care taskurile sunt
executate).
Scop: reducerea costului comunicatie si sincronizarii vazute de procesoare,

planificarea executiei mai devreme a taskurilor de care depind alte taskuri, reducerea
overhead-ului corespunzator gestionarii paralelismului.
4. Maparea: repartizarea proceselor la procesoare (dupa etapele 1, 2, 3 =>

program paralel).
Controlul maparii:
-program;
-S.O.
In cazul cel mai simplu: procesoarele masinii impartite in subseturi si doar un
singur program poate rula la un moment dat pe un subset (partajarea spatiului).
Cealalta solutie extrema: S.O. controleaza dinamic momentul si spatiul (setul

de procesoare) pentru executia proceselor (fara interventia utilizatorului).
=> o mai buna partajare si utilizare a resurselor.
In multe situatii reale: combinatie a celor doua.
Paralelizarea unui program

Modul al aplicatiei de simulare a curentilor oceanici: rezolvarea iterativa de
ecuatii (equation solver).
Limbaj pseudocod tip C, cu extensii pentru specificarea paralelismului
(primitive de sincronizare si comunicatie, in cadrul arhitecturilor cu memorie partajata
sau in transfer de mesaje).
Metoda de diferente finite (Gauss-Siedel): tablou bidimensional de
(n+2)x(n+2) elemente corespunzator unui grid (sectiune orizontala prin volumul
oceanului). Punctele de pe granite nu se modifica, in timp ce cele nxn puncte interioare
sunt actualizate de program pornind de la valorile lor initiale, intr-un numar de pasi. La
fiecare pas se opereaza asupra tuturor punctelor interioare ale gridului, fiecare punct
fiind inlocuit printr-o medie ponderata a vecinilor imediati.
Actualizarile se fac imediat (un punct va vedea valorile noi la vecinii sus si
stanga si valorile vechi la vecinii jos si dreapta).
Se calculeaza de asemenea si diferenta dintre valoarea veche si valoarea noua
pentru fiecare punct. Daca diferenta medie peste toate elementele este mai mica decat o
valoare predefinita solutia a convers si se incheie algoritmul, altfel se continua cu un
nou pas.
Algoritmul secvential:
1) Descompunerea.
-studierea buclelor: daca iteratiile pot fi executate in paralel (aici nu exista
concurenta: datele utilizate in iteratia curenta sunt actualizate in iteratia precedenta, deci
iteratiile nu se pot executa in paralel).
-examinarea dependentelor fundamentale. Ordinea de actualizare a punctelor
gridului este stanga->dreapta si sus->jos, deci punctele de pe antidiagonala (diagonala
secundara, NE->SV) sunt independente din p.d.v. al calculului si deci pot fi calculate in
paralel. Dezavantaje: prea multe puncte de sincronizare si incarcarea este dezechilibrata
(procese cu numar de puncte intre 1 si n).
-cunoasterea problemei: ordinea de evaluare a punctelor din grid nu este

esentiala in metoda Gauss-Seidel => alta ordine: ordinea gri-negru. Fiecare pas al
algoritmului este impartit in doua faze complet echilibrate (actualizarea n2/2 puncte gri
si actualizare n2/2 puncte negre) ce se pot executa in paralel, cu o singura operatie de
sincronizare (care nu este absolut necesara, dar convenabila).
Daca se opteaza pentru o descompunere la nivel de puncte de grid se inlocuiesc liniile

15-26 prin secventa:
for -> for_all (paralelizare, gradul de concurenta obtinut fiind n2).

Descompunere pe randuri: linia 18 for_all -> for (grad de concurenta n).
Sincronizare globala la sfarsitul buclei for_all (end for_all).
2) Asignarea. Solutia statica (cea mai simpla): se asigneaza cate un bloc compact de
randuri la un proces (asignare de blocuri), astfel incat randul i este asignat procesului
Avantaj: reducerea comunicatiilor (randurile adiacente sunt pastrate impreuna la acelasi

proces).
Solutia dinamica: un proces terminand de calculat un rand, va prelua un alt

rand necalculat.
3a) Orchestrarea in modelul paralelismul datelor. Declaratiile globale

desemneaza date partajate, iar toate celelalte date sunt private unui proces. Se utilizeaza
o instructiune DECOMP: asignarea iteratiilor la procese (aici asignare de blocuri, adica,
prima dimensiune, randuri, se distribuie in blocuri compacte, uniform, celor nprocs
procese).
3b) Orchestrarea in modelul cu memorie partajata. Tabloul A este declarat

partajat, elementele acestuia fiind accesate de procese pe masura ce sunt necesare,
folosind instructiuni load/store obisnuite. Sunt utilizate mecanisme pentru crearea de
procese, coordonarea acestora prin sincronizare si controlul asignarii lucrului la acestea.
Program de tip SPMD (Single Program Multiple Data). Se utilizeaza o serie de

primitive cu implementari in diferite masini fizice cu memorie partajata:
3c) Orchestrarea in modelul cu transfer de mesaje. Matricea A reprezentata

prin structuri de date mai mici, alocate spatiilor private ale proceselor care le
prelucreaza. In cazul acestui algoritm se aloca fiecarui proces cate un set de randuri
consecutive din cadrul gridului.
Se pot utiliza operatiile REDUCE si BROADCAST pentru simplificarea codului:
Concluzii:
-descompunerea si asignarea sunt asemanatoare in cele doua modele
importante, cu memorie partajata si in transfer de mesaje;
-orchestrarea este diferita (structuri de date, accesul/denumirea datelor,
comunicatia, sincronizarea).
Diferente:
RETELE DE INTERCONECTARE
PROPRIETATI ALE RETELELOR DE INTERCONECTARE

RETELE STATICE
RETELE DINAMICE
RETELE PE UN CIP
RETELE DE SORTARE
RETELE DICTIONAR SI DE CAUTARE
PROPRIETATI ALE RETELELOR DE

INTERCONECTARE
Consideratii de proiectare a retelelor

1) Cerinte de performanta. Procesele rulate pe diferite procesoare executa
sincronizari si comunicatii (prin transfer de mesaje sau acces la variabile
partajate) utilizand reteaua de interconectare cu o latenta ce influenteaza
performantele. De asemenea, reteaua se poate satura, limitand puterea de calcul.
Alt factor: rata ("throughput") = cantitatea maxima de informatie livrata prin
retea per unitate de timp.
2) Scalabilitate. Arhitectura scalabila permite ca prin adaugarea de procesoare

sa creasca proportional largimea de banda pentru memorie, I/E si reteaua de
interconectare (altfel componentele respective devin gatuiri in sistem).
3) Expandabilitate incrementala. Utilizatorul nu achizitioneaza intotdeauna

configuratia maxima de procesoare si memorie. Unele retele necesita 2k
procesoare, sau expandabilitatea poate implica costuri mari. Retelele de
interconnectare trebuie sa permita expandabilitate incrementala pentru adaugarea
unui numar mic de procesoare minimizand costurile.
4) Partitionabilitate. Calculatoarele paralele sunt utilizate de mai multi
utilizatori la un moment dat si este necesar ca traficul fiecarui utilizator sa nu
afecteze celelalte aplicatii.
5) Simplicitate. Solutiile simple conduc de multe ori la frecvente mai mari ale
ceasului si deci si performante mai mari. O structura simpla poate fi usor
inteleasa de utilizator si deci mai bine exploatata.
6) Distanta. Distanta dintre componente si solutiile de impachetare duc la
diferite solutii pentru retelele de interconectare: fire de cupru (multicalculatoare),
legaturi optice (NOW).
7) Fiabilitate si reparabilitate.
8) Constrangeri de cost.
Marimi caracteristice
O retea - graf cu un numar finit de noduri, conectate prin arce orientate sau
neorientate.
Gradul nodului (d degree) = numarul de arce (legaturi sau canale) conectate la

nod. Reflecta numarul de porturi de I/E necesare pentru un nod, deci costul unui nod.
Diametrul (D) = maximul dintre cele mai scurte cai care leaga oricare doua noduri
(numar de legaturi traversate).
Largimea sectiunii (b bisection width) = numarul minim de arce (canale) de-a
lungul unei sectiuni care imparte reteaua in doua jumatati. Daca fiecare canal are o
largime de w biti, atunci largimea sectiunii la nivel de fire este B = bw.
Lungimea firului (canalului) intre noduri poate afecta latenta semnalului, alunecarea
ceasului si cerintele de alimentare.
Functiile de rutare a datelor sunt utilizate pentru transferul de date intre elementele
de prelucrare, fiind implementate in routere hardware. Exemple: deplasare (shifting),
rotatie, permutatie (unu la unu), broadcast (unu la toate), multicast (unu la mai
multe), shuffle, etc.
Tipuri simple de operatii
-calcul de semigrup;
-calcul de prefixe paralele;
-rutare de pachete;
-broadcasting si versiunea mai generala multicasting;
-sortarea inregistrarilor in ordine crescatoare/ descrescatoare a cheilor.
Calcul de semigrup.
Fie un operator binar asociativ:
(x y) z = x (y z)
pentru x, y, z S.
Un semigrup este perechea (S, ).
Calcul de semigrup: considerand o lista de n valori x0, x1, ... , xn-1, calculeaza x0
x1 ... xn-1.
Operatorul poate sa fie +, x, , U, max, min.
Operatorul poate sa fie comutativ sau nu (foarte important, caci algoritmul
paralel poate sa calculeze bucati din expresie, iar apoi bucatile trebuie combinate in
ordinea stanga-dreapta).
Exemplu de calcul de semigrup pe un uniprocesor:
Calcul de prefixe paralele. Cu aceleasi presupuneri ca mai inainte, calculul de

prefixe paralele se defineste ca evaluarea simultana a tuturor prefixelor expresiei x0 x1
... xn-1., adica x0 x1, x0 x1 x2, ..., x0 x1 ... xn-1. Graful reprezentand
calculul de prefixe paralele este asemanator cu cel precedent, dar sunt furnizate iesiri
pentru valori intermediare.
Rutare de pachete. Un pachet se afla la procesorul i si trebuie trimis la
procesorul j, intr-un timp cat mai scurt. Problema se complica daca pachete multiple se
gasesc la procesoare diferite, fiecare avand destinatie proprie. Daca fiecare procesor are
cel mult un pachet de trimis si unul de primit, problema se numeste comunicatie unu-launu sau rutare 1-1.
Broadcasting. O valoare a de la procesorul i trebuie trimisa cat mai rapid la

toate celelalte procesoare din sistem. Se mai numeste comunicatie unu-la-toti.
Sortare. Fiind data o lista de n chei x0 , x1 , ..., xn-1 si o ordine totala peste
chei, trebuie rearanjate cele n chei sub forma xi0 , xi1 , ... , xi(n-1). astfel incat xi0 xi1 ...
xi(n-1). Se considera numai sortarea in ordine nedescendenta (orice algoritm de sortare
in ordine nedescendenta poate fi convertit in ordine neascendenta).
Clasificarea retelelor de interconectare

-retele statice:
-conexiuni fixe in timp (nu se modifica in timpul executiei programului);
-o conexiune => legatura punct-la-punct intre doua noduri;
-se utilizeaza in multicalculatoare (sisteme MIMD cu transfer de mesaje).
-retele dinamice:
-conexiuni dinamice intre componente (se modifica in timpul executiei
programului paralel, in functie de cerintele de comunicatie);
-contin comutatoare (switches) si interconexiuni (links);
-se utilizeaza in multiprocesoare (sisteme MIMD cu memorie partajata).
O clasificare mai detaliata:

1) Retele cu mediu partajat
-LAN (Local Area Networks)
-Contention Bus (Ethernet)
-Token Bus (Arcnet)
-Token Ring (FDDI Ring, IBM Token Ring)
-Backplane Bus (Sun Gigaplane, DEC AlphaServer8X00, SGI PowerPath-2):
2) Retele directe (retele bazate pe routere)

-Topologii strict ortogonale
-Mesh
-2-D Mesh (Intel Paragon)
-3-D Mesh (MIT J-Machine)
-Torus (k -ary n -cube)
-1-D Unidirectional Torus / Ring (KSR First-Level Ring)
-2-D Bidirectional Torus (Intel/CMU iWarp)
-3-D Bidirectional Torus (Cray T3D, Cray T3E)
-Hypercube (Intel iPSC, nCUBE)
-Alte topologii: Trees, Cube-Connected Cycles, de Bruijn Network, Star
Graphs, etc.
3) Retele indirecte (retele bazate pe comutatoare)

-Topologii regulate
-Crossbar (Cray X/Y-MP, DEC GIGAswitch, Myrinet)
-Retele de interconectare multinivel (MIN)
-Retele blocante
-MIN unidirectional (NEC Cenju-3, IBM RP3)
-MIN bidirectional (IBM SP, TMC CM-5, Meiko
CS-2)
-Retele neblocante: retele Clos
-Topologii neregulate (DEC Autonet, Myrinet, ServerNet)
4) Retele hibride
-Multiple-Backplane Buses (Sun XDBus)
-Retele ierarhice (Bridged LANs, KSR)
-Retele bazate pe clustere (Stanford DASH, HP/Convex Exemplar)
-alte topologii hipergraf: Hyperbuses, Hypermeshes, etc.
RETELE STATICE
Retea liniara
Inel. Inel cu coarde
Barrel shifter
Arbore si stea
Arbore gros
Retea plasa. Tor
Retele sistolice
Hipercuburi
Cicluri cub-conectate
Retea n-cub de baza k
Retea liniara
retea unidimensionala care conecteaza N noduri prin N-1 legaturi.
-grad nod intermediar d = 2;

-grad nod terminal d = 1;
-diametrul D = N-1 (afecteaza performantele pentru N mare);
-largimea sectiunii b = 1.
=> Este cea mai simpla topologie de conectare, fiind economic pentru N mic. Nu se
utilizeaza pentru N mare.
Algoritm simplu pentru o retea liniara din categoria calcul de semigrup:

gasirea maximului (fiecare procesor sa detina valoarea maxima). Fiecare procesor
detine valoarea proprie si contine o variabila locala maxim_curent. Fiecare procesor
primeste valorile de la vecinii dreapta si stanga si seteaza variabila maxim_curent la cea
mai mare valoare dintre (stanga, propriu, dreapta). Exemplu: retea cu 9 procesoare.
In cazul cel mai defavorabil sunt necesari N-1 pasi de comunicatie.
Algoritm din categoria calcul de prefixe paralele: fiecare procesor detine cate
o valoare initiala si in etape succesive procesorul curent preia valoarea de la vecinul
stang, aduna cu valoarea proprie si trimite la vecinul drept.
Timp necesar: N-1 unitati de timp (pasi de comunicatie).
Rutarea de pachete: pentru a trimite un pachet de la procesorul i la

procesorul j, se ataseaza un tag de routare cu valoarea j-i.
Semnul tagului determina sensul de deplasare (+ = dreapta, - =
stanga), iar valoarea indica actiunea (0 = este la destinatie, nonzero =
transmite pachetul).
La fiecare deplasare tagul este decrementat cu 1=> in retea pachete
multiple pot tranzita spre dreapta sau spre stanga, fara sa interfereze.
Broadcast:
-procesorul sursa i doreste sa trimita o valoare a la toate procesoarele
=> trimite mesaje:
- rbcast(a) procesorului din dreapta;
-lbcast(a) procesorului din stanga.
-un procesor receptionand rbcast(a) copiaza local valoarea lui a
=> trimite mesaj rbcast(a) catre vecinul din dreapta.
-un procesor receptionand lbcast(a) copiaza local valoarea lui a

=> trimite mesaj lbcast(a) catre vecinul din stanga.
Sortare: doua versiuni, cu I/E (a) si fara I/E (b).

a) Se considera N valori care intra in retea, cate una la un moment dat, de la
stanga la dreapta. Fiecare procesor, receptionand o valoare compara valoarea de la
intrare cu valoarea proprie memorata intr-un registru (initial +), pastreaza valoarea
mai mica in registru si trimite vecinului din dreapta valoarea mai mare.
Dupa intrarea valorii N (ultima) mai sunt necesare N-1 cicluri suplimentare de
comunicatie pentru ca valorile in tranzit sa ajunga la destinatie.
Daca lista sortata trebuie furnizata in exterior incepand din stanga, faza de
iesire poate sa inceapa imediat ce ultima valoare a intrat in retea. In acest caz lungimea
retelei poate sa scada la , obtinand un timp de sortare zero, timpul total necesar fiind
egal cu timpul de I/E.
b) Daca cheile de sortat se gasesc deja la procesoare se poate utiliza

algoritmul transpozitie impar-par ("odd-even transposition") cu N pasi:
-la fiecare pas impar fiecare procesor impar compara valoarea proprie cu
valoarea vecinului dreapta (par), schimband valorile daca ordinea nu este buna;
-la fiecare pas par fiecare procesor par compara valoarea proprie cu
valoarea vecinului dreapta (impar), schimband valorile daca ordinea nu este buna.
In cazul cel mai defavorabil, valoarea cea mai mare aflata in procesorul 0 ajunge
in celalalt capat al retelei in N-1 pasi, adaugand inca un pas suplimentar, caci nu
are loc nicio deplasare la primul pas.
(pasii impari sunt marcati).
Evaluarea performantelor algoritmului:

-cel mai bun algoritm secvential necesita Nlog2N pasi comparatie-interschimb
pentru a sorta N valori;
T(1) = O(1) = N log2N
T(N) = N;
O(N) = N2/2
=>
(O=numar operatii unitare)
S(N) = log2 N
(supozitia lui Minsky?)
E(N) = (log2N)/N
=>
R(N) = N/(2log2N)
U(N) = 1/2
Q(N) = 2(log2N)3/N2
Inel. Inel cu coarde

conectarea nodurilor terminale ale unei retele liniare. Poate fi unidirectional
sau bidirectional. Este simetric !
sau intr-o alta reprezentare:

-grad nod d = 2 (constant);
-diametru D = N/2 (inel bidirectional) sau D = N
(inel unidirectional).
Prin cresterea gradului de nod (exemplu la 3 sau 4 => un inel cu

coarde (de grad 3, respectiv 4).
scade diametrul retelei !
Comparand retelele inel si inel cu coarde de grad 4

=> diametrul D 4 2.
In caz extrem, pentru reteaua complet conectata gradul de nod d = 7, iar

diametrul D = 1.
Exemple: Token Ring IBM, CDC Cyberplus Multiprocessor, KSR-1.
Barrel shifter
Intr-o retea de dimensiune N=2n , nodul i este conectat la nodul j, daca distanta
dintre nodurile j si i =2r, pentru r=0, 1, 2, ..., n-1. Gradul de nod este d=2n-1 si
diametrul D=n/2.
Exemplu: retea barrel shifter cu N=8 (n=3).
=> d=2n-1=5 si D=3/2=1.5 (=2).
Arbore si stea
-arbore complet echilibrat avand k niveluri => N = 2k 1 noduri;
-grad maxim de nod d = 3;
-diametrul D = 2(k - 1) (lungimea caii care leaga doua frunze cu radacina ca
unic ascendent comun).
Exemplu: k = 5 => arbore N = 31 noduri.
sau intr-o alta reprezentare:
=> grad de nod constant (arhitectura scalabila), dar diametru mare.
Steaua este un arbore cu doua niveluri, grad de nod maxim d = N-1 (nodul
central) si diametrul D = 2.
Exemplu: sistemul multiprocesor DADO de la Columbia University (arbore binar cu 10

niveluri si 1023 noduri).
Arbore gros
Arborele gros (fat tree) propus de Leiserson in 1985 => largimea de canal
creste de la frunze spre radacina.
sau
Exemplu: sistemul CM-5.
Retea plasa. Tor

Retea plasa (mesh):
N = nk noduri;
grad de nod interior d = 2k;
diametru D = k(n 1).
-numar de dimensiuni k
-numar de noduri dintr-o dimensiune n
Exemplu: k = 2, n = 6, N = 36 => d = 4 (gradele nodurilor de pe granite si din

colturi: 3, respectiv 2).
Exemple de sisteme: Illiac IV, MPP, DAP, CM-2, Intel Paragon.
- reteaua mesh Illiac: dimensiune n*n => diametru D=n-1 (jumatate din
diametrul mesh-ului pur).
Torul
-varianta de mesh (diametru si mai mic - combina inelul si meshul);
-conexiuni de inel dupa fiecare linie si coloana.
=> tor n*n: grad de nod d = 4, diametru D = 2 n/2 .
Retele sistolice
- implementeaza algoritmi ficsi.
Exemplu: retea pentru inmultirea a doua matrici.
-grad nod interior d = 6;

-utilizare: sisteme cu fluxuri multidirectionale de date, procesoare de masive
VLSI, pentru aplicatii speciale;
-raport performanta / cost bun;
-dezavantaje: aplicabilitate limitata si dificultate de programare.
Hipercuburi
=> hipercub de dimensiune n are N = 2n noduri (2 noduri / dimensiune);
-grad nod d = n si diametru D = n;
-fiecare nod: ci de comunicaie directe i separate ctre n alte noduri
(muchiile cubului);
-fiecare nod: adres n bii (2n adrese distincte).
=> alta reprezentare 2D a unei retele hipercub de dimensiune mare:

n=4
n=5
n=4
n=5
Exemple:
-cubul cosmic Caltech, dimensiune n=6 i N=64 de procesoare;
-sisteme comerciale: NCUBE, Intel i FPS - Floating Point System
(memoria distribuit ntre noduri, numai cu memorie local la fiecare nod).
Avantaje:
-fiecare procesor cu memoria sa local i canalele directe de
comunicaie => problema gtuirii sistemului este mai puin important!
Dezavantaj:
-sisteme hipercub comerciale - comunicaie direct interprocesor
serial => limiteaza productivitatea!
Cicluri cub-conectate
=> ciclurile cub-conectate (CCC cube connected cycles) - modificare a
arhitecturii hipercub.
Exemplu: hipercub de dimensiune 3 => ciclu cub-conectat de dimensiune 3.
-retea CCC de dimensiune k provine de la un hipercub de dimensiune

k (cu n = 2k noduri) in care fiecare nod inlocuit printr-un inel avand k noduri.
=>retea cu k*2k noduri !
In general, diametrul unei retele CCC de dimensiune k este D = 2k.
Pentru reteaua din figura (k = 3) => diametrul D = 6 (dublul
diametrului hipercubului de origine).
-avantaj: grad constant de nod d = 3 (nu depinde de dimensiunea
hipercubului)
=> o arhitectura mai buna pentru realizarea sistemelor
scalabile (daca se permite tolerarea latentei).
Retea n-cub de baza k

(k -ary n -cube)
n = dimensiunea cubului;
k = numarul de noduri de pe fiecare dimensiune.
Exemplu: retea 3-cub de baza 4:
-numarul de noduri este N=kn;
-un nod => adresa de n cifre in baza k:

A = a0a1...an-1
unde ai reprezinta pozitia nodului in dimensiunea i;
-toate legaturile sunt bidirectionale;
-torul obisnuit bidimensional 3*3 este un 2-cub de baza 3;
-costul acestei retele este dominat de numarul de fire si
mai putin de numarul de comutatoare.
Tabel recapitulativ cu principalele caracteristici ale retelelor statice:
Implementarea fizica a retelelor statice

=> solutii tridimensionale (placile dispun de conectori pe ambele fete, nu
numai lateral).
-fiecare nod: un modul de prelucrare si un modul de comunicatie;

-modulul de comunicatie: CFSM (Communication Finite State Machine);
-interfata catre procesor: cozi FIFO.
Datele sunt transferate intre doua noduri vecine intr-o perioada de ceas !
Exemplu: nod NuMesh.
-topologia: tip mesh (posibil anumite noduri nu sunt populate);

-nodurile speciale -> periferia sistemului.
-sistemul ~ banda de asamblare bidimensionala;

-buffer-ele FIFO -> functionarea procesoarelor la viteze diferite;
-ceas de control: distribuit.
RETELE DINAMICE
Magistrale
Comutatoare grila
Retele multinivel
Magistrale
-una sau mai multe magistrale pentru inteconectarea componentelor;
-organizarea general: magistral multiplexat n timp cu n procesoare, m
module de memorie partajat i d dispozitive de I/E (partajate ntre procesoarele
sistemului).
Exemple: sisteme multiprocesor comerciale - Sequent, Encore, ELXSI.
Avantaj:
-flexibilitate (se pot oricnd aduga sau elimina module);

Dezavantaj:
-magistrala - resurs critic a sistemului:
-scade productivitatea pe msur ce se adaug noi module;
-cderea magistralei - catastrofal pentru sistem.
Solutia: magistrale multiple!
=> variant: multiprocesor cu magistral multipl !
Avantaj: previne gtuirea sistemului !

Dezavantaj: creterea costului sistemului prin utilizarea de mai multe
magistrale i fiecare modul cuplat la magistral (procesor, memorie sau dispozitiv de
I/E) este de tip multiport.
=> n practic numrul mic de magistrale (ex: 2)
Exemplu: sistemul Alliant (magistral dual ntre memoriile cache i memoria
principal partajat i o magistral concurent pentru conectarea n exclusivitate a
procesoarelor).
Factori care afecteaz caracteristicile i performanele magistralei:
-numr de dispozitive active pe magistral;

-algoritmul de arbitrare a magistralei;
-centralizarea sau distribuia controlului;
-numr de bii de date care se transfer la un moment dat (lungimea
cuvntului);
-sincronizarea transmisiei de date;
-detectarea erorilor.
Comutatoare grila
=> un comutator gril (crossbar switch) conecteaza simultan oricare
procesor sau procesor de I/E la oricare modul liber de memorie partajat.
Organizarea general:
Comutatorul gril permite legturi de comunicaie concurente ntre toate

procesoarele i toate modulele de memorie partajat.
Dirijarea informatiei: prin comutatoarele punctelor de intersecie CS
(crosspoint switch).
Structura unui CS:
Starile unui switch din reteaua crossbar:
Tehnologia VLSI permite integrarea intr-un cip a unui numar foarte mare de switch-uri
(mii), dar numarul de pini limiteaza numarul de switch-uri la cateva sute.
Avantaj: productivitate mare prin ci de comunicaie concurente multiple.
Dezavantaj: cost mare i logica complex.
Exemplu: un sistem cu n procesoare i n module de memorie partajate => n2
puncte de intersecie, deci cost O(n2 ) !
Structura unui comutator grila:
Implementare comutator elementar:
Varianta:
Retele multinivel
-n sistemele multiprocesor mari;
-interconectare mai general procesor-procesor i procesor memorie.
Model generalizat de retea multinivel
Se considera N intrari si M iesiri, g etaje G0 Gg-1, fiecare etaj Gi cu wi switchuri de dimensiune ai,j x bi,j (1 j wi). Astfel etajul Gi are pi intrari si qi iesiri, unde:
wi
pi ai , j
j 1
wi
qi bi , j
j 1
Conexiunea intre doua etaje adiacente Gi-1 si Gi, notata Ci, defineste tiparul de
conexiune pentru pi = qi-1 legaturi (p0 = N si qg-1 = M). Astfel, o retea multinivel poate fi
reprezentata:
C0(N) G0(w0) C1(p1) G1(w1)... Cg-1(pg-1) Gg-1(wg-1) Cg(M)
Etajul i poate fi reprezentat:
=> interconexiuni de patru tipuri (Feng i Wu):

a) interconexiune strict fr blocare (strictly nonblocking): poate conecta
orice intrare liber la orice ieire liber, fr nici o condiionare fa de celelalte
conexiuni existente n sistem.
Exemplu: comutatorul gril.
Implementare eficient - reelele Clos !
Reea Clos cu trei etaje:
Numrul de intrri : N = r n
(r = numr de comutatoare gril din primul i ultimul nivel, n = numr de intrri n
fiecare comutator de pe primul nivel).
=> reeaua are mai puin dect N2 puncte de intersecie pentru N24 i, n general,
necesit
O ( Ne
log N
puncte de intersecie.
=> pentru m2n-1 reeaua Clos cu trei etaje este strict fr blocare.
b) interconexiune fr blocare n sens larg (wide-sense nonblocking):

poate suporta toate conexiunile posibile fr blocare, dar aceasta numai dac se
utilizeaz reguli specifice de rutare pentru realizarea conexiunilor.
=> pentru m3n/2 reeaua Clos cu trei etaje este o reea fr blocare n sens larg !
c) interconexiune fr blocare rearanjabil (rearrangeable nonblocking):
poate suporta toate conexiunile posibile ntre intrri i ieiri prin rearanjarea
(reordonarea) conexiunilor sale existente.
-nainte de nceperea prelucrrilor trebuie s se specifice toate conexiunile
dorite.
=> reeaua Clos cu trei etaje este rearanjabil dac mn.
Exemplu: reea rearanjabil cu numr minim de puncte de intersecie (Benes):
n general, pentru N=2n intrari => 2n-1 etaje i N(2n-1)/2 comutatoare.
Exemplu: se considera reteaua Benes 8x8 avand stabilite conexiunile simultane

110100 si 010110.
Noua conexiune 101001 nu poate fi stabilita decat daca conexiunea 110100 va fi

rearanjata :
d) interconexiune cu blocare (blocking): poate realiza multe conexiuni, dar

nu toate conexiunile posibile.
Exemple: reeaua Banyan, reeaua Omega, reeaua Data Manipulator, etc.
-blocul de interschimb (comutator elementar) :
numr procesoare N => numr de niveluri log2N, numr blocuri de interschimb N/2
pentru fiecare nivel.
numr total blocuri de interschimb (N/2)log2N (n comparaie cu N2 numrul de
puncte de intersecie ale unui comutator gril).
Retea cu legaturi hipercub

-reprezentarea binar a oricrei etichete de legtur: L = bm-1 . . . b1 b0
-funcia de interconectare a cubului:
cub i ( L ) = cub i ( bm-1 . . . b1 b0 ) = bm-1 . . . bi+1 bi bi-1 . . . b1 b0
(pentru i=0,1, . . . , m-1, unde bi este complementul logic al bitului bi).
=> nivelul (etajul) i=2 :

0 (000)
4 (100)
1 (001)
5 (101)
2 (010)
6 (110)
3 (011)
7 (111)
=> nivelul i=1 :

0 (000)
2 (010)
1 (001)
3 (011)
4 (100)
6 (110)
5 (101)
7 (111)
=> nivelul i=0 :

0 (000)
1 (001)
2 (010)
3 (011)
4 (100)
5 (101)
6 (110)
7 (111)
Legaturi hipercub pentru N=8 de ordin 2 (a), de ordin 1 (b) si de ordin 0 (c).
Retea omega
Pentru N intrri, notate cu i=0, 1, 2, , N-1, funcia de conexiune shuffle (amestecare
a crilor de joc):
sh ( i ) = ( 2 i + 2 i / N ) mod N
Exemplu: pentru o conexiune shuffle cu un singur nivel (N=8):
sh ( 0 ) = ( 0 + 0 / 8 ) mod 8 = ( 0 + 0) mod 8 = 0 mod 8 = 0
sh ( 1 ) = (2 + 2 / 8 ) mod 8 = ( 2 + 0) mod 8 = 2 mod 8 = 2
sh ( 2 ) = ( 4 + 4 / 8 ) mod 8 = ( 4 + 0) mod 8 = 4 mod 8 = 4
sh ( 3 ) = ( 6 + 6 / 8 ) mod 8 = ( 6 + 0) mod 8 = 6 mod 8 = 6
sh ( 4 ) = ( 8 + 8 / 8 ) mod 8 = ( 8 + 1) mod 8 = 9 mod 8 = 1
sh ( 5 ) = ( 10 + 10 / 8 ) mod 8 = ( 10 + 1) mod 8 = 11 mod 8 = 3
sh ( 6 ) = ( 12 + 12 / 8 ) mod 8 = ( 12 + 1) mod 8 = 13 mod 8 = 5
sh ( 7 ) = ( 14 + 14 / 8 ) mod 8 = ( 14 + 1) mod 8 = 15 mod 8 = 7
Conexiunea shuffle poate fi definita si prin relatia:
sh(bm-1 bm-2 . . . b1 b0) = bm-2 . . . b1 b0 bm-1
Interconexiunea shuffle pentru opt linii :
Se pot defini si conexiunile "inverse perfect shuffle":

sh(bm-1 bm-2 . . . b1 b0) = b0 bm-1 bm-2 . . . b2 b1
si "bit reversal":
sh(bm-1 bm-2 . . . b1 b0) = b0 b1 b2 ... bm-2 bm-1
Conexiunile "perfect shuffle" (a), "inverse perfect shuffle" (b) si "bit reversal" (c)
pentru 8 intrari si 8 iesiri:
=> reea cu m = log2N etaje de conexiune shuffle cascadate se numete reea

omega.
Exemplu: sistemul Ultracomputer de la New York University.
-retea omega n*n contine (n/2)log2n comutatoare => complexitate (cost)
O(nlog n) < O(n2)
Reteaua omega este o retea blocanta!
Exemplu: retea omega de dimensiune 8*8 (n = 8 intrari / iesiri, k = 3 etaje):
Retea butterfly
-pentru o etichet binar bm-1 . . . b1 b0, funcia butterfly de ordinul k, notat Bk,
este definit pentru k = 1, 2, , m-1 :
Bk ( bm-1 . . . bk+1 bk bk-1 . . . b1 b0 ) = bm-1 . . . bk+1 b0 bk-1 . . . b1 bk
Exemplu: funcia butterfly pentru m = 2, eticheta binar b1b0, k=1 este:
B1 (b1b0 ) = b0b1
avnd valorile:
B1 ( 0 0 ) = 0 0
B1 ( 0 1 ) = 1 0
B1 ( 1 0 ) = 0 1
B1 ( 1 1 ) = 1 1
Exemplu: reeaua butterfly pentru m=2 i k=1:
-cascadarea a dou reele butterfly identice => comutator 4x4 BBN (Bolt,
Beranek i Newmann) Butterfly:
Interconexiunile Butterfly pentru 8 intrari si 8 iesiri de ordin 2 (a), ordin 1 (b) si ordin
(0):
Retea baseline
=> generare recursiva: primul nivel contine un bloc N*N (N intrari si N iesiri),
al doilea nivel contine doua blocuri N/2*N/2, . . . , in final se obtin N/2 blocuri de
dimensiune 2*2 (comutatoarele 2x2 au numai doua stari stabile: conexiune directa si
conexiune inversa).
Exemplu: retea baseline cu 8 intrari si 8 iesiri:
Permutarea baseline de ordin k poate fi definita prin:

k ( bm-1 . . . bk+1 bk bk-1 . . . b1 b0 ) = bm-1 . . . bk+1 b0 bk bk-1 . . . b1
(deplasare ciclica a ultimilor k+1 biti mai putin semnificativi). Pentru N=8 permutarile
de ordin 2 (a), ordin 1 (b) si ordin 0 (c):
Exemple de retele unidirectionale bazate pe aceste tipuri de permutari, cu 16 intrari si

16 iesiri.
Retea Baseline:
(etaj I Shuffle!)
Retea butterfly:
Retea multinivel:
C1-C4 butterfly,
C0 shuffle
Retea Omega:
Retele multinivel bidirectionale

Intr-un switch bidirectional fiecare port este asociat cu o pereche de canale
unidirectionale de sensuri opuse, astfel ca informatia poate fi transmisa simultan intre
switch-urile vecine in sensuri opuse. Un switch bidirectional poate suporta trei tipuri de
conexiuni: forward, backward si turnaround:
Exemplu: retea butterfly bidirectionala 8x8:
Stabilirea cailor in retele multinivel bidirectionale: datele sunt transmise inainte

(conexiune "forward"), sunt posibile mai multe cai, apoi se stabileste o conexiune
"turnaround" si in final in directia inapoi (conexiune "backward").
Exemplu: retea butterfly bidirectionala cu 8 noduri.
In cazul cel mai defavorabil pentru o retea cu n etaje sunt traversate 2n-1 etaje.
O retea butterfly bidirectionala cu rutare "turnaround" este echivalenta cu o

retea arbore gros ("fat tree"), avand procesoarele plasate in nodurile frunza:
Retele hibride
Retelele hibride combina mecanisme ale retelelor "shared-medium" cu cele ale
retelelor directe sau indirecte.
1) Magistrale backplane multiple: rezolva dezavantajele retelelor "sharedmedium (suporta un numar mic de dispozitive, au distanta limitata si nu sunt scalabile,
pentru dezvoltarea de sisteme mari).
2) Retele ierarhice: diferitele magistrale sunt conectate prin routere si bridgeuri. Exemplu: magistrale ierarhice cu doua niveluri:
3) Retele bazate pe clustere. Au o structura ierarhica (subclasa a retelelor

ierarhice). Este posibil sa se combine avantajele magistralelor si legaturilor punct-lapunct, utilizand magistrale pe un nivel mai coborat pentru a forma clustere si o
topologie de retea directa pentru a conecta clustere pe un nivel mai ridicat. Exemplu:
Stanford Directory Architecture for Shared Memory (DASH).
4) Alte topologii hipergraf.

Hypermesh set de noduri aranjate in cateva dimensiuni, fiecare nod fiind
conectat cu toate nodurile de pe fiecare dimensiune printr-o magistrala. Exemplu:
hypermesh 2D (propusa de Wittie, referita ca "spanning-bus hypercube"):
Avantaje: topologia are un diametru foarte mic si distanta medie dintre noduri scaleaza
foarte bine cu dimensiunea retelei. Dezavantaj: largimea de banda nu scaleaza foarte
bine. Solutie: inlocuirea magistralei singulare conectand nodurile de pe o dimensiune
printr-un set de k magistrale (k = numarul de noduri de pe dimensiunea respectiva).
(aceasta solutie propusa in Distributed Crossbar Switch Hypermesh - DCSH). Fiecare

magistrala este comandata de un singur nod. Largimea de banda scaleaza cu numarul de
noduri. Dar dezavantaje: numarul mare de magistrale si numarul mare de porturi de
intrare pentru fiecare nod.
Tabel recapitulativ cu principalele caracteristici ale retelelor dinamice:
RETELE PE UN CIP
Dezvoltarea tehnologica => cipuri performante SoC (System-on-chip) si

MPSoC (Multi-processor systems-on-chip).
Corespunzator => NoC (Network-on-chip) micro-retele de interconectare in

cadrul acestor sisteme: conectarea scalabila si concurenta de tipul punct-la-punct sau
punct-la-mai-multi intre elementele de prelucrare (procesoare) si memorii (memorii
cache) sau porturi de I/E.
O serie de topologii deja discutate au fost adaptate pentru NoC.
Componentele NOC:
1) Adaptor de retea: rol = interfatarea nucleelor in cadrul retelei intr-un mod

standardizat.
Caracteristicile retelei devin transparente pentru nuclee.
Un adaptor contine doua module: interfata de nucleu si interfata de retea.
2) Router: cel mai important element in cadrul NOC. Implementeaza strategia

de rutare si algoritmul de control al fluxului.
Poate sa contina buffere pentru salvarea de pachete de intrare.
Algoritmul de rutare determina destinatia fiecarui pachet de intrare.
3) Stratul (layer) retelei: topologia retelei si protocolul de rutare

implementat.
Dally si Towles: retea tor (disponibilitate de comunicatie).

-in nodurile retelei: procesoarele si memoriile (dimensiuni fizice omogene,
amplasare uniforma pe nivelul de baza al cipului).
-comunicatia intre noduri: comutare de pachete -> fiecare bloc (nod) executa
in mod independent rutarea de pachete si arbitrarea.
Reteaua Nostrum (Kumar): topologie mesh 2D cu blocurile pe nivelul de baza

-transferul de date: rutarea pachetelor.
-diferenta fata de reteaua precedenta: functia de rutare realizata de o retea
dedicata de comutatoare functionand ca o interfata de retea pentru fiecare nod.
-reteaua dedicata = switch-uri (in nodurile retelei) si conexiuni (fire).
-fiecare switch dispune de buffere si circuite de arbitrare proprii.
Reteaua Spin (Guerrier si Greiner): topologie de tip arbore gros => o

arhitectura de comunicatie pentru MPSoC.
-fiecare procesor = nod frunza.
-transfer de mesaje: pachetele traverseaza arborele (jos-sus sus-jos).
-header-ul de pachet: adresa de destinatie, identificator, informatii de rutare.
-fiecare pachet incheiat cu o suma de control pentru detectarea erorilor.
Reteaua Octagon (Karin): arhitectura de comunicatie pentru procesoare de

retea.
-8 procesoare conectate in inel + patru diametre (intarzierea de comunicatie
intre oricare doua noduri locale maxim 2T).
-reteaua scalabila: un nod -> bridge pentru conectarea inelului la un alt inel.
Topologii de retele MPSoC
-retele NoC utilizate in MPSoC (ierarhia procesoare-memorii si interconectare

procesoare).
Clasificarea retelelor MPSoC:
-retele directe;
-retele indirecte.
Retele directe: un procesor este conectat la alte procesoare direct prin retea, fiecare
nod efectuand rutarea fluxului de date si arbitrarea.
Retelele indirecte: procesoarele sunt interconectate prin unul sau mai multe switchuri intermediare(functii de arbitrare si rutare) -> retele de interconectare multinivel.
Topologii de retele directe

-topologii ortogonale:
retea mesh (dimensiune k si n noduri/dimensiune);
tor (dimensiune k si n noduri/dimensiune);
-topologie Octagon (discutat anterior);

-cicluri cub conectate (CCC);
Topologii de retele indirecte

-retea de comutatoare grila (crossbar): poate conecta N porturi de intrare la N porturi de
iesire.
-retea complet conectata: multiplexoare pentru a furniza toate intrarile la iesiri.

Multiplexor: controlat de arbitru care determina intrarea conectata la iesire.
-retea arbore gros: cai de date multiple de la sursa la destinatie.

~retea arbore extinsa cu noduri radacina multiple. Exemplu: reteaua Spin (vezi
desenul).
-retea Butterfly: fiecare ruta sursa-destinatie utilizeaza o cale de date dedicata.
Intarzierea intre oricare doua noduri constanta (numar de etaje).
Variante ale topologiei:

-reteaua Banyan cu N=2n intrari si N=2n iesiri (n dimensiunea retelei), Nlog2N
switch-uri in n=log2N etaje.
-reteaua Batcher-Banyan: retea de sortare Batcher + retea Banyan.
Reteaua de sortare: comparatoare si fire => sortarea unui set de numere.

Comparator: doua intrari (compara doua valori) => trimite valoarea mai mare la o
iesire (aici, iesirea de jos) si valoarea mai mica la cealalta iesire (sus).
Exemplu: retea cu 4 intrari si 4 iesiri (sorteaza 4 numere).
O retea de sortare Bubble Sort recursiva:

-n+1 intrari -> bloc pentru compararea a n+1 valori (n comparatoare)
=> valoarea cea mai mare pe linia cea mai de jos;
-n linii ramase -> bloc pentru compararea a n valori (n-1 comparatoare);
.......
-ultimul nivel: un comparator -> compara cele doua valori de pe primele doua linii.
Implementarea pentru sortarea a 6 valori:
intarziere mare.
In practica: retele mai performante. Exemplu: retele Batcher: odd-even mergesort,
bitonic sort si Shell sort.
Analiza retelelor de switch-uri indirecte

Retele indirecte: switch-urile = circuite intermediare intre nodurile procesor.
Circuitele plasei de switch-uri:

-fire de interconectare;
-buffere.
-switch-uri de noduri;
Switch-urile directioneaza pachetele: etaj intermediar -> etajul urmator,,->destinatie.
Exemplu: retea Banyan -> switch-uri de nod 2x2 (grad 4).
Directionarea pachetelor: conform adresei destinatie din pachete.
Unitatea de intrare: paralelizarea fluxului serial de date => flux paralel de 16 / 32
de biti.
Alocator: citeste adresa de destinatie intr-un singur tact => daca portul de destinatie
este disponibil, alocatorul aloca portul de iesire pachetului.
oncurenta de pachete -> buffere pentru memorarea pachetelor de prioritate mai mica.
Tipuri de concurenta intre pachetele de intrare:
-concurenta de destinatie (dependenta de aplicatie): doua sau mai multe pachete din
porturile de intrare necesita acelasi port destinatie. Presupunere: arbitrul a rezolvat deja
acest tip de concurenta inainte ca unitatea de intrare sa livreze pachetele plasei de
switch-uri.
-concurenta de interconectare (blocare interna): in interiorul plasei de circuite aceeasi
legatura trebuie partajata de pachete cu destinatii diferite. Apare in interiorul retelelor de
switch-uri si depinde de arhitectura.
Bufferele implementate cu memorii partajate SRAM sau DRAM.
Retea mesh 2D:

-procesoarele amplasate in planul de baza (a).
-fiecare latura a blocului: o intrare si o iesire.
-switch-ul = interfata de retea pentru nodul procesor plasat in centrul blocului (b).
-fiecare bloc: patru intrari si patru iesiri interconectate (c).
-switch-ul suporta conexiuni concurente de la oricare canale de intrare catre oricare
canale de iesire.
Fiecare buffer: informatie de control -> lungimea cozii (codificata binar) -> logica
combinationala (alocator) pentru implementarea algoritmului de rutare.
Canalul de iesire selectat de DeMUX pe baza rezultatelor comparatorului privind

penalizarile de intarziere pe toate canalele de iesire:
-lungimile cozilor buferelor de intrare ale nodurilor adiacente;
-suma lungimii cozii si 2Ds intarzierea suplimentara de switch cauzata de selectarea
canalului gresit (Misroute).
RETELE DE SORTARE
Retele de sortare
Retea de sortare: circuit care primeste n intrari x0, x1, x2, ... , xn-1 si produce o
permutare a acestora y0, y1, y2, ... , yn-1 astfel incat y0 y1 y2 ... yn-1.
Algoritm de sortare se bazeaza pe compararea si interschimbarea a doua valoricircuit

de sortare pentru n valori se bazeaza pe un bloc de sortare 2x2.
sau reprezentare alternativa:
Implementarea unui modul de sortare 2x2 pentru numere fara semn: un comparator si
doua multiplexoare 2:1:
In cazul unui numar mare de valori de sortat sau valori pe multi biti se pot utiliza si
module de sortare seriale:
Pe baza modulelor de sortare 2x2 se pot realiza circuite de sortare mai mari. Exemplu:
circuit de sortare 4x4:
Parametrii importanti ai unui circuit de sortare:

-cost: numar total de module de sortare 2x2;
-intarzierea: numar de module de sortare 2x2 de la intrare la iesire pe calea critica (cea
mai lunga).
Exemple de circuite de sortare de cost scazut:
Nu exista o metoda generala de dezvoltare sistematica de circuite de sortare de cost

scazut.
Exemplu de circuit rapid de sortare (cu intarziere mica):
Considerand produsul cost x intarziere, de exemplu pentru circuitul de sortare

cu 10 intrari rezulta:
-circuitul 1 (29 module, 9 unitati de intarziere):
cost x intarziere = 261
-circuitul 2 (31 module, 7 unitati de intarziere):
cost x intarziere = 217
circuitul 2 este mai performant!
Proiectarea retelelor de sortare

Exista diferite metode de sortare, conducand la solutii diferite din p.d.v. al
performantelor (produs cost x intarziere).
Exemplu: circuit de sortare bazat pe algoritmul de sortare transpozitie impar-par ("oddeven transposition") rezultand o schema tip "zid de caramida":
Avantaj: simplitatea conexiunilor (conexiuni scurte si care nu se intersecteaza).

Dezavantaj: ineficienta - utilizeaza nn/2 module si are intarziere n unitati de timp =>
produs cost x intarziere O(n3).
Cum se pot proiecta circuite mai eficiente?

Algoritm recursiv bazat pe sortarea cu insertie: pentru a sorta n intrari se sorteaza n-1
intrari, iar cea de-a n-a intrare se plaseaza pe pozitia sa corecta.
Algoritm recursiv bazat pe sortarea cu selectie: se selecteaza cea mai mare valoare si se
furnizeaza la iesirea yn-1, apoi se sorteaza celelalte n-1 valori ramase.
Ambii algoritmi conduc la urmatoarea implementare:
si la urmatoarele performante de cost C si intarziere D ("delay"):

C(n) =C(n 1) + n 1 = (n 1) + (n 2) + ... + 2 + 1 = n(n 1)/2
D(n) = D(n 1) + 2 = 2 + 2 + ... + 2 + 1 = 2(n 2) +1 = 2n 3
Cost ntrziere = n(n 1)(2n 3)/2 = O(n3)
Algoritmii sunt ineficienti: se asteapta cost O(n log n) si intarziere O(log n),
aceste valori corespunzand intr-un algoritm de sortare la numarul de parametrii,
respectiv la numarul minim de comparatii. Rezulta pentru produsul cost x
intarziere O(n log2 n).
O solutie: circuite de sortare AKS (Ajtai, Komlos, Szemeredi),
prezinta interes teoretic (utilizeaza constante mari pe patru cifre).
Alte solutii: utilizeaza valori de intrare partial sortate sau furnizeaza
iesiri partial sortate.
Solutii practice de circuite de sortare: Batcher (si altii), avand cost O(n
log2 n) si intarziere O(log2 n).
Retele de sortare Batcher

Retea de sortare Batcher bazata pe algoritmul de fuzionare par-impar ("even-odd
merger" sau "odd-even merger"): doua secvente sortate de lungimi m si m' sunt
fuzionate intr-o singura secventa de lungime m+m'. Fie secventele:
x0 x1 x2 ... xm-1
y0 y1 y2 ... ym'-1
daca m = 0 sau m' = 0 nu se face nimic;
daca m = m' = 1 este necesar un singur comparator pentru fuzionare;
daca mm'>1 fuzionarea impar-par se face fuzionand separat elementele de indici pari si
impari din cele doua liste.
Astfel, din:
x0, x2, x4, ... , x2m/2 -2
y0, y2, y4, ... , y2m'/2 -2 se obtine:
v0, v1, v2, ... , vm/2 +m'/2 -1
iar din:
x1, x3, x5, ... , x2m/2 -1
y1, y3, y5, ... , y2m'/2 -1 se obtine:
w0, w1, w2, ... , wm/2 +m'/2 -1
Se compara-interschimba perechile w0: v1, w1: v2, w2: v3,.... (v0 nu trebuie
comparat, este cel mai mic), obtinand o secventa ordonata.
Exemplu: circuit de sortare pentru secvente ordonate de 4 si 7 elemente.
Exista trei segmente: segment fuzionare intrari pare (2, 4),

segment fuzionare intrari impare (2, 3) si segmentul final pentru
comparatie-interschimb. Solutia are 16 module si o intarziere de 4
unitati.
Fiecare segment se poate implementa din module mai simple!
Exemplu: segmentul de fuzionare (2, 4) se poate realiza din
doua segmente de fuzionare (1, 2) pentru intrari pare si impare, urmate
de doua unitati paralele de comparatie-interschimb.
Pe linia x0 (posibil acolo sa fie o alta valoare decat x0 initial) este

valoarea minima, pe linia y6 este valoarea maxima, deci pe etajul
final sunt doua comparatoare x2 cu y0 si y2 cu y4..
Un circuit de fuzionare par-impar Batcher (m, m), unde m este putere a lui 2 se
caracterizeaza prin urmatoarele valori pentru cost si intarziere:
C(m) = 2 C(m/2) + m 1 = (m - 1) + 2(m/2 1) + 4(m/4 1) + ... = m log2m + 1
D(m) = D(m/2) + 1 = log2m + 1
Cost x Delay = O(m log2m)
Dispunand de un circuit eficient de fuzionare se poate proiecta un circuit de
sortare de dimensiune n cu doua circuite de sortare de dimensiune n/2 si un circuit
de fuzionare (n/2, n/2).
(vezi figura urmatoare)
Costul:
C(n) = 2C(n/2) + (n/2)(log2(n/2)) + 1 = n(log2n)2/2

(doua circuite de sortare n/2 si un circuit de fuzionare n/2, n/2), intarzierea:
D(n) = D(n/2) + log2(n/2) + 1 = D(n/2) + log2n = log2n(log2n+1)/2
iar produsul cost x intarziere:
Cost x Delay = O(nlog4n)
Retea de sortare Batcher bazata pe secvente bitonice. O secventa bitonica

este o secventa care initial creste apoi scade:
x0 x1 x2 ... xi xi+1 xi+2 ... xn-1
sau initial scade, apoi creste
x0 x1 x2 ... xi xi+1 xi+2 ... xn-1
sau rotatii ale primelor doua categorii. Exemple:
1 3 3 4 6 6 6 2 2 1 0 0 (creste, apoi scade)
8 7 7 6 6 6 5 4 6 8 8 9 (scade, apoi creste)
8 9 8 7 7 6 6 6 5 4 6 8 (secventa precedenta rotita dreapta cu doua pozitii)
Daca se sorteaza prima jumatate si a doua jumatate a unei secvente in
directii opuse, secventa rezultata va fi bitonica si deci poate fi sortata de un circuit
special de sortare pentru secventa bitonica.
=>
Cost(circuit de sortare pentru secventa bitonica cu n intrari) = Cost(circuit de

fuzionare par-impar (n/2, n/2));
Delay(circuit de sortare pentru secventa bitonica cu n intrari) = Delay(circuit de
fuzionare par-impar (n/2, n/2));
Daca intr-o secventa bitonica se compara-interschimba elementele din prima

jumatate cu cele din a doua jumatate (in figura precedenta, comparatoarele cu linie
punctata) fiecare jumatate a secventei rezultate va fi o secventa bitonica si fiecare
element din prima jumatate nu va fi mai mare decat orice element din a doua jumatate.
Astfel, cele doua jumatati pot fi sortate independent de circuite de sortare bitonice mai
mici. Exemplu: circuit de sortare bitonic cu 8 intrari:
RETELE DICTIONAR SI DE CAUTARE

Operatii dictionar si de cautare
-categorie importanta de operatii (cautarea reprezinta aprox. 25% din timpul
total de calcul).
Problema: cautarea unei valori y intr-o lista de n chei ordonate crescator x pe un
PRAM cu p procesoare.
Intr-un sistem uniprocesor algoritmul de cautare binara necesita log2(n+1) pasi
de comparatie. Se compara y cu valoarea de la mijloc x n/2. Daca:
-y = x n/2 cautarea s-a incheiat;
-y < x n/2 cautarea se face de la x0 la x n/2-1;
-y > x n/2 cautarea se face de la x n/2+1 la x n-1 .
In cazurile 2 si 3 dimensiunea problemei se reduce la n/2.
Extinderea algoritmului de cautare binara la cautare de ordin (p+1) pe

un PRAM cu p procesoare conduce la un timp de k = log2(n+1)/ log2(p+1)
pasi. Se considera n = (p+1)k-1 pentru un anumit k, sau se considera cel mai mic
k astfel incat n (p+1)k-1. La pasul 1 procesorul i compara y cu elementul din
pozitia i (p+1)k-1, cand fie un procesor gaseste egalitate, fie cautarea se restrange
la un interval care nu depaseste (p+1)k-1-1. Factorul de accelerare:
log2(n+1) / log2(n+1)/ log2(p+1) log2(p+1)
Cautarea nu poate fi accelerata semnificativ prin paralelizare. Dar
cautarea paralela poate fi eficienta in cazul in care se cauta m valori in aceeasi
lista de n chei (ex: verificator ortografic al unui procesor de text, care are de
verificat ca anumite cuvinte din document apar intr-un dictionar standard).
Se definesc trei operatii de dictionar de baza:

search(y): cauta inregistrarea avand cheia y si returneaza data asociata;
insert(y,z): se adauga o inregistrare avand cheia y si data z;
delete(y): sterge inregistrarea avand cheia y (optional returneaza data asociata).
In plus se pot defini operatii suplimentare:
findmin: gaseste inregistrarea avand cheia minima si returneaza data asociata;
findmax;
findmed;
findbest(y): gaseste inregistrarea avand cheia cea mai apropiata de y ("best match");
findnext(y): gaseste succesorul;
findprev(y): gaseste predecesorul;
extractmin: elimina inregistrarea avand cheia cu cea mai mica valoare (returneaza data);
extractmax;
extracmed.
Masina dictionar cu structura tip arbore

Masina arbore consta din doi arbori binari completi pozitionati in oglinda, avand
frunzele fuzionate.
Arborele cu cerculete executa broadcast pentru operatiile dictionar introduse prin nodul
radacina de intrare catre toate nodurile frunza care detin inregistrarile. Arborele cu
triunghiuri combina rezultatele operatiilor individuale intr-un rezultat global furnizat
prin nodul radacina de iesire. Intr-o implementare hardware cei doi arbori pot fi
fuzionati intr-unul singur.
Implementarea operatiei de cautare. Prima operatie de cautare

search(y0) este trecuta de la nodul radacina la cei doi fii, cand poate fi acceptata
operatia urmatoare search(y1). Astfel se pot propaga in maniera banda de
asamblare operatii succesive de cautare. Tot in banda de asamblare rezultatele
pot fi propagate de la nodurile frunza catre radacina de iesire (ex. yes/no, ID
nodului frunza, valoarea cheii, data, etc).
Factor de accelerare. Pentru n noduri frunza, o instructiune search

ajunge la frunze in log2n pasi, iar rezultatul ajunge la iesire tot in log2n pasi, in
total 2log2n + 1 pasi, dar productivitatea este de un rezultat per ciclu. Astfel, se
utilizeaza 3n 2 noduri (procesoare elementare) pentru a scadea timpul de la
log2n la1.
Implemetarea operatiei de stergere. Instructiunea delete(y) este

difuzata (broadcast) catre nodurile frunza, asemanator cu search, se marcheaza
inregistrarile avand cheia y ca sterse, iar o noua operatie de search poate sa
inceapa imediat in ciclul urmator.
Implementarea operatiilor extractmin si extractmax. Se realizeaza in
doua faze: dupa identificarea nodului frunza continand minimul sau maximul,
iar rezultatul (identificatorul nodului frunza) obtinut de la nodul radacina de
iesire, se insereaza o noua instructiune de extragere a inregistrarii. Astfel
latenta este dubla, iar o instructiune search se poate lansa numai dupa
inceperea celei de-a doua faze.
Implementarea operatiei insert. Spre deosebire de search, insert nu se
difuzeaza catre toate nodurile frunza. Este necesar un mecanism de evidenta a
nodurilor frunza libere. Solutie: fiecare nod care nu este frunza detine doua
contoare indicand nodurile frunza libere din subarborele stang, respectiv
subarborele drept. La o instructiune insert ajunsa la un nod, aceasta este
transmisa mai departe catre unul din fii (corespunzand contorului cu valoare
mai mare, sau intotdeauna catre fiul stang, daca are contor nenul vezi figura).
In cazul operatiei de stergere este necesara o a doua faza dupa furnizarea ID-ului
nodului care a sters inregistrarea, pentru actualizarea contoarelor. Rezulta o intarziere
intre o stergere si refolosirea spatiului respectiv
Varianta de masina arbore pentru operatiile de cautare minim, maxim si valoare

mediana: fiecare nod memoreaza trei valori: valoare minima, maxima si mediana in
subarborele avand nodul respectiv ca radacina.
Calcul de prefixe paralele
Fie un operator binar asociativ:

(x y) z = x (y z)
pentru x, y, z S. Se considera o lista de n valori x1, x2, ... , xn, se calculeaza relatia de
recurenta
si = si-1 xi
unde s0 este elementul identitate pentru operatorul (ex. 0 pentru adunare si 1 pentru
inmultire) si = x1 x2 ... xi.
Relatia de recurenta sugereaza imediat o implementare prin circuit secvential.
Perioada de ceas trebuie sa fie suficient de mare corespunzand intarzierii de propagare

maxime, plus timpii de memorare in latch si setup.
Varianta: unitate in banda de asamblare avand q segmente. Chiar daca perioada de ceas
poate fi mai mica, o intrare poate fi furnizata la fiecare q tacturi de ceas. Din cauza
overhead-ului de memorare a rezultatelor intermediare unitatea in banda de asamblare
scade viteza calculului.
O solutie de aplicare a paralelismului pentru cresterea ratei rezultatelor:
Se utilizeaza o unitate de calcul a functiei cu mai multe segmente. Exista totusi o

limitare: daca overhead-ul cauzat de memorare in latch este c, atunci rata nu poate
depasi 1/c, indiferent de numarul de segmente sau de aranjarea acestora.
Retele pentru calcul de prefixe paralele

Se are in vedere operatia de adunare numere intregi fara semn. Algoritmul de
baza: algoritmul pentru calcul de semigrup pe EREW PRAM:
Processor j, 0 j<p copy X[j] into S[j]
s=1
while s<p Processor j, 0 j<p-s do
S[j+s]=S[j] S[j+s]
s=2s
Broadcast S[p-1] to all processors
Retea Brent-Kung
Printr-o prima abordare "divide-and-conquer" (considerand p putere a lui 2): se
imparte problema in doua subprobleme, calculul rezultatelor indici impari s1, s3, s5, ... si
calculul rezultatelor indici pari s0, s2, s4, ....
Prima subproblema: perechi de valori de intrare consecutive (x0 si x1, x2 si x3, etc.)
se combina pentru a obtine o lista cu lungimea jumatate decat cea initiala. Aplicand
calcul de prefixe paralele se obtin rezultatele corecte cu indici impari.
A doua subproblema: se combina fiecare valoare de intrare cu indice par cu
rezultatul de indice impar precedent (x2 si s1, x4 si s3, etc.). Schema:
Timpul de calcul se poate determina din urmatoarea relatie de recurenta:

T(p) = T(p/2) + 2
cu solutia:
T(p) = 2 log2p
Pe baza acestor considerente se obtine reteaua de insumare de prefixe pentru n valori

realizata dintr-o retea de insumare de prefixe pentru n/2 valori si n-1 sumatoare:
(retea Brent-Kung). Se pot determina costul si intarzierea:

C(n) = C(n/2) + n 1 => C(n) = 2n 2 log2n
D(n) = 2 log2n
Retea Kogge-Stone
O a doua abordare"divide-and-conquer" vede lista de intrare ca fiind compusa din doua
subliste, sublista valorilor cu indici impari x1, x3, x5, ... si sublista valorilor cu indici pari
x0, x2, x4, .... Se executa calculul de prefixe paralele separat pe fiecare sublista, iar
rezultatele finale se obtin prin combinatii de perechi de rezultate partiale adiacente intrun singur pas PRAM.
Timpul de calcul se poate determina din urmatoarea relatie de recurenta:

T(p) = T(p/2) + 1
cu solutia:
T(p) = log2p
Chiar daca acest al doilea algoritm este mai eficient decat primul algoritm "divide-andconquer", el poate fi aplicat numai daca operatorul este comutativ.
Reteaua rezultata pe baza acestui algoritm, reteaua Kogge-Stone:
Se pot determina costul si intarzierea:

C(n) = 2C(n/2) + n/2 => C(n) = (n/2) log2n
D(n) = log2n
deci reteaua este mai rapida, dar mai costisitoare.
Exemple de implementare
Se considera implementari cu 16 intrari ale retelelor Brent-Kung:
Kogge-Stone:
este cea mai rapida solutie de implementare a calculului de prefixe paralele, dar costul
poate fi prohibitiv pentru n mare.
Combinand cele doua retele se poate realiza o retea hibrida:
Solutia hibrida avand D = 5 si C = 32 se plaseaza intre reteaua Brent-Kung (6, 26) si

Kogge-Stone (4, 49).
Transformata Fourier discreta (DFT)

Fiind data secventa x0, x1, ... , xn-1, se calculeaza secventa y0, y1, ... , yn-1 pe baza
relatiei:
n 1
yi x j
j 0
ij
n
Se poate exprima si sub forma matriciala y = Fn x, adica:
1
1
y0 1
y 1
2
n
n
1
... ... ...
...

n 1
2 ( n 1)
y
1
n
n
n 1
x0
n 1
... n x1
...
... ...
( n 1) 2
... n
x n 1
...
unde n este radacina de ordinul n a unitatii, adica nn = 1 si nj 1, pentru 1 j < n.

Exista relatiile:
n = e2i/n
nj = e2ji/n = cos(2j/n) + isin(2j/n)
Transformarea inversa permite refacerea secventei x din secventa y:
1 n 1 ij
xi n y j
n j 0
Un sisteme cu n procesoare poate calcula DFT intr-un timp O(n),

fara comunicatii, procesorul j calculand yj.
Pe baza formularii matriciale a transformatei se poate utiliza orice
algoritm de inmultire matrice vector pentru calculul DFT.
Tinand cont de structura Fn printr-o abordare "divide-andconquer" se poate calcula mai rapid DFT => FFT.
Se partitioneaza suma DFT in termeni impari si termeni pari:

n 1
yi nij x j
j 0
ij
n xj
j par ( 2 r )
ij
n xj
j impar( 2 r 1)
n / 21
n / 21
r 0
r 0
ir
i
n / 2 2r n
ir
n / 2 x2r1
unde s-a utilizat identitatea n/2 = n2. Cei doi termeni din ultima expresie reprezinta
DFT de n/2 puncte fiecare si se pot scrie:
x0
x
u Fn / 2 2
...
xn2
x1
x
v Fn / 2 3
...
x n 1
Astfel:
yi
i
u
n vi n / 2
i n / 2
u i ni vi
0 i n/2
n/2 i n
sau
y i n / 2 u i ni n / 2 vi
Rezulta ca algoritmul FFT de n puncte consta in calcularea a doua FFT

independente de n/2 puncte, apoi se combina rezultatele utilizand operatii inmultireadunare.
Complexitatea de timp pentru FFT secvential:
T(n) = 2T(n/2) + n = n log2n
Daca cele doua transformari de n/2 puncte se pot realiza in paralel si operatiile de
inmultire-adunare se pot executa de asemenea in paralel, atunci:
T(n) = T(n/2) + 1 = log2n
(unitatea de timp corespune unei operatii de inmultire-adunare).
Retele de calcul FFT

Direct din algoritmul precedent se poate obtine o retea de calcul FFT pentru 8 puncte:
Fiecare nod executa un calcul de imultire-adunare. Reteaua rezultata: retea butterfly.
Prin rearanjarea retelei precedente se poate obtine o reprezentare echivalenta: reteaua

shuffle-exchange:
Avantaj: simplitate si interconexiuni identice intre etaje. Iesirile sunt obtinute in ordinea
cu inversarea-bitilor.
Exista si retele mai simple avand un cost mai mic intr-o implementare VLSI: reteaua
Yeh si Parhami, obtinuta din reteaua shuffle-exchange prin inlaturarea unor conexiuni:
Sagetile indica calea de deplasare a datelor in locul legaturilor lipsa.
Pentru valori mari ale lui n reteaua butterfly devine complexa. O solutie: proiectarea
circuitului in directia orizontala a.i. un singur nod inmultire-adunare sa efectueze in pasi
succesivi de timp functia tuturor nodurilor dintr-un rand:
Singura coloana de noduri inmultire-adunare joaca rolul coloanelor multiple din schema
initiala, rezultatele partiale fiind salvate in registre pentru utilizare la urmatorul pas de
timp. Costul solutiei se reduce de la O(n logn) la O(n), fara crestere semnificativa a
intarzierii.
O alta solutie si mai economica: proiectarea retelei initiale pe verticala (in loc de
proiectare pe orizontala).
Se obtine o retea liniara cu registre de deplasare de feedback, pentru a mentine timingul

intrarilor in noduri.
MULTIPROCESOARE
ORGANIZARE GENERALA
MODELE DE CONSISTENTA PENTRU MEMORIA
PARTAJATA
COERENTA MEMORIILOR CACHE
PROIECTAREA MULTIPROCESOARELOR CU
SUPRAVEGHERE
ORGANIZARE GENERALA
Sistemele multiprocesor caracterizate prin :
-un multiprocesor este un singur calculator care include mai multe procesoare i un
singur spaiu de memorie adresabil de acestea;
-procesoarele pot comunica i coopera la diferite niveluri pentru rezolvarea unei
probleme date;
-un multiprocesor este controlat de un singur sistem de operare integrat, care
permite interaciunea ntre procesoare i programele lor la nivel de proces, set de date i
chiar date elementare.
Exist dou modele arhitecturale de baz pentru sistemele multiprocesor:
-multiprocesoare slab cuplate LCM (Loosely Coupled Multiprocessors);
-multiprocesoare strns cuplate TCM (Tightly Coupled Multiprocessors).
Multiprocesoarele slab cuplate:

-grad mai sczut al conflictelor de memorie, fa de multiprocesoarele strns
cuplate;
-fiecare procesor dispune de un set de echipamente periferice i o memorie local

mare, unde sunt accesate aproape toate instruciunile i datele;
-procesorul, dispozitivele de I/E i memoria local => modul de calcul (nod);
-modulele de calcul sunt conectate ntre ele printr-o reea de interconectare.
-modulele calculator pot fi conectate pentru realizarea unui sistem multiprocesor
ierarhic sau neierarhic;
-un modul calculator poate fi fabricat ntr-un singur cip => folosit pentru
construirea de sisteme de calcul mari;
-reeaua de interconectare ntre modulele calculator : magistrala multiplexata n
timp sau memorie multiport.
Organizarea unui multiprocesor slab cuplat
Multiprocesoarele strns cuplate:

-productivitate mai buna;
-n prelucrrile de vitez mare sau de timp real;
-un grad nalt de interaciune ntre procesoarele componente.
-reeaua de interconectare procesoare memorie PMIN (Processor-Memory
Interconnection Network) => rat mare de comunicaie (comutatoare gril i reele de
comutatoare multinivel);
-PMIN trebuie s permit nscrierea simultan a datelor n mai multe module de memorie
i s rezolve conflictele de acces.
-accesul procesoarelor la echipamente comune: reea de interconectare
procesoare-dispozitive de I/E, IOPIN (I/O Processor Memory Interconnection
Network);
-procesoarele pot comunica direct, eventual pot executa operaii de
sincronizare prin reeaua de interconectare ISIN (Interrupt Signal Interconnection
Network).
Tipuri de sisteme multiprocesor:
-sisteme bazate pe magistral, multiplexat n timp;
-sisteme bazate pe comutator gril;
-sisteme bazate pe comutator multinivel.
MODELE DE CONSISTEN PENTRU MEMORIA

PARTAJAT
Modelul de memorie pentru programele paralele dintr-un multiprocesor:
Accesul concurent al procesoarelor pentru scrieri i citiri la o aceeai locaie de

memorie partajat: pe baza unor reguli => modelul de consisten al memoriei
partajate.
Modele de consisten:
-consistena strict;
-consistena secvenial;
-consistena de procesor;
-consistena slab;
-consistena la eliberare.
1) Consistena strict (strict consistency): fiecare citire de la o locaie x va

furniza ntotdeauna valoarea celei mai recente scrieri n x.
-model comod;
-greu de implementat: nu permite memorie cache sau date duplicate;
-trebuie s existe un singur modul de memorie care s serveasc toate cererile

n ordinea FIFO;
-aglomerare a memoriei partajate.
2) Consistena secvenial (sequencial consistency): pentru cereri multiple

de citire i scriere, hardware-ul va alege nedeterminist o succesiune a lor, dar toate
procesoarele vor vedea aceeai ordine.
Exemplu: ntr-un sistem multiprocesor, procesoarele P1-P4 execut operaii de

citire scriere la o aceeai locaie de memorie x:
P1:
P2:
P3:
P3:
P4:
P4:
write 100
write 200
read x
read x
read x
read x
=> o anumit ordine, dar dac P3 citete din locatia x valorile 100, 200 (n
aceast ordine), => cu siguran i P4 va citi tot valorile 100, 200 (n aceeai ordine).
O solutie de implementare a modelului de consistenta secventiala:
Definitie. Un sistem multiprocesor este secvential consistent daca rezultatul oricarei

executii este acelasi ca si cand operatiile tuturor procesoarelor ar fi fost executate intr-o
anumita ordine secventiala si operatiile fiecarui procesor individual apar in aceasta
secventa in ordinea specificata de program.
Aspecte:
a) mentinerea ordinii din program pentru operatiile fiecarui procesor;

b) mentinerea unei ordini unice secventiale pentru operatiile tuturor
procesoarelor.
Exemple care ilustreaza aceste aspecte:
a) mentinerea ordinii din program pentru operatiile fiecarui procesor

Exemplu: algoritmul Dekker pentru sectiune critica.
P1
P2
(initial Flag1=Flag2=0)
Flag1=1
if(Flag2==0)
sectiune critica
Flag2=1
if(Flag1==0)
sectiune critica
P1 seteaza Flag1 si citeste Flag2, care daca are valoarea 0 inseamna ca P2

nu a incercat sa intre in sectiunea critica si atunci P1 intra in sectiunea critica.
Algoritmul se bazeaza pe faptul ca citirea procesorului P1 a variabilei
Flag2 are loc inainte ca P2 sa execute operatiile de scriere si citire.
=> Consistenta secventiala mentine ordinea din program a operatiilor
efectuate de P1 si P2 impiedicand ca cele doua procesoare sa citeasca 0 si sa intre
simultan in sectiunea critica.
b) mentinerea unei ordini unice secventiale pentru operatiile tuturor

procesoarelor.
Exemplu: Trei procesoare partajeaza variabilele A si B, initializate cu 0.
Presupunem ca P2 citeste 1 (dupa scrierea lui P1 in A), scrie in B si P3 citeste 1
pentru B.
Aspectul de atomicitate a consistentei secventiale permite sa presupunem
ca efectul scrierii lui P1 este vazut de intregul sistem in acelasi timp.
=> se garanteaza ca P3 vede efectul scrierii lui P1 si returneaza valoarea

1 pentru variabila A (caci P3 vede efectul scrierii lui P2 dupa ce P2 vede efectul
scrierii lui P1 in A).
P1
P2
(initial A=B=0)
P3
A=1
if(A==1)
B=1
if(B==1)
reg=A
Implementarea consistentei secventiale in sisteme fara cache
1) Buffere de scriere cu posibilitate de ocolire ("bypassing

capability"): ilustreaza importanta mentinerii ordinii din program intre o
scriere si o operatie de citire urmatoare.
La o scriere procesorul inscrie data in buffer si continua fara sa
astepte terminarea operatiei de scriere la memorie. Citiri urmatoare pot ocoli
oricare scrieri anterioare in bufferul de scriere pentru incheierea mai rapida,
daca adresa de citire nu coincide cu nicio adresa de scriere din buffer.
Exemplu: algoritmul Dekker. Un sistem consistent secvential trebuie sa impiedice

furnizarea valorii 0 pentru ambele variabile (Flag1 si Flag2).
Bufferele de scriere pot incalca consistenta secventiala: daca ambele
procesoare au inscris 1 si scrierile sunt in bufferele procesoarelor, iar citirile se executa
din memorie inainte de actualizarile operatiilor din buffere cu memoria.
2) Suprapunerea operatiilor de scriere: ilustreaza importanta mentinerii

ordinii din program intre doua operatii de scriere.
Se considera o retea generala de interconectare (nu magistrala) si
module multiple de memorie. Lipsa magistralei si existenta unor module
multiple de memorie permit servirea unor operatii multiple de scriere.
Presupunem ca procesoarele lanseaza operatiile de scriere cu
memoria in ordinea din program si isi continua executia fara sa astepte
incheierea operatiilor.
Diferenta fata de situatia precedenta: scrieri multiple ale unui
procesor pot fi realizate in paralel in memorii diferite.
Exemplu:
P1
P2
Data=2000
while (Head==0){;}
Head=1
... =Data
Un sistem secvential consistent garanteaza ca citirea variabilei Data de catre P2 va
intoarce valoarea inscrisa de P1. Dar permitand suprapunerea scrierilor procesorului P1 se
poate incalca consistenta secventiala. Daca Data si Head sunt in module diferite si
scrierea lui Head este plasata in reteaua de interconectare inainte de Data, scrierile se pot
incheia in alta ordine decat cea din program, ceea ce face ca celalalt procesor sa gaseasca
Head==1 (valoarea noua) si Data==valoarea veche.
Solutie: asteptarea incheierii unei operatii de scriere inainte de

lansarea in reteaua de interconectare a unei noi operatii de scriere de la
acelasi procesor. In general se poate utiliza un semnal de achitare a
scrierii catre procesor ("acknowledge").
3) Operatii de citire neblocante: ilustreaza importanta mentinerii ordinii din program

intre o citire si o operatie urmatoare de citire sau scriere.
Se considera citiri neblocante in sistem: chiar daca exista procesoare care se
blocheaza pana la citirea datei (citire blocanta) alte procesoare trec de o operatie de
citire utilizand tehnici cum sunt memorii cache neblocante, executie speculativa si
planificare dinamica.
Exemplu: se presupune ca scrierile lui P1 sunt in ordinea din program, dar daca
se permite ca operatiile de citire ale lui P2 sa fie lansate in maniera suprapusa este
posibil ca citirea variabilei Data de catre P2 sa se incheie inainte de scrierea valorii
acestei variabile de catre P1.
Implementarea consistentei secventiale in sisteme cu memorii cache

Memorarea datelor in cache poate conduce la o reordonare a operatiilor care
sa incalce consistenta secventiala.
Probleme:
a) Coerenta memoriilor cache: prezenta de copii multiple necesita
un mecanism care sa propage cea mai noua valoare scrisa la toate copiile din
cacheuri (protocol de coerenta a memoriile cache);
b) Detectarea incheierii operatiilor de scriere: detectarea incheierii
unei operatii de scriere necesita mai multe tranzactii in prezenta datelor
replicate;
c) Mentinerea iluziei de atomicitate pentru scrieri: propagarea
modificarilor la copii multiple este inevitabil o operatie non-atomica, pentru
care (deci pentru scrieri) trebuie sa se furnizeze iluzia atomicitatii in raport
cu alte operatii.
a) Coerenta memoriilor cache:

-o scriere este facuta vizibila la toate procesoarele;
-scrierile la aceeasi locatie trebuie vazute in aceeasi ordine

de catre toate procesoarele (serializarea scrierilor in aceeasi locatie).
Propagarea unei valori inscrise se obtine prin fie invalidarea
(sau eliminarea) fie actualizarea copiei.
b) Detectarea incheierii operatiilor de scriere. Mentinerea ordinii din program a unei

scrieri fata de urmatoarele operatii necesita un acknowledge pentru a semnala
incheierea scrierii.
Se considera exemplul precedent de la solutia fara cache, dar in plus
procesoarele sunt dotate cu memorii cache. Presupunem ca P2 are Data in cache. Dupa
ce P1 a scris Data in memorie dar inainte de actualizarea in cahe-ul P2, P1 lanseaza
scrierea Head. Este posibil ca P2 sa citeasca noua valoare Head, dar sa citesca vechea
valoare Data => incalcarea consistentei secventiale. Solutia: P1 asteapta ca P2 sa
actualizeze copia Data in cache, inainte ca P1 sa scrie Head.
Astfel daca se face o scriere intr-un bloc care se gaseste si intr-un alt cache
sistemul necesita un mecanism de acknowledge pentru invalidarea sau actualizarea
copiilor, implementat la nivelul memoriei partajate sau la nivelul procesorului care a
lansat scrierea. Procesorul care lanseaza urmatoarea scriere trebuie sa primeasca aceasta
notificare privind incheierea operatiei de scriere anterioare.
c) Mentinerea iluziei de atomicitate pentru scrieri: propagarea schimbarilor la copii

multiple nu este o operatie atomica. Exista doua conditii care trebuie indeplinite pentru
a asigura atomicitatea scrierilor.
c1) Ilustrarea primei conditii: presupunem ca patru procesoare executa:
P1
P2
P3
P4
(initial A=B=C=0)
A=1
A=2
while(B!=1){;} while(B!=1){;}
B=1
C=1
while(C!=1){;} while(C!=1){;}
reg1=A
reg2=A
Este posibil ca scrierile lui A de catre P1 si P2 sa ajunga la P3 si P4 in ordine diferita,
astfel P3 si P4 citesc valori diferite pentru A.
=>Este necesar sa se impuna serializarea scrierilor in aceeasi locatie.
c2) Pentru cea de-a doua conditie se considera exemplul:

P1
P2
(initial A=B=0)
A=1
if(A==1)
B=1
P3
if(B==1)
reg=A
Se poate incalca consistenta secvetiala daca:
-P2 citeste valoarea noua a lui A inainte ca actualizarea lui A sa ajunga la P3;
-actualizarea lui P2 asupra variabilei B ajunge la P3 inainte de actualizarea lui
A;
-P3 citeste noua valoare a lui B, apoi incearca sa citeasca A din propriul cache
(inainte sa primeasca actualizarea lui A).
=> P2 si P3 observa scrierea lui A la momente diferite, facand
scrierea neatomica (apare in schemele cu invalidare).
=> Pentru prevenirea incalcarii consistentei: interzicerea citirii unei valori nou
scrise pana ce toate copiile din cacheuri au confirmat receptia mesajului de invalidare
sau de actualizare generate de scriere.
3) Consistena de procesor (processor consistency) - definit de urmtoarele

proprieti:
a) scrierile oricrui procesor sunt vzute de toate procesoarele n aceeai ordine
n care au fost emise;
b) pentru fiecare cuvnt de memorie toate procesoarele vd toate scrierile n
aceeai ordine.
Exemplu: procesorul P1 scrie n x valorile 100, 200, 300 (n aceast ordine), iar
procesorul P2 scrie tot n x valorile 400, 500, 600.
P3 citeste din x: 100, 400, 200, 500, 300, 600;
P4 citeste din x: 100, 200, 400, 300, 500, 600 (etc. alte combinaii);
=> niciun procesor nu va citi o combinaie, de exemplu, de tipul ,200, 100,
-proprietatea b): toate procesoarele s fie de acord cu ultima scriere dintr-o

succesiune de scrieri (locaia x s aib o valoare neambigu).
O solutie de implementare a consistentei de procesor (utilizata in arhitectura

SPARC) :
4) Consistena slab (weak consistency): nu garanteaz nici mcar c

scrierile fcute de un procesor sunt vzute n aceeai ordine.
Exemplu: procesorul P1 scrie valorile 100, 200 n locaia x. Procesorul P2 vede
succesiunea 100, 200, iar P3 vede 200, 100.
operaie de sincronizare: toate operaiile de scriere sunt ncheiate i nu se ncep altele
noi, pn cnd cele vechi nu sunt terminate (operaiile de sincronizare: secvenial
consistente).
Exemplu: P1 scrie n locaia de memorie x urmtoarele valori:

100,
200
300
.....
pct.sinc.
pct.sinc.
-procesorul P2 poate vedea valorile 100, 200;
-procesorul P3 poate vedea valorile 200, 100;
=> dar ambele vd succesiunea 100, 300 i 200, 300.
5) Consistena la eliberare (release consistency):

-rezolva dezavantajul modelului precedent: sunt oprite toate operaiile noi n
punctul de sincronizare pn cnd se termin toate operaiile n curs;
-operaia de sincronizare este mprit n dou operaii diferite:
-acaparare (acquire): acapararea variabilei de sincronizare pentru a
obine acces exclusiv la datele partajate;
-eliberare (release): eliberarea variabilei de sincronizare pentru a
indica terminarea.
=> avantaj: nu ntrzie instruciunile aa de des cum face consistena slab.
COERENA MEMORIEI CACHE

Categorii de ierarhii de memorie:
1) Memoria cache partajat
2) Memorie principal bazat pe magistral
3) Dance hall
4) Memorie distribuit :
Definitie. Un sistem de memorie este coerent daca rezultatele oricarei executii

a unui program sunt astfel incat pentru fiecare locatie este posibil sa se construiasca o
ordine seriala ipotetica a tuturor operatiilor cu locatia care este consistenta cu rezultatele
executiei si in care:
1) operatiile generate de oricare proces particular au loc in ordinea generata de
proces;
2) valoarea returnata de o citire este valoarea scrisa de ultima operatie de
scriere in locatia respectiva in cadrul ordinii seriale.
Caracteristici:
-propagarea scrierii: valoarea scrisa trebuie sa devina vizibila altor procesoare;
-serializarea scrierii: scrierile in locatia respectiva trebuie sa fie vazute in
aceeasi ordine de toate procesoarele.
Solutii:
a) bazate software: in clustere de statii de lucru (PC-uri) extinzand sistemul de
memorie virtuala;
b) bazate hardware - variante:
-scheme de supraveghere: broadcast pentru observarea intregului trafic de
coerenta (sisteme pe magistrala si sisteme cu numar mic de procesoare, exemplu: SGI
Challange);
-scheme de directoare: informatii centralizate pentru evitarea broadcastului
(sisteme cu numar mare de procesoare. exemplu: SGI Origin 2000).
Scheme de supraveghere pentru coerenta memoriilor cache

Exemplu de acces al unei variabile partajate de catre trei procesoare cu
memorii cache:
Cea mai simpl metod: sistemul de memorii cache cu actualizare la scriere

(write through) -> orice operaie de scriere => tranzacie de scriere pe magistral
(toate memoriile cache observ aceast tranzacie) !
O memorie cache cu observare (snooping cache) are o copie a blocului => va

invalida copia blocului sau o va actualiza.
Categorii de protocoale:
-protocoale cu invalidare;
-protocoale cu actualizare.
Memorie cache write through, varianta write no allocate (fr alocare la

scriere dac la o operaie de scriere blocul nu este n memoria cache, acesta nu va fi
ncrcat n cache i operaia de scriere se va face direct n memoria principal) -2 stri:
-valid;
-invalid.
Memorie cache cu actualizare la eliminare (write back)
-valid;
-invalid;
-modificat (sau murdar).
Protocoale write-through
1) Protocol VI simplu cu invalidare pentru memorie cache write through,
varianta write no allocate.
Exemplu: se considera un sistem multiprocesor bazat pe magistrala cu protocol writethrough in care fiecare procesor lucreaza la frecventa de 1GHz, 1CPI (un ciclu per
instructiune), iar 15% din program sunt instructiuni de scriere in memorie de cuvinte pe
8 octeti.
fiecare procesor executa 15*107 instructiuni de memorare pe secunda (1.2
Gocteti/sec)
magistrala 2 Gocteti/sec => magistrala poate suporta numai un singur procesor, fara sa
se satureze!
Solutia write-through nu este indicata pentru SMP-uri! Memoriile cache write-back
reduc accesele la magistrala!
Protocoale write-back cu invalidare
Protocoalele write-back:
-protocoale cu invalidare:
-protocoale cu actualizare.
2) Protocol MSI de baz cu invalidare pentru memorie cache de tipul write

back (utilizat prima dat n sistemele multiprocesor din seria Silicon Graphics 4D).
3) Protocol ESI write-back cu invalidare. Un bloc poate sa fie intruna din urmatoarele stari:
a) la nivelul memoriei partajate:
-Clean: valid intr-un subset de memorii cache si in memoria partajata;
-Dirty: intr-o singura memorie cache;
-nu se gaseste in nicio memorie cache.
b) la nivelul memoriei cache:
-I (invalid): blocul nu este valid in memoria cache curenta (se
gaseste in alt cache sau in memoria partajata);
-E (exclusiv): blocul este valid numai in memoria cache a
procesorului curent;
-S (shared): blocul este valid in una sau mai multe memorii cache.
Diagrama de tranzitii cuprinde actiuni initiate de un procesor si
actiuni initiate de pe magistrala. Evenimentele lipsa de cache la citire
(ReadMiss) produc operatii de supraveghere de catre toate memoriile cache.
Scrierile in blocuri curate sunt tratate ca eveniente lipsa de cache la scriere
(WriteMiss).
Diagrama procesor:
Diagrama magistrala:
Diagrama combinata:
Aplicatie. Se consiera doua procesoare care acceseaza doua blocuri de cache

care se mapeaza in acelasi cadru de bloc in memoria cache a fiecarui procesor. Initial
blocul nu se gaseste decat in memoria principala.
P1Wr
10A1
P1Rd
A1
P2Rd
A1
stare
E
P1
adresa
A1
valoare
10
A1
10
S
P2Wr
20A1
P2Wr
40A2
A1
stare
P2
adresa
A1
RdMs
P2
A1
A1
A1
WrBk
RdData
WrMs
P1
P2
P2
A1
A1
A1
WrMs
P2
A2
WrBk
P2
A1
valoare
10
S
E
A2
10
20
40
actiune
WrMs
Mag.
proc.
adresa
P1
A1
valoare
10
10
Mem.
adresa valoare
10
10
10
10
20
20
3) Protocol MESI cu invalidare pentru memorie cache de tipul write back.
Aplicatie. Se considera un sistem multiprocesor cu trei procesoare in care

consistenta memoriei cache se asigura printr-un protocol MESI. Se executa o
succesiune de operatii de citire si scriere referitoare la un acelasi bloc de memorie
cache:
P1Rd, P2Rd, P3Rd, P1Rd, P1Wr, P1Rd, P2Wr, P3Rd
Initial nu exista copii ale blocului in nicio memorie cache. Sa se specifice succesiunea
de stari corespunzatoare blocului la nivelul fiecarei memorii cache, actiunile pe
magistrala si dispozitivul care furnizeaza datele.
Protocoale write-back cu actualizare
Protocol cu actualizare: o operatie de scriere realizeaza actualizarile valorii in

celelalte cache-uri.
Avantaje:
-un alt procesor care acceseaza aceeasi informatie va avea valoarea actualizata;
-se executa o singura tranzactie pe magistrala pentru actualizarea mai multor
memorii cache, ceea ce conduce la o economisire a ratei de transfer.
Dezavantaj:
-scrieri multiple ale aceluiasi procesor genereaza tranzactii multiple de
actualizare.
4) Protocol Dragon write-back cu actualizare.

Stari:
-E (exclusiv): blocul este detinut de memoria cache curenta si de memoria
principala;
-Sc (shared clean): blocul este detinut de alte memorii cache, posibil de
memoria principala si de memoria cache curenta, care nu este proprietara (nu este
responsabila cu furnizarea blocului la o cerere);
-Sm (shared modified): blocul este detinut de alte memorii cache, de memoria
cache curenta, care este proprietara (este responsabila cu furnizarea blocului la o
cerere), dar nu este detinut de memoria principala;
-M (modified) sau D (dirty): blocul este detinut numai de memoria cache
curenta.
Aplicatie. Se considera o secventa de operatii de scriere si citire efectuate de

trei procesoare P1, P2 si P3 pentru un acelasi bloc de memorie cache. Sa se specifice
succesiunea starilor la nivelul fiecarei memorii cache, actiunea pe magistrala si sursa de
date pentru fiecare operatie.
PROIECTAREA MULTIPROCESOARELOR CU
SUPRAVEGHERE
Memorii cache cu un singur nivel si magistrala atomica
Probleme:
1) proiectarea memoriei cache: asigura accesul procesorului si al agentului de
supraveghere la taguri;
2) rezultatele supravegherii din partea controloarelor de cache raportate ca
parte a tranzactiei pe magistrala (cand si cum?);
3) chiar daca magistrala este atomica, actiunile pentru o cerere procesor
implica si alte resurse, de exemplu controloarele cache, care nu sunt atomice;
4) operatiile de actualizare "write-back" introduc conditii asupra competitiei
pentru magistrala.
1)
2) In timpul unei operatii cu memoria pe magistrala fiecare memorie cache verifica

adresa tranzactiei cu tagurile proprii, iar rezultatul supravegherii trebuie raportat de
toate cache-urile inainte de continuarea tranzactiei.
Probleme:
-cand trebuie sa se faca raportarea;
-cum trebuie sa se faca raportarea.
Solutii pentru momentul raportarii supravegherii:

-hardware-ul garanteaza ca rezultatele supravegherii sunt disponibile intr-un
numar fix de perioade de ceas. Posibil ca la un cache procesorul tocmai sa faca o
actualizare E -> M in ambele memorii de tag, ceea ce intarzie controlorul de cache
pentru magistrala. Avantaj: proiectare simpla a sistemului de memorie. Dezavantaje:
hardware complex si posibil latenta crescuta pentru supraveghere. Solutia adoptata la
Pentium Pro Quads (extinde faza de supraveghere daca este necesar).
-supraveghere intr-un interval variabil. Solutia presupune ca memoria asteapta

pana cand o memorie cache furnizeaza datele sau pana cand s-a incheiat supravegherea
si este indicata o alta situatie. Exemplu: SGI Challenge.
-memoria principala gestioneaza cate un bit pentru fiecare bloc de cache, daca
blocul este in starea M intr-unul din cache-uri sau nu. Dezavantaj: complexitatea
sistemului de memorie.
Modalitatea raportarii supravegherii. Considerente:

-la incarcarea unui bloc controlorul de cache trebuie sa cunoasca daca blocul
este si intr-un alt cache (E / S);
-la o tranzactie memoria trebuie sa cunoasca daca blocul este in starea M la un
alt cache sau nu.
=> solutie: trei linii sau-cablat (doua pentru rezultatul supravegherii si una pentru
validarea rezultatului):
-linia 1: indica daca vreun cache detine o copie a blocului;
-linia 2: indica daca vreun cache are blocul modificat;
-linia 3: initial inactiva, fiecare controlor de cache activeaza linia pe masura ce
a incheiat supravegherea. Cand toate cache-urile activeaza linia, aceasta devina activa.
3) Operatia "writeback" complica implementarea caci implica doua

blocuri de cache (un bloc de intrare si un bloc de iesire).
se acorda prioritate procesorului => memorie suplimentara
(buffer "writeback).
Problema: posibil inainte de actualizare, pe magistrala sa apara o

cerere pentru acest bloc => blocul plasat pe magistrala din bufferul
"writeback" si se va anula cererea pentru magistrala (comparator
suplimentar de adresa pentru supravegherea bufferului
writeback).
4) Problema importanta: doua procesoare P1 si P2 detin un

acelasi bloc in memoriile cache in starea S si simultan genereaza o
scriere in bloc, facand cerere de magistrala. Daca arbitrarea este
castigata de P2, starea blocului se va modifica din S in M, in timp ce
la P1, care are o cerere de magistrala in asteptare, starea blocului
ramane S (incorect!).
=> P1 trebuie sa supravegheze magistrala si pentru cererile

sale in asteptare si sa modifice starea blocului din S in I, iar ulterior
sa faca o noua cerere pentru scrierea in bloc (BusRdX).
Solutie: extinderea protocolului cu stari intermediare sau
tranzitorii.
MULTIPROCESOARE CU ACCES UNIFORM LA

MEMORIE
(UMA)
ORGANIZARE GENERALA
SPECIFICAIA MULTIPROCESOR INTEL
SISTEM MULTIPROCESOR CU MICROPROCESOARE
INTEL PENTIUM
GESTIONAREA PROCESOARELOR MULTIPLE IN
ARHITECTURILE INTEL 64 SI IA-32
MULTIPROCESOARE UMA BAZATE PE COMUTATOARE
GRIL
MULTIPROCESOARE UMA BAZATE PE REELE DE
COMUTATOARE CU MAI MULTE TREPTE
ORGANIZARE GENERALA
Organizarea general a unui sistem multiprocesor cu acces uniform la memorie UMA
(Uniform Memory Access):
SPECIFICAIA MULTIPROCESOR INTEL

Specificaia multiprocesor de la firma Intel (Intel MP Multiprocessor
Specification) definete sistemele multiprocesor bazate pe arhitecturile procesoarelor
Intel i a circuitelor controloare de ntreruperi programabile avansate APIC (Advanced
Programmable Interrupt Controller).
Modelul specificaiei MP:

-arhitectur cu memorie partajat, strns cuplat i capabiliti distribuite
pentru ntreruperi de I/E i interprocesor;
-sistem complet simetric (toate procesoarele funcional identice, fiecare
procesor poate comunica cu toate celelalte procesoare);
-nu exist ierarhie, relaie master-slave sau geometrie care s permit numai
comunicarea cu procesoarele vecine.
Simetrie din dou puncte de vedere:
-simetrie de memorie: toate procesoarele partajeaz acelai spaiu de memorie,
accesndu-l cu aceleai adrese, de aici rezultnd o caracteristic foarte important: toate
procesoarele execut o singur copie a S.O.;
-simetrie de I/E: toate procesoarele partajeaz accesul la acelai subsistem de

I/E i oricare procesor poate primi ntreruperi de la orice surs.
Procesoarele sistemului
-procesor BSP (Bootstrap Processor);
-procesoare de aplicaii AP (Application Processors).
Dispozitivele APIC
APIC: arhitectur distribuit => funciile de control ntreruperi:
-unitatea local;
-unitatea de I/E (comunic prin magistrala ICC - Interrupt Controller
Communications Bus).
ntr-un sistem MP: uniti APIC locale i de I/E multiple => avantaje:
-descarc traficul legat de ntreruperi de pe magistrala de memorie , care astfel
rmne la dispoziia procesoarelor;
-preiau de la procesoare o parte din ncrcarea prelucrrii ntreruperilor.
Unitile APIC locale -> ntreruperi interprocesor (IPI InterProcessor Interrupts).
-fiecare APIC local: registru de identificare (Local Unit ID Register);
-fiecare APIC de I/E: registru de identificare (I/O Unit ID Register).
Implementare:
-unitile APIC locale i de I/E -> Intel 82489DX;
-APIC-urile locale -> procesoare (exemplu: incepand cu Intel Pentium 735/90,
815/100);
-APIC-urile de I/E -> set de cipuri de I/E (exemplu: Intel 82430 PCI-EISA
Bridge Chipset).
Memoria sistemului
Sistemul: arhitectura de memorie AT standard => ntreaga memorie : alocat ca
memorie sistem (exceptnd adresele 0A_0000h-0F_FFFFh i 0FFFE_0000h0FFFF_FFFFh, zone rezervate pentru dispozitive de I/E i BIOS).
Sistemul MP simetric => o rat mare de transfer pe magistrala memoriei (n
funcie de numrul de procesoare).
Reducerea transferurilor pe magistral: cache secundar actualizare de tipul WB

(Write Back) i avnd un protocol de supraveghere pentru consistena memoriei cache.
Magistrala de extensie de I/E

Sistemul MP poate incorpora diverse magistrale standard ISA, EISA, MCA,
VL i PCI.
BIOS
Sistem uniprocesor -> functii BIOS :
-testeaz componentele sistemului;
-construiete tabelele de configurare utilizate de sistemul de operare;
-iniializeaz procesorul i restul sistemului la o stare cunoscut;
-n timpul rulrii furnizeaz servicii orientate spre dispozitive.
Sistem MP -> BIOS execut urmtoarele funcii adiionale:
-furnizeaz informaiile de configurare ctre S.O:, care identific toate
procesoarele i alte componente multiprocesor din sistem;
-iniializeaz toate procesoarele i restul componentelor multiprocesor la o
stare cunoscut.
Controlul ntreruperilor multiprocesor

-un APIC local / CPU;
-unul sau mai multe APIC-uri de I/E (n funcie de numrul total de linii de
ntrerupere).
Moduri ntreruperi n sistemul MP:
1) Modul PIC unteaz toate componentele APIC i foreaz sistemul s
opereze n modul single processor;
2) Modul Virtual Wire utilizeaz un APIC ca un fir virtual, dar n rest opereaz
la fel ca n modul PIC;
3) Modul Symmetric I/O permite sistemului s opereze cu mai multe
procesoare.
=> la pornirea sistemului MP : modul 1/ 2 -> modul 3 (specific multiprocesor).
Modul PIC
-compatibil PC/AT (aceeasi configuraie hardware pentru ntreruperi).

-componentele APIC: untate prin registrul IMCR Interrupt Mode Configuration
Register (IMCR controleaz dac ntreruperile sosesc la BSP de la PIC-ul master sau de
la APIC-ul local).
-acces IMCR: dou porturi de I/E (adresele 22h pentru adrese i 23h pentru date):
-scrie 70h n portul 22h (selecteaz IMCR);
-scrie data n portul 23h.
La pornirea sistemului: IMCR <- 0
=> conecteaz NMI i INTR (8259A) direct la BSP.
IMCR <- 01h (portul 23h) => NMI i INTR (8259A) trec prin APIC.
Modul Virtual Wire.

Circuitul PIC echivalent 8259A preia toate cererile de ntrerupere -> APIC local BSP
=> APIC BSP ~ fir virtual (transmite ntreruperile de la PIC la BSP prin
LINTIN0 (Local Interrupt 0) al APIC-ului local al BSP.
-pinul LINTIN0 APIC local : programat ca ExtINT (PIC ~ controlor de
ntreruperi extern).
-AP1, AP2 i APIC-ul de I/E nu se utilizeaz;
-linia INTR 8259A: conectat la LINTIN0.
Variant: se utilizeaz APIC-ul de I/E care preia ntreruperile de la 8259A i le transfer
prin ICC Bus la APIC-ul local al BSP. AP1 i AP2 nu se utilizeaz.
Modul Symmetric I/O.
-intreruperile de I/E: preluate de APIC-ul de I/E;

-8259A este mascat;
-intreruperile APIC-ului de I/E: transmise APIC-urilor locale ale tuturor
procesoarelor prin ICC Bus;
-sistemul poate utiliza mai multe APIC-uri de I/E => creterea capacitilor de
ntrerupere;
-pentru compatibilitate PC/AT n modurile PIC i Virtual Wire -> ntreruperile
conectate la APIC-urile de I/E suplimentare trebuie conectate i la 8259A !
-intreruperile non-ISA: conectate la intrrile IRQ de la 8259A i la intrrile
APIC 2 de I/E => pentru ca aceste ntreruperi s nu apar la intrrile ambelor APIC-uri
de I/E: hardware-ul dezactiveaz reeaua de rutare a ntreruperilor.
Tabela de configuraie MP
Structurile de date pentru configuraia MP au urmtoarea organizare general:
Structura pointerului mobil MP

Este o structur de date variabil n multipli de 16 octei:
unde:
-SIGNATURE (_MP_) se utilizeaz drept cheie de cutare a structurii;
-PYSICAL ADDRESS POINTER este adresa de nceput a tabelei de
configurare MP sau este 000 dac tabela nu exist;
-LENGTH reprezint lungimea structurii, n paragrafe (de 16 octei), structura
avnd lungimea de un paragraf;
-SPEC_REV este numrul de versiune al specificaiei MP (exemplu valoarea
01h pentru versiunea 1.1, sau valoarea 04h pentru versiunea 1.4);
-MP FEATURE INFORMATION
-BYTE 1 codific tipul de configuraie MP; dac =0 tabela de
configuraie este prezent, dac 0 atunci indic tipul de configuraie implicit;
-BYTE 2 are biii 0-6 rezervai pentru dezvoltri ulterioare, bitul 7
semnific IMCR (dac =0 este implementat modul Virtual Wire, dac=1 IMCR este
prezent i este implementat modul PIC);
-BYTES 3-5 sunt rezervai pentru dezvoltri ulterioare(=0).
Headerul tabelei de configuraie MP
-SIGNATURE (PCMP) confirm prezena tabelei;

-BASE TABLE LENGTH este lungimea tabelei de configuraie (n octei),
incluznd headerul, ncepnd de la adresa 0;
-SPEC_REV este numrul de versiune a specificaiei MP;
-CHECKSUM este suma de control pentru ntreaga tabel de configuraie de baz;
-OEM ID este un ir de caractere pentru identificarea productorului hardware_ului
sistemului;
-PRODUCT ID este un ir de caractere pentru identificarea familiei de produse;
-OEM TABLE POINTER reprezint un pointer de adres fizic ctre o tabel de
configuraie definit de OEM; tabela este opional, dac lipsete, cmpul conine 0;
-OEM TABLE SIZE reprezint lungimea tabelei OEM, n octei;
-ENTRY COUNT este numrul de intrri din poriunea variabil a tabelei;
-ADDRESS OF LOCAL APIC este adresa de baz prin care fiecare procesor
acceseaz APIC-ul local;
-EXTENDED TABLE LENGTH furnizeaz (n octei) lungimea intrrilor extinse
care sunt plasate n memorie la sfritul tabelei de configuraie de baz;
-EXTENDED TABLE CHECKSUM este suma de control a intrrilor tabelei
extinse, ncepnd de la sfritul tabelei de configuraie de baz.
Headerul tabelei de configuraie: urmat de un numr variabil de intrri de

lungime variabil. Primul octet al fiecrei intrri identific tipul, fiecare tip avnd ns o
lungime fix cunoscut.
Tipurile de intrri n tabela de configuraie MP de baz sunt:
SISTEM MULTIPROCESOR CU
MICROPROCESOARE INTEL PENTIUM
Caracteristicile magistralei sistemului

Magistrala Pentium Pro -> sisteme multiprocesor:
-se pot gestiona pe magistral maxim opt tranzacii n ateptare, simultan,
aflate n diferite faze de realizare;
-dac inta tranzaciei nu poate executa tranzacia imediat -> trimite un retry
ctre iniiator: va atepta un interval de timp i va ncerca o nou tranzacie ulterior
(elibernd astfel magistrala pentru ali iniiatori);
-permite amnarea tranzaciilor (tranzaction deferral): dac inta unei
tranzacii constat c tranzacia va necesita prea mult timp, va anuna iniiatorul s
ntrerup conexiunea, care va fi reluat mai trziu.
Dispozitivele conectate la magistral = ageni:
-agent de cerere (request agent) iniiaz o tranzacie (agent iniiator);
-agent de rspuns (response agent) este destinaia tranzaciei;
-ageni de supraveghere (snoop agent) sunt toate dispozitivele care dispun de
memorie cache, care execut anumite operaii pentru actualizarea informaiilor i a
strilor liniilor din memoria cache.
Agenii de cerere:
-simetrici (procesoarele), avnd prioriti egale (pot fi maxim patru);
-prioritari (unul sau mai muli), prioriti mai mari dect agenii simetrici.
O tranzacie pe magistrala Pentium Pro cuprinde ase faze:

-faza de arbitrare;
-faza de cerere;
-faza de eroare;
-faza de supraveghere;
-faza de rspuns;
-faza de date.
Exemplu: utilizarea grupurilor de semnale de ctre tranzacii succesive :
Fazele: cerere Rq (request), eroare E (error), supraveghere S (snoop), rspuns

Rp (response) i date D (data).
Preluarea controlului magistralei

Preluarea controlului semnalelor de cerere : schem cu rotirea prioritilor (cci toate
procesoarele au aceeai prioritate) fara logic extern.
-fiecare procesor i cunoate propriul ID i ID-ul agentului care a utilizat
ultimul magistrala => urmtorul agent care va prelua magistrala;
-asignarea ID-ului: pe frontul cresctor al semnalului RESET, prin
eantionarea intrrilor BR[3:1]#;
Starea de deinere a magistralei :
-B (Busy): ultimul proprietar deine magistrala;
-I (Idle): proprietarul precedent a predat magistrala i nici un alt procesor nu
deine grupul de semnale de cerere.
Preluarea controlului magistralei
-fiecare agent utilizeaz linia BR0# pentru cerere, iar BR1-3# sunt intrri care
anun dac vreun alt agent a fcut cerere (se cunoate ce agent se afl pe fiecare linie).
Faza de cerere
Grupul de semnale de cerere :
-A[35:3]# (Address): magistrala de adrese de memorie sau de I/E, aliniat
quadword;
-AP[1:0]# (Address Parity): biii de paritate par ai adresei;
-REQ[4:0]# (Request): liniile de cerere de magistral;
-RP# (Request Parity): bit de paritate par pentru liniile de cereri i ADS#;
-ADS# (Address Strobe): semnal de validare a liniilor de adres, activat de
agentul care a lansat cererea.
-DSZ (Data Size) reprezint mrimea magistralei de date (00b pentru Pentium
Pro, magistrala pe 64 de bii);
-LEN (Length) este lungimea transferului de date, astfel:
00b: quadword, sau subset de quadword (specificare cu Byte Enable);
01b: dublu quadword (16 octei), utilizat de ali ageni dect
procesoarele (puntea);
10b: patru quadword (32 de octei);
11b: rezervat.
-ASZ (Address Space Size) indic dimensiunea spaiului de adres, astfel:
00b: adresa de memorie n intervalul 04GB-1;
01b: adresa de memorie n intervalul 4GB64GB-1;
1Xb: rezervat.
Codificrile tipurilor de cerere :

A=00000, B=XXXXX Deferred Replay (rspuns amnat): iniiat de agentul de
rspuns pentru a ncheia o cerere primit mai devreme.
A=01000, B=DSZX00 Interrupt Acknowledge (luare n considerare a unei
cereri de ntrerupere): generat de un procesor cnd s-a recepionat o cerere de
ntrerupere de la un controlor de ntreruperi 8259A, pentru a citi vectorul de ntreruperi.
A=01000, B=DSZX01 Special Transaction (tranzacie special): generat de
procesor pentru transmite (emite) un mesaj privind un eveniment intern (cdere, halt,
etc.).
A=01001, B=DSZX00 Branch Trace Message (mesaj de urmrire a
ramificaiei): generat de procesor cnd se efectueaz o ramificaie, cnd transmite
adresa instruciunii de ramificaie i adresa int.
A=10000, B=DSZXLEN I/O Read (citire de la un port de intrare): generat de
procesor cnd execut o instruciune IN sau INS pentru a citi date sau cuvnt de stare de
la un dispozitiv de I/E. Se poate genera i de la un dispozitiv altul dect procesor, de
exemplu o punte gazd/PCI.
A=10001, B=DSZXLEN I/O Write (scriere la un port de ieire): generat de

procesor cnd execut o instruciune OUT sau OUTS.
A=ASZ010, BB=DSZXLEN Memory Read and Invalidate (citire din memorie
i invalidare): generat de un procesor pentru a ctiga proprietatea exclusiv a unei linii
de cache. Este cauzat de insucces la o citire din memoria cache, cnd se execut RMW
(Read Modify Write) sau nainte de a executa RMW pentru o linie n starea partajat.
Este generat de asemenea cnd apare un insucces la scriere ntr-o zon de memorie de
tipul WB (Write Back).
A=ASZ100, B=DSZXLEN Memory Code Read (citirea codului din memorie):
generat de procesor cnd citete coduri de instruciuni din memorie.
A=ASZ110, B=DSZXLEN Memory Data Read (citirea de date din memorie):
generat de procesor cnd execut o instruciune care necesit citirea de date din
memorie.
A=ASZ101, B=DSZXLEN Memory Write-dont retry (scriere de date n
memorie, fr reluare): generat de procesor cnd nscrie napoi n memorie o linie de
cache modificat pentru a face loc unei linii noi n memoria cache de nivel 1.
A=ASZ111, B=DSZXLEN Memory Write-may be retried (scriere de date n
memorie cu posibil reluare): generat de procesor cnd execut o instruciune care
necesit scrierea de date n memorie, de exemple STORE.
Faza de eroare
Toi agenii memoreaz pachetele de cerere A i B pe ciclurile de ceas 2 i 3:
-faza de cerere ciclurile 1 i 2;
-faza de eroare ciclurile 3 i 4.
Desfasurarea fazei de eroare:
-toi agenii verific paritatea AP[1:0]# i RP#, n ciclurile 2, respectiv 3;
-la detectarea unei erori, n oricare pachet => activeaz semnalul AERR# n
ciclul 4, pentru o perioad de ceas (acest semnal fiind de tipul open drain poate fi
comandat de mai multe dispozitive).
Faza de supraveghere
n faza de supraveghere, agentul de cerere eantioneaz semnalele de supraveghere
pentru a determina:
-dac agentul de rspuns adresat intenioneaz s completeze tranzacia
imediat sau dac tranzacia va fi rencercat sau terminarea ei amnat la un moment de
timp ulterior;
-dac tranzacia este o citire sau scriere de memorie pe care agentul de rspuns
o va ncheia imediat, determin dac vreo alt memorie cache are o copie a liniei, iar n
caz afirmativ, care va fi starea liniei (curat sau modificat) la ncheierea tranzaciei.
Semnalele de supraveghere sunt:
-HIT# i HITM# utilizate de agenii de supraveghere pentru a furniza
rezultatul supravegherii memoriilor cache sau pentru a bloca ncheierea fazei de
supraveghere dac unul sau mai muli ageni de supraveghere nu sunt gata s livreze
rezultatul supravegherii. Semnalele HIT# i HITM# sunt activate de ageni multipli
pentru a bloca ncheierea fazei de supraveghere pn ce rezultatul supravegherii este
disponibil. n acest moment, nici un agent nu mai comand ambele linii: fie nu comand
nicio linie (pentru un insucces), fie comand numai HIT# (pentru succes n starea E sau
S a unei linii de cache) sau numai HITM# (pentru succes la o linie modificat);
-DEFER# este activat de agentul de rspuns, numai n timpul fazei de
supraveghere, pentru a indica rencercarea sau un rspuns amnat ctre agentul de
cerere.
Durata fazei de supraveghere variabil: ea ncepe imediat dup faza de eroare i se

ncheie la un rezultat valid de supraveghere (cnd nu sunt activate ambele semnale
HIT# i HITM#).
Rezultatele fazei de supraveghere =>codificate prin valorile semnalelor HIT#, HITM#
i DEFER#:
HIT#=0, HITM#=0, DEFER#=0: insucces n toate memoriile cache, tranzacia
nu se amn.
HIT#=0, HITM#=0, DEFER#=1: ncheierea tranzaciei se amn de ctre
agentul de rspuns, rezultatul de supraveghere fiind ignorat.
HIT#=0, HITM#=1, DEFER#=0: succes pentru o linie modificat, deci
agentul cu linia de cache modificat va furniza linia n faza de date ctre agentul de
rspuns sau ctre agentul de cerere dac este o operaie de citire.
HIT#=0, HITM#=1, DEFER#=1: succes pentru o linie de memorie cache
modificat, semnalul DEFER# fiind ignorat (n rest analog cazului de mai sus).
HIT#=1, HITM#=0, DEFER#=0: succes pentru o linie curat n unul sau mai
multe memorii cache.
HIT#=1, HITM#=0, DEFER#=1: tranzacia este amnat, semnalul HIT#
fiind ignorat.
HIT#=1, HITM#=1, DEFER#=0: Cel puin un agent de supraveghere nu poate
livra nc rezultatul supravegherii, rezultnd astfel, o blocare de supraveghere. Agentul
de cerere ateapt dou cicluri de ceas nainte de a eantiona din nou rezultatul
supravegherii, pn cnd apare un rezultat corect.
HIT#=1, HITM#=1, DEFER#=1: analog cazului anterior, dar DEFER# este
ignorat.
Exemplu: sistem cu dou clustere de procesoare - citire in cluster 0 pentru o locatie in

cluster 1=> HITM#=1 in cluster 0(HIT#=0, HITM#=1, DEFER#=1: succes pentru o
linie de memorie cache modificat, semnalul DEFER# fiind ignorat)
Faza de rspuns
n faza de rspuns, agentul de rspuns trebuie s indice agentului de cerere, dac:
-va servi imediat cererea;
-nu o va servi imediat, dar o va servi mai trziu;
-o va servi off-line i va reveni cu ncheierea mai trziu;
-este defect i nu va putea deservi cererea;
-un agent de supraveghere are o copie modificat a liniei i va furniza linia
ctre controlorul de memorie.
Grupul semnalelor fazei de rspuns :
-RS[2:0]# (Response): furnizeaz rspunsul ctre agentul de cerere;
-RSP# (Response Bus Parity): furnizeaz bitul de paritate pentru RS[2:0]#,
astfel nct s foreze un numr par de zerouri pentru RS[2:0]# i RSP#;
-TRDY# (Target Ready): indic agent de rspuns gata s accepte date de
scriere de la agentul de cerere sau un agent de supraveghere.
Faza de rspuns => liniile RS[2:0]# :

RS[2:0]#=000 Idle (stare inactiv): imediat dup intrarea n faza de rspuns,
liniile RS[2:0]# sunt n starea inactiv, pn la furnizarea unui rspuns valid;
RS[2:0]#=001 Retry (rencercare): agentul de rspuns cere agentului de cerere
s reia tranzacia repetat pn cnd va avea succes sau va cdea, deci cererea nu poate fi
servit acum, dar va fi servit mai trziu;
RS[2:0]#=010 Deffered (amnat) are loc amnarea tranzaciei pentru mai
trziu;
RS[2:0]#=011 rezervat;
RS[2:0]#=100 Hard Failure (cdere irecuperabil): defeciune la agentul de
rspuns;
RS[2:0]#=101 No Data (fr date): nu se transfer date de ctre agentul de
cerere, deci are loc scriere la agentul de cerere sau citire cu zero octei;
RS[2:0]#=110 Implicit Write Back (actualizare la eliminare implicit): n cazul
unui succes pentru o linie modificat (HITM# activ n faza de supraveghere), agentul de
supraveghere va furniza linia de cache modificat ctre agentul de cerere (pentru o
tranzacie de citire) i ctre agentul de rspuns (controlorul de memorie);
RS[2:0]#=111 Normal Data (date normale): reprezint rspunsul corect pentru
cerere de citire care nu a dat succes pe o linie modificat i nu este amnat.
Faza de date
Grupul semnalelor fazei de date :
-DBSY# (Data Busy): activat de agentul care va furniza datele pe magistrala
de date, care poate fi agentul de rspuns la o citire, agentul de cerere la o scriere sau
agentul de supraveghere la un succes pe o linie modificat, cnd preia controlul
magistralei de date;
-DRDY# (Data Ready): activat de agentul care furnizeaz datele pentru a le
valida;
-D[63:0]# (Data): reprezint magistrala de date cu opt ci pentru a transfera un
quadword;
-DEP[7:0]# (Data ECC/Parity): reprezint biii de protecie ECC/paritate a
magistralei de date (utilizai ca bii ECC permit corectarea erorilor de un singur bit i
detectarea erorilor de doi bii, fiecare bit de control fiind legat la una din cele opt ci de
date).
Tranzacii de I/E
Tranzaciile de I/E: cinci faze (de cerere, de eroare, de supraveghere, de rspuns i de

date).
Caracteristici :
-deoarece informaiile din spaiul de I/E nu se plaseaz n memoria cache, nu
apare niciodat evenimentul de succes n memoria cache;
-ntotdeauna rezultatul supravegherii este curat, semnalele HIT# i HITM#
fiind inactive, sau blocat, ambele semnale active;
-n faza de rspuns, singurul rspuns care nu poate s apar este Implicite
Write Back, cci nu exist succes pe o linie modificat de memorie cache.
GESTIONAREA PROCESOARELOR MULTIPLE IN

ARHITECTURILE INTEL 64 SI IA-32
Mecanisme pentru gestionarea de procesoare multiple conectate pe o aceeasi magistrala
in arhitecturile Intel 64 si IA-32:
-zavorararea magistralei si / sau gestiunea coerentei pentru executia de operatii atomice
cu sistemul de memorie;
-serializarea instructiunilor (numai pentru Pentium 4, Intel Xeon, familia P6 si
procesoarele Pentium);
-APIC plasat pe cip (introdus la procesoarele Pentium);
-cache L2 la procesoarele Pentium 4, Xeon, familia P6 inclus pe cip;
-cache L3 pentru Xeon inclus in modulul processor;
-tehnologia Hyper-Threading (un singur core poate executa concurent doua sau mai
multe fire de executie).
Observatie: familia P6 include procesoarele care au urmat dupa linia Intel Pentium:
Intel Pentium III Xeon processor, Intel Pentium II Xeon processor, Intel
Pentium III Processor, Intel Pentium II processor, Intel Pentium Pro processor,
Intel Celeron processor, Mobile Intel Pentium III processor, Mobile Intel
Celeron processor, Mobile Intel Pentium II processor si Mobile Intel Pentium
processor .
Operatii atomice zavorate

Operatii atomice zavorate: utilizate pentru gestionarea structurilor partajate
(semafoare, descriptori de segmente, tabele de pagini), cand doua sau mai multe
procesoare incearca sa le modifice simultan. Mecansime utilizate:
-operatii atomice garantate;
-zavorarea magistralei utilizand semnalul LOCK# si prefixul LOCK# de
instructiuni;
-protocoale de coerenta pentru memorii cache, asigurand operatii atomice pe
structuri de date de cache.
Operatii atomice garantate.

Este garantata atomicitatea unor operatii: citire/scriere octet, cuvant (word) aliniat
la 16 biti, dublu cuvant aliniat 32 biti, quadword aliniat 64 biti.
Zavorarea magistralei utilizand semnalul LOCK# si prefixul LOCK# de instructiuni.

1) Zavorarea automata:
-la executia instructiunii XCHG cu referinta la memorie;
-la setarea indicatorului B (bussy) de la descriptorul TSS (Task State Segment) la
comutarea unui task, (impiedicand ca doua procesoare sa comute pe acelasi task);
-la actualizarea descriptorilor de segmente;
-la actualizarea directorului de pagini si a intrarilor in tabela de pagini;
-la luarea in considerare a unei intreruperi.
2) Zavorarea explicita cu prefixul LOCK pentru instructiuni de modificare in memorie:
-instructiuni de test si modificare bit (BTS, BTR si BTC);
-instructiuni interschimb (XADD, CMPXCHG si CMPXCHG8B);
-automat pentru XCHG;
-instructiuni aritmetice cu un operand (INC, DEC, NOT, NEG);
-instructiuni aritmetice si logice cu doi operanzi (ADD, ADC, SUB, SBB, AND, OR,
XOR).
Ordonarea operatiilor cu memoria

1) Intr-un sistem uniprocesor (printre alte reguli):
-citirile pot fi incheiate speculativ in orice ordine;
-scrierile sunt intotdeauna incheiate in ordinea din program.
2) Intr-un sistem multiprocesor:
-procesoarele individuale utilizeaza aceleasi reguli ca in sistemele uniprocesor;
-scrierile unui procesor sunt observate in aceeasi ordine de toate procesoarele;
-scrierile mai multor procesoare pe magistrala sistem nu sunt ordonate unele fata de
altele.
Exemplu: trei procesoare scriu la locatiile A, B si C. Scrierile individuale sunt in ordinea

din program dar din cauza arbitrarii magistralei si altor mecanisme de acces la memorie
ordinea in care cele trei procesoare acceseaza memoria poate sa difere la fiecare
executie a codului.
Tehnologiile Hyper-Threading si multi-core

Tehnologiile Hyper-Threading si multi-core sunt extensii ale arhitecturilor Intel 64
si IA-32 -> permit unui singur procesor sa execute doua sau mai multe fire de cod
concurent.
Hyper-Threading: un singur core (procesor fizic) furnizeaza doua procesoare logice
identice care partajeaza resursele de executie.
Tehnologia multi-core: un cip furnizeaza doua sau mai multe core-uri.
=> pentru ambele tehnologii sunt necesare cipseturi si BIOS.
Detectarea hardware-ului Multi-Threading

Se utilizeaza instructiunea CPUID:
MOV EAX,xxH
CPUID
Se incarca un cod in EAX (uneori si in ECX) si intoarce caracteristicile de
identificare ale procesorului in registrele EAX, EBX, ECX si EDX. Astfel:
MOV EAX,1
CPUID
Intoarce in EDX[28]=1 daca cipul este capabil sa suporte tehnologia HyperThreading si / sau core-uri multiple, iar in EBX[23:16] indica numarul maxim de
procesoare logice intr-un cip fizic.
MOV EAX,4
MOV ECX,0
CPUID
Intoarce in EAX[31:26]+1 = y, unde y este numarul maxim de core-uri procesor
intr-un cip fizic.
Initializarea procesoarelor suportand tehnologia Hyper-Threading si

tehnologia multi-core: identica cu cea pentru sistemele MP conventionale.
=>un procesor logic este selectat BSP si celelalte sunt AP.
=>in timpul initializarii : fiecare procesor logic primeste un APIC ID unic
(memorat in registrul local APIC ID), dupa care software-ul poate comunica cu aceste
procesoare logice prin mesaje APIC IPI.
Gestionarea intreruperilor: la fel cu cea de la sistemele MP conventionale.

Intreruperile externe receptionate de I/O APIC-> distribuie ca mesaje de intrerupere
catre procesoare logice specifice. Procesoarele logice pot de asemenea sa trimita IPI-uri
catre alte procesoare logice prin scrierea in registrul ICR din propriul APIC local.
Valoarea APIC_ID pe 8 biti asociata cu un procesor logic este unica si poate fi

descompusa in campuri corespunzand nivelurilor ierarhice:
Aceste patru niveluri sunt:

-cluster: unele sisteme constau din mai multe clustere de sisteme
multiprocesor, pentru sisteme non-cluster, CLUSTER_ID = 0;
-package: un sistem poate avea unul sau mai multe cipuri, PACKAGE_ID
identifica pachetul (cipul) dintr-un cluster;
-core: identifica core-urile dintr-un cip, pentru single-core CORE_ID = 0;
-SMT: distinge procesoarele logice dintr-un core.
Exemplu: intr-un sistem MP relatiile intre nivelurile ierarhice:
Exemplu: patru procesoare Intel Xeon MP suportand tenologia Hyper-Threading (in

total 8 procesoare logice), APIC_ID-urile.
Exemplu: doua procesoare dual core cu tehnologie Hyper-Threading, APIC_ID-urile.
APIC
APIC local (Advanced Programmable Interrupt Controller) de la familia P6,
Pentium 4, Intel Xeon si procesoarele mai recente Intel 64 si IA-32 -> doua functii
importante:
-primeste intreruperi de la pinii de intrerupere ai procesorului, de la surse interne si de
la un I/O APIC (sau alt controller extern de intreruperi) si le trimite la core-ul procesor
pentru gestionare;
-in sisteme MP trimite si receptioneaza mesaje de intreruperi interprocesor (IPIinterprocessor interrupt) la / de la celelalte procesoare logice pe magistrala sistem
(mesajele IPI pot fi utilizate pentru distribuirea intreruperilor printre procesoare sau
pentru executia unor functii sistem ca bootarea procesoarelor, distribuirea lucrului la
procesoare, etc).
Sursele de intrerupere sunt: pinii LINT0 si LINT1 ai procesorului, timer-ul

APIC-ului, contoarele de monitorizare a performantelor, senzorul de temperatura si
detectorul de eroare interna (exemplu: incercarea de a accesa un registru
neimplementat).
Livrarea intreruperii catre core-ul procesorului se face pe baza unei tabele LVT
(local vector table), in care exista cate o intrare pentru fiecare sursa de intrerupere
locala.
Un procesor poate genera un IPI prin programarea registrului ICR (interrupt command
register). O scriere in ICR => generarea si lansarea unui mesaj pe magistrala sistem
(pentru procesoarele Pentium 4 si Xeon) sau pe magistrala APIC (pentru Pentium si
familia P6).
I/O APIC face parte din setul de cipuri sistem Intel. Primeste intreruperi externe din
sistem si echipamentele de I/E si le transmite la APIC local ca mesaje IPI. In sisteme
MP dispune de un mecanism de livrare a intreruperilor la APIC-urile locale ale unor
procesoare selectate sau unui grup de procesoare.
Conectarea I/O APIC si APIC local in sistemele monoprocesor.
Conectarea I/O APIC si APIC local in sistemele multiprocesor cu procesoare Pentium

si familia P6.
Conectarea I/O APIC si APIC local in sistemele multiprocesor cu procesoare Intel

Xeon.
MULTIPROCESOARE UMA BAZATE PE

COMUTATOARE GRIL
Multiprocesoarele UMA bazate pe magistral -> limiteaz numrul de microprocesoare
la aproximativ 16-32.
Pentru a mri numrul de microprocesoare: alt sistem de interconectare a procesoarelor.

=> comutatorul gril (crossbar switch).
Exemplu: sistem cu 8 procesoare si 8 module de memorie partajata.
Sun Enterprise 10000
Exemplu de multiprocesor UMA bazat pe comutator gril: Sun Enterprise 10000.

-un dulap cu maxim 64 de procesoare;
-comutator gril Gigaplane-XB cu 16 sloturi pentru plci;

-fiecare plac: patru procesoare UltraSPARC la 333 MHz i 4 GB de RAM;
-latena sczute a comutatorului + temporizare rigida in sistem => timpii de
acces la memoria de pe plac i la memoria din afara plcii sunt egali.
MULTIPROCESOARE UMA BAZATE PE REELE DE

COMUTARE CU MAI MULTE TREPTE
Reeaua se bazeaz pe un comutator elementar 2x2.
Un mesaj -> cmpuri:
-modul: specific modulul de memorie utilizat;
-adres: reprezint adresa din cadrul modulului;
-cod operaie: specific operaia care se realizeaz la memorie (de exemplu
CITIRE sau SCRIERE);
-valoare: este un cmp opional i poate s conin un operand (de exemplu un
cuvnt pe 32 de bii care este scris la o operaie de scriere).
Comutatorul inspecteaz cmpul Modul -> determina ieirea pe care este trimis mai
departe mesajul respectiv.
O soluie simpl i economic este reeaua omega, exemplu: conectarea a opt
procesoare la opt module de memorie partajat, cu 12 comutatoare elementare.
n general, pentru a conecta n procesoare la n module de memorie -> log2(n) trepte, cu
n/2 comutatoare pe nivel => total (n/2)log2(n) comutatoare (< n2 puncte de comutare la
un comutator gril).
(0 dirijare spre ieirea de sus, 1 dirijare spre ieirea de jos)
CIPURI CU PROCESOARE MULTIPLE

SMT (Simultaneous Multithreading)
Arhitectura Hirata
Modelele Tullsen
Hyperthreading Technology (Intel)
CMP (Chip Multiprocessors) / multi-core
Hydra
Piranha
Proiectul Teraflop (Intel)
Proiectul Cell
MicroBlaze
Arhitecturi GPU
Multi-core DSP
Exemplu de multicore DSP: Texas Instruments TMS320C6678
Istoric MPSoC
SMT (Simultaneous Multithreading)

SMT vs. CMP
Dezvoltarea tehnologiei de fabricatie a circuitelor integrate => cresterea
optiunilor de proiectare.
Paralelism:
-executia simultana de instructiuni in cadrul unui program secvential.
Ex: arhitecturile superscalare -> executie out-of-order si executie speculativa a
instructiunilor (cu tehnici de predictie dinamica).
=> cost mare pentru extragerea de paralelism dintr-un singur thread (marirea
suprafetei necesare pe cip, timpi crescuti de proiectare si verificare).
Alternative microarhitecturale cu thread-uri multiple de control: SMT
(simultaneous multithreading) si CMP (chip multiprocessors).
SMT = thread-uri multiple independente trimit instructiuni la unitati
functionale superscalare intr-un singur ciclu => utilizare mai buna a resurselor
procesorului si toleranta superioara la intarzieri.
CMP = utilizeaza core-uri relativ simple de procesor single-thread, executand
thread-uri multiple in paralel.
Paralelism:
-paralelism la nivel de instructiuni (ILP instruction-level of
parallelism): procesoarele au hardware special pentru identificarea dinamica a
instructiunilor independente care pot fi lansate in acelasi ciclu (se utilizeaza un rezervor
de instructiuni);
-paralelism la nivel de thread-uri (TLP thread-level parallelism):
executia in paralel a mai multor thread-uri.
SMT: mai multe thread-uri intra in competitie si partajeaza resursele

disponibile ale procesorului in fiecare ciclu.
Executia unui program paralel: TLP si ILP (in mod interschimbabil).
Probleme de design hardware:
-aria ocupata creste cu gradul de complexitate al core-ului
(complexitatea crescand si timpul de proiectare);
-creste durata ciclului din cauza logicii complexe;

-core-urile CPU sunt complexe, compuse din mai multe componente
strans interconectate => cresterea costului proiectarii si verificarii.
Cauze pentru resurse inactive:

a) pierderea orizontala ;
b) pierderea verticala.
a) Pierderea orizontala: lipsa paralelismului la nivel de instructiuni pentru

instructiuni apartinand unui singur proces.
b) Pierderea verticala: asteptarea pentru citirea dintr-o memorie indepartata cu
latenta mare => nu se mai lanseaza noi instructiuni (fenomen asemanator cu blocarea
procesorului).
Principiul de baza al SMT: intr-un ciclu de memorie instructiunile lansate nu

apartin neaparat aceluiasi thread. Astfel exista putin ILP pentru un thread, dar pentru ca
se lanseaza si instructiuni ale altor thread-uri => pierderea orizotala este diminuata. In
acelasi timp, executia simultana de thread-uri diferite => cresterea TLP.
Arhitectura Hirata
Instructiunile lansate sunt planificate dinamic de unitatile de planificare instructiuni.

Daca unitatile functionale sunt libere -> aceste instructiuni sunt trimise la unitatile
functionale pentru executie.
Logica de arbitrare implementeaza un mecanism de rotatie a prioritatilor.
Daca totusi instructiunile nu pot fi trimise imediat la unitatile functionale, atunci acestea
sunt memorate in statiile de asteptare (de adancime 1).
Fisierul de registre comun tuturor thread-urilor, dar impartit in bancuri
=> un banc: set privat de registre pentru fiecare thread.
Registrele de coada sunt utilizate pentru comunicatia intre thread-uri la nivelul

transferurilor intre registre.
Starea fiecarui thread, inclusiv registrele reprezinta un cadru de context. Schimbarea de
context se face rapid prin schimbarea legaturii logice intre un thread si cadrul context,
fara referinta la memorie => overhead scazut.
Modelele Tullsen
Modele Tullsen (University of California, San Diego) pentru SMT
(complexitati hardware diferite) cu 10 unitati functionale, permitand lansarea a 8
instructiuni pe ciclu:
-multithreading de granulatie fina: in fiecare ciclu un singur thread lanseaza
instructiuni (impiedica pierderea verticala, dar nu si cea orizontala);
-lansare complet simultana: toate cele 8 thread-uri active pot intra in

competitie pentru fiecare slot de lansare. Se poate intampla ca toate cele 8 instructiuni
care se executa intr-un ciclu sa apartina aceluiasi thread;
-lansare singulara, lansare duala, lansare ordin patru: fiecare thread poate lansa
1, 2 sau 4 instructiuni per ciclu, rezultand numarul de thread-uri 8, 4 sau 2;
-conexiune limitata: fiecare thread este direct conectat la o singura instanta a
fiecarui tip de unitate functionala (exemplu: daca exista 4 unitati intregi, atunci o unitate
de intregi poate primi instructiuni de la exact doua thread-uri) => flexibilitate redusa.
Performante:
Complexitatea hardware pentru modelul cu lansare complet simultana este foarte mare
(deci si costul). Performantele modelelor cu lansare de ordin 4 si chiar 2 sunt apropiate,
dar la un cost mai scazut.
Asigurarea fluxului de instructiuni

Problema importanta: asigurarea ca in fiecare ciclu sa fie suficiente instructiuni
citite din memorie. Solutii:
-unitatea de fetch este divizata pentru citirea de instructiuni de la thread-uri diferite;
-fetch selectiv: se aplica algoritmi pentru selectarea thread-urilor pentru care se vor
citi instructiuni. Algoritmi:
-BRCOUNT: prioritate maxima thread-ul cu probabilitate minima de
a se afla pe o secventa gresita (se numara instructiunile de salt branch => prioritate
maxima thread-ul cu numarul minim de instructiuni branch);
-MISSCOUNT: prioritate maxima thread-ul cu numarul minim de
evenimente lipsa in cache;
-ICOUNT: prioritate maxima thread-ul cu numarul minim de
instructiuni in banda de asamblare in segmente anterioare unitatilor functionale;
-IQPQSN: prioritate minima thread-ului care are instructiuni in coada
in ultimele pozitii (introduse recent) => cele mai bune rezultate cu ICOUNT.
-pre-executie: accelerarea thread-urilor prin generarea de noi thread-uri care
realizeaza diferite pre-executii (precitirea datelor si instructiunilor, predictia
ramificatiilor, etc.);
-tehnici de paralelizare a buclelor (restructurarea buclelor, fuziunea buclelor,
desfacerea buclelor etc);
-optimizari ale compilatoarelor;
-planificarea de joburi.
Analiza ariei ocupate in functie de numarul de thread-uri

Burns si Gaudiot: cresterea liniara a capacitatilor de fetch, decodificare,
redenumire si a numarului de registre pentru redenumire (capacitatea de repartizare
instructiuni) => cresterea suprafetei ocupate pe cip. Rezultatele (functie de numarul de
thread-uri t):
Bloc functional
Tabele de remapare (reg. arhitecturale->reg. fizice)
Registre INT si FP
Bloc fetch, reg. PC multiple si algoritm fetch icount
Bloc predictie ramificatii, stiva separata per bloc
Coada instructiuni (out-of-order)
Dtag, Itag
Rutare
Aria
O (t*log (t))
O (t)
O (t)
O (t)
O (log (t))
O (log (t))
O (log (t))
Factor cheie - tabelele de remapare (RAM multiport): aria creste cu cresterea

latimii de repartizare instructiuni -> t*log2t (nu numai se adauga noi registre pentru
thread-uri noi, dar se memoreaza si bitii de adresa - termenul log).
La fel si fisierele de registre INT si FP (RAM multiport), aria creste cu cresterea
latimii de repartizare instructiuni. Totusi, deoarece numarul de biti de adresa este fix,
aria acestora creste liniar cu numarul de thread-uri.
Intels Hyperthreading Technology

O implementare comerciala de SMT: Hyperthreading Technology = un
procesor fizic apare ca doua procesoare logice (resursele fizice de executie sunt
partajate, iar starea arhitecturala este dublata pentru cele doua procesoare logice).
S.O. si programele utilizator planifica procese si thread-uri catre
procesoarele logice, ca si cum ar fi procesoare fizice multiple.
Scop al tehnologiei: minimizarea ariei cipului si costului implementarii.
Alt scop: cand un procesor este blocat, celalalt face progrese.
Exemplu de organizare: doua procesoare fizice, fiecare cu cate

doua copii ale starii arhitecturale => sistemul apare ca si cand ar avea 4
procesoare.
Implementarea tehnologiei : + 5% dim. cipului si cerinte maxime de putere

performante mult mai mari.
Starea arhitecturala: registrele, incluzand registrele de scop general, registrele
de control, registrele APIC si anumite registre de stari ale masinii.
Cele mai multe instructiuni se executa din TC (Execution Trace Cache). Se
utilizeaza doua seturi de pointeri de instructiune urmatoare. Procesoarele logice
concureaza pentru acces la TC in fiecare ciclu => accesul este permis alternativ. Daca
un procesor este blocat atunci celalalt procesor are acces complet.
Executia de instructiuni complexe (necesita secventa complexa de microcod)
se utilizeaza doi pointeri de microcod catre Microcod ROM, controland secvente
independente de microcod (accesul la Microcod ROM se face de asemenea alternativ).
Structurile de predictie a ramificatiilor sunt duplicate.
Logica de redenumire a registrelor utilizeaza un RAT (Register Alias Table):
urmareste ultima versiune a fiecarui registru arhitectural => doua RAT-uri, unul pentru
fiecare procesor logic, operand in paralel.
CMP
CMP : chip multiprocessor sau multi-core
=> TLP prin rularea unor secvente complet separate de instructiuni pe
procesoare separate.
Avantaje:
-durata ciclului redusa: fiecare CPU este mic si rapid (S.O. aloca
fiecarui CPU un singur thread de control);
-utilizarea unui grup de procesoare mici, identice => costul de
proiectare si verificare este scazut;
-arhitectura CMP este mai putin sensibila la o slaba organizare de date
si gestiune a comunicatiilor, deoarece intarzierile in comunicatii sunt mici si rata de
transfer este mare.
Arhitecturi:
-CMP omogen: toate procesoarele sunt de acelasi tip;
-CMP heterogen: contine procesoare de tipuri diferite (disponibil in
special sub forma multiprocessor systems-on-chip MPSoC).
Utilizeaza core-uri relativ simple pentru thread singular, dar executa thread-uri
multiple in paralel pe core-uri multiple.
simplitatea proiectului;
frecventa mai mare a ceasului;
scaderea timpului consumat cu validarea proiectului.
Scurt istoric CMP
Primul multicore de scop general: 2005 Intel Duo (doua nuclee Pentium M pe
un singur cip). Procesoarele partajau memoria cache L2 si logica de gestiune a puterii.
AMD Opteron dual-core: memorii cache L2 separate, dar o interfata comuna
procesoare - controller de memorie si HyperTransport.
Niagara SPARC: opt nuclee simetrice multithread cu patru procesoare logice
fiecare.
Prima arhitectura CMP de baza propusa de L. Hammond, B. A. Nayfeh, and K.
Olukotun, A single-chip multiprocessor,, Computer, vol. 30, no. 9, pp. 7985, Sep.
1997:
8 procesoare mici superscalare cu unitate de lansare de dim. 2.

Core-urile:
-complet independente;
-strans integrate cu memoriile cache (accesul la cache intr-un singur
ciclu).
CMP = platforma ideala pentru rularea de aplicatii multithread.

In multithreading speculativ: thread-urile speculative din aplicatie
trebuie identificate fie la momentul compilarii, fie complet la momentul rularii
(cu suport hardware).
Pentru implementarea multithreading speculativ exista doua abordari

generale:
-utilizarea de suport hardware complex: permite comunicatia intre
procesoare la nivelul memoriei si la nivelul registrelor;
-utilizarea de suport hardware minim: comunicatia se face numai la
nivelul memoriei.
Implementare a arhitecturii CMP: Hydra
Hydra (Stanford University) integreaza 4 procesoare bazate MIPS, cache-urile L1 si

cache-ul L2 pe un cip.
Procesoarele suporta instructiunile normale load/store, plus instructiunile speciale

load locked (LL) si store conditional (SC) pentru implementarea primitivelor de
sincronizare.
Procesoarele+cache-uri -> conectate la cache-ul L2 prin magistrala de scriere si
magistrala de citire, plus cateva magistrale de adrese si control (logic functioneaza ca
magistrale, magistralele virtuale sunt fizic conexiuni (wires) impartite in mai multe
segmente utilizand repetoare si buffere in banda de asamblare, pentru a impiedica
scaderea frecventei ceasului).
Magistrala de citire functioneaza ca o magistrala sistem de scop general,
pentru transferul datelor intre procesoare, cache-ul secundar si memoria externa cipului
( transfera o linie de cache intr-o singura perioada de ceas).
Magistrala de scriere executa scrierile core-urilor in cache-ul L2.
-> protocol de coerenta cu invalidare pentru cache-urile L1 (scrierile sunt
transmise pe magistrala pentru invalidarea copiilor blocului in cache-urile L1);
-> consistenta memoriei (toate scrierile trebuie plasate pe magistrala pentru a fi
vizibile procesoarelor, in ordinea in care ele actualizeaza memoria partajata).
Arhitectura bazata pe magistrala suficienta pentru accesul la memoria cache
L2 a 4 - 8 procesoare. Pentru implementari cu mai multe procesoare sunt necesare
solutii cu mai multe magistrale, interconectari crossbar sau conexiuni ierarhice.
Specularea la nivel de thread-uri

Suportul hardware pentru specularea la nivel de thread-uri -> elimina necesitatea ca
programatorii sa imparta explicit programul original (secvential) in thread-uri
independente.
Hydra utilizeaza specularea la nivel de thread-uri => paralelizarea unui program in
thread-uri. Secventa de instructiuni este impartita arbitrar intr-un grup de thread-uri care
pot fi rulate in paralel pe un multiprocesor.
Hardware-ul trebuie sa urmareasca toate dependentele interthread: cand un thread
ulterior genereaza o incalcare a dependentei prin citirea prea devreme de date,
hardware-ul trebuie sa asigure ca thread-ul prost speculat va fi reexecutat (sau cel putin
portiunea cu citirea incorecta, de data aceasta cu datele corecte).
Pentru a suporta specularea la nivel de thread-uri este necesar un hardware de
coerenta special care sa monitorizeze datele partajate de thread-uri.
Cerintele de baza pentru un hardware de coerenta care sa implementeze

specularea la nivel de thread-uri:
1) transmiterea datelor intre thread-uri paralele: un sistem speculativ trebuie sa

fie capabil sa transmita datele partajate rapid si eficient, de la un thread anterior (mai
devreme) ruland pe un procesor la un thread ulterior ruland pe alt procesor (figura b).
2) mecanism de urmarire a citirilor si scrierilor in memoria de date partajate,
pentru a detecta cand o citire apare prea devreme (hazarduri RAW): daca o data este
citita de un thread ulterior si inscrisa de thread anterior, hardware-ul trebuie sa
consemneze ca citirea a gasit data incorecta (incalcare de dependenta) => thread-ul care
a incalcat dependenta trebuie reexecutat cu valorile corecte de date (figura b).
3) mecanism pentru descarcarea sigura a starii speculative dupa incalcare.

Memoria speculativa: un mecanism care sa permita descarcarea schimbarilor
speculative in starea masinii dupa o incalcare (in acest timp nu se poate pierde nicio
stare permanenta a masinii - figura c).
4) retragerea scrierilor speculative in ordinea corecta (hazarduri WAW). O data
ce thread-urile speculative s-au incheiat cu succes starea lor trebuie adaugata la starea
permanenta a masinii in ordinea corecta din program, considerand secventierea
originala a thread-urilor => hardware-ul trebuie sa intarzie scrieri ale unor thread-uri
ulterioare care au loc de fapt inaintea scrierilor unor thread-uri anterioare (figura d).
5) furnizarea redenumirii de memorie (hazarduri WAR). Figura e) indica un

thread anterior care citeste de la o adresa la care un thread ulterior a scris deja date.
Hardware-ul speculativ trebuie sa asigure ca thread-ul anterior nu poate vedea nicio
modificare facuta de un thread ulterior (aceste modificari nu s-au produs inca in
secventa originala) => complicat: fiecare procesor va rula eventual thread-uri generate
mai noi (exemplu thread i+2), care trebuie sa vada modificarile.
In Hydra, coerenta speculativa a memoriei este asigurata de hardware, iar

coerenta la nivel de registre este asigurata de software.
Resursele hardware care asigura coerenta speculativa a memoriei:
1) bitii de tag suplimentari adaugati la fiecare linie de cache primar

pentru a indica daca vreo data din linie a fost citita sau scrisa speculativ;
2) set de buffere de scriere care pastreaza scrierile speculative pana cand
pot fi executate sigur in cache-ul L2 (garantat sa pastreze numai date
nespeculative).
Fiecare thread speculativ are un astfel de buffer. Numai dupa incheierea executiei
thread-urilor bufferele sunt inscrise in L2 si scrierile raman permanente. Daca un thread
speculativ (Me) citeste din cache-ul L1, se executa cautarea si in bufferele de scriere
ale thread-urilor, in caz de coincidenta se furnizeaza linia din buffer si se seteaza bitul
Modified al liniei (optim numai pentru thread-urile i-1 si i). Daca exista coincidenta in
bufferul thread-ului speculativ i+1, se seteaza bitul de preinvalidare al liniei:
O arhitectura scalabila bazata pe un CMP: Piranha

Schema bloc (Compaq ):
-8 core-uri CPU Alpha, cu lansare o singura instructiune, executie in-order.
-core: cale de date in banda de asamblare de 500 MHz cu v.m., 8 segmente:

-fetch instructiune;
-citire registru;
-UAL1 5 (suporta instructiuni in v.m. si de inmultire);
-write-back.
-fiecare core CPU conectat direct la cache de instructiuni (iL1) si cache de date
(dL1) de 64 KB, organizare set asociativa de dim. 2, protocol MESI.
-ICS (Intra-Chip Switch): conecteaza cache-urile la alte module (crossbar);

-interfata unidirectionala (initiatorul furnizeaza datele)-> daca destinatia este
ready se trimite un grant si are loc transferul cu rata de un cuvant de 64 biti per
ciclu;
-fiecare port are doua cai independente de date de 64 biti;
-rata globala interna 32 GB/s.
-cache L2 de 1 MB, intretesut, cu 8 module separate, fiecare cu controller, tag-uri si

memorie separate.
-o linie = 64 octeti, organizare set asociativa, de dim 8, cu algoritm round-robin

(least-recently-loaded) de inlocuire a blocurilor.
-controller de memorie (MC) la fiecare modul L2, interfatat direct la un banc cu
maxim 32 cipuri Rambus DRAM. Capacitati:
-2 GB (cipuri de 64 Mb) = 8x32x64/8;
-8 GB (cipuri de 256 Mb);
-32 GB (cipuri de 1Gb);
=>rata de transfer de 1.6 GB/s per canal (in total 12.8 GB/s).
-doua motoare de protocol HE (Home Engine) si RE (Remote Engine) conectate la
ICS (suporta memorie partajata pentru mai multe cipuri Piranha):
-HE exporta blocurile avand home local;
-RE importa blocurile avand home la distanta.
=> implementare: controllere microprogramate.
Un motor:
Un motor de protocol are trei module:

-controller de intrare (primeste mesajele);
-unitate de executie microcodata;
-controller de iesire (transmite mesajele).
Microcodul are 1024 de instructiuni pe 21 biti, impartite in sapte categorii:

-SEND;
-RECEIVE;
-LSEND (local);
-LRECEIVE (local);
-TEST;
-SET;
-MOVE.
TSRF este Transaction State Register File avand 16 intrari, memorand starea thread-ului
pentru fiecare tranzactie.
Exemplu: citire de la un nod la distanta:
SEND request to home
RECEIVE reply
TEST state variable
LSEND to requesting node
Interconectarea cipurilor Piranha:

-RT (Router);
-IQ (Input Queue);
-OQ (Output Queue);
-PS (Packet Switch).
=> largimea de banda: 32 GB/s (pentru fiecare cip).
Modulul SC (System Control): gestioneaza functiile diverse de intretinere (configurare
sistem, initializare, distribuirea intreruperilor, manipularea exceptiilor, monitorizarea
performantelor).
Piranha = un multiprocesor pe un cip fara capabilitati de I/E.

=> cip special Piranha de I/E (continand o interfata PCI/X):
Exemplu de sistem Piranha cu cipuri de prelucrare si cipuri de I/E:
-max 1024 noduri (raport variabil noduri prelucare / noduri I/E);

-routerul suporta topologii arbitrare de retea si reconfigurare dinamica.
Software compatibil binar cu software-ul Alpha (de sistem si de aplicatii)

=> aplicatiile utilizator fara modificari, S.O. modificari minime (Tru64 Unix).
Comparatie de performante: uniprocesor P1 500MHz, uniprocesor INO (inorder) 1 GHz, uniprocesor OOO (out-of-order) 1 GHz si multiprocesor P8 (8 core-uri)
500 MHz, pentru doua aplicatii de baze de date OLTP (on-line-transaction-processing)
si DSS:
Necesitatea arhitecturilor tera-scalare:
-impunerea procesoarelor duale in ultimii ani;
-tendinta de crestere a numarului de core-uri;
-tehnicile SMP permit integrarea unor PE-uri (Processing Engine) mici pe
cip.
tendinta este de a integra zeci-sute de core-uri pe un cip, impreuna cu controloare

de memorie, punti de I/E si motoare grafice.
Conectarea: infrastructura formata din retea de interconectare pe cip, ierarhie de
memorie cache, memorie, I/E si interfete de sistem (Intel: uncore = toate elementele
care nu sunt motoare de calcul).
O posibila abordare: tiled architecture -> imparte pastila de siliciu intr-un numar
mare de blocuri (tiles) (aproape) identice, interconectate printr-o retea scalabila,
eficienta energetic => simplifica layout-ul si permite o integrare rapida a diferitelor
blocuri.
Arhitectura tera-scale integreaza un numar mare de core-uri de calcul de scop

general impreuna cu motoare de calcul de scop special (unitati de textura, unitati de
umbrire shader units, unitati cu functii fixe), elemente de platforma (memorie si
controloare de I/E) si interfata de sistem pentru conectarea unor procesoare multiple si a
altor periferice:
Uncore-ul arhitecturii tera-scale consta din urmatoarele elemente:

-retea de interconectare scalabila de banda larga, latenta scazuta si eficienta de
putere pentru conectarea elementelor de calcul si de platforma;
-ierarhie de cache-uri care sa permita elementelor de calcul multiple sa
utilizeze si sa partajeze resursele de memorie de pe cip;
-arhitectura de memorie scalabila si de banda larga, care sa alimenteze cu date
numarul mare de elemente de calcul.
Reteaua de interconectare
Cerinte:
-scalabilitate: multe zeci pana la cateva sute de noduri (agenti) -> crestere
subliniara a distantei medii in raport cu numarul de noduri;
-partitionabilitate: topologia arhitecturii partitionata dinamic pentru a permite
performanta si izolarea defectelelor;
-toleranta la defecte: degradare eleganta la defecte;
-validare si testare: furnizeaza suport pentru testare si validare -> se prefera
rutarea deadlock-free fata de deadlock-recovery;
-regularitate: se obtine simetrie fizica;
-flexibilitate si proiectare prietenoasa: cu un efort minim de reproiectare sa se
satisfaca un segment larg de pe piata.
Solutii pentru implementarea retelei:

-mesh 3D implementat 2D;
-inel;
-tor / mesh 2D, impreuna cu variante ale acestora. Impachetare 2D a
unui mesh 3D pentru 64 de noduri:
Solutii de toleranta la defecte:

1) Noduri de rezerva: procesoare de rezerva dotate cu interfete de retea si
switch-uri -> la detectarea unor defecte in unele procesoare, procesoarele de rezerva
sunt activate dupa reconfigurarea retelei de interconectare, pastrandu-se insa topologia
initiala.
2) Rutare toleranta la defecte: la initializarea sistemului se ruleaza un algoritm

de identificare a defectelor si a topologiei => se determina locatia / identitatea
componentelor defecte (sunt marcate). De asemenea se marcheaza si alte regiuni daca
sunt sigure sau nu din p.d.v. al rutarii deadlock-free.
3) Partitionare pentru izolarea performantelor: se pot realiza mai multe partitii pe cip,
fiecare cu cate o fractie din numarul total de unitati de calcul, unitati de scop special si
alte elemente de platforma, fiecare partitie fiind utilizata intr-o aplicatie precisa:
Ierarhia de cache-uri si protocolul de coerenta

Ierarhia de cache-uri trebuie sa suporte eficient o gama larga de modele de
programare si de incarcare:
-incarcari multiprogramate: nu exista comunicare si partajare de date intre
procese ruland pe core-uri diferite;
-incarcari cu combinatii de sectiuni scalare si paralele: performantele sunt
limitate de performantele sectiunii scalare (legea Amdahl);
-incarcari puternic paralele, care pot fi de tipuri diferite:
-paralelism de thread-uri: thread-urile pot fi similare sau foarte
diferite, pot sau nu sa partajeze date. Exemple: prelucrarea tranzactiilor si aplicatiile
web;
-paralelism de date: un task similar este executat pe seturi diferite de
date, unde anumite date pot fi partajate intre taskuri. Exemple: media, analiza numerica
si data-mining;
-stream-uri: programele sunt structurate sub forma unor nuclee
(kernels) unde date de intrare sunt prelucrate si date de iesire sunt transferate la alte
nuclee. Exemple: media si aplicatii grafice.
In procesoarele multicore cache-urile L1 sau L1 si L2 sunt private fiecarui

core, iar ultimul nivel este partajat. In CMP-urile cu putine core-uri ultimul nivel de
cache este implementat sub forma unui singur bloc UMA, dar pe masura ce creste
numarul de core-uri se opteaza pentru o distribuire fizica a cache-ului. Organizarile
cache-ului multicore, in functie de incarcari:
Coerenta: protocoale bazate pe directoare (adaptate CMP-urilor).
Director:
-evidenta starilor copiilor liniilor la nivelul memoriilor cache;
-intrari corespunzatoare liniilor;
-intrare = camp de stare + camp pentru memorarea identitatilor cache-urilor
care au copii ale liniei (pointeri).
Stari:
-I (invalid): niciun cache nu contine copie a liniei;
-S (shared): anumite cache-uri pot avea copii ale blocului in starea Shared;
-X (exclusive): unul din cache-uri poate avea o copie a liniei intr-una din
starile Modified, Exclusive sau Shared.
Informatia de identificare:
-harta completa de biti (un bit pentru fiecare cache);
-harta partiala de biti (un bit pentru un grup de cache-uri);
-set limitat de identitati de cache-uri cu un mecanism de gestionare a
depasirilor.
Arhitectura de memorie
Cresterea numarului de core-uri (puterii de calcul) => cresterea ratei de transfer a
datelor (pentru majoritatea aplicatiilor).Solutii:
-transfer de I/E off-chip cu eficienta de putere si viteza mare;
-acces DRAM cu eficienta de putere si banda larga.
Solutii CMP:
-memorii mai eficiente;
-imbunatatirea gestiunii memoriei de pe cip.
Exemplu: DRAM incorporat permite cresterea densitatii de memorie on-chip in
comparatie cu SRAM. In plus, gestiunea eficienta a memoriei de pe cip prin evitarea
datelor duplicate in ierarhia de cache-uri => cresterea capacitatii de pe cip.
Integrarea DRAM (ex. GDDR) pe cip permite un control mai bun al canalului I/E
si astfel o rata mai mare, in comparatie cu conectarea la un conector DIMM de pe placa
de baza. Solutii recente: 3D stacked SRAM cu rata mare (exemple: prototipul Intel
tera-scale si cercetarile IBM in domeniul circuitelor integrate 3D).
Proiectul Intel cip multicore - Teraflop

=> septembrie 2006: cip cu 80 core-uri, la 4 GHz, arie de 10x8 core-uri, retea mesh
interna. Performante: 1.28 Tflops.
Core:
-router cu 5 porturi;
-motor de prelucrare (PE processing engine);
-fisier de registre cu 32 de intrari (6 porturi de citire si 4 porturi de scriere);
-2 K memorie de date / 3 K memorie de instructiuni;
-doua unitati de v.m. (fiecare FPU este un multiplicator accumulator de v.m.
simpla precizie: FMAC single-precision, floating-point multiply-accumulator) cu o
banda de asamblare avand 9 segmente si o rata de 2 Flops/ciclu.
PE:
-implementeaza VLIW ISA, non-x86;
-instructiuni de 96 biti;
-maxim 8 operatii/ciclu.
Reteaua mesh care conecteaza PE-urile: comunicatia bazata pe pachete.
(RIB Router Interface Block).
Pentru economie de energie, fiecare core este impartit in 21 de regiuni

separate, iar pe baza conditionarii ceasului, diferite blocuri functionale pot fi trecute in
stare inactiva in mod dinamic, in functie de incarcarea de lucru. Chiar si routerul poate
fi oprit sau pornit pentru adaptarea la trafic!
=> proiect de testare a solutiilor de organizare, distribuire a ceasului si fabricare a

cipurilor masiv multicore.

-lansat 14 noiembrie 2011;
-frecvente 3.4 GHz (max 3.8 GHz Turbo);
-4 nuclee (8 thread-uri)
-suporta Intel 64 Architecture;
-Intel Turbo Boost Technology:
-creste dinamic frecventa procesorului pana la 3.9 GHz pentru aplicatii
performante;
-Intel Smart Cache:
-pana la 8 MB (256 KB x 6) de memorie cache partajata;
-permite alocarea dinamica si eficienta a memoriei cache pentru a raspunde
cerintelor nucleelor;
-unitate imbunatatita de v.m si multimedia pentru performanta

superioara in aplicatii video, audio, 3D;
-capabilitati de gestionare a puterii;
-interfata memorie:
-controller de memorie integrat maxim 32 GB;
-2 canale, fiecare suportand DIMM DDR3-1066/1333
MB/s;
-microarhitectura Sandy Bridge;
-o serie de chipseturi compatibile, dintre care chipsetul Q67 Express;
-diverse placi de baza compatibile, dintre care pentru chipsetul Q67
Express Intel Desktop Board DQ67SW;
Arhitectura Sandy Bridge

In cadenta de lansare a procesoarelor Intel "Tick-Tock" Sandy-Bridge este un "Tock",
insemnand o arhitectura aproape noua si nu o revizie a uneia mai vechi:
Procesorul:
-ultimul nivel de memorie cache LLC (Last Level Cache) este partajat intre nuclee,
grafica si media:
-driverul de grafica controleaza care streamuri sunt in cache / coerente;
-orice agent poate accesa toate datele in LLC independent de cine a alocat
linia, dar dupa verificarea intervalului de memorie;
-in arhitecturile precedente Nehalem / Westmere fiecare core (din 2, 4 sau 6) poseda
cale privata la cache L3 => aprox 1000 fire / core;
-in arhitectura Sandy Bridge toate nucleele, GPU si motorul de transcodare video
("System Agent" ~ North Bridge) partajeaza cache-ul L3 printr-o interconectare in inel
compusa din 4 inele:
-Data Ring (32 octeti);
-Request Ring;
-Acknowledge Ring;
-Snoop Ring;
cu arbitrare distribuita. Avantaj: scalabilitate!
GPU
-GPU are aceleasi "drepturi" ca si nucleele din p.d.v. al accesului la cache-ul L3:
-driverul de grafica controleaza datele din L3 pentru afisare;
-se poate seta cantitatea de memorie cache utilizabila de GPU;
-GPUutilizeaza hardware pentru functii fixe:
=> eficienta din p.d.v. performante / putere / arie ocupata;
=> scadere de flexibilitate;
(spre deosebire de GPU NVIDIA proiectate cat mai programabile)
Sandy Bridge Processor Graphics:

-fisier marit de registre pentru cresterea paralelismului, dar un numar fix de
registre 120 registre/thread (spre deosebire de versiunile anterioare, cu numar variabil
de registre/thread);
-unitatile de executie (EU) pot prelua instructiuni de la thread-uri multiple (la
lansarea Sandy Bridge doua versiuni: 6 / 12 EU);
-ISA intern se mapeaza pe instructiunile DirectX 10 API => arhitectura CISClike.
Chipsetul Intel Q67 Express

Structura sistemului pe baza chipsetului Intel Q67 Express
Q67 este in principiu un hub I/E (PCH "Platform Controller Hub"), deoarece
functiile Northbridge-ului sunt integrate chiar in procesor.
Caracteristici sistem:
-conectivitate procesor PCI Express 2.0 x16 (16 lanes, un "lane" ~ doua perechi de
semnale diferentiale, deci 4 fire, o pereche pentru transmisie si cealalta pentru receptie,
transferul facandu-se serial la nivel de octeti);
-Q67 furnizeaza inca 8 lane-uri PCI Express 2.0;
-procesorul conectat la PCH prin 4 "lanes" DMI ("Direct Media Interface") fiecare
asigurand 5 Gb/s. Tipuri de trafic:
-DMI -> DRAM;
-DMI -> core;
-core -> DMI.
Conectare memorie:
-doua canale DDR3 cu maxim 2 SO-DIMM-uri ("small outline dual in-line memory
module", aprox dintr-un DIMM obisnuit) sau UDIMM-uri ("unregistered DIMM"
sau "unbuffered DIMM" ofera cu un singur UDIMM / canal o rata usor crescuta de
transfer, dar la doua sau mai multe UDIMM-uri rata scade sub cea oferita de RDIMMuri "registered DIMM");
-largime canal 64 biti
Direct Media Interface (DMI)

-DMI: conexiunea chip-to-chip intre procesor si PCH;
-interfata de viteza mare;
-complet transparenta software.
Intel Flexible Display Interconnect (FDI)
-FDI: conecteaza motorul de afisare din procesor cu interfetele de display din PCH;
-datele din bufferul de cadre sunt prelucrate de motorul de afisare si trimise la PCH;
-in PCH datele sunt transcodate si trimise in exterior;
-doua canale: A si B.
PCH Display Interface
-PCH integreaza tehnologii de afisare recente/clasice ca:
-HDMI (High-Definition Multimedia Interface: transfera date video
necomprimate si audio digital comprimate/necomprimate);
-DisplayPort (interfata digitala display dezvoltata de VESA Video
Electronics Standars Association);
-SDVO (Serial Digital Video Out) tehnologie Intel;
-DVI (Digital Video Interface) dezvoltata de Digital Display Working Group
(DDWG) pentru video digital necomprimat;
-VGA (Video Graphics Array);
PCI Express* Interface

-furnizeaza 8 porturi radacina PCI Express x1 (1 "lane"), fiecare grup de porturi 1-4 si
5-8 se poate configura independent ca 4 x1, 2x2, 1x4 sau 1x2 & 2x1;
Serial ATA (SATA) Controller
-doua controllere SATA integrate suportand operatii DMA independente pentru maxim
6 porturi
PCI (Peripheral Component Interconnect) Interface
-interfata PCI la 33 MHz;
-arbitru PCI suporta maxim 4 masteri de magistrala PCI externi;
Low Pin Count (LPC) Interface
-magistrala LPC conecteaza dispozitive de rata scazuta la procesor (boot ROM, porturi
seriale si paralele, tastatura, mouse);
Serial Peripheral Interface (SPI)
-interfata alternativa pentru BIOS flash device;
-max doua dispozitive flash;
Compatibility Modules (DMA Controller, Timer/Counters, Interrupt

Controller)
-controller DMA echivalent cu doua controllere DMA 82C37;
-7 canale programabile independente;
-canalele 0-3: transfer pe 8 biti;
-canalele 5-7: transfer pe 16 biti;
-canalul 4 rezervat;
-bloc timer/counter cu trei contoare echivalent cu 82C54;
-functia de timer sistem ;
-generator de tonuri pentru difuzor;
-oscilator de intrare de 14.31818 MHz;
-PIC (Programmable Interrupt Controller) compatibil ISA;
-echivalent cu doua 82C59;
-gestioneaza 14 intreruperi externe si doua interne;
Advanced Programmable Interrupt Controller (APIC)

Universal Serial Bus (USB) Controllers
-doua controllere EHCI (Enhanced Host Controller Interface);
-USB 2.0 rata 480 Mb/s;
-max 14 porturi USB;
Gigabit Ethernet Controller

-interfata mapata in memorie sau mapata in I/E;
-doua FIFO configurabile de transmisie si receptie (20 KB fiecare);
-controllerul LAN poate opera la viteze diferite (10/100/1000 MB/s) in modurile full
duplex si half duplex;
RTC
-compatibil Motorola MC146818B cu RAM de 256 octeti pe baterie;
-data si ora;
-alarma cu max 30 de zile inainte;
GPIO (General Purpose Inputs Outputs)
-pentru proiecte custom;
Enhanced Power Management
-furnizeaza functii de gestionare a puterii;
-control ceas;
-diferite stari low-power (ex: "Suspend-to-RAM", "Suspend-to-Disk")
Manageability
-functii de gestiune a sistemului (raportare de erori, diagnosticarea sistemului,
recuperare din blocari sistem):
-TCO ("total cost ownership") timer: prima expirare a timerului utilizata pentru
refacere din blocare software, iar a doua expirare, refacere din blocare hardware;
-Processor Present Indicator: PCH verifica daca procesorul executa primul
fetch dupa reset, altfel reboot-eaza sistemul;
-ECC Error Reporting: la detectarea unei erori ECC controllerul host trimite
mesaj la PCH, care va genera o intrerupere;
-Function Disable: PCH poate dezactiva functii integrate: LAN, USB, LPC,
Intel HD Audio, SATA, PCI Express sau SMBus;
-Intruder Detect: PCH genereaza intrerupere la deschiderea capacului
sistemului;
System Management Bus (SMBus 2.0)
-interfata SMBus Host pentru comunicatie cu slave-uri SMBus (compatibil cu
majoritatea dispozitivelor I2C, cum sunt sursa de alimentare, bateria reincarcabila,
supraveghere temperatura, ventilatoare);
Intel High Definition Audio Controller

-interfata digitala pentru conectarea de diferite tipuri de codecuri (codecuri audio sau
modem);
-max 4 codecuri;
-operare la 3.3 V sau 1.5 V;
-audio de inalta calitate: stream audio multi-canal, esantioane pe 32 biti si rata de
esantionare de 192 kHz;
-intrare: arie de microfoane;
JTAG Boundary-Scan
-interfata JTAG activand pentru testare "Boundary-Scan" in loc de lanturi XOR (ca in
chipseturile precedente);
Integrated Clock Controller
-genereaza diferite frecvente de ceas pornind de la o sursa de 25 MHz;
-contine max 8 PLL-uri ("phase-locked loop"-genereaza o frecventa de iesire legata de
frecventa de intrare).
Placa de baza
Intel Desktop
Board DQ67SW
unde:
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
Conventional PCI bus add-in card connector

Front panel audio header
PCI Express x4 add-in card connector
Internal mono speaker header
Back panel connectors
12 V internal power connector (ATX12V)
LGA1155 processor socket
Processor fan header
DIMM 3 (Channel A DIMM 0)
DIMM 1 (Channel A DIMM 1)
DIMM 4 (Channel B DIMM 0)
DIMM 2 (Channel B DIMM 1)
Serial port header
Chassis intrusion header
Battery
Front chassis fan header
S
T
U
V
W
X
Y
Z
AA
BB
CC
DD
EE
FF
Main power connector (2 x 12)

Standby power LED
Piezoelectric speaker
Intel Q67 Express Chipset
Alternate front panel power LED header
Front panel header
BIOS setup configuration jumper block
Intel Management Engine BIOS Extension (Intel MEBX) Reset header
SATA connectors
Intel Fast Call for Help (Intel FCFH) header
Front panel USB headers (4)
IEEE 1394a front panel header
S/PDIF header
Rear chassis fan header
Proiectul Cell
Proiectul Cell:
-lansat in anul 2000 de IBM, Sony si Toshiba => arhitectura Cell Broadband
Engine Architecture (tip multiprocesor pe cip heterogen);
-prima implementare: Cell BE (Cell Broadband Engine);
-suporta instructiuni scalare, instructiuni SIMD si furnizeaza un mediu de
executie cu fire multiple de inalta performanta pentru toate aplicatiile.
Cell furnizeaza paralelism la toate nivelurile de abstractizare sistem:
-paralelism la nivel de fire de executie: proiect multi-core;
-paralelism la nivel de instructiuni: planificare statica;
-paralelism de date: instructiuni pentru date paralele.
Un element esential: SPU (synergistic processor unit) -> suporta paralelism

la nivel de date (instructiuni cu paralelism de date). Avand unitati multiple SPU pe un
cip se obtine si paralelism la nivel de fire de executie.
Cell BE = CMP (single cip multiprocessor) cu noua procesoare operand pe o

memorie partajata coerenta. Functiile procesoarelor:
-PPE (Power processor element) optimizat pe taskuri de control;
-SPE (synergisitic processor element) optimizat pentru prelucrarea de date.
PPE:
-arhitectura IBM Power 64 biti;
-extensie vectoriala pentru prelucrari media pe 128 biti;
-memorie cache pe cip cu doua niveluri.
SPE-urile:
-procesoare independente ruland fiecare cate un fir de executie independent,
fiind optimizate pentru aplicatii de calcul intensiv;
-memorie locala (partajata) pentru acces eficient la instructiuni si date;
-acces complet la memoria partajata coerenta (inclusiv spatiul de I/E mapat in
memorie).
SPE =SPU + controller SMF (synergistic memory flow).
Controllerul SMF: transfera datele si realizeaza sincronizarea in paralel cu
SPU, implementand si interfata pentru magistrala interna de interconectare.
Structura SPU:
SPU implementeaza paralelism la nivel de date prin integrarea unitatilor de executie

scalare si SIMD. Nu exista suport separat pentru prelucrari scalare, acestea realizanduse prin unitatile vectoriale. Nu exista fisier separat de registre scalare: SPU memoreaza
scalarii in fisierul de registre unificate scalare/vectoriale de 128 biti cu 128 intrari.
Astfel, se simplifica rutarea datelor si partajarea datelor intre date scalare si vectoriale.
Executia operatiilor scalare se face utilizand caile largi de date SIMD (scalar
layering). Pentru exemplificare se considera executia operatiilor SIMD pe un vector de
patru elemente de un cuvant fiecare. O instructiune SIMD se realizeaza prin executia in
paralel a aceleiasi operatii pe toate elementele vectorului (a).
Operatiile SIMD paralele nu se pot utiliza pentru elemente scalare aliniate arbitrar si
incarcate in registrele vectoriale (b). Este necesar ca datele sa fie aliniate la aceeasi
componenta.
In figura (c) este prezentata compilarea codului scalar pentru a fi executat pe unitatile
SIMD. Realizarea operatiei se bazeaza pe alinierea operandului in componenta cea mai
din stanga, dar un programator sau un compilator poate alinia operandul in orice
pozitie. Pe baza alinierii specificate de adresa scalarului se utilizeaza instructiuni de
rotatie pentru plasarea scalarului in pozitia corecta.
Figura (d) prezinta utilizarea secventei read-modify-write pentru memorarea unui

scalar prin intermediul interfetei de memorare pentru date de tip quad-word. Secventa
de operatii este generata de compilator. Inserarea unui scalar intr-un quad-word se face
prin utilizarea unei instructiuni shuffle pentru rutarea datelor din doua registre de
intrare. Pentru implementarea secventei read-modify-write SPU suporta o
instructiune generate controls for insertion, care genereaza un cuvant de control care
comanda instructiunea shuffle de inserare a unui octet/halfword/word intr-o pozitie
specificata de adresa de memorie.
Interconectarea procesoarelor Cell se face prin intermediul IOIF (I/O interface)

si BIF (broadband engine interface).
Configuratie cu un singur nod avand doua interfete IOIF:
Configuratie cu doua noduri cate o interfata IOIF si un port configurat BIF pentru
conectarea nodurilor:
Configuratie multinod utilizand un switch atasat la porturile configurate BIF:
Procesoare Cell sunt utilizate in sisteme pentru jocuri, echipamente HDTV,

servere si supercomputere.
Supercalculator hibrid de la Los Alamos National Laboratory (Roadrunner):
-aplicatii stiintifice si comerciale;
-peste 16000 core-uri AMD Opteron + peste 16000 procesoare Cell/B.E.;
-performantele sistemului >1.6 Pflops;
-tehnologii avansate de racire si gestiune a puterii;
-aria ocupata 12000 ft2 (aproximativ trei terenuri de basket).
IBM BladeCenter QS21
-aplicatii HPC (high performance computing): prelucrarea de imagini si semnale,
cercetare stiintifica, supraveghere digitala video;
-doua procesoare Cell/B.E. la 3.2 GHz (fiecare cu un core PPE si opt core-uri SPE);
-512 KB memorie cache L2 pentru fiecare procesor Cell/B.E. ;
-256 KB memorie locala pentru fiecare SPE;
-memorie principala 2GB (1GB per procesor);
-S.O. Linux Red Hat.
Sisteme de la Mercury Computer Systems:

-prelucrari si reconstructie de imagini, inclusiv in domeniul medical;
-Exemplu: computer tomograf cu aplicatie de reconstructie de imagini ruland pe un
Mercury Dual Cell-Based Blade;
-alte sisteme Mercury in diferite domenii: EDA (electronic design automation),
semiconductori, aerospatial, aparare, prelucrarea datelor seismice, prelucrare video.
Supercalculatorul de la University of Massachusetts:

-16 module PS3 (Playstation 3 de la Sony);
-studierea coliziunii dintre doua gauri negre;
-modulele conectate impreuna cu un switch comercial;
-S.O. PowerPC Linux;
-aplicatii bazate pe OpenMPI (distributie MPI pentru PowerPC Linux).
MicroBlaze
Prezentare generala MicroBlaze
MicroBlaze (nucleu soft de procesor incorporat) este un RISC (Harvard
Reduced Instruction Set Computer) pentru implementare in FPGA-uri (Field
Programmable Gate Arrays) Xilinx cu instrumentele software Xilinx EDK (Embedded
Development Kit). Schema bloc:
-magistrale separate pentru instructiuni si date de 32 biti functionand in paralel pentru
acces pe cip sau in exterior;
-componente principale:
-32 registre de scop general de 32 biti;
-ALU;
-unitate de deplasare (Shift);
-doua niveluri de intrerupere.
-optional (marcat cu gri) se poate completa cu:
-barrel shifter;
-unitate de impartire;
-unitate de inmultire;
-unitate de v.m. simpla precizie (FPU);
-cache-uri de instructiuni si date;
-unitate de gestionare a memoriei (MMU).
=> flexibilitate pentru a adapta complexitatea procesorului la cerintele aplicatiei!
-baza procesorului: banda de asamblare cu 3 segmente lansare singulara de instructiuni.

Segmentele: Fetch, Decode si Execute (fiecare necesitand o perioada de ceas) => se
executa o instructiune la fiecare perioada de ceas.
-Instruction Buffer: reduce impactul intarzierilor de citire din memorie a instructiunilor;
-I/E sunt mapate in memorie;
-trei interfete pentru acces la memorie:
-LMB (Local Memory Bus): acces intr-un singur ciclu la RAM bloc dual-port
de pe cip (BRAM);
-OPB (On-chip Peripheral Bus de la IBM): conexiune la memorie si periferice
on-chip si off-chip;
-XCL (Xilinx Cache Link): pentru utilizare cu controllere de memorie externa
specializate.
-suporta maxim 8 porturi FSL (Fast Simplex Link), fiecare cu un master si un slave. Un
port FSL permite conectarea de acceleratoare (co-procesoare) hardware dezvoltate de
utilizator la MicroBlaze pentru a accelera algoritmii "time-critical".
Formatele instructiunilor
Suporta doua formate de instructiuni: Tip A (pentru instructiuni registru registru) si Tip B (pentru instructiuni registru-valoare imediata).
Tip A
Tip B
Setul de instructiuni este format din urmatoarele categorii: aritmetice, logice,

ramificatie, load/store si speciale.
Nu poate efectua direct operatii in memorie (este de tip load/store).
Conventia de stiva: stiva creste catre adrese mici (la operatii push).
MicroBlaze dispune de registre speciale:

-contor de program PC;
-MSR (Machine Status Register) indicand starea procesorului
(transport, impartire prin zero, eroare FSL, activare/dezactivare intreruperi);
-EAR (Exception Address Register) memoreaza intreaga adresa

load/store care a cauzat o exceptie;
-ESR (Exception Status Register) indicand tipul de exceptie produsa;
-FSR (Floating Point Status Register) indicand operatie invalida,

eroare de impartire prin zero, overflow, underflow, eroare de operand
denormalizat.
MicroBlaze suporta reset, intreruperi, exceptie utilizator, break si exceptii

hardware:
-o singura sursa de intreruperi, conectata la portul de intrare de intrerupere.
Pentru gestionarea intreruperilor multiple este necesar un controller de intreruperi
multiple (exista un controller de intreruperi disponibil in EDK); se face salt la vectorul
de intreruperi (adresa 0x10), adresa de revenire din intrerupere se salveaza in registrul
R14, se dezactiveaza intreruperi viitoare prin stergerea bitului IE din MSR, bitul IE
fiind automat setat la executia instructiunii RTID (Return from Interrupt).
Software-ul de cotrol pentru procesorul MicroBlaze se scrie in C/C++.
Periferice
EDK furnizeaza un numar mare de periferice ce se pot conecta la MicroBlaze

sau se pot crea de catre utilizator diferite periferice conectate prin:
-OPB (On-chip Peripheral Bus);
-PLB (Processor Local Bus);
-eventual si alte interfete de magistrala suportate de Xilinx, ca FSL (Fast
Simplex Link).
Caracteristici multiprocesor
Sincronizare prin semafor
MicroBlaze furnizeaza pentru implementarea operatiilor de tip semafor doua
instructiuni LWX (Load Word Exclusive) si SWX (Store Word Exclusive) (permit
implementarea test&set, compare&swap, exchange memory, fetch&add, spinlocks).
Aceste instructiuni sunt utilizate tipic de programele sistem, apelate de catre programele
de aplicatii.
LWX incarca un semafor din memorie, cauzand setarea rezervarii (rezervarea
memorata intern de catre procesor). Programul calculeaza un rezultat bazat pe valoarea
semaforului si memoreaza conditionat (pe baza existentei rezervarii stabilite de
instructiunea LWX precedenta) rezultatul in aceeasi locatie de memorie cu instructiunea
SWX:
-daca exista rezervarea la momentul executiei instructiunii SWX, memorarea
se efectueaza si MSR[C]0, este bitul MSR[29] cu semnificatia: Arithmetic Carry
0 = No Carry (Borrow)
1 = Carry (No Borrow);
-daca rezervarea nu exista, locatia de memorie nu este modificata, iar
MSR[C]1;
Daca memorarea se executa cu succes => secventa intre citirea semaforului si
inscrierea semaforului apare ca fiind executata atomic (niciun alt dispozitiv nu a
modificat semaforul).
Exemplu: implementare Test&Set (semafor=0 liber, semafor0 ocupat):

loop:
lwx r5,r3,r0
bnei r5,next
; load and reserve

; branch if not equal to zero (Branch Immediate if Not
addik r5,r5,1
swx r5,r3,r0
addic r5,r0,0
bnei r5,loop
.
; increment value (Add Immediate and Keep Carry)

; try to store non-zero value
; check reservation (Add Immediate with Carry)
; loop if reservation lost
Equal)
next:
Exemplu: imbunatatirea performantei prin utilizarea unei instructiuni load

obisnuite pentru verificarea initiala a valorii. Implementare spinlock:
loop:
lw r5,r3,r0
bnei r5,loop
lwx r5,r3,r0
bnei r5,loop
addik r5,r5,1
swx r5,r3,r0
addic r5,r0,0
bnei r5,loop
; load the word

; loop back if word not equal to 0
; try reserving again
; likely that no branch is needed
; increment value
; try to store non-zero value
; check reservation
; loop if reservation lost
Operare lockstep
Doua sau mai multe nuclee MicroBlaze identice executa acelasi
program, iar prin compararea iesirilor furnizate de nuclee se pot detecta
incercarile de falsificare ("tampering attempts"), defecte tranzitorii sau defecte
hardware permanente.
Configuratia sistemului: un singur nucleu este setat master, celelalte
nuclee sunt setate slave. Nucleul master controleaza semnalele de iesire si
gestioneaza functionalitatea "debug".
Portul Lockstep_Master_Out de la master este conectat la portul
Lockstep_Slave_In de la slave (slave-uri).
Nucleele slave primesc doar semnale de intrare, fara sa controleze

semnale de iesire.
In cazul in care nu apare nicio eroare, semnalele individuale de la toate
nucleele sunt identice in fiecare ciclu de ceas!
Protectie la falsificare
Sistemul devine sigur la falsificare ("tamper-proof"). Exemplu: aplicatie

criptografica.
Sistemul contine doua procesoare MicroBlaze cu memorie locala
dedicata si comparatoare redundante, fiecare intr-o zona protejata. Iesirile de la
cele doua procesoare intra in doua comparatoare, iar procesoarele primesc
aceleasi semnale de intrare.
Procesoarele MicroBlaze sunt functional identice si complet
independente, fara semnale de conexiune intre acestea (exceptie: doar semnalele
pentru debugging).
Iesirile de la nucleul master controleaza perifericele. Iesirile sunt
furnizate in exterior prin circuite de inhibare controlate de comparatoare.
Detectarea erorilor
Sistemul detecteaza erorile tranzitorii si permanente, important in
aplicatii tolerante la defecte. Se utilizeaza un comparator care semnaleaza
aparitia unei erori (iesirile celor doua nuclee nu sunt identice), caz in care cele
doua procesoare sunt oprite pentru a nu propaga eroarea.
Ca in sistemul precedent, master controleaza perifericele, slave primeste
doar semnale de intrare (nu furnizeaza semnale de iesire in exterior).
Pe baza Xilinx Platform Studio (XPS) si Embedded Development Kit (EDK)

se pot implementa rapid in FPGA-uri solutii eficiente de CMP ("chip multiprocessing").
Flux de proiectare tipic:
-proiectantul porneste de la cerintele aplicatiei si aplica o serie de
constrangeri si compromisuri => o solutie cu o anumita arhitectura
hardware si software;
-creaza un prototip intr-un FPGA utilizand instrumentele Platform Studio;
-rafinarea succesiva a solutiei (etapele precedente pot dura cateva ore, dar
aici doar cateva minute);
-solutia finala.
Folosind Platform Studio se pot proiecta FPGA-uri incluzand nuclee hard

PowerPC si/sau nuclee soft MicroBlaze.
Dispozitivele FPGA Virtex-II Pro si Virtex-4 FX furnizeaza nucleu hard
PowerPC 405 (PPC405) bazat pe familia de procesoare IBM PowerPC.
Caracterisitici PPC 405:
-400 MHz;
-performante 600+ DMIPS (Dhrystone benchmark performante calcule cu
intregi, spre deosebire de Whetstone pentru v.m.);
-nucleu RISC (arhitectura Harvard pe 32 biti) cu banda de asamblare 5
segmente;
-MMU permitand implementari RTOS.
Procesoarele Xilinx utilizeaza magistrala sistem tip PLBv4.6 CoreConnect de

la IBM (toate perifericele sunt conectate prin PLB ("Processor Local Bus").
Separat de magistrala PLB fiecare procesor se poate conecta la o memorie
locala pe cip (BRAM Block RAM) printr-o magistrala de memorie:
-OCM (On-chip Memory Bus) pentru PPC405;
-LMB (Local Memory Bus) la MicroBlaze.
Exemplu: sistem cu doua procesoare independente.
Exemplu: sistem cu doua procesoare care pot comunica prin mai multe cai
posibile.
-cele doua procesoare pot fi de orice fel, in schema un PPC405 si un MicroBlaze;

-componentele partajate sunt multi port sau dual port, astfel ca cele doua
magistrale PLBv46 pot functiona independent;
-accesul la perifericele multiport este arbitrat;

-dispozitiv cheie: MPMC controller de memorie externa. Ofera diferite interfete
(porturi) catre aceeasi memorie externa:
-XCL (MicroBlaze Xilinx Cache Link) pentru instructiuni IXCL si pentru
date DXCL;
-IPLB si DPLB in cazul PPC405;
-memorie interna BRAM dual port, partajata intre cele doua procesoare, permitand
schimb de cantitati mari de date (ordinul kB);
-doua nuclee XPS Mailbox si XPS Mutex furnizand solutii simple de comunicatie
intre procesoare;
-bridge PLBv46 la PLBv46 conectand cele doua magistrale sistem (permite
partajarea unui periferic care nu este multiport).
Varianta mai economica: plasarea procesoarelor pe o singura magistrala
sistem:
=> economie prin eliminarea unei magistrale si utilizarea de dispozitive
IP uniport;
=> sistem mai putin determinist;
=> creste incarcarea pe magistrala.
Comunicatie si sincronizare
Memorie partajata
-toate procesoarele pot accesa direct memoria partajata;
-comunicatia se realizeaza prin instructiuni load si store;
-accesul la memoria partajata trebuie sincronizata printr-un protocol
hardware/software;
-permite transfer de blocuri mari de date (kB);
-memoria partajata poate fi realizata in exteriorul cipului;
-memoria partajata externa se implementeaza prin controllerul de memorie
MPMC: fiecare port este mapat in aceeasi zona de adrese;
-memoria partajata pe cip se implementeaza cu BRAM, dual port, porturile fiind

conectate la interfete LMB si/sau OCM;
-in cazul utilizarii memoriei partajate impreuna cu memorii cache:

=> coerenta se asigura prin software.
Mailbox
Xilinx furnizeaza nucleul de comunicatie interprocesor XPS Mailbox:
-fiecare mailbox are o pereche de cozi FIFO (pentru transmisie si pentru receptie),
lungimea configurabila de catre utilizator;
-functionare
a) sincrona: receiverul interogheaza permanent mailboxul pentru date noi;
b) asincrona: mailboxul trimite o intrerupere (linia IRQ) catre receiver la
sosirea datelor;
-un mailbox dispune de o pereche de interfete pentru conectarea procesoarelor
(chiar daca se pot conecta mai multe procesoare la un mailbox, se recomanda
conectarea a numai doua procesoare);
-utilizare pentru mesaje scurte si medii (pana la sute de octeti);
-transfer: fiecare procesor scrie/citeste un mesaj intreg in/din mailbox => consuma
multe cicluri;
-dezvoltare viitoare: utilizarea DMA;
-implementare IPI (Interprocessor interrupts) prin mailbox: un procesor trimite un

mesaj (scurt) catre celalalt procesor, mesajul se inscrie in mailbox, iar mailboxul
genereaza intrerupere catre celalt procesor. Procesorul destinatie extrage mesajul din
mailbox, generandu-se acknowledge pentru intrerupere.
Sincronizare
Tehnicile de sincronizare de tip semafoare si mutex bazate software necesita
operatii atomice read-modify-write, indisponibile la MicroBlaze.
Xilinx Platform Studio furnizeaza un modul de sincronizare hardware XPS

Mutex pentru crearea regiunilor mutual exlusive.
XPS Mutex furnizeaza un numar configurabil de registre mutex mapate in
memorie. Un registru are doua componente:
-componenta valoare;
-componenta ID procesor.
Protocolul:
-valoare initiala mutex = 1 (unlocked);
-procesorul inscrie valoarea 0 si ID propriu (cereri simultane, arbitrare);

-daca mutexul este locked valorile din mutex nu se modifica;
-daca mutexul este unlocked se inscriu valorile trimise de procesorul castigator al
arbitrajului;
-toate procesoarele citesc ID din mutex si-l compara cu ID propriu: identitate
pentru procesorul castigator;
-procesorul castigator intra in sectiunea critica;
-eliberare: procesorul inscrie in mutex valoarea 1 si ID propriu.
Depanare
Ambele procesoare MicroBlaze si PowerPC se pot conecta la instrumente de

depanare Platform Studio.
PowerPC se conecteaza printr-un modul on-chip, controller JTAGPPC, care
furnizeaza o interfata pentru doua procesoare PPC. Instrumentele de depanare, ca de
exemplu XMD (Xilinx Microprocessor Debugger), pot accesa oricare procesor PPC in
lantul JTAG si executa operatii de depanare: pornirea/oprirea procesorului, inserare de
instructiuni, citirea registrelor, etc.
MicroBlaze se conecteaza printr-un modul on-chip, MDM

(Microprocessor Debug Module), care furnizeaza un numar configurabil de
interfete de depanare pentru controlul a maxim opt procesoare. Selecteaza la un
moment oricare dintre procesoare si executa operatii specifice de depanare cu
acesta (multiplexare in timp).
Controllerul MDM furnizeaza si o interfata UART bazata JTAG,

accesibila prin interfata PLBv46.
Arhitecturi GPU
GPU (Graphics Processing Unit) lansat de NVIDIA in 1999 permite
accelerarea unei varietati de aplicatii paralele, in primul rand cele grafice, dar si de scop
general (in acest caz GPGPU General Purpose GPU).
Din cauza unor inconveniente legate de GPGPU (cunostinte detaliate API si
GPU, exprimarea problemelor in coordonate de varfuri, texturi, iar scrieri/citiri cu
memoria nu erau suportate, fara suport de dubla precizie), NVIDIA a introdus doua
tehnologii cheie:
-arhitectura de calcul si grafica G80 (prima data in GPU-urile GeForce 8800,
Quadro FX 5600 si Tesla C870);
-CUDA (Compute Unified Device Architecture), arhitectura software si
hardware permitand programarea GPU cu o varietate de limbaje de programare de nivel
inalt.
Arhitectura G80
GeForce 8800: lansata in noiembrie 2006:

-suporta limbajul C;
-procesor unificat executand aplicatii grafice si programe de calcul;
-introduce modelul de executie SIMT ("single instruction multiple thread");
-introduce memorie partajata si sincronizarea cu bariera pentru comunicarea
inter-thread.
GT200 - a doua generatie lansata in iunie 2008 :
-cresterea numarului de core-uri (numite core-uri CUDA) 128 240;

-fiecare fisier de registre dublat;
-suport v.m. dubla precizie pentru aplicatii HPC ("high performance
computing).
Arhitectura de calcul si grafica CUDA (nume de cod "Fermi")

Imbunatatiri:
-cresterea performantelor de calcul in dubla precizie;
-ierarhie de cache-uri;
-memorie partajata mai mare;
-comutare de context mai rapida;
-operatii atomice mai rapide (read-modify-write) pentru implementarea
algoritmilor paraleli.
Elementele arhitecturale cheie ale arhitecturii Fermi:
1) a treia generatie SM (Streaming Multiprocesor):
-32 core-uri CUDA per SM (4x fata de GT200);
-8x performantele v.m. dubla precizie fata de GT200;
-planificator de warp-uri dual (warp = unitate de thread-uri multiple,
numarul de thread-uri difera functie de implementare);
-RAM 64 KB cu o partitionare configurabila de memorie partajata si
cache L1;
2) a doua generatie ISA pentru executie de thread-uri paralele:

-spatiu unificat de adrese cu suport complet C++;
-optimizat pentru OpenCL (1) si DirectCompute(2);
-v.m. IEEE 754-2008 pe 32 biti si 64 biti;
-intregi 32 biti cu extensii pe 64 biti;
(1)
OpenCL (Open Computing Language) este un framework pentru scrierea programelor

executate pe platforme heterogene formate din CPU-uri, GPU-uri si alte procesoare. OpenCL include un
limbaj de tip C pentru scrierea de kernel-uri (functii executate pe dispozitive OpenCL) si API-uri utilizate
pentru definirea si controlul platformelor. OpenCL ofera unei aplicatii acces la GPU pentru prelucrari
negrafice.
(2)
Microsoft DirectCompute este un API suportand prelucrare de scop general pe GPU-uri sub
Microsoft Windows Vista si Windows 7. DirectCompute face parte din colectia de API-uri Microsoft
DirectX.
3) subsistem imbunatatit de memorie:

-ierarhie NVIDIA Parallel Data Cache cu memorie cache
configurabila L1 si unificata L2;
-suport ECC (Error Control Coding);
-operatii atomice cu memoria imbunatatite;
4) NVIDIA GigaThread Engine:
-comutare de context pentru aplicatii 10x;
-executie kernel concurenta;
-executie blocuri de thread-uri out-of-order;
-engine-uri duale pentru transfer de memorie.
In industria de semiconductoare incepand din jurul anului 2003 s-au remarcat

doua traiectorii pentru productia de micropocesoare:
-traiectoria multicore cu solutii de paralelizare a aplicatiilor secventiale;
-traiectoria many-core focalizata in principal pe aplicatii paralele.
Grafic cu performantele diferitelor procesoare:
(performantelor microprocesoarelor de scop general au crescut lent, cele ale GPU-urilor

au crescut puternic).
Diferentele mari de performanta intre cele doua categorii de procesoare sunt

cauzate in primul rand de filozofiile diferite de proiectare:
CPU:
-optimizat pentru executia de cod secvential;
-logica control complexa permitand executia in paralel de instructiuni de la un
singur thread, chiar si out-of-order;
-memorii cache mari pentru reducerea latentei accesului la date si instructiuni;
-rata de transfer cu memoria la un GPU 10x;
GPU:
-memorii cache mici, lasand o arie mai mare pentru calcule performante v.m.;
-nu este optimizat pentru anumite tipuri de prelucrari => majoritatea
aplicatiilor vor utiliza CPU (portiunile secventiale ale aplicatiei) si GPU (portiunile
numeric intensive) => NVIDIA a introdus in 2007 modelul de programare CUDA
pentru a suporta executia unitara CPU/GPU a unei aplicatii.
Arhitectura generala a unui GPU tip CUDA:
Organizarea de baza:
-arie de SM-uri (Streaming Multiprocesor), doua SM-uri formand un bloc constructiv
(numarul de SM-uri dintr-un bloc poate sa varieze);
-fiecare SM contine un numar de SP-uri (Streaming Processor), care partajeaza logica
de control si cache-ul de instructiuni;
-G80: 128 SP-uri (16 SM x 8 SP), fiecare SP cu unitate inmultire-adunare si o
unitate de inmultire suplimentara;
-GT200: 240 SP-uri;
-G80 suporta 768 thread-uri / SM, in total aprox. 12000 thread-uri;
-GT200 suporta 1024 thread-uri/SM, in total aprox.30000 thread-uri;
(un procesor clasic dual-core sau quad-core suporta 2-4 thread-uri /core);
-memoria globala, externa GPU, este de tip GDDR DRAM ("graphics double data rate
DRAM"), diferita de memoria sistem;
-pentru aplicatii grafice contine imagini video si informatii de texura pentru
generare ("rendering") 3D;
-pentru calcule functioneaza ca o memorie off-chip de banda foarte larga.
Multi-core DSP
Conceptul DSP introdus la mijlocul anilor 1970, permitand prelucrari
matematice complexe in timp real, pe baza unor caracteristici arhitecturale ca:
-magistrale de date duale/multiple;
-instructiuni complexe intr-un singur ciclu;
-unitati de inmultire hardware performante;
-instructiuni speciale pentru gestiunea constructiilor de prelucrari de semnale.
Cresterea performantelor DSP => dezvoltarea de aplicatii in timp real mai
sofisticate, in domenii ca voce, audio, imagini, video.
Constatare: majoritatea utilizatorilor de DSP folosea in sistemele lor mai multe
procesoare, in loc de unul singur pentru rezolvarea problemelor.
Un pas intermediar: TI a creat in TMS320C40 porturile necesare pentru
plasarea impreuna a mai multor procesoare intr-o matrice de elemente de prelucrare.
Pasul urmator: integrarea in acelasi cip a mai multor DSP-uri, cu diverse

optiuni arhitecturale:
-multiprelucrare omogena /heterogena;
-procesoare + acceleratoare;
-functii fixe/programabile;
-procesoare de scop general + DSP-uri, etc.
Dezvoltarea DSP stimulata de sectorul wireless (aprox. 68% din procesoare DSP
utilizate in acest sector).
DSP multicore tipic:
Doua categorii principale de arhitecturi:

1) arhitectura omogena: toate nucleele sunt de acelasi tip;
2) arhitectura heterogena: nuclee de tipuri diferite (DSP, GPP general
purpose processors, GPU graphics processing units, MCU micro controller units).
O alta clasificare: in functie de solutiile de interconectare intre nuclee:

1) platforme multi-core DSP ierarhice: transferurile de date intre nuclee se
realizeaza prin una sau mai multe unitati de comutare:
-comunicatii intre procesoare vecine, cu banda larga, iar prin
interconectarea comutatoarelor se permite comunicarea unor procesoare la distanta, cu o
latenta mai mare;
-arhitectura de memorie uzuala: memorie locala L1 dedicata fiecarui
nucleu, L2 poate sa fie dedicata/partajata intre nuclee, L3 memorie partajata
interna/externa;
2) platforme mesh, procesoarele DSP organizate intr-un tablou 2D, nodurile
conectate printr-o retea de magistrale sau prin unitati de comutatoare multiple:
-fiecare nucleu este conectat cu vecinii est, vest, sud, nord;
-memoria este in general locala, fiecare nod poate avea o ierarhie de
niveluri de cache.
O alta clasificare a platformelor DSP:
1) platforme multiprocesor simetrice (SMP Symmetric Multiprocessing):

un task poate fi asignat oricarui nucleu, fara afectarea performantelor;
2) platforme multiprocesor asimetrice (AMP Asymmetric
Multiprocessing): plasarea unui task poate influenta performantele (latenta)
=> necesitatea optimizarii plasarii taskurilor pentru optimizarea performantelor.
Exemplu:
-reteaua mesh: taskurile cu cerinte mari de intercomunicare trebuie plasate in
procesoare vecine;
-reteaua ierarhica: procesoarele comunica prin cache-ul L2/L3 => taskurile pot
fi plasate in oricare procesoare.
Concluzie: SMP sunt mai usor de programat, dar implica latenta mai mare in
comparatie cu AMP.
Platforme DSP multi-core reprezentative

TI: serie de platforme DSP multi-core omogene si heterogene, toate bazate pe
arhitectura de interconectare ierarhica.
Exemplu: TNETV3020 optimizat pentru aplicatii de voce si video de inalta
performanta in infrastructura de comunicatie wireless.
-platforma contine sase TMS320C64x+ la 500 MHz;
-consum de 3.8 W fiecare.
Freescale: dispozitive DSP multi-core bazate pe subsistemele DSP StarCore

140, 3400 si 3850:
-MSC8112 (doua nuclee DSP SC140);
-MSC8144E (patru nuclee DSP SC3400);
-MSC8156 (sase nuclee SC3850), bazat pe o arhitectura de interconectare
ierarhica omogena cu sistem de arbitrare si comutare (CLASS chip level arbitration
and switching system):
Aplicatii: 3G-LTE, WiMAX, 3GPP/3GPP2 si TD-SCDMA.
PicoChip: dispozitive DSP multi-core bazate pe arhitecturile de interconectare

mesh heterogena (PC205) si omogena (PC203). Exemplu: PC205:
Principalele module: microprocesor ARM926EJ-S (RISC pe 32 de biti pentru functii

de control) si picoArray. PicoArray consta din 248 procesoare VLIW DSP conectate
intr-o arie 2D (fiecare procesor: memorie dedicata pentru instructiuni si date + acces la
memoria externa):
Aplicatii: standarde de comunicatie de date wireless de mare viteza in retele

metropolitane (WiMAX) si retele celulare (HSDPA si WCDMA).
Tilera: procesoare DSP

multi-core TILE64,
TILEPro36 si TILEPro64,
bazate pe o arhitectura de
interconectare mesh
omogena puternic scalabila.
TILE64 contine 64 nuclee
identice (tiles)
interconectate printr-o retea
mesh de magistrale:
Fiecare tile contine:

- un procesor;
-memorie cache L1 si L2;
-switch non-blocant conectand tile-ul la mesh.
Organizare: grid 8x8.

Memorie cache totala pe cip: 5 MB.
Frecventele de operare: 500-866 MHz.
Consum 15-22 W.
Aplicatii: retele avansate, video digital si telecomunicatii.
Exemplu de multicore DSP:

Texas Instruments TMS320C6678
Multicore Fixed and Floating-Point Digital Signal Processor
(feb 2012)
Caracteristici:
-8 nuclee TMS320C66x DSP, fiecare cu:
-1/1.25 GHz nucleu CPU v.f./v.m.;
-memorie 32 KB L1P/nucleu, 32 KB L1D/nucleu, 512 KB L2/nucleu;
-controller memorie MSMC ("Multicore Shared Memory Controller") cu 4096 KB
SRAM partajat de cele 8 nuclee;
-coprocesor de retea;
-periferice:
-patru "lanes" SRIO (Serial Rapid IO);
-PCIe;
-HyperLink suportand conexiuni cu alte dispozitive avand arhitectura
KeyStone;
-Gigabit Ethernet cu operare 10/100/1000 Mbps;
-interfata DDR3 64 biti cu 8 GB spatiu adresabil;
-interfata UART;
-interfata I2C (Inter-Integrated Circuit);
-GPIO (General-Purpose Input/Output) 16 pini;
-intefata SPI (Serial Peripheral Interface);
-module semafor;
-16 timers 64 biti;
-3 PLL-uri pe cip;
Arhitectura KeyStone
-integreaza nuclee RISC si DSP cu coprocesoare specifice aplicatiei si de I/E;
-acces neblocant la toate nucleele de prelucrare, periferice, coprocesoare, I/E prin patru
elemente principale hardware:
-Multicore Navigator (trimite taskurile la hardware-ul corespunzator
disponibil);
-TeraNet (transfer de pachete);
-Multicore Shared Memory Controller (acces direct al nucleelor la memoria
partajata, fara utilizare TeraNet);
-HyperLink (interconectare la nivel de cipuri pentru lucrul in tandem al S0Curilor).
Schema bloc TMS320C6678:
-platforma programabila integrand diferite subsisteme (nuclee C66x, memorie,

periferice, acceleratoare), permitand comunicatia intre diverse resurse DSP;
-cele patru componente de baza:
-Multicore Navigator;
-TeraNet;
-Multicore Shared Memory Controller;
-HyperLink.
-fiecare nucleu dispune de 4 unitati MAC ("multiply accumulate") v.f si unitati
v.m simpla si dubla precizie;
-instructiuni noi de prelucrare vectoriala;
-memorie on-chip:
-32 KB cache L1 pentru program si 32 KB cache L1 pentru date / nucleu;
-512 KB / nucleu memorie dedicata configurabila ca memorie RAM mapata
sau cache;
-4096 KB memorie partajata MSM ("Multicore Shared Memory") ca memorie
cache L2 sau L3;
-detectie si corectie de erori;
-interfata de memorie externa DDR-3 64 biti EMIF ("External Memory Interface");
-multitudine de interfete standard (PCI Express, Gigabit Ethernet, I2C, UART, TSIP
Telecom Serial Interface Port, EMIF 16 biti, GPIO, etc);
Structura nucleului:
-doua blocuri de registre generale A si B, fiecare cu 32 de registre de 32 de

biti (date sau adrese);
-operatii pe 8/16/32/40/64/128 biti;
-opt blocuri functionale (.M1, .L1, .D1, .S1, .M2, .L2, .D2, .S2), fiecare
poate executa o instructiune/ciclu de ceas:
-unitatile functionale .M -> operatii de inmultire;
- unitatile functionale .S si .L -> functii generale aritmetice, logice
si de ramificatie;
- unitatile functionale .D -> operatii de citire / scriere cu memoria;
-LPSC (Local Power/Sleep Controller) conectat la core.
Memory Protection:
-S.O. defineste cine poate accesa L1D, L1P si L2;
-impartire pe pagini (16 pagini x 2KB pentru L1P si L1D, 32 pagini x 16 KB
pentru L2);
-controllerele de memorie contin registre specificand permisiunile de acces la
paginile de memorie;
-acces:
-utilizator / supervizor cu drepturi de citire, scriere, executie;
-local (DSP) / global (initat de DMA);
-accesele neautorizate -> intrerupere;
-blocheaza accesul (citire returneaza 0, scriere ignorata);
-memoreaza info initiator (ID, adresa, tip acces);
Controller de memorie
-interfateaza memorie SDRAM DDR3;
-adresa 33 biti -> spatiu 8 GB;
-magistrala date 16/32/64 biti;
-1/2/4/8 bancuri;
-mod "self-refresh";
Semnale importante:
-DDRD [63:0] magistrala bidirectionala de date;
-DDRCB [7:0] biti verificare ECC;
-DDRA [15:0] adresa;
-DDRCE0,1 "chip enable";
-DDR3CLKOUTP [1:0]/DDR3CLKOUTN [1:0] ceas diferential;
-DDRDQSP [8:0]/DDRDQSN [8:0] strobe diferential date;
etc.
Controllerul transmite comenzi catre SDRAM, cum sunt:
-ACT activeaza banc si rand (se transmite inainte de o operatie de citire sau scriere);
-DES deselecteaza dispozitiv;
-NOP;
-RD furnizeaza adresa de coloana de start si incepe operatia de citire;
-REF autorefresh;
-WR furnizeaza adresa de coloana de start si incepe operatia de scriere;
Comenzile sunt codificate prin nivelurile semnalelelor de control.
Operatia de citire:
Operatia de scriere:
Controllerul contine mai multe cozi FIFO:

-Command FIFO: memoreaza comenzile de la dispozitivele de cerere on-chip;
-Write Data FIFO: memoreaza datele de inscris in SDRAM;
-Write Status FIFO memoreaza informatiile de stare pentru fiecare tranzactie de
scriere;
-Read Command FIFO: memoreaza citirile;
-SDRAM Read Data FIFO: memoreaza datele citite din SDRAM pentru
dispozitivele de cerere on-chip;
-Register Read Data FIFO: memoreaza datele de la MMR-uri (Memory Mapped
Registers) pentru dispozitivele de cerere on-chip;
Controllerul analizeaza cozile FIFO efectuand arbitrarea si optimizarea operatiilor.
Exemplu de conectare la controller a doua dispozitive 16 MB x 16 x 8 (4 Gb in total):
Timer64P
-poate fi configurat utilizand bitii de mod (TIMMODE) din registrul
TGCR ("timer global control register"):
-timer scop general GP ("general purpose") pe 64 biti;
-timere duale de 32 biti TIMLO si TIMHI;
-timer watchdog.
-un pin intrare TINPL si un pin de iesire TOUTL, cu functii controlate prin registrul
TCR ("timer control register");
Dintre modurile de functionare:
Exemplu: modul timer scop general pe 64 biti.
-un singur numarator pe 64 biti (CNTLO, CNTHI), incrementat de o sursa de

impulsuri selectata;
-cand CNTLO, CNTHI = PRDLO, PRDHI ("period registers") se genereaza:
-intrerupere mascabila TINTLO;
-eveniment timer TEVTLO;
-semnal de iesire la TOUTL.
-se incarca in registrele de perioada valoarea din registrele de
reincarcare RELLO, RELHI ("reload registers");
Universal Asynchronous Receiver/Transmitter (UART)
-cozi FIFO pentru receptie si transmisie de 16 octeti, plus biti aditionali de eroare
pentru receptie;
-conversii serie/paralel si paralel/serie a datelor;
-citirea in orice moment a starii UART;
-capabiltati de control si generare intrerupere;
-generator de baud programabil pentru selectarea ratei de comunicatie.
Semaphore2 Hardware Module

-accesibil tuturor nucleelor;
-suporta max 64 semafoare independente pentru implementarea protectiei resurselor
partajate;
-fiecare semafor poate fi accesat de nuclee in modurile direct, indirect sau combinat;
-cozi pentru cereri;
-permite aplicatiei verificarea starii semafoarelor;
-detectarea de erori si intreruperi;
(N=numar de nuclee, M=numar de semafoare)

-genereaza doua seturi de intreruperi:
-SEMINTn ("semaphore grant interrupt");
-SEMERRn ("semaphore error interrupt");
-trei registre SEM_DIRECT, SEM_INDIRECT, SEM_QUERY, fiecare semafor fiind
alocat cate unui set de registre;
-controlul semafoarelor se face prin citiri/scrieri cu aceste registre;
-semafoarele nu sunt asociate cu resurse ale DSP, aplicatia realizeaza asocierile si
gestioneaza informatiile de stare;
Cerere directa. Un nucleu lanseaza o cerere directa pentru un semafor prin

citirea registrului SEM_DIRECT, cand se returneaza:
- daca semaforul este liber -> valoarea 1 (in registru bit 0 = 1);
-daca semaforul este detinut -> ID-ul nucleului detinator (in registru bit 0 = 0);
Structura registrului de cerere directa (SEM_DIRECTi, unde i este numarul
semaforului):
unde
-Owner (acces R): ID-ul nucleului detinator al semaforului (FREE=0) sau zero
(FREE=1);
-Free (acces RW):
0:
R: semaforul nu este atribuit nucleului care a facut cererea;
W: cererea trecuta in coada;
1:
R: semaforul este atribuit nucleului care a facut cererea;
W: semaforul este setat liber;
-Reserved: campuri rezervate.
Nu se genereaza intreruperi pentru atribuirea semaforului (SEMINTi).
Cerere indirecta. Semaforul poate fi preluat printr-o singura cerere (spre

deosebire de cererea directa, cand aplicatia repeta cererea pana la atribuirea
semaforului). Daca semaforul este ocupat cererea este plasata intr-o coada FIFO.
Cerea indirecta este lansata prin scrierea valorii 0 intr-unul din registrele
SEM_DIRECT, SEM_INDIRECT sau SEM_QUERY.
Registrul SEM_INDIRECT are o structura asemanatoare cu cea a registrului
SEM_DIRECT (singura diferenta: daca FREE=0 la citire semaforul nu este atribuit, dar
cererea este plasata in coada).
La atribuirea semaforului prin cerere indirecta se lanseaza o intrerupere
SEMINTi catre nucleul respectiv.
Cerere combinata. Cererea actioneaza ca o cerere directa daca semaforul este
liber, altfel ca o cerere indirecta, plasand cererea in coada.
Lansare cerere combinata: citirea registrului SEM_INDIRECT corespunzand
semaforului:
-daca semafor liber -> 1;
-daca semafor ocupat: ID-ul detinatorului, iar cererea este plasata in coada.
Intreruperi:
-daca semaforul este liber in momentul cererii: nu se lanseaza intrerupere;
-daca semaforul este ocupat, cererea este plasata in coada, iar cand semaforul
este atribuit nucleului se lanseaza intrerupere SEMINT.
Eliberarea semaforului. Nucleul detinator inscrie valoarea 1 in oricare dintre

registrele SEM_DIRECT, SEM_INDIRECT sau SEM_QUERY.
Citirea starii unui semafor. Fara a cere semaforul un nucleu poate citi starea
acestuia prin citirea registrului SEM_QUERY (structura asemanatoare cu cea a
registrului SEM_DIRECT).
Gestionarea erorilor. Patru tipuri de erori:
-Already Free Error: incercarea de eliberare a unui semafor liber;
-Illegal Free Error: incercarea de eliberare a unui semafor de catre un nucleu
care nu-l detine;
-Already Own Error: incercarea de acaparare a unui semafor deja detinut de
nucleu;
-Already Requested Error: lansarea unei noi cereri de acaparare a unui semafor
pentru care nucleul are deja o cerere in coada.
La aparitia unei erori registrul SEMERR este actualizat cu numarul codului de
eroare (0-63) si ID-ul nucleului care a generat eroarea.
unde
-Faultid: ID-ul nucleului care a generat eroarea;
-SEMNUM: numarul semaforului asociat cu eroarea;
-ERR: codul de eroare:
-00h: No Error;
-01h: Already Free Error;
-02h: Illegal Free Error;
-03h: Already Own Error;
-04h: Already Requested Error.
Registrul SEMERR poate fi sters inscriind valoarea 1 in registrul SEMERR_CLEAR.
Intreruperi. Modulul semafor poate genera doua tipuri de intreruperi:
-Semaphore Grant Interrupt (SEMINTn);
-Semaphore Error Interrupt (SEMERRn).
(fiecare cu linii independente, capabile sa adreseze oricare nucleu)
SEMINTn se genereaza la atribuirea unui semafor pentru o cerere aflata in
asteptare.
SEMERRn se genereaza la detectarea unei conditii de eroare.

Sistemele multiprocesor pe un cip (MPSoC Multiprocessor Systems on
Chip) reprezinta o clasa importanta de sisteme VLSI, care incorporeaza majoritatea
sau toate componentele necesare unei aplicatii, inclusiv mai multe procesoare, de obicei
heterogene, fiind proiectate in special pentru aplicatii embedded.
Utilizare: retele, comunicatii, prelucrarea semnalelor, multimedia, etc.
Istoric MPSoCs
Primul MPSoC a fost Lucent Daytona (Lucent Technologies), proiectat pentru
statii de baza wireless, in care se efectueaza prelucrari identice de semnale pe un numar
de canale:
-arhitectura simetrica;
-patru CPU bazate SPARC V8 (RISC 32 biti & SIMD 64 biti) conectate la o magistrala
de mare viteza;
-fiecare CPU memorie cache 8KB;
-memoriile cache supravegheaza magistrala pentru a asigura coerenta;
-procesoarele partajeaza un spatiu comun de adrese de memorie;
-cip 200 mm2 proces CMOS 0.25 m 3.3 V 100 MHz.
In scurt timp dupa Lucent Daytona au aparut mai multe MPSoC-uri.

C-5 Network Processor (Freescale) proiectat pentru prelucrarea de pachete in
retele:
-pachetele gestionate de procesoarele de canale (CP channel processor), grupate in

patru clustere de cate patru procesoare fiecare;
-trei magistrale pentru tipuri diferite de trafic;
-procesoare aditionale, foarte specializate (ex: procesor executiv, de tip RISC).
Philips Viper Nexpiria utilizat in multimedia:
-doua procesoare: procesor MIPS (arhitectura introdusa de Hennessy) si procesor

Trimedia VLIW;
-MIPS: master ruland S.O.;
-Trimedia: slave, executand comenzi de la MIPS;
-trei magistrale, cate una pentru fiecare procesor, plus o magistrala pentru interfata de
memorie externa;
-bridge-uri pentru conectarea magistralelor;
-acceleratoare hardware pentru calcule (conversie de spatiu de culoare, scalare, etc.).
Arhitectura Texas Instruments OMAP cu aplicatii in telefonia celulara, a avut

mai multe implementari, exemplu OMAP 5912:
-doua procesoare: ARM9 si TMS320C55x de tip DSP;

-ARM9: master;
-TMS320C55x: slave, efectuand operatii de prelucrare de semnale;
Obs. Lucent Daytona arhitectura omogena, celelalte exemple arhitectura
heterogena.

Procesoare necomunicante
-este o topologie de baza, doar o duplicare a resurselor;

-procesoare independente care nu comunica;
-fiecare procesor are memoria sa locala si dispozitive sistem conectate printr-o
magistrala locala (ex: PLB, processor local bus)
-procesoarele nu pot fi coordonate pentru rezolvarea aceleiasi probleme, fiecare
executand o functie specifica;
-mai rar utilizat.
Procesoare comunicante punct-la-punct
-se utilizeaza conexiuni directe pentru comunicatii intre procesoare;

-implementare simpla si eficienta (schimb rapid de date);
-limitare a scalabilitatii si flexibilitatii;
Exemplu: implementarea unui codor MPEG2 utilizand comunicare punct-lapunct, cu 7 noduri si 10 conexiuni:
Pentru comunicatii punct-la-punct au fost propuse diferite protocoale:

-CoWare (Karl Van Rompaey, Diederik Verkest, Ivo Bolsens, Hugo De Man
CoWare A design environment for heterogeneous hardware/software systems);
-Rendezvous: asigura sincronizarea inainte de transfer (Sender se blocheaza
pana cand Receiver este ready si invers);
-OCP (Open Core Protocol) protocol al OCP-IP (Open Core Protocol
International Partnership), www.ocpip.org;
Procesoare conectate prin crossbar
-rata mare de transfer;

-dezavantaj: complexitatea logicii interconectarilor si resurselor de rutare;
-ex: ARM PL300/301, AMBA3 si SonicsMX.
Exemplu de MPSoC bazat pe crossbar:
-procesoare Motorola PowerPC (MPC) 750 cu memorii cache;

-module de memorie partajata SRAM A-D;
-orice procesor poate accesa orice memorie libera;
-la cereri simultane pentru acelasi modul de memorie se utilizeaza un arbitru.
Procesoare conectate prin magistrala
-IP core(1);
-solutia traditionala in MPSoC;
-avantajul major este simplitatea => cost scazut de proiectare si suprafata mica ocupata;
-dezavantaj: rata limitata de transfer intre module;
-solutie aplicabila pentru un numar redus de procesoare.
IP core (Intellectual Property core)este un bloc de logica sau date utilizat in realizarea unui FPGA (Field Programmable Gate Array)sau
ASIC (Application-Specific Integrated Circuit) pentru un produs. Ulterior, blocul poate fi reutilizat si pentru alte produse, ca parte a EDA
(Electronic Design Automation). IP core trebuie sa fie portabil pentru a putea fi inserat in tehnologia altui producator. Exemple de IP cores:
UART (Universal Asynchronous Receiver/Transmitter), CPU, cotroller Ethernet, interfete PCI, etc.
(1)
Exemple de magistrale industriale
IBM CoreConnect
-arhitectura embedded bazata pe magistrala;

-trei magistrale sincrone:
-PLB Processor Local Bus;
-OPB On chip Peripheral Bus;
-DCR Device Control Register;
-modul bridge si doua module arbitru.
AMBA de la ARM
-ARM: www.arm.com;
-proiectat pentru familia de procesoare ARM;
-protocoale pentru trei magistrale:
-AHB Advanced High Performance Bus;
-ASB Advanced System Bus;
-APB Advanced Peripheral Bus (proiectat pentru tranzactii de performanta
scazuta cu perifericele);
-bridge: conexiune intre doua entitati operand cu protocoale diferite si/sau frecvente
diferite => adapteaza protocoalele, asigurand sincronizarea si bufferarea;
CoreFrame de la Palmchip Corp
-arhitectura de mare performanta si consum redus;

-trei magistrale sincrone:
-CPU Bus;
-Palm Bus: interfata master slave permitand comunicatiile intre CPU si
periferice, la viteza mai scazuta;
-M Bus: transferuri efectuate de CPU si periferice cu memoria partajata;
-controller Palm Bus: conecteaza CPU Bus si Palm Bus;
-bridge/cache pentru conectarea M Bus si CPU Bus.
Avalon de la Altera Corporation
-utilizat in principal pentru conectarea modulelor embedded (procesoare, periferice) ale

sistemelor programabile pe un cip, tipic pentru proiectele FPGA bazate pe procesoare
NIOS (de la Altera);
-magistrala suporta multimaster si utilizeaza o tehnica speciala de arbitrare distribuita;
-transfer de date pe magistrala de largime 8, 16, 32, 64 sau 128 biti
Global Bus I Architecture (GBIA)
-un nod de calcul este alcatuit din procesor Motorola PowerPC (MPC) 750 si
memorie cache de instructiuni si date;
-fiecare procesor are o magistrala dedicata (CPU Bus X), iar sistemul dispune de
o magistrala globala partajata;
-doua registre, DONE_OP si DONE_RV, pentru dialogul intre procesoare:
fiecare procesor seteaza un indicator in aceste registre dupa prelucrarea datei sau
receptia datei de la procesorul corespondent;
-accesul unui procesor la modulele de memorie se face prin magistrala globala;
-BB_x (Bus Bridge) permit accesul procesoarelor la modulele de memorie;
Exemplul 1 de comunicare: MPC 750_A scrie in SRAM_A => BB_1
realizeaza conexiunea procesorului A la memorie, in timp ce BB_2 si BB_8
blocheaza accesul la SRAM_A de la oricare alt procesor.
Exemplul 2 de comunicare: MPC 750_B citeste de la SRAM_A: BB_1
deconecteaza CPU Bus A de la SRAM_A, BB_2 si BB_3 conecteaza CPU Bus
B la Global Bus si SRAM_A.

Organizarea generala a unui MPSoC:
unde
PE: procesor;
IP: IP unit;
HW: unitate de accelerare.
PE1 si PE2 pot comunica direct sau utilizand memoria partajata, utilizand protocolul
magistralei Bus 1. Alte comunicatii se realizeaza prin intermediul puntilor, de exemplu
Bridge 1 executa translatare intre trei protocoale Bus 1, Bus 2 si Bus 3.
=> in schemele complexe MPSoC comunicatiile influenteaza semnificativ
performantele globale ale sistemului.
Clasificarea sincronizarilor in comunicatia proceselor MPSoC

Comunicatia intre procese la nivelul tranzactiei include:
-definirea unei rute intre procesele transmitator si receptor;
-sincronizarea celor doua procese;
-transferul de date.
Se considera doua procesoare PE1 si PE2, conectate printr-un canal
BusChannel care modeleaza o magistrala. Fiecare PE contine cate un proces:
Sender() si respectiv Receiver().
Rutinele send( ) si recv( ) contin primitive de comunicatie implementand fazele de

comunicatie:
-FindRoute( ): rutarea(determina o magistrala sau un set de magistrale si
componente punte conectand procesoarele continand procesele Sender( ) si Receiver( ));
-Synchronize( ): sincronizarea (asigura ca cele doua procese sa fie pregatite sa
transmita, respectiv sa receptioneze);
-SendData( ) / RecvData( ): transferul de date.
Schemele de sincronizare a proceselor pot fi clasificate dupa mai multe criterii:

-tipul comunicatiei (comunicatie blocanta / non-blocanta);
-tipul rutei de comunicatie (comunicatie directa / indirecta);
-numarul de indicatori de sincronizare (1 sau 2);
-pozitia indicatorilor de sincronizare (in memoria partajata sau in PE-uri);
-tipul de acces la indicatorul de sincronizare (interogare / intrerupere prin
master/slave).
-marcate cu gri cazurile specifice de implementare pentru cazul general prezentat

anterior;
-cu linie intrerupta cazurile a caror implementare imposibila;

-in schemele non-blocante Sender( ) continua prelucrarile fara sa cunoasca daca
Receiver( ) a preluat datele (se bazeaza pe planificator de procese si buffere de date);
-in comunicatia directa ruta dintre Sender si Receiver contine o singura magistrala;
-in comunicatia indirecta ruta contine memoria partajata si/sau modul punte;
-indicatorii specifica starea ready a proceselor:
-doi indicatori, cate unul pentru fiecare proces Sender si Receiver;
-un singur flag: daca setat un singur proces este ready, daca resetat, fie
ambele procese sunt ready, fie niciunul; poate fi localizat in Sender, Receiver sau in
memoria partajata;
Scheme de comunicatie blocanta

Necesita ca procesele ready sa se blocheze pana cand are loc transferul de
date. Se poate realiza prin:
a) Sender initiaza scrierea datei in memoria/registrele locale la Receiver
(destinatia datelor trebuie sa fie accesibila Sender-ului prin magistrala);
b) Receiver initiaza citirea datei din memoria/registrele locale la Sender prin
magistrala (sursa de date trebuie sa fie accesibila Receiverului);
c) ambele procese Sender si Receiver initiaza scrierea si citirea datelor in/din
memoria partajata (memoria accesibila ambelor procese).
=> (a) si (b) scheme de comunicatie directa, (c) comunicatie indirecta.
Comunicatie directa:
Transferul de date se face prin citirea din / scrierea in registre locale sau memorie
locala. Procesul transmitator trebuie sa incarce registrul de date cu data inainte sau in
timpul sincronizarii, dupa care operatia bus write sau bus read (in functie de
transfer initiat de Sender sau respectiv de Receiver) copiaza data in celalalt registru.
Comunicatia indirecta:
Ambele procese acceseaza memoria partajata prin rutine read( ) si write( ), incapsulate
in canalul de magistrala partajata. Procesul 2 trebuie sa astepte scrierea datei in
memoria partajata de catre Procesul 1 inainte de a o citi.
a) Comunicatie directa
Necesita in cazul general doi indicatori de sincronizare, cate unul
pentru fiecare proces (0=proces not ready, 1=proces ready). Indicatorul local
unui proces semnalizeaza disponibilitatea celuilalt proces in comunicatie,
astfel fiecare proces poate testa starea celuilalt procesul printr-o citire locala,
fara accesul la magistrala.
Diagrama sincronizarii in cele doua procese, Sender si Receiver:
Un proces testeaza indicatorul local FL, daca FL= 0 ~ celalalt proces nu

este ready, deci primul proces ready seteaza indicatorul la distanta FR si se
blocheaza. Daca FL=1, ambele procese sunt ready si initiaza transferul
mesajului.
Evitarea blocarii (cele doua procese nu seteaza fiecare FR in doua
cicluri succesive de magistrala): fiecare proces testeaza FL si seteaza FR intr-o
operatie atomica, prin preluarea magistralei inainte de verificarea FL.
Diagramele de timp, in cele doua cazuri:
Sender este ready primul:
Intre t2-t3 Sender este blocat.
Receiver este ready primul:
In cazul in care cele doua procese ruleaza pe acelasi procesor, comunicatia este
gestionata de S.O.
In cazul proceselor ruland pe procesoare distincte, daca au aceleasi drepturi de
acces la magistrala, comunicatia se desfasoara ca mai sus.
In multe scheme de gestiune a magistralei modulele sunt impartite in module
master si module slave. Astfel daca Sender este master, acesta va initia o operatie
Write Data, sau daca Receiver este master, acesta va initia o operatie Read Data.
Schema bazata pe interogare

Se considera cazul Sender este slave si Receiver este master., un singur
indicator (la Sender).
Diagrama Sender este ready primul:
Diagrama Receiver este ready primul:
Receiver interogheaza repetat starea indicatorului, consumand cicluri de magistrala,

pana cand indicatorul este setat de Sender, apoi reseteaza indicatorul si initiaza
transferul.
Problema. Sa se construiasca diagramele de semnale in cele doua cazuri, dar
considerand Sender modul master si Receiver modul slave.
Schema bazata pe intrerupere

Daca indicatorul este in PE master, PE slave nu poate accesa indicatorul prin
magistrala, dar se poate utiliza o linie dedicata de intrerupere.
Diagrama Sender (master, contine indicatorul) ready primul:
Diagrama Receiver (slave) ready primul:
In ambele diagrame Receiver (slave) lanseaza o intrerupere catre master, iar in

procedura de tratare a intreruperii masterul seteaza indicatorul la momentul t1. Dupa ce
masterul reseteaza indicatorul, initiaza transferul.
b) Comunicatie indirecta
Intre Sender si Receiver exista o memorie partajata. Nu mai este necesar ca
cele doua procese sa fie ready simultan, ci data sa fie ready pentru scriere cand Sender
este ready, respectiv data sa fie ready pentru citire cand Receiver este ready.
Se utilizeaza un singur indicator FD:
FD=0 data este ready pentru scriere;
FD=1 data este ready pentru citire.
Scrierea precede citirea => Sender seteaza FD, Receiver reseteaza FD.
Pentru procese locale: comunicatia gestionata de S.O. (folosind mecanisme tip
mutex, locks).
Pentru procese la distanta, indicatorul de sincronizare poate fi plasat la Sender,

sau la Receiver, sau in memoria globala partajata.
Diagrama in timp a procesului de sincronizare:
Observatie. Operatiile de setare/resetare se pot implementa ca rutine de

interogare (operatii de citire/scriere care utilizeaza magistrala) sau ca evenimente de
intrerupere (ambele procese Sender si Receiver anunta celalalt proces ca data este ready
sa fie citita/scrisa prin activarea liniilor corespunzatoare de intrerupere).
MULTIPROCESOARE CU ACCES NEUNIFORM LA

MEMORIE (NUMA)
MULTIPROCESOARE NC-NUMA
MULTIPROCESOARE COMA
MULTIPROCESOARE CC-NUMA
Multiprocesoarele cu acces uniform la memorie (UMA) au un numr relativ

mic de procesoare (maxim 100).
Pentru creterea numrului de procesoare la sistemele cu memorie partajat :

multiprocesoare cu acces neuniform la memorie NUMA (NonUniform Memory
Access).
=> asigur un singur spaiu de adrese pentru toate procesoarele, dar accesul la memoria
local este mai rapid dect accesul la memoria la distan.
=> toate programele scrise pentru UMA se pot executa fr modificri pe NUMA, dar
performanele vor fi mai slabe.
MULTIPROCESOARE NC-NUMA
NC-NUMA (NonCoherent NUMA). Exemplu: Cm* de la Carnegie Mellon University
(procesoare LSI-11),
Fiecare cuvnt de memorie -> o singur locaie de memorie (nu

exist copii).
Performanele sunt determinate de care pagini se gsesc n memoria
local pentru un procesor (penalizrile de timp severe n cazul acceselor n
afara memoriei locale).
Programe sofisticate pentru mutarea paginilor ntre modulele de
memorie, n scopul creterii performanelor: explorator de pagini (page
scaner) -> examineaz statisticile de folosire a paginilor => va muta anumite
pagini pentru mbuntirea performanelor.
Prevenirea fenomenului de mutare succesiv a unei pagini
(thrashing): se foreaz nghearea paginii ntr-un anumit modul pentru un
anumit interval de timp.
MULTIPROCESOARE COMA
Dezavantaj NUMA: accesele la memoria aflat la distan sunt mult

mai lente dect accesele la memoria local.
COMA (Cache Only Memory Access) utilizeaza memoria fiecrui
procesor ca memorie cache.
-liniile (blocurile) de cache nu au localizri fixe;
-spaiul de adrese fizice este mprit n linii de memorie cache care
migreaz prin sistem la cererile procesoarelor;
-memoria principal local a fiecrui procesor este utilizat ca
memorie cache;
-> capacitate mare => cele mai multe accese sunt locale =>
mbuntirea performanelor sistemului.
Organizarea unui multiprocesor COMA:
-memorii cache (Ci);

-directoare de memorie cache (Di);
-migraia liniilor de cache printre nodurile de prelucrare, n funcie de cerinele
procesoarelor;
-exemple de sisteme COMA: Data Diffusion Machine i Kendall Square KSR1 i KSR-2;
Probleme:
-localizarea liniilor de memorie cache;
-eliminarea unei linii dintr-o memorie cache n cazul n care aceasta este ultima
copie.
Solutii:
-localizarea liniilor de cache: harta de bii (un bit pentru fiecare linie, care s
indice dac linia respectiv este sau nu prezent n memoria cache);
-localizarea liniilor aflate la distan: atribuirea fiecrei linii unei maini gazd,
nu n raport cu localizarea fizic a liniilor (liniile pot migra n cadrul sistemului), ci n
raport cu localizarea directoarelor liniilor, care rmn n poziii fixe;
-pot fi mai multe copii ale unei linii cache n noduri diferite -> unele copii pot
fi eliminate pentru aducerea altor linii n nodurile respective => ultima copie a liniei s
nu fie tears! Soluie: evidena copiilor unei linii la nivelul catalogului de pe nodul
gazd (la eliminarea unei linii din memoria cache se face acces la catalogul gazd i
dac aceasta este ultima linie => transferat ntr-un alt nod) sau una din copii marcat
copie principal (nu va fi tears niciodat).
MULTIPROCESOARE CC-NUMA
NUMA cu memorie cache coerent CC-NUMA (Cache Coherent
NUMA): coerena memoriilor cache prin utilizarea unor cataloage
(multiprocesoare bazate pe cataloage sau directory-based multiprocessors).
Baz de date cu informaii despre locul i starea fiecrei linii (bloc) de
cache. La referirea unei linii cache, baza de date este interogat pentru a afla
unde se gsete i dac aceasta este valid sau modificat.
Interogarea bazei de date la fiecare instruciune de referire la memorie
=> implementare cu hardware extrem de rapid.
Coerenta memoriilor cache ierarhice

Ierarhiile de memorii cache :
a) procesor singular cu memorie cache L1 pe chip si memorie cache L2

externa.
Proprietatea de incluziune: orice informatie din cache-ul L1 este prezenta si in
cache-ul L2 (dim(L1)dim(L2)).
Supravegherea L2 este responsabila cu actualizarea sau invalidarea datelor
corespunzatoare cererilor de la distanta.
b) multiprocesor de scara larga cu o ierarhie de magistrale (ierarhie

multicache).
=> cea mai simpla solutie de realizare a sistemelor MP cu cache-uri coerente

de scara larga. Se utilizeaza supravegherea de cache la fiecare nivel.
b1) toata memoria principala este pe magistrala globala (B2);
L1 -> inalta performanta prin memorii SRAM.

Magistrala B1 -> protocol de supraveghere standard.
L2 -> solutia set-asociativa, incluziune, DRAM (primeste mai putine cereri).
b2) memoria principala este distribuita printre clustere.
reduce traficul global pe magistrala (memoria contine datele locale si o parte utila a
datelor partajate).
micsoreaza latenta (accesele locale sunt mai rapide).
Exemplu: Encore Gigamax.
Encore Gigamax:
UIC = Uniform Interconnection Card;

UCC = Uniform Cluster (Node) Cache card.
Coerenta cache-urilor se pastreaza pe baza unor reguli:

-o scriere pe magistrala locala este trecuta pe magistrala globala daca:
-data este alocata intr-un MP (multiprocesor) la distanta;
-data este alocata local, dar este prezenta si intr-un cache la distanta.
-o citire pe magistrala locala este trecuta pe magistrala globala daca:
-data este alocata intr-un MP la distanta si nu este in cache din
clusterul curent;
-data alocata local, dar in starea Dirty intr-un cache la distanta.
-o scriere pe magistrala globala este trecuta pe magistrala locala daca:
-data este alocata in MP local;
-data alocata la distanta dar este Dirty in cache-ul local.
(etc.)
Varianta la solutia b2) : ierarhia de inele (exemplu: KSR). Supravegherea la
cereri se face pe un inel. Legatura punct la punct a inelului implica o rata de transfer
mai mare decat magistralele, dar si o intarziere mai mare.
Coerenta cache-urilor bazate pe directoare
Schemele cu supraveghere nu se pot scala (broadcast) => schemele

bazate pe directoare se pot scala!
Caracteristici:
-nu utilizeaza broadcast;
-tin evidenta amplasarii blocurilor in cache-urile procesoarelor;
-pastreaza coerenta prin mesaje punct-la-punct.
Se considera un sistem avand k procesoare:

-pentru fiecare bloc de cache in memorie: k biti de prezenta P si un bit DM (Dirty).
-pentru fiecare bloc de cache in cache: un bit V (Valid) si un bit D (Dirty, Owner).
Schema de baza:
Schema de multiprocesor scalabil bazat pe cataloage:
La un eveniment lipsa de cache la citire pentru un bloc in starea Dirty aflat la un nod
care nu este Requestor sau nodul care detine informatiile de director:
Eveniment lipsa in cache la o scriere pentru un bloc care se gaseste in starea Shared in
doua noduri (literele suplimentare suprapunere):
Organizarea directoarelor
Scheme de directoare (in functie de sursa informatiilor din director):
-centralizate.
-distribuite:
-ierarhice.
-neierarhice (in functie de localizarea copiilor):
-bazate pe memorie;
-bazate pe cache.
Schemele centralizate sunt usor de implementat , dar nu sunt scalabile.
Schemele distribuite neierarhice au directoarele implementate alaturi de memorie,
iar localizarea directorului se bazeaza pe informatiile de adresa din cuvantul curent.
Scheme ierarhice
=> directorul: structura de date ierarhica
-frunzele sunt noduri de prelucrare;
-nodurile interne: informatii de stare a directorului (intrarea de
director a unui nod pentru un bloc specifica daca fiecare subarbore are blocul in cache
(bit de prezenta) si daca este in starea modificat (dirty))
Pentru gasirea informatiilor de director -> trimite un mesaj search catre
nodul parinte.
Asemanarea cu schemele de supraveghere ierarhica, dar aici se trimit mesaje
intre nodurile fiu si parinte.
Exemplu: Data Diffusion Machine.
-nod director nivel 1:

-care noduri fiu (noduri de prelucrare) detin copie a blocului;
-evidenta blocurilor de memorie locala incarcate in cache-uri in afara
subarborelui curent.
-nod director nivel 2:
-care noduri director fiu nivel 1 au o copie a blocului;
-evidenta blocurilor de memorie locala incarcate in cache-uri in afara
subarborelui curent.
Scheme neierarhice bazate pe memorie

=> informatii despre copiile incarcate in intregul sistem, impreuna cu blocul de
memorie in nodul home.
Localizarea copiilor: in nodul home -> comunicata direct prin mesaje punct
la punct.
Exemple: Standford Dash/Flash, MIT Alewife, SGI Origin, HAL.
Cea mai simpla reprezentare: matrice de biti.
Daca p este numarul de procesoare si m numarul de

blocuri de memorie => overhead-ul este proportional cu
produsul pm. Scalarea nu este eficienta in functie de p.
Exemplu: pentru linie de cache de 64 octeti valorile
overhead-ului:
Noduri
Overhead
64
12.5%
256
50%
1024
200%
Optimizari:
-cresterea dimensiunii blocului de cache => reduce
overhead-ul prin micsorarea spatiului de memorie ocupat de director;
-utilizarea de noduri multiprocesor => aloca cate un bit

pentru un nod multiprocesor si nu pentru fiecare procesor.
=> overhead-ul scade, dar ramane important. Exemplu: 256
procesoare, 4 procesoare per nod, bloc de cache de 128 octeti:
overhead 6.25%.
Exemplu: multiprocesor bazat pe cataloage.
Sistemul : 256 de noduri, nod: un procesor i 16 MB de RAM cu magistral

local.
Memoria total = 232 octei = 226 linii de cache x 64 de octei.
Memoria -> alocat static n cadrul nodurilor

=> 0-16MB -> nodul 0;
=> 16MB-32MB -> nodul 1, etc.
Nodurile legate printr-o reea de interconectare (de tip gril, hipercub, etc.).
Fiecare nod: intrrile catalogului pentru 218 linii de cache de 64 octei (corespunznd
memoriei nodului de 224 octei).
>> O linie poate fi inut n cel mult o memorie cache!

O adres de 32 de bii :
Funcionarea catalogului: se consider LOAD procesorul 20 => MMU procesor 20

translateaz cererea ntr-o adres fizic (exemplu 0x24000108, nodul 36, linia 4 i
deplasamentul 8) -> mesaj prin reeaua de interconectare ctre nodul 36 -> catalog nod
36 -> intrarea 4 (bit de control 0, linia nu este n memoria cache) => citete linia 4 din
memoria RAM local nodul 36 -> nodul 20 => actualizeaz intrarea 4 din catalog (linia
4 se gsete la nodul 20).
O alt cerere de la nodul 20 -> la nodul 36 pentru linia 2 (bit de control 1, in memoria
cache a nodului 82) => n tabela nodului 36 se actualizeaz informaia pentru linia 2 ->
mesaj nodul 82 pentru a furniza nodului 20 linia.
Limitare a modelului: o linie numai n memoria cache a unui singur nod.

Memorarea n mai multe noduri: eviden pentru localizarea tuturor nodurilor (pentru a
le invalida sau actualiza n urma unei scrieri).
Soluie: pentru fiecare intrare n tabel m cmpuri (plasarea liniei respective n maxim
m noduri simultan).
Alt soluie: harta de bii (256 bii), specifica dac o anumit linie se gsete sau nu n
cele 256 de noduri ale sistemului => memoria cataloage = 50% din memoria util (256
bii pentru evidena a 64 octei = 512 bii).
Alt soluie: lista nlnuita pentru fiecare linie de cache (numerele de noduri n care se
gsete linia respectiv) => spaiu suplimentar pentru legturile listei nlnuite i
parcurgerea de fiecare dat a unei astfel de liste!
Probleme:
-marcarea liniilor cache dac sunt curate sau modificate => cerere de citire
ctre un nod avnd linia modificata -> nodul care conine o copie curat;
-la scriere -> toate nodurile care dein copii ale liniei respective;
-cereri simultane de scriere n aceeai linie cache.
Multiprocesorul DASH
DASH (Directory Architecture for Shared Memory)
sisteme comerciale (exemplu: SGI Origin 2000).
la Universitatea Stanford ->
-16 grupuri, fiecare grup = patru procesoare MIPS R3000, 16 MB de memorie

RAM global i echipamente periferice, conectate printr-o magistral local;
-grupurile interconectate prin magistrale intergrup;
-coerena: fiecare procesor supraveghez magistrala local, dar nu i celelalte
magistrale => coerena global un alt mecanism;
-memoria = 256 MB (16 regiuni de 16 MB fiecare):
-grup 0 : 0-16M;
-grup 1 : 16M-32M, etc.
-linia cache = 16 octei => un grup conine 1 M linii de cache;
-fiecare grup: catalog pentru evidena liniilor de cache (1 M intrri), fiecare
intrare:
-hart de bii -> linia respectiv este sau nu n memoria cache a
celorlalte grupuri;
-doi bii -> starea grupului
=> fiecare intrare = 18 bii => memoria total cataloage > 36 MB (aprox. 14%
din 256 MB).
Creterea numrului de procesoare n cadrul unui grup nu afecteaz dimensiunea

memoriei alocate cataloagelor! => amortizarea costului cataloagelor
Sistemul de legturi intergrup : dirijarea wormhole.
Magistralele intergrup sunt fr supraveghere.
O linie de cache :
-UNCACHED (nememorat n cache): unica copie a liniei este n memoria

partajat;
-SHARED (partajat): memoria este actualizat, linia poate s existe n mai multe
cache-uri;
-MODIFIED (modificat): memoria este incorect, doar o singur memorie cache
conine linia.
Scheme neierarhice bazate pe cache-uri
=> informatiile despre copii distribuite printre chiar copiile respective in memoriile
cache,
-fiecare copie indica catre copia urmatoare => lista inlantuita distribuita.
-in nodul home exista un pointer la prima copie a blocului.
Operatie de scriere:
-traficul este proportional cu numarul de noduri care detin copii ale blocului;
-invalidarea se face in paralel.
Exemple: Scalable Coerent Interface (SCI IEEE standard), Sequent NUMA-Q.
Exemplu: lista dublu inlantuita la Scalable Coherent Interface (SCI) IEEE

Standard:
-traficul la scriere: proportional cu numarul de noduri care partajeaza blocul;

-latenta la scriere: de asemenea proportionala cu numarul de noduri care partajeaza
blocul;
-scalarea pentru ambele axe (numar de procesoare si numar de blocuri)
=> overhead acceptabil: necesita un singur pointer pentru un bloc de memorie
cache.
-alte avantaje: standard IEEE, tratare egala a nodurilor;
-dezavantaj: complexitate.
Multiprocesoare NUMA bazate pe microprocesoare AMD Opteron

Microprocesorul AMD Opteron are o arhitectura x86-64 cu suport pentru cod de 32 biti
x86 si pentru software de 64 biti. Core-ul este de tip out-of-order, superscalar cu
memorii cache L1 si L2.
Caracteristici de baza:
-controllerul de memorie DDR integrat;
-conectarea procesorului la alte procesoare prin legaturi HyperTransport.
Arhitectura x86-64:
-arhitectura AMD x86-64 suporta adrese virtuale pe 64 biti si adrese fizice pe
52 biti (Opteron suporta adrese virtuale pe 48 biti si adrese fizice pe 40 biti);
-extinde toate instructiunile logice si aritmetice pe intregi la 64 biti, inclusiv
inmultirea pe 64 biti cu rezultat pe 128 biti;
-dubleaza numarul de registre intregi de scop general (GPR general-purpose
registers) si registre SSE (streaming SIMD extension) de la 8 la 16.
-modelul de programare:
SSE- Streaming SIMD Extensions. Adresarea noilor registre se face cu un prefix de

instructiune REX (register extension).
Structura core-ului
Caracteristici:
-instructiunile x86-64 de lungime variabila sunt convertite in microops de
lungime fixa si trimise la doua planificatoare: unul pentru intregi si celalalt pentru
virgula mobila si multimedia (MMX, SSE, SSE2, 3Dnow! extensie a setului x86 cu
adaugarea de instructiuni SIMD), in plus micro-ops de citire/scriere la unitatea
load/store;
-trei unitati de executie pentru intregi;
-trei unitati de generare de adrese;
-trei unitati de v.m. si multimedia;
-doua unitati load/store;
-memorii cache L1 pentru date si cod fiecare de 64 KB, de tip set-asociativ
dimensiune 2 si blocuri de 64 octeti;
-memorie cache L2 de 1 MB de tip set asociativ dimensiune 16, utilizand un
algoritm LRU de inlocuire a blocurilor si algoritm MOESI (modified, owner, exclusive,
shared, invalid) de coerenta;
Controllerul de memorie de pe cip:

-furnizeaza o interfata cu doua canale de 128 biti pentru memorie DDR 333
MHz compusa din DIMM-uri PC2700;
-rata de varf 5.3 GB/s;
-suporta 8 DIMM-uri de 2 GB => 16 GB;
-initial controllerul a fost integrat in Northbridge:
Multiprocesor cu doua procesoare Athlon.
Multiprocesor cu patru procesoare Intel Xeon.
Integrarea controllerului de memorie in procesorul Opteron:

-reduce semnificativ intarzierile in operatiile cu memoria;
-creste performantele cu 20%-30% fata de Athlon.
Caracteristica de baza: integrarea in Opteron a trei legaturi HyperTransport,

fiecare avand 16 biti si 3.2 GB/s per directie. Pot fi configurate:
-cHT (coherent HyperTransport) pentru conectarea de procesoare;
-HT (noncoherent HyperTransport) pentru conectarea de dispozitive de I/E.
Multiprocesor cu doua/patru procesoare Opteron.
Multiprocesor cu opt procesoare Opteron.
Performantele unui sistem multiprocesor cu procesoare Opteron legate de

accesul la memoria partajata sunt in functie de tipul de acces:
-acces la memoria locala: fiecare procesor acceseaza numai memoria sa locala;
-acces incrucisat (Xfire): fiecare procesor acceseaza memoriile tuturor
procesoarelor.
Performantele sunt prezentate in tabela:

Parametrul
unidoua
procesor proc.
patru
proc.
Numar de DIMM-uri
16
32
Memoria totala (cu DIMM-uri de 2 GB)
16
32
64
Numar de legaturi HyperTransport
Diametru
Rata citire memoria locala (GB/s)
5.3
10.67
15.59
Rata/procesor (GB/s)
5.3
5.3
3.9
Rata citire Xfire (GB/s)
5.3
7.06
11.23
Rata/procesor Xfire (GB/s)
5.3
3.53
2.8
Pentru sisteme cu mai multe procesoare: switchuri externe HyperTransport.

Switchul contine un filtru de supraveghere (gestioneaza starile blocurilor de cache din
sistem) si o memorie cache mare (de tip indepartata pentru procesoarele dintr-un nod quad). Cele patru procesoare dintr-un quad partajeaza doua seturi de memorii cache
indepartate si filtre de supraveghere. Procesoarele se conecteaza la restul sistemului prin
doua switchuri coerente (SW0 si SW1) si sase legaturi HyperTransport.
Filtrele de supraveghere si memoriile cache indepartate reduc traficul intre switchuri si

permit scalare eficienta cu cresterea numarului de procesoare. Quadurile se pot
interconecta prin legaturile HyperTransport pentru obtinerea unor sisteme mari:
PROGRAMAREA MULTIPROCESOARELOR (1)

Excludere mutuala
Primitiva Fetch&Add
Sisteme de operare multiprocesor:

S.O. master-slave: supervizorul este executat ntotdeauna pe acelai procesor.
Dac un procesor slave necesit un serviciu al supervizorului => genereaz o cerere de
servire i ateapt pn ce programul curent de pe procesorul master este ntrerupt, iar
supervizorul este disponibilizat. Caracteristici:
-se simplific problema conflictului de tabel;
-sistemul este inflexibil;
-hardware i software simple;
-cdere catastrofal cnd procesorul master se defecteaz.
S.O. cu supervizor separat pe fiecare procesor: fiecare procesor i execut
propriile servicii. Fiecare procesor (supervizor) dispune de propriul su set de fiiere,
dispozitive de I/E, tabele private.
S.O. cu supervizor mobil: funcia de master se deplaseaz de la un procesor la
altul. Caracteristici:
-conflictele pentru cereri de servicii sunt rezolvate prin prioriti care pot fi
setate static sau dinamic;
-conflicte de acces la tabele.
O cale de a desemna concurena este utilizarea instruciunilor FORK i JOIN:

-FORK genereaz un proces nou :
-FORK A: iniiaz un alt proces la adresa A i continu procesul curent;
-FORK A,J: analog, dar n plus incrementeaz un contor de la adresa J;
-FORK A,J,N: analog cu FORK A, dar n plus seteaz un contor de la adresa J
la valoarea N.
-JOIN ateapt terminarea unui proces creat anterior: JOIN J, decrementeaz contorul
de la adresa J cu 1; dac rezultatul decrementrii este zero, procesul de la adresa J+1
este iniiat, altfel procesorul care execut JOIN este eliberat. Deci, toate procesele
execut n final o instruciune JOIN, exceptnd ultimul proces.
Exemplu: utilizarea acestor instruciuni pentru controlul a trei procese

concurente.
Extensie FORK-JOIN : limbajul structurat pe blocuri, propus de Dijkstra. n

acest caz, fiecare proces dintr-un set de n procese S1, S2, , Sn poate fi executat
concurent utiliznd urmtoarea construcie cu cobegin-coend (parbegin-parend):
begin
S0;
cobegin S1; S2; ; Sn coend;
Sn+1
end
Graf de preceden:
Instruciunile concurente pot fi structurate arbitrar:

begin
S0;
cobegin
S1;
begin S2; cobegin S3; S4; S5 coend S6 end;
S7
coend;
S8
end
Paralelismul n cadrul ciclurilor. Primitivele utilizate pentru implementarea

simpl a instruciunii parfor (parallel for) :
PREP: un contor de ci paralele PPC (Parallel Path Counter) este iniializat cu
1 i se utilizeaz o stiv pentru PPC-uri n cazul buclelor structurate;
AND(L): este bifurcaia cu dou ci, prin care PPCPPC+1, procesul de la
adresa L este iniiat, iar procesul curent este continuat;
ALSO(L): analog cu AND(L), dar fr incrementarea contorului PPC;
JOIN: PPCPPC1, dac PPC = 0, atunci PPC este extras din stiv i
prelucrarea continu cu urmtoarea instruciune, altfel procesorul executnd JOIN este
eliberat;
IDLE: ncheie o cale i elibereaz procesorul care execut instruciunea.
Exemplu: implementarea unei instruciuni parfor, utiliznd aceste primitive

(instruciunea S este executat pentru fiecare valoare a lui i i schema este independent
de numrul de procesoare disponibile n sistem).
parfor i1 until n do
begin
...S...
end
Organigrama implementarii:
Exemplu: nmulirea matrice vector, CA*B, unde A este o matrice n*n, iar
B i C sunt vectori coloan n*1, pentru un n foarte mare. Algoritmul utilizeaz
instruciunea parfor pentru a genera p procese independente (cu p divide pe n, n/p=s).
parfor i 1 until p do
begin
for j (i-1)s+1 until si do
begin
C[j] 0;
for k 1 until n do
C[j] C[j] + A[j,k]*B[k]
end
end
Thread-ul = unitate de baza de utilizare a UCP, avand o stare redusa.
Starea redusa <= gruparea unui numar de thread-uri corelate intre ele in cadrul unui
task, pentru a partaja diferite resurse de calcul (memoria, fisiere, etc.).
Un thread : stiva proprie si stare hardware (registre si indicatori).

Comutarea thread-urilor aceluiasi proces este mai rapida, implicand salvarea starii
hardware si a stivei.
In Windows un proces este o colectie de resurse sistem, ca spatiu de adrese de
memorie, handle-uri de fisiere si dispozitive, atribute de securitate, obiecte de
sincronizare si in plus, cel putin un thread de executie. Fiecare thread dintr-un proces
are resursele sale private: stivele nucleu si utilizator, un set de registre, atribute de
obiecte si un contor de program.
Starile unui thread in Windows:
Crearea thread-urilor
Un proces incepe cu executia unui singur thread, din care se pot crea noi
thread-uri:
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);
unde:
lpThreadAttributes = pointer la o structura care contine un descriptor de
securitate. Daca descriptorul de securitate este NULL, handle-ul thread-ului are toate
privilegiile de acces care i se adreseaza si nu va fi mostenit de nici un subproces.
dwStackSize = dimensiunea stivei in octeti. Daca este NULL atunci are
dimensiunea stivei thread-ului initial al procesului.
lpStartAddress = adresa functiei cu care incepe executia noului thread. Functia
trebuie sa aibe un argument si sa returneze un cod de iesire la terminare.
lpParameter = parametrul furnizat acestei functii. Daca functia necesita mai
multi parametri, acestea se incorporeaza intr-o singura structura de date si se furnizeaza
un pointer la aceasta structura.
dwCreationFlags = specifica daca thread-ul trebuie sa inceapa executia
imediat sau nu. Daca acest parametru este 0 atunci se incepe imediat executia threadului; daca are valoarea CREATE_SUSPEND, thread-ul este creat, imediat suspendat si
nu se executa decat la apelul functiei ResumeThread cu handle-ul sau ca parametru.
lpThreadId = furnizeaza identificatorul thread-ului la crearea sa. Programatorul
creaza o locatie DWORD si furnizeaza un pointer la aceasta locatie.
ID-ul thread-ului curent :

DWORD GetCurrentThreadId(void);
Functia CreateThread => handle valid la crearea cu succes a unui nou thread sau 0 la
insucces. In caz de esec: apel GetLastError => codul de eroare. Exemplu:
HANDLE hThread1, hRedPen;
DWORD ThreadID1, ErrorCode;
void ThreadProc (HANDLE hDrawPen);
hThread1 = CreateThread (
NULL,
//fara atribute de securitate
0,
//dimensiune stiva implicita
(LPTHREAD_START_ROUTINE)ThreadProc,
//start thread
hRedPen,
//argument pentru noul thread
(LPDWORD)&ThreadID1
//ID-ul thread-ului
);
if (hThread1==0) {
ErrorCode = GetLastError();
//handle eroare
}
Se poate crea un nou thread care sa se execute in spatiul de adrese al altui

proces :
HANDLE CreateRemoteThread(
HANDLE hProcess,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);
unde hProcess = handle-ul procesului in care este lansat noul thread.

Functia => handle-ul noului thread in caz de succes, sau NULL pentru insucces
(necesar ca handle-ul procesului sa detina privilegiul de acces
PROCESS_CREATE_THREAD si sa cunoasca adresa functiei de start).
Noul thread : acces la toate resursele procesului => pentru scrierea depanatoarelor si a
analizoarelor.
Terminarea thread-urilor
Un thread isi incheie executia proprie:
void ExitThread(
DWORD dwExitCode
);
Executia unui thread se poate incheia de alte thread-uri:

BOOL TerminateThread(
HANDLE hThread,
DWORD dwExitCode
);
Incheierea tuturor thread-urilor dintr-un proces -> prin terminarea procesului:

void ExitProcess(
UINT uExitCode
);
BOOL TerminateProcess(
HANDLE hProcess,
UINT uExitCode
);
Executia unui thread se poate suspenda / relua:

DWORD SuspendThread(
HANDLE hThread
);
DWORD ResumeThread(
HANDLE hThread
);
=> valoarea precedenta a contorului de suspendari in caz de succes, sau valoarea 1 la

insucces. Astfel:
-un thread in executie: contor=0;
-apel SuspendThread: contor++ (thread-ul este suspendat);
-la fiecare apel ulterior SuspendThread: contor++ pana la o valoare maxima
MAXIMUM_SUSPEND_COUNT;
-fiecare apel ResumeThread: contor--;
-daca contor == 0 atunci thread-ul poate intra in executie.
Exemplu: procesele P1 si P2 acceseaza o variabila partajata reprezentand un

cont bancar pentru actualizari ale sumei de bani:
Excludere mutuala
Accesul la o variabila partajata pentru actualizare ~ sectiune critica (o secventa de
instructiuni care este executata complet numai de un singur proces, inainte ca un alt
proces sa acceseze acea sectiune critica).
O problem important: dou sau mai multe procese concurente partajeaz date care
sunt modificabile => segmente de program -> seciuni critice.
Supoziii privind seciunile critice:
Excludere mutual: cel mult un singur proces se poate afla ntr-o seciune
critic la un moment dat.
Terminare: seciunea critic este executat ntr-un timp finit.
Planificare echilibrat: un proces ateptnd intrarea n seciunea critic o va
face ntr-un timp finit.
Accesul mutual exclusiv la un set de variabile partajate se poate realiza prin diferite
construcii, printre care: MUTEXBEGIN i MUTEXEND.
Notaia pentru a declara un set de variabile ca fiind partajate de un tip T:
var v : shared T;
O seciune critic controlat de variabila partajat v :
csect v do S;
asociaz o instruciune S cu o variabil partajat v => S trebuie s aib acces exclusiv la
v.
Seciunile critice care se refer la variabile diferite se pot executa n paralel:

var v : shared V;
var w : shared W;
cobegin
csect v do P;
csect w do Q
coend
Seciunile critice pot fi structurate pe mai multe niveluri:
csect v do
begin
........
csect w do S;
........
end
Pericolul blocrii: unul sau mai multe procese ateapt pentru evenimente care nu se
produc niciodat. Exemplu: dou procese concurente P1 i P2 intr concomitent n
seciuni critice exterioare controlate de variabilele v i w:
cobegin
P1:
csect v do csect w do S1;
P2:
csect w do csect v do S2
coend
Accesul unui singur proces la o sectiune critica, in timp ce toate celelalte

procese nu pot intra in sectiunea respectiva -> mecanismul de excludere mutuala.
Etape:
Solutii pentru implementarea excluderii mutuale:

-de nivel scazut (prin hardware): instructiuni de invalidare / validare a
intreruperilor (DI / EI), instructiuni de tip TestAndSet, etc;
-de nivel ridicat (mecanisme / obiecte de sincronizare): mutex, semafoare,

bariere, monitoare, etc.

Invalidarea / validarea intreruperilor -> solutie specifica sistemelor
uniprocesor.
di
:invalidarea intreruperilor
sectiune critica
ei
;validarea intreruperilor
=> Solutie pesimista, ineficienta (poate bloca procese care nu au legatura cu

sectiunea critica). Mecanismul periculos in programele utilizator insuficient testate!
di
halt
:invalidarea intreruperilor
;oprire procesor si blocare sistem
Solutia: functii sistem care utilizeaza di / ei apelate de programele utilizator.

Dezavantaj: overhead la comutarea intre modul de executie utilizator si sistem.
Evenimente
Cnd un proces ateapt pentru un eveniment execuia urmtoarelor sale operaii se
amn pn cand un alt proces semnaleaz producerea evenimentului.
Exemplu: doua procese ciclice (operaiile concurente wait i signal acceseaz aceeai
variabil partajat e de tip eveniment):
var e : shared event;
cobegin
cycle sender
begin
. . . signal(e) ; . . .
end;
cycle receiver
begin
. . . wait(e) ; . . .
end
coend
O implementare a accesului mutual exclusiv la o sectiune critica: operaiile LOCK i

UNLOCK (se presupune v=0/1 dac accesul este deschis/nchis la seciunea critic).
Un proces testeaz valoarea variabilei v i dac gsete starea deschis, atunci modific
starea la nchis, ntr-o singur operaie indivizibil!
Accesul la seciunea critic se exprim prin secvena:
LOCK(v)
execut seciunea critic
UNLOCK(v)
Operaia LOCK :
var x: shared integer;
LOCK(x):
begin
var y: integer;
y x;
while y=1 do y x; //ateapt pn deschis//
x 1 //ocup//
end
Implementarea operaiei UNLOCK este urmtoarea:
UNLOCK(x): x 0;
Mecanismul LOCK nesatisfctor: dou sau mai multe procese pot gsi x=0 i
intra simultan n seciunea critic, nainte de a face x1.
Solutia: instruciuni speciale! Exemplu: TEST_AND_SET(x), care testeaz i seteaz o
variabil partajat ntr-un singur ciclu de memorie de tipul read-modify-write:

TEST_AND_SET(x):
begin
var y: integer;
y x;
if y=0 then x 1; //indivizibil//
end
Operaia LOCK poate fi rescris astfel:
LOCK(x):
begin
var y: integer;
repeat { y TEST_AND_SET( x)} until y=0
end
Dezavantaj al operatiei LOCK cu TAS: pierderea de timp pentru procesele care

intr n seciunile critice (procesul care execut LOCK blocat pn la permisiunea de
intrare n seciunea critic).
LOCK i UNLOCK nu n modul utilizator! => cerere de supervizor la intrarea ntr-o
seciune critic => degradare a performanelor sistemului.
TAS i n modul utilizator => cnd un proces n bucla de ateptare din TAS => crete
foarte mult rata cererilor de memorie. Soluia: ntrzierea cererilor la memorie cu T:
LOCK(x):
begin
var y: integer;
y TEST_AND_SET( x);
while y 0 do
begin
PAUSE(T);
y TEST_AND_SET( x)
end
end
Instruciune de forare a excluderii mutuale pentru accesul la o variabil

partajat n locaia de memorie m_addr: CAS (comapare and swap), cu doi operanzi
suplimentari r_old i r_new (care sunt registre ale procesorului).
Definiia instruciunii CAS r_old, r_new, m_addr :
var m_addr: shared address;
var r_old, r_new: register;
var z: CASflag;
CAS: if r_old = m_addr then
m_addr r_new; z 1
else
r_old m_addr; z 0
Indicatorul z este setat dac comparaia furnizeaz egalitate. Execuia
instruciunii CAS (de fapt a instruciunii if) este indivizibil.
Exemplu: utilizarea instruciunii CAS ntr-o coad simplu nlnuit partajat,

accesat curent de dou procese P1 i P2. Operaii:
ENQUEUE(X): adaug nodul X n coada listei specificat de pointerul TAIL;
DEQUEUE(X): ntoarce un pointer ctre capul ters al listei (HEAD).
Variabilele HEAD i TAIL sunt variabile partajate.
Presupunnd coada nevid, pentru un sistem secvenial monoprocesor:
procedure ENQUEUE(X);
var P: pointer; //P este local fiecrui apel al procedurii//
begin
LINK(X) ; //termin legtura ultimului nod//
P TAIL;
TAIL X;
LINK(P) X //ataeaz noul nod la coad//
end
Utilizarea procedurii ntr-un sistem paralel n care dou procese concurente P1

i P2 ncearc adugarea cte unui nod n coad : P1 ncepe execuia procedurii pentru
ataarea nodului X i dup ce a executat PTAIL, se genereaz o ntrerupere, cnd P2
execut procedura i ataeaz nodul Y. n continuare, se reia execuia procedurii de
ctre P1, care ataeaz nodul X, iar nodul Y rmne detaat!
=> utilizarea instruciunii CAS pentru a actualiza P s indice ultimul nod ataat
(CAS asigur c starea logic a programului ntrerupt, variabila P, este meninut la
reluarea programului, altfel P este setat la valoarea cea mai recent a lui TAIL:
procedure ENQUEUE(X);
var P: pointer; //P este local fiecrui apel al procedurii//
begin
LINK(X) ; //termin legtura ultimului nod//
P TAIL;
repeat CAS P, X, TAIL until TAIL = X;
LINK(P) X //ataeaz noul nod la coad//
end
Primitiva Fetch&Add
Primitiv care permite o anumit form de concuren a accesului la o locaie
de memorie: fetch-and-add, F&A(X,e), unde X este o variabil partajat ntreag, iar e
este o expresie ntreag. Primitiva ntoarce vechea valoare a lui X (Y) i nlocuiete
coninutul locaiei de memorie prin suma Y+x, ntr-o singur operaie indivizibil!
Mai multe operaii iniiate simultan de diferite procesoare => efectul final este acelai
indiferent de ordine, dar valorile intermediare ale lui X specific poziia n cadrul
ordinii.
Exemplu: dou procese P1 i P2, care execut fiecare:
P1:
P2:
S1 F&A(X,e1);
S2 F&A(X,e2);
=> S1 i S2 vor conine valorile Y i Y+e1 sau Y+e2 i Y

=> X = Y+e1+e2.
F&A implementat n comutatorul procesor-memorie.
Se presupune c exist dou cereri simultane, P1 avnd prioritate mai mare dect P2.
PROGRAMAREA MULTIPROCESOARELOR (2)

SEMAFOARE
SINCRONIZAREA THREAD-URILOR IN WINDOWS
DETECTAREA PARALELISMULUI IN PROGRAME
SEMAFOARE
Primitivele P i V (Dijkstra): operaii indivizibile care opereaz pe o variabil
semafor (indic numrul de procese care ncearc s intre n seciunea critic).
var s: semaphore;
P(s):
MUTEXBEGIN(s)
s s-1;
if s < 0 then
begin
Blocheaz procesul executnd P(s) i-l introduce
ntr-o coad FIFO asociat semaforului s;
Reia procesul gata de prioritatea cea mai mare
end
MUTEXEND;
V(s):
MUTEXBEGIN(s)
s s+1;
if s 0 then
begin
Dac exist un proces inactiv asociat cu semaforul s, atunci
activeaz procesul blocat cu prioritatea cea mai mare
asociat cu s i-l introduce ntr-o list de procese gata
end
MUTEXEND
Semaforul s iniializat la valoarea 1 (numrul de procese concurente care se pot afla

simultan n seciunea critic).
Dac s = 0 / 1 => semafor binar (un singur proces la un moment dat este n seciunea
critic). Dac s = o valoare numeric ntreag => semafor numrtor.
Utilizare comun : procese concurente schimba date n timpul execuiei.
Exemplu: procese productor i consumator - comunic printr-un tampon finit

de dimensiune n numit BUFFER, de tip coad circular cu locaiile 0, 1, ,n-1.
-pointeri c i p (indicatori de cap al cozii (head) i coad a cozii (tail));
-consumatorul consum mesaje din capul listei, actualiznd c i prelund
mesajul (c indic locaie vid nainte de fiecare consum);
-productorul depune mesaje n coad, actualiznd pointerul p nainte de

operaia de adugare;
-iniial p=c=0 (tampon vid);
-empty i full => starea tamponului (tampon vid, respectiv tampon plin) => de
fapt, empty indic productorului numrul de locaii disponibile, full indic
consumatorului numrul de locaii de consumat;
-productorul i consumatorul se suspend dac empty=0, respectiv full=0.
shared record
begin
var p, c: integer;
var empty, full: semaphor;
var BUFFER[0:n-1]: message
end;
initial empty = n; full = 0; p = 0; c = 0;
cobegin
Producer:
begin
var m: message;
cycle
begin
produce un mesaj m;
P(empty);
p (p+1) mod n;
BUFFER[p] m;
V(full)
end
end;
Consumer:
coend
begin
var m: message;
cycle
begin
P(full);
c (c+1) mod n;
m BUFFER[c];
V(empty);
consum mesajul m
end
end
Operaiile P i V extinse => primitivele extinse PE i VE (Agerwala),

indivizibile, opereaz fiecare pe un set de semafoare iniializate la valori pozitive.
PE(s1, s2,, sn, sn+1#,, sn+m#);
MUTEXBEGIN
if (for all i, 1 i n, si>0) and (for all j, 1 j m, sn+j# = 0) then
for all i, 1 i n, si si-1
else
Procesul este blocat i depus ntr-un set de cozi
asociate cu setul de semafoare s1, s2,, sn
MUTEXEND
VE(s1, s2,, sn);
MUTEXBEGIN
for all i, 1 i n, si sI+1;
Activeaz procesul cu prioritatea cea mai mare asociat
cu setul de semafoare s1, s2,, sn
MUTEXEND
Exemplu: n procese de prioriti egale i m resurse la care procesele fac acces

exclusiv. Dac dou procese utilizeaz seturi disjuncte de resurse, acestea se pot executa
n paralel:
var r1, r2,, rm: semaphore;

initial r1 = r2 = = rm = 1;
Proces i: begin
PE(ra, rb,, rx);
utilizeaz resursele a, b, , x;
VE(ra, rb,, rx)
end
Observatii:
-semaforul ri asociat cu resursa i;
-dac primitiva PE s-a ncheiat cu succes de ctre un proces => resursele a, b,
, x sunt disponibile (alocate procesului).
Exemplu: trei procese X, Y i Z care intr n concuren pentru trei

echipamente (cititor R, imprimant P i un disc D). Fiecare proces cere simultan dou
resurse (X cere R i P, Y cere R i D, iar Z cere P i D).
var rR, rP, rD: semaphore;

initial rR = rP = rD = 1;
cobegin
Proces X: begin PE(rR, rP); utilizeaz R i P; VE(rR, rP) end;
Proces Y: begin PE(rR, rD); utilizeaz R i D; VE(rR, rD) end;
Proces Z: begin PE(rP, rD); utilizeaz P i D; VE(rP, rD) end
coend
Exemplu: n procese paralele de prioriti diferite i o resurs. Procesul Pi are

prioritate mai mare dect Pi+1. Procesele cer acces la o resurs i sunt alocate la resurs
ntr-o manier mutual exclusiv, bazat pe prioriti. O cerere nu este onorat pn ce
toate cererile de prioritate mai mare nu au fost rezolvate.
var s1, s2, , sn, R: semaphore;
initial s1 = s2 = = sn = 0;
initial R = 1;
cobegin
Proces i: begin
VE(si); //cererea procesului i//
PE(R, s1#, s2#, , si-1#); //verific dac resursa este disponibil
si dac exist cereri nesatisfcute ale unor procese
de prioritate mai mare//
PE(si); //dac nu, aloc resursa la procesul i i retrage cererea//
Utilizeaz resursa;
VE(R) //elibereaz resursa//
end
coend
Exemplu: sistem biprocesor, pe care ruleaz un proces supervizor i unul

utilizator. Dac cele dou procese intr n competiie simultan pentru o anumit resurs,
procesul supervizor are prioritate mai mare:
var s, u, R: semaphore;
initial s = u = 0;
initial R = 1;
cobegin
Supervisor: begin
VE(s);
PE(R);
PE(s);
Utilizeaz resursa;
VE(R)
end
User:
begin
VE(u);
PE(R, s#);
PE(u);
Utilizeaz resursa;
VE(R)
end
coend
SEMAFOARE IN WINDOWS
Crearea unui semafor :
HANDLE CreateSemaphore(
LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
LONG lInitialCount,
LONG lMaximumCount,
LPCTSTR lpName
);
unde:
lpSemaphoreAttributes = pointer specificand un descriptor de securitate a
semaforului. Daca este NULL, atunci semaforul nu va avea descriptor de securitate.
lInitialCount = valoarea initiala a contorului asociat semaforului. Se poate
initializa cu 0 pentru a impiedica preluarea acestuia de vreun thread in timpul
initializarii programului.
lMaximumCount = este numarul maxim de thread-uri concurente care pot
prelua semaforul fara sa fie blocate.
lpName = numele semaforului.
Apel wait pentru un semafor => decrementeaza contorul cu 1. Cand contorul

== 0, urmatoarele apeluri wait sunt blocate pana ce un thread elibereaza detinerea
semaforului.
Functii de asteptare: WaitForSingleObject si WaitForMultipleObjects.
Starile unui obiect de sincronizare Windows : signaled (disponibil) si notsignaled (detinut).
DWORD WaitForSingleObject(
HANDLE hHandle,
DWORD dwMilliseconds
);
unde:
hHandle = handle-ul obiectului de sincronizare pentru care se asteapta;
dwMilliseconds = timeout, care poate fi 0, INFINITE (-1) sau o valoare
pozitiva, in milisecunde. Daca obiectul este signaled, functia intoarce 0 (succes), iar
daca este not-signaled functia se blocheaza pana ce obiectul devine disponibil sau
expira timpul de timeout. In cazul expirarii timpului de timeout functia intoarce starea
WAIT_TIMEOUT. Daca intoarce WAIT_ABANDONED inseamna ca un thread s-a
terminat fara se aelibereze obiectul de sincronizare. Daca intoarce valoarea 1, se
apeleaza functia GetLastError.
DWORD WaitForMultipleObjects(
DWORD nCount,
const HANDLE* lpHandles,
BOOL bWaitAll,
DWORD dwMilliseconds
);
unde:
nCount = numarul de obiecte din tablou pentru care se asteapta;
lpHandles = pointer la un tablou de handle-uri de obiecte pentru care se
asteapta;
bWaitAll daca are valoarea TRUE asteapta ca toate obiectele sa fie in starea
signaled, iar daca are valoarea FALSE functia revine daca oricare obiect ajunge in
starea signaled. Pentru un apel wait-any functia intoarce indexul obiectului in starea
signaled, o valoare intre 0 si nCount 1.
dwMilliseconds = durata timeout in ms.
Cand un thread termina sectiunea critica va apela functia ReleaseSemaphore,

incrementand contorul si permitand unui alt thread sa castige semaforul:
BOOL ReleaseSemaphore(
HANDLE hSemaphore,
LONG lReleaseCount,
LPLONG lpPreviousCount
);
unde:
hSemaphore = handle-ul semaforului care se elibereaza;
lReleaseCount = increment la valoarea curenta a contorului asociat
semaforului;
lpPreviousCount = optional, pointer la o variabila care primeste ultima valoare
a semaforului.
Exemplu: utilizarea unui semafor.

HANDLE hSema;
hSema=CreateSemaphore(NULL,0,3,NULL); //fara nume
if (hSema==NULL) {
..... //eroare de handle
}
..... //alte initializari in program
ReleaseSemaphore(hSema,3,NULL); //max. 3 thread-uri pot detine semaforul
......
//acces la semafor
Status=WaitForSingleObject(hSema,INFINITE);
if (Status==-1) {
}
//succes wait, contorul semaforului decrementat cu 1
//acces la resursele partajate
.....
//eliberare semafor
ReleaseSemaphore(hSema,1,NULL); //incrementare contor cu 1
.....
Mutex
Mutex (mutual exclusion): asigura dreptul exclusiv de utilizare a unei
resurse. Operatii cu mutex:
-acces (obtinere) la mutex (lock).
-daca mutex liber -> se ocupa mutex si se intoarce imediat controlul la
procesul apelant, intr-o operatie atomica;
-daca mutex ocupat -> procesul apelant trebuie sa astepte eliberarea acestuia.
Protocolul de asteptare : sleep-wait sau busy wait/sleep-wait.
-eliberare mutex (unlock sau release) cand procesul a terminat accesul la
resursa partajata.
Crearea unui obiect mutex:

HANDLE CreateMutex(
LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner,
LPCTSTR lpName
);
unde:
lpMutexAttributes = pointer la o structura de atribute de securitate. Daca

NULL mutex este creat fara un atribut de securitate.
bInitialOwner = detinere initiala. Daca TRUE, creatorul mutex-ului va prelua
imediat detinerea acestuia, altfel mutex este disponibil pentru primul apelant de functie
wait asupra mutex-ului.
lpName = sir de caractere cu numele mutex, pentru a putea fi accesat si de alte
procese. Daca NULL, atunci mutex este fara nume.
Preluarea mutex: una din cele doua functii wait. Dupa preluarea mutex, threadul executa codul din regiunea protejata de mutex. Pentru eliberarea mutex:
BOOL ReleaseMutex(
HANDLE hMutex
);
Exemplu: utilizare mutex.
HANDLE hMutex;
char * szMutexName=mutex1;
hMutex=CreateMutex(NULL,FALSE,szMutexName):
if (hMutex==NULL) {
}
.....
if (WaitForSingleObject(hMutex,INFINITE)!=0) {
else { //incepe sectiunea critica
.....
ReleaseMutex(hMutex); //sfarsit sectiune critica, elibereaza
mutex
}
Alte obiecte de sincronizare in Windows

Sectiune critica: la un moment dat un singur thread poate prelua obiectul
sectiune critica. La o incercare de preluare => succes sau thread-ul este blocat pana ce
obiectul de sincronizare este disponibil (fara timeout).
Operatiile de initializare, preluare, eliberare si distrugere a unui obiect sectiune
critica :
void InitializeCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
);
void EnterCriticalSection(
);
void LeaveCriticalSection(
);
void DeleteCriticalSection(
);
Eveniment = un mecanism de sincronizare intre procese sau thread-uri

concurente => se anunta aparitia unui anumit eveniment (indeplinirea unei anumite
conditii).
Crearea unui obiect eveniment:
HANDLE CreateEvent(
LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL bManualReset,
BOOL bInitialState,
LPCTSTR lpName
);
unde:
lpEventAttributes = pointer specificand atributul de securitate, indicand daca
procesele create ulterior vor mosteni handle-ul.
bManualReset = indica tipul obiectului care va fi creat. Daca TRUE, atunci
obiectul este cu resetare manuala (se apeleaza explicit SetEvent pentru a-l trece in starea
signaled si ResetEvent pentru a-l trece in starea not-signaled. Daca FALSE, atunci
obiectul este cu resetare automata: apelul SetEvent il trece in stare signaled, lasand un
thread in asteptare sa ruleze, apoi reseteaza automat obiectul in starea not-signaled.
bInitialState = reprezinta starea initiala signaled sau not-signaled.
LpName= numele evenimentului.
Functiile pentru setarea si resetarea unui eveniment:

BOOL SetEvent(
HANDLE hEvent
);
BOOL ResetEvent(
HANDLE hEvent
);
BOOL PulseEvent(
HANDLE hEvent
);
PulseEvent in mod automat seteaza apoi reseteaza starea obiectului eveniment.
DETECTAREA PARALELISMULUI IN PROGRAME

Reprezentarea ierarhic a unui program organizat secvenial:
Considernd T1, T2, T3 instruciuni ale unui program secvenial, dac execuia lui T3
este independent de ordinea de execuie a instruciunilor T1 i T2, atunci exist
paralelism ntre T1 i T2.
Pentru ca procese organizate secvenial s poat fi executate n paralel este

necesar s satisfac condiiile lui Bernstein (dou seturi de variabile pentru fiecare
proces Ti):
1) setul de citire Ii, reprezentat de toate locaiile de memorie din care Ti
execut citire ca prim operaie ce implic aceste locaii;
2) setul de scriere Oi, reprezentat de toate locaiile n care Ti execut scrieri.
Condiiile sub care dou procese secveniale T1 i T2 pot fi executate ca dou procese
independente i concurente :
1) Locaiile din I1 nu trebuie modificate de operaii de scriere din O2:
I1 O2 =
2) Prin simetrie:
I2 O1 =
n plus, la nceperea execuiei lui T3, independent de modul de execuie (paralel sau
secvenial) al proceselor T1 i T2, I3 trebuie s fie independent de operaiile de
memorare din T1 i T2:
(O1 O2 ) I3 =
Exemplu: se consider trei instruciuni pentru evaluarea a trei expresii

matriciale, unde A, B, C, D, X, Y, Z sunt matrici n*n:
T1:
T2:
T3:
X(A+B)*(AB)
Y ( C D ) * ( C + D )-1
ZX+Y
Se pot determina urmtoarele seturi: I1=A,B, I2=C,D, O1=X, O2=Y.

Deoarece I1 O2 = , I2 O1 = , O1 O2 = => procesele T1 i T2 se pot
executa n paralel. Procesul T3 nu se poate executa n paralel cu procesele T1 i T2,
deoarece I3 O2 , i I3 O2 . Programul concurent pentru execuia
proceselor T1, T2 i T3 este prezentat n continuare:
begin
cobegin
X ( A + B ) * ( A B );
Y ( C D ) * ( C + D )-1
coend;
ZX+Y
end
Proiectarea programelor de aplicaii -> tehnic de baz: descompunerea algoritmilor

pentru execuie paralel. Etape:
1) Partiionarea - mprirea algoritmului n proceduri, module i procese.
2) Asignarea - alocarea acestor uniti de calcul la procesoarele sistemului pe
care se ruleaz algoritmul respectiv.
Exemplu: algoritmul de calcul al histogramei unei imagini, scris pentru un

uniprocesor, care va fi descompus i restructurat pentru un sistem multiprocesor.
Fiecare pixel este un ntreg n intervalul [0,b-1], cu 2b256 (valoare tipic pentru b
este reprezentarea pe opt bii, deci b=256). Algoritmul utilizeaz un tablou histog[0:b1] pentru contorizarea nivelelor de gri din imagine, acestea avnd valorile 0, 1, , b-1.
Imaginea este reprezentat prin tabloul bidimensional pixel[0:m-1;0:n-1], avnd m
rnduri i n coloane de pixeli.
var pixel[0:m-1;0:n-1]: pixel;

var histog[0:b-1]: integer;
initial histog[0:b-1]=0; //iniializare contoare//
for i0 until m-1 do
for j0 until n-1 do
histog[pixel[i,j]] histog[pixel[i,j]]+1
end
end
Complexitatea de timp: O(mn).

Programul restructurat - mprind imaginea iniial n p segmente egale i disjuncte,
fiecare cu m/p=s rnduri de pixeli (p divide pe m).
=> p procese concurente, fiecare calculnd histograma unui segment distinct al
imaginii. Procesele partajeaz vectorul histog[0:b-1].
var histog[0:b-1]: integer shared; //declararea variabilelor partajate//

initial histog[0:b-1]=0; //iniializare contoare//
parfor i1 until p do
begin
var pixel[(i-1) s:s i-1;0:n-1]: pixel;
for k(i-1) s until s i-1 do
for j0 until n-1 do
csect histog[pixel[k,j]] do
histog[pixel[k,j]] histog[pixel[k,j]]+1
end
end
end
O cretere de performan: fiecare proces dispune de setul su de b contoare

pentru a genera histograma local a segmentului propriu din imagine.
var histog[0:b-1]: integer; initial histog[0:b-1]=0;
var lhistog[1:p;0:b-1]: integer; //numrtoare locale//
initial lhistog[1:p;0:b-1]=0; //iniializare contoare locale//
parfor i1 until p do
begin
var pixel[(i-1) s:s i-1;0:n-1]: pixel;
var lhistog[i,0:b-1]: integer;
for k(i-1) s until s i-1 do
for j0 until n-1 do
lhistog[i,pixel[k,j]] lhistog[i,pixel[k,j]]+1
end
end
end
for j0 until b-1 do
for i1 until p do
histog[j] histog[j]+lhistog[i,j]
end
end
OpenMP
OpenMP : API (Application Program Interface) utilizat pentru a controla
explicit paralelismul cu memorie partajata si fire multiple de executie.
Componente:
-directive compilator;
-functii runtime de biblioteca;
-variabile de mediu.
OpenMP este disponibil pentru C/C++ si Fortran. Exista implementari pe o multitudine
de platforme, inclusiv Unix si Windows.
Model de programare
OpenMP: memorie partajata si fire multiple de executie.

-> model de programare explicit (nu automat) => programatorul are un control
deplin asupra paralelismului.
-> modelul fork-join de executie paralela:
Program OpenMP incepe cu un proces singular (thread master) -> secvential ->
constructie de regiune paralela (FORK) -> mai multe thread-uri in paralel -> JOIN ->
thread-ul master, etc.
Numarul de thread-uri : se poate modifica dinamic.
Structura unui program OpenMP :
#include <omp.h>
void main ( )
{
int var1, var2, var3;
..... cod secvential .....
//incepe sectiunea paralela => FORK
#pragma omp parallel private (var1, var2) shared (var3)
{
..... sectiune paralela executata de toate thread-urile .....
//toate thread-urile => JOIN => thread master
}
..... reia cod secvential .....
}
Formatul unei directive
#pragma omp nume_directiva [clauza, clauza, ...] newline
unde clauzele pot fi plasate in orice ordine si se pot chiar repeta. Liniile directive lungi
se pot continua pe randul urmator cu \.
Directiva pentru regiune paralela
Regiunea paralela = bloc de cod care se va executa de mai multe thread-uri.

(constructia paralela OpenMP fundamentala !)
La o directiva parallel un thread creaza un set de thread-uri si devine masterul setului

(cu numarul de thread 0 in cadrul setului).
Numarul de thread-uri : omp_set_num_threads() sau cu variabila de mediu
OMP_NUM_THREADS.
Clauza if evalueaza expresia scalara: daca expresia 0 (adevarat) se creaza setul de

thread-uri, iar daca expresia = 0 (fals) regiunea este executata numai de thread-ul
master.
La sfarsitul sectiunii paralele numai thread-ul master isi continua executia.
Exemplu: toate thread-urile executa codul corespunzator sectiunii paralele.
Directiva pentru partajarea lucrului
Aceasta directiva imparte regiunea de cod intre thread-urile membre, fara insa
sa lanseze noi thread-uri.
Constructiile de partajare a lucrului sunt:
-for;
-sections;
-single.
O constructie de partajare a lucrului trebuie inclusa dinamic intr-o regiune paralela
pentru a fi executata in paralel.
Directiva for
Partajeaza iteratiile unei bucle for intre thread-urile setului (reprezinta un tip de
paralelism de date):
Forma generala a directivei for este:
Clauza schedule, in functie de tip, descrie cum se impart iteratiile buclei for intre
thread-urile din set:
-static: iteratiile se impart in sectiuni de dimensiune chunk si asignate static
thread-urilor (daca nu se specifica chunk, iteratiile se impart in mod egal).
-dynamic: iteratiile se impart in sectiuni de dimensiune chunk si se asigneaza
dinamic thread-urilor. Cand un thread termina bucata sa, acesta este asignat dinamic la
o alta bucata din totalul de iteratii (valoarea implicita chunk=1).
-guided: dimensiunea bucatii este redusa exponential cu fiecare bucata
repartizata din totalul iteratiilor. Dimensiunea bucatii reprezinta numarul minim de
iteratii de repartizat de fiecare data (implicit chunk=1).
-runtime: decizia de repartizare este amanata pana in timpul executiei, fiind
determinata de variabila de mediu OMP_SCHEDULE (nu se specifica dimensiune
chunk).
Clauza ordered trebuie sa fie prezenta cand sunt incluse in directiva for si
directive ordered.
Clauza nowait indica faptul ca thread-ul nu se sincronizeaza la sfarsitul buclei
paralele.
Exemplu: program pentru adunarea a doi vectori.
Directiva sections
Imparte lucrul in sectiuni discrete separate, fiecare sectiune fiind executata de
un thread, pentru implementarea unui paralelism functional.
Forma generala a directivei sections este:
Fiecare sectiune section se executa o singura data de catre un singur thread, sectiuni
diferite vor fi executate de thread-uri diferite. Exista bariera implicita la sfarsit, numai
daca nu se utilizeaza nowait.
Exemplu: adunarea a doi vectori, primele n/2 iteratii fiind distribuite primului
thread, iar restul la un al doilea thread.
Directiva single
Aceasta directiva serializeaza o sectiune de cod. Codul este executat de un

singur thread. Forma generala:
Directiva parallel for

Se pot combina directivele de sectiune paralela si de partajare a lucrului cu
ajutorul directivei parallel for, prin care se specifica o regiune paralela care contine o
singura directiva for. Forma generala:
Exemplu: iteratiile sunt repartizate in blocuri de dimensiuni egale la toate

thread-urile din set.
Directiva parallel sections

Aceasta directiva specifica o regiune paralela continand o singura directiva
sections. Forma generala este:
Directive de sincronizare
Directiva master
Specifica o regiune care este executata numai de thread-ul master, toate

celelalte thread-uri ale setului o neglijeaza. Forma generala a directivei este:
Directiva critical
Specifica o regiune de cod care trebuie executata numai de un singur thread la
un moment dat.
Exemplu: mai multe thread-uri incrementeaza o locatie x, reprezentand o

sectiune critica.
Directiva barrier
Sincronizeaza toate thread-urile din set. Forma generala:
#pragma omp barrier newline
Aceasta directiva trebuie sa fie intalnita de catre toate thread-urile din set, sau
de niciunul. Un thread care atinge bariera va astepta pana ce toate celelalte thread-uri
ating bariera, dupa care se continua executia paralela. Exemplu:
(obligatoriu aceasta directiva trebuie sa fie continuta intr-un bloc structurat).
Directiva atomic
Indica actualizarea atomica (operatie indivizibila) a unei locatii de memorie,

furnizand astfel o mini sectiune critica. Forma generala:
Se aplica numai instructiunii imediat urmatoare, de forma:

x binop = expr
x++
++x
x---x
Alte directive
Directiva flush: specifica un punct de sincronizare in care se furnizeaza o

imagine consistenta a memoriei (toate variabilele vizibile thread-urilor se inscriu in
memorie in acest punct).
Directiva ordered: specifica faptul ca iteratiile buclei incluse in aceasta
directiva vor fi executate in aceeasi ordine ca la executia pe un uniprocesor.
Directiva threadprivate: face ca variabilele globale sa fie locale persistente
unui thread in cadrul executiei regiunilor paralele multiple.
Clauze
Clauza private declara variabilele din lista ca fiind private fiecarui thread:
private (lista)
Clauza shared declara variabilele din lista ca fiind partajate intre toate threadurile:
shared (lista)
Clauza default permite utilizatorului sa specifice domeniul implicit al
variabilelor din extinderea lexicala a unei regiuni paralele:
default (shared | none)
Clauza firstprivate combina clauza private cu initializarea automata a

variabilelor din lista:
firstprivate (lista)
Se initializeaza cu valorile obiectelor de origine inainte de intrarea in constructia
paralela.
Clauza lastprivate combina private cu o copie dupa ultima iteratie sau sectiune
a obiectului variabila de origine:
lastprivate (lista)
Clauza copyin asigneaza aceeasi valoare variabilelor threadprivate pentru toate

thread-urile setului:
copyin (lista)
Sursa este setul de variabile ale thread-ului master.
Clauza reduction executa o reducere asupra variabilelor din lista:
reduction (operator : lista)
Exemplu: produs scalar

a doi vectori.
Functii
OpenMP defineste un API pentru apeluri de functii din biblioteca, care executa
o varietate de operatii:
-functii legate de numarul de thread-uri;
-functii de zavorare (semafoare);
-functii de stabilire a mediului de executie.
Variabila de zavorare trebuie sa fie de tipul omp_lock_t sau omp_nest_lock_t, depinzand
de functia utilizata.
void omp_set_num_threads(int num_threads)

seteaza numarul de thread-uri care se vor utiliza in urmatoarea regiune paralela. In
modul dinamic activat specifica numarul maxim de thread-uri, iar in modul dinamic
dezactivat specifica numarul exact de thread-uri.
int omp_get_num_threads(void)
returneaza numarul de thread-uri din set in regiunea paralela.
int omp_get_max_threads(void)
returneaza valoarea maxima care poate fi furnizata de un apel al functiei
omp_get_num_threads.
int omp_get_thread_num(void)
returneaza identificatorul de thread in cadrul setului, fiind o valoare cuprinsa intre 0 si
omp_get_num_threads 1. Masterul primeste identificatorul 0.
int omp_get_num_procs(void)
returneaza numarul de procesoare disponibile programului.
int omp_in_parallel(void)
returneaza un intreg 0 (adevarat) daca sectiunea de cod care se executa este paralela,
respectiv un intreg = 0 (fals) daca sectiunea nu este paralela.
Aplicatie: calcularea valorii aproximative a numarului .

1) Solutia secventiala.
2) Solutia cu thread-uri Win32.

Caracteristici:
-gestiunea thread-urilor si interactiunea intre thread-uri sunt explicite;
-programatorul are control complet asupra thread-urilor.
=> se dubleaza dimensiunea codului.
3a) Solutia OpenMP - regiune paralela. Program SPMD: toate threa-urile

executa acelasi cod, dar utilizand ID-ul thread-ului se poate specifica o executie
selectiva.
3b) Solutia OpenMP constructie de partajare a lucrului.
3c) Solutia OpenMP clauza Private si o sectiune critica.
3d) Solutia OpenMP parallel for cu o reducere.
=> OpenMP adauga un numar mic de linii de cod la solutia secventiala (2-4
linii)!
Intel Cilk Plus

Cilk a fost creat la mijlocul anilor 1990 la M.I.T., evoluand astazi la Intel Cilk
Plus pe platforme Windows si Linux, iar in curand si Mac OS X.
-solutie simpla si puternica pentru specificarea paralelismului in C si C++;
-compilatorul permite cuvinte cheie simple prin care un program serial este
transformat in program paralel.
Cilk a fost lansat initial cu numai doua cuvinte cheie: Cilk_spawn si
Cilk_sync, prin care o functie poate rula in background (thread separat) si apoi toate
functiile asteapta o operatie de sincronizare.
Au fost adaugate la Intel Cilk Plus trei lucruri:
-Cilk_for: executia in paralel a iteratiilor unui ciclu for;
-hyper-objects: desfacerea unei variabile partajate in copii private permitand
paralelismul si specificarea de operatii de reducere;
-specificarea de operatii paralele de date explicit prin notatii noi de tablouri, ca
de exemplu:
for (i=0; i<10000; i++) {
a[i] = b[i] + c[i];
}
se scrie:
a[:] = b[:] + c[:];
Dezvoltarea de aplicatii paralele pentru procesoarele multicore

utilizate in servere, PC-uri, laptop-uri, dispozitive mobile se poate realiza si
dupa un nou model de programare Intel Parallel Building Blocks (Intel PBB),
constand din trei componente:
-Intel Cilk Plus, extensie a limbajului C++, imlementata in Intel
C++ Compiler;
-Intel Threading Building Blocks (Intel TBB) furnizand primitive
pentru taskuri low-level si algoritmi paraleli high-level, fiind implementat ca
biblioteca de sabloane independenta de compilator;
-Intel Array Buiding Blocks (Intel ArBB): biblioteca C++ furnizand
o solutie de programare paralela pentru vectori, care elibereaza dezvoltatorii
de aplicatii dependente de mecanisme particulare de paralelism low-level sau
de arhitecturi hardware (momentan disponibil ca test beta).
Sumar Intel PBB:
Intel Cilk Plus furnizeaza doua constructii pentru paralelism la nivel de taskuri:
-doua cuvinte cheie: _Cilk_spawn si _Cilk_sync;
-_Cilk_for.
Comparatie intre implementarea algoritmului recursiv Fibonacci in cod serial C:

int fib (int n)
{
if (n <= 2)
return n;
else {
int x,y;
x = fib(n-1);
y = fib(n-2);
return x+y;
}
}
si in cod utilizand Cilk Plus:

int fib (int n)
{
if (n <= 2)
return n;
else {
int x,y;
x = _Cilk_spawn fib(n-1);
y = fib(n-2);
_Cilk_sync;
return x+y;
}
}
Codul secvential nu este modificat, sunt inserate doar cuvintele cheie Cilk.
Cuvantul cheie _Cilk_spwan
Indica faptul ca functia spawned (spawned function, numita si functia

parinte) poate fi executata concurent. Functia generata se numeste functie fiu.
Valorile argumentelor functiei sunt evaluate de parinte inainte de generarea
fiului si executie concurenta.
_Cilk_spawn nu forteaza executie paralela, dar furnizeaza o oportunitate de
executie paralela. Worker-ul a carui executie a ajuns la _Cilk_spawn va continua
prelucrarea uneia din cele doua ramuri identificata de cuvantul cheie, in timp ce ramura
ramasa este plasata intr-o coada pentru executie ulterioara. Ramura ramasa poate sa fie
preluata de un alt worker executat pe un alt core.
Nota importanta. Cuvintele cheie _Cilk_spawn si _Cilk_sync pot fi evitate in
cazul compilatoarelor care nu suporta Intel Cilk Plus, pastrand portabilitatea codului
sursa:
#define _Cilk_spawn
#define _Cilk_sync
Cuvantul cheie _Cilk_sync
Cuvantul cheie _Cilk_sync inseamna ca parintele trebuie sa astepte

pana cand toate taskurile fiu intorc controlul catre parinte.
In exemplul Fibonacci cuvantul cheie este necesar pentru a asigura
ca valorile variabilelor x si y sunt actualizate de executia asincrona a fib(n-1)
si fib(n-2) inainte de utilizare.
In plus fata de cuvantul cheie explicit exista un _Cilk_sync implicit la
sfarsitul fiecarei functii spawned, inserat de compilator. Efectul: functia
spawned se executa cat timp toti fiii generati sunt in executie.
Cuvantul cheie _Cilk_for

Permite paralelizarea buclelor for. _Cilk_for indica compilatorului ca nu
exista ordonare a iteratiilor buclei, iar compilatorul aranjeaza loturi de iteratii pentru
executie paralela. Se considera instructiunea:
_Cilk_for (int i = 0; i < N; ++i) {
body;
}
La utilizarea acestui cuvant cheie compilatorul impune cateva restrictii asupra
for:
-variabila index (i in exemplu) aparand in toate cele trei expresii ale buclei este
initializata in prima expresie;
-este comparata cu o valoarea care nu se modifica in bucla;
-este incrementata cu o valoare care nu se schimba in bucla;
-nu se poate modifica in interiorul buclei.
=>inainte de executie se cunoaste exact numarul de repetari.
Workerul care ajunge la _Cilk_for:

-calculeaza numarul de iteratii;
-pune jumatatea superioara in coada de lucru pentru evaluarea ulterioara;
-preia jumatatea inferioara, continuand operatia divide-and-conquer pana cand se
obtine un numar de iteratii suficient de mic (se determina euristic, la executie);
-executa iteratiile secvential;
-dupa terminare, preia din coada urmatoarea transa de lucru;
-daca un alt worker are o coada de lucru vida, poate prelua o transa de lucru din coada
core-ului care a creat lista de lucru (workerul initial).
Notatia tablourilor
1) Intel Cilk Plus furnizeaza o noua sintaxa permitand operatii simple pe

tablouri. Instructiunea:
a[:] = b[:] + c[:];
indica compilatorului faptul ca elementele tablourilor b si c trebuie adunate si ca nu
exista ordonare intre operatiile de adunare => se genereaza cod vectorial in loc de cod
scalar.
2) Se defineste un operator de sectiune de tablou cu sintaxa:
array_base[start:length:stride]
unde:
array_base este o expresie tablou permisa in C/C++, incluzand tablouri si
pointeri;
start este primul element de tablou caruia i se aplica sectiunea;
length furnizeaza numarul de elemente de tablou;
stride este un increment intre elemente, optional, valoarea implicita 1.
Se poate aplica si tablourilor multidimensionale, de exemplu:
a[0:5][3][0:8:2]
3) Sunt furnizate cateva functii intrinseci pentru operatii comune,

ca de exemplu adunarea componentelor unui tablou. Astfel, un produs
scalar se poate exprima:
x = __sec_reduce_add(a[:] * b[:]);
4) O alta solutie este adaugarea la o bucla a directivei:

#pragma simd
prin care se specifica ca desi sintaxa este scalara, compilatorul genereaza
cod vectorial, fara sa fie necsar sa verifice echivalenta codurilor scalar si
vectorial.
5) Se poate scrie o functie scalara C/C++ si declara ca functie de baza

(elemental function), in intentia de a o desface in mai multe elemente de tablou fara
specificarea unei anumite ordini a operatiilor. Exemplu: adunare de tablouri:
__declspec(vector)
float v_add(float x1, float x2)
{
return x1+x2;
}
apel:
for (int j = 0; j < N; ++j) {
res[j] = v_add(a[j],b[j]);
}
Utilizarea _declspec(vector) indica comilatorului ca functia v_add se va utiliza

ca functie de baza. Intel C++ Compiler va genera doua versiuni de cod: cod
standard si cod vectorial, care primeste ca argumente doi vectori pentru x1 si
x2, executand operatiile cu registrele vectoriale hardware. La un apel scalar se
va executa codul scalar.
La apel intr-un context paralel de date (ca in exemplul de mai sus)
compilatorul apeleaza versiunea vectoriala. Daca targetul este un CPU
suportand registru vectorial XMM, de exemplu cu extensia set instructiuni
SSE2, compilatorul determina ca patru valori consecutive ale tablourilor de
intrare se pot incarca intr-un registru. Compilatorul genereaza o versiune a
functiei care opereaza pe patru elemente de tablou consecutive, iar functia va fi
apelata de N/4 ori => crestera performantelor.
Daca la apel se inlocuieste for cu _Cilk_for, nu numai ca se apeleaza
versiunea vectoriala a functiei, dar se va facilita executia iterativa a buclei pe
core-uri multiple.
Descrierea structurii unui program Cilk prin DAG

Descrierea structurii unui program Cilk se poate face printr-un graf cu
noduri (knots) si fire (strands), referit ca graf aciclic directat (DAG
Directed Acyclic Graph).
Firul este o sectiune seriala a programului (secventa de instructiuni
fara nicio structura de control paralela). Astfel un program serial poate fi
descris prin mai multe fire secventiale, oricat de scurte, chiar si o singura
instructiune. Fire secventiale succesive se pot combina pentru a forma un
singur fir (chiar intregul program secvential).
Nodul este un punct unde se intalnesc trei sau mai multe fire. Cilk are
doua tipuri de noduri: noduri spawn si noduri sync.
Exemplu: patru fire (1, 2, 3, 4), un nod spawn (A) si un nod sync (B).
Numai firele 2 si 3 se pot executa in paralel. Programul Cilk corespunzator:

.....
executa_operatia_1();
_Cilk_spawn functia_3();
_Cilk_sync;
....
Un nod spawn are exact un fir de intrare si doua fire de iesire. Un nod sync are doua sau
mai multe fire de intrare si un fir de iesire.
Exemplu:
Firele 2 si 3 se pot executa in paralel, iar firele 3, 4 si 5 se pot executa de asemenea in

paralel.
Obs. DAG nu depinde de numarul de procesoare ale sistemului pe care se
executa!
Analiza performantelor si scalabiltate.

Se considera graful structurii paralele a unui program Cilk:
(Tema. Sa se scrie un program Cilk corespunzand acestui graf.)
Se eticheteaza firele prin timpul in ms necesar executie fiecarui fir:
Se defineste ca volum de lucru (work) timpul total necesar executiei

intregului program, ca suma a tuturor timpilor. In acest exemplu, pentru cele 25 de fire
volumul de lucru este 181 ms (timpul necesar pe un uniprocesor).
Un alt concept este durata (span), numita si lungimea caii critice, ca fiind
calea cea mai costisitoare de la inceputul programului pana la sfarsit. Pentru exemplul
considerat, durata este 68 ms (reprezinta timpul de executie al programului in conditii
ideale, fara overhead de planificare, numar infinit de procesoare).
Notatii:
T(P) timpul de executie pe un sistem cu P procesoare;

T(1) este volumul de lucru;
T() este durata.
Se poate stabili legea volumului de lucru: T(P) T(1)/P.
Similar, pentru P procesoare timpul de executie nu poate fi mai mic decat timpul pe un
sistem cu numar infinit de procesoare => legea volumului de lucru: T(P) T().
Se defineste factorul de accelerare pe un sistem cu P procesoare:
T(1) / T(P)
Accelerarea maxima se obtine pe un sistem cu numar infinit de procesoare,
astfel se defineste paralelismul:
T(1) / T().
MULTICALCULATOARE
(1/2)
ORGANIZARE GENERAL
TRANSFERUL DE MESAJE LA MULTICALCULATOARE
ARHITECTURI DE ROUTERE
PROIECTAREA UNUI ROUTER PENTRU TOPOLOGIE 2D
ORGANIZARE GENERAL
Multicalculatoarele = sisteme MIMD (Multiple Instruction Multiple Data)
comunicaia - transfer de mesaje.
=> rezolv limitri ale multiprocesoarelor:
-scalabilitate redus: multiprocesoare numr redus de procesoare: 64 de
procesoare la ENTERPRISE 10000, 256 de procesoare la NUMA-Q =>
multicalculatoare numr mare de procesoare : 2048 de procesoare la Cray T3E, sau
9152 de procesoare la Intel/Sandia Option Red;
-concuren crescut la memoria partajat => multicalculatoarele dispun de
module de memorie proprii fiecrui procesor, comunicatie prin send i receive.
Structura general a unui multicalculator.
dou mari categorii de multicalculatoare:

-MPP (Massively Parallel Processors) procesoare masiv paralele;
-COW (Cluster Of Workstations) clustere de staii de lucru.
Structura de baza a unui nod:
unde:
-router: implementeaza protocolul de comunicatie de nivel scazut, continand
switch-uri, buffere si o unitate de rutare si arbitrare;
-canale externe: interconecteaza routerele si defineste topologia retelei de
interconectare;
-canale interne: conecteaza routerul la nodul de prelucrare local si
implementeaza interfata HW fizica dintre ele.
Arhitectura de principiu a unui router cu un canal de intrare si un canal de

iesire (conectare la nod):
unde
-LC (link controller): controlor de legatura;
-unitatea de rutare si arbitrare: implementeaza algoritmul de rutare si
protocolul de control al fluxului de pachete, rezolvand conflictele intre cereri simultane
pentru aceeasi legatura de iesire (algoritmi de tip round-robin, prioritati fixe sau
primul sosit primul servit).
TRANSFERUL DE MESAJE LA
MULTICALCULATOARE
Formatul mesajelor
Scheme de rutare a mesajelor
Analiza latentei
Canale virtuale. Blocare.
Rezolvarea coliziunii pachetelor
Algoritmi de rutare
Operatiile send si receive
Protocoale pentru transfer de mesaje
Soluii de interpretare a informaiilor din tranzacia prin reea
Formatul mesajelor
Mesajul = unitatea logica de comunicare intre noduri - numar arbitrar de
pachete de lungime fixa (=> lungime variabila).
Pachetul = unitatea de baza continand adresa de destinatie (pentru rutare) si un

numar de secventa (pentru reasamblarea mesajului). Un pachet este impartit intr-un
numar de flituri (flits flow control digits) de lungime fixa reprezentand:
-informatii de rutare (R) specificand destinatia;
-numar de secventa (S);
-date (D).
La randul sau un flit poate fi divizat in phit-uri, un astfel de phit fiind cea mai mica
unitate fizica de informatie la nivelul fizic care este transferata de-a lungul unei legaturi
fizice intr-un ciclu.
Pentru transferul datelor se pot utiliza diferite protocoale:

1) Protocol asincron (cu patru faze solutie clasica):
Routerul R1 activeaza semnalul RQ indicand plasarea datelor pe liniile Data (un phit).
Routerul R2 raspunde cu ACK la preluarea datelor, care in continuare produce
dezactivarea RQ, iar apoi dezactivarea ACK (reprezinta un ciclu elementar pentru
transferul unui phit). In continuare se poate initia un nou transfer.
2) Protocol sincron:
Controlul fluxului de date pe canalul fizic poate fi si sincron. Se transmite un
semnal de ceas, ambele fronturi ale ceasului valideaza datele. Exemple: Intel iPSC/2 si
iPSC/860.
In plus, se poate utiliza un semnal de acknowledge pentru a indica disponibilitatea

bufferelor.
Scheme de rutare a mesajelor

Modelul temporal general pentru o comunicatie fara conflicte intre doua
noduri la distanta:
unde:
-ts timpul de lansare (startup) componenta comuna tuturor tehnicilor de
comunicatie (sec);
-tm intarzierea prin canal, intre doua routere adiacente (sec/flit);
-tr timpul de decizie a routerului (sec);
-tw intarziere de comutare a routerului dupa luarea deciziei de rutare (sec/phit).
Se noteaza:
-w latimea canalului: numarul de biti ai canalului fizic
care pot fi transmisi simultan intre doua routere adiacente
(dimensiunea unui phit);
- rata canalului: rata de varf a canalului in biti/sec care
se pot transfera pe fiecare fir intr-un canal fizic;
-B largimea de banda a canalului: B= in phits/sec, sau
se mai poate defini B=w in biti/sec;
-M dimensiunea unui pachet (in flits);

-d lungimea caii de rutare (numar de canale).
Comutarea de circuite (circuit switching). Comunicatia intre sursa si

destinatie are doua faze: faza de stabilire a circuitelor si faza de transmisie a mesajului.
-se injecteaza o sonda de rutare: rezerva calea de la sursa la destinatie,
continand adresa de destinatie si informatii de control, avand dimensiunea de p phits;
-sonda inainteaza catre destinatie prin routerele intermediare, rezervand calea
(a);
-calea este setata cand sonda a ajuns la destinatie;
-in acest moment se transmite inapoi un flit de achitare acknowledge (b);
-la receptia achitarii sursa trimite intregul mesaj la viteza maxima a caii, care
formeaza un circuit hardware rezervat intregul timp cat dureaza transmisia mesajului
(c);
-circuitul este eliberat de catre nodul destinatie sau de ultimii biti din mesaj.
Intarzierea (mesaj de lungime M transmis la distanta d):

tCS = d (tr + (p + 1)(tw + tm)) + M tm
unde
d (tr + p(tw + tm)) este timpul pentru sonda sa ajunga la destinatie;
d (tw + tm) este timpul pentru intoarcerea achitarii;
M tm este timpul de transmisie a mesajului.
=> circuitul opereaza ca un singur fir de la sursa la destinatie.

Avantaj: mesaje lungi si rare.
Dezavantaj: mesaje scurte si dese.
Exemplu: hipercub binar JPL Mark III, cu 2048 noduri in configuratie maxima,
structura sondei de rutare:
Biti 0 si 16 definesc tehnica de comutatie utilizata, bitii 1-11 adresa de destinatie si 11

campuri (maxim 2048 noduri) de patru biti fiecare CHN pentru a specifica pentru
fiecare nod canalul de iesire (11 canale). Calea este calculata la nodul sursa.
Rutarea memoreaza si inainteaza (store-and-forward) are ca unitate de baza

pachetul. Fiecare nod utilizeaza un buffer de pachet. Pachetul este transmis de la un nod
sursa la un nod destinatie printr-o secventa de noduri intermediare.
Aceasta tehnica se mai numeste si comutare de pachete:

-mesajul impartit in pachete de lungime fixa (fiecare pachet constand din flituri
incepand cu flitul header);
-fiecare nod are buffere de intrare si de iesire pentru un intreg pachet;
-fiecare pachet este rutat individual de la sursa la detinatie;
-un pas: copierea intregului pachet dintr-un buffer de iesire in bufferul de
intrare urmator;
-deciziile de rutare sunt luate de fiecare router intermediar numai dupa ce
intregul pachet a fost complet memorat in bufferul de intrare.
Intarzierea (pachet de lungime M trasmis pe distanta d):
tSF = d (tr + (tw + tm) M)

la fiecare pas:
-se iau deciziile de rutare tr ;
-pachetul este transferat la routerul urmator (tw + tm) M ;
-> se repeta de d ori.
Avantaj: mesaje scurte si dese (o transmisie ocupa cel mult un canal din
intreaga cale, dar bufferarea intregului pachet creste costul si scade viteza.
Dezavantaj: intarzierea in comunicatie este proportionala cu produsul M d,
=> se utilizeaza rutarea de cale minima si retele de diametru mic.
Exemplu: header de pachet utilizat in JPL Hyperswitch.
Bitii 12-15 si bit 0 indica tehnica de comutatie utilizata (aici, algoritm de rutare de cale
fixa), biti 1-11 identifica adresa destinatie , iar campul LEN specifica lungimea
pachetului in unitati de 192 octeti (implementarea curenta limiteaza la 384 octeti). In
cazul unei rutari adaptive, pachetele pot ajunge la destinatie intr-o alta ordine, iar in
acest caz headerul trebuie sa contina informatii de secventiere pentru reconstruirea
mesajului la destinatie.
Rutarea cu fortare virtuala (virtual cut-through) -> cea mai sofisticata si

scumpa tehnica de rutare:
-mesajele impartite in pachete iar fiecare router are un buffer pentru
memorarea unui intreg pachet;
-in loc sa se astepte ca intregul pachet sa fie bufferat, flitul header care intra in
router este fortat in routerul urmator imediat ce s-a luat decizia de rutare si canalul de
iesire este liber (b);
-fiecare flit urmator este bufferat cand ajunge in router, dar imediat este fortat
catre routerul urmator daca canalul de iesire este liber (c);
-in cazul in care headerul nu poate inainta el asteapta in routerul curent si toate
fliturile urmatoare sunt receptionate, posibil astfel sa elibereze canalele ocupate pana
atunci (d);
-daca nu exista conflict de resurse pe ruta, pachetul este efectiv transmis in
banda de asamblare prin routere succesive (e).
Intarzierea (pachet de lungime M transmis pe distanta d ):

tVCT = d (tr +tw + tm) + max(tw , tm ) M
Presupunere: nu exista penalizare de timp pentru acest mecanism de rutare. Headerul
ajuns la destinatie => ciclul benzii de asamblare pentru flituri este maximul dintre
timpul de comutare si intarzierea intre routere (s-a presupus ca exista buffer de intrare si
buffer de iesire).
Numai flitul header contine informatii de rutare => fiecare flit urmator este
simplu inaintat dupa canalul de iesire ca predecesorul sau => nu se poate efectua
transmisia intretesuta sau multiplexata a unor pachete diferite peste un acelasi canal
fizic.
Rutarea gaura de vierme (wormhole) divizeaza pachetele in flituri mai mici.

Se utilizeaza buffere de flituri in routere hardware atasate nodurilor.
-nu se pot intretese sau multiplexa transmisii de pachete diferite, fara un suport
arhitectural aditional;
-daca headerul nu poate inainta (din cauza ocuparii canalelor de iesire) =>
intregul lant de flituri este blocat, ocupand bufferele de flit din routerele de pe cale,
blocand astfel alte posibile comunicatii.
Latenta (in lipsa conflictelor de comunicatie):

tWH = d (tr +tw + tm) + max(tw , tm ) M
(aceeasi ca in rutarea cu fortare virtuala)

-permite utilizarea de routere simple, rapide si ieftine (cea mai utilizata in masinile
comerciale).
-uneori routerele utilizeaza numai buffere de intrare.
-dezavanaj: blocarea resurselor in cazul stoparii lantului de flituri.
In cazul considerarii timpului de lansare (startup) ts >> tm si tm tw tr. Se pot utiliza
si unele formule simplificate:
tSF = ts + d M tm
tCS = tVCT = tWH == ts + d td + M tm
unde td = tr + tw. Deoarece d td << M tm (dimensiune mare a mesajului, cateva sute de
flituri), in situatiile fara conflict de comunicatie in cadrul tehnicilor VCT, CS si WH nu
conteaza lungimea drumului, iar SF este senzitiva fata de distanta.
Varianta simpla de analiza a latentei:

Se noteaza:
-L: lungimea pachetului (biti);
-B: largimea de banda a canalului (biti / secunda);
-d: distanta de la nodul sursa la nodul destinatie (numar de canale traversate);
-F: lungimea unui flit (biti).
Latenta de comunicatie pentru mecanismul store-and-forward:
TSF
( d 1)
B
iar pentru wormhole:
TWH
L
F
d
B
B
TSF ~ d, iar TWH = L / B pentru L >> F (distanta d avand un efect neglijabil).

Mecanismul store-and-forward este adesea controlat software, iar wormhole
complet hardware.
Diagramele de timp pentru cele doua mecanisme:
Canale virtuale. Blocare.

Exemplu: patru canale virtuale care partajeaza un singur canal fizic.
Situatia de blocare de tip buffer (buffer deadlock) intr-o retea store-andforward apare din cauza unei asteptari circulare:
Situatia de blocare de tip canal (channel deadlock) intr-o retea mesh cu

rutare wormhole, cand patru mesaje sunt simultan transmise, patru flituri de la cele
patru mesaje ocupa canalele simultan.
Asteptarile circulare - graf dependenta de canal (nodurile = canale, arcele =

relatiile de dependenta intre acestea).
=> Situatia de blocare se poate evita prin adaugarea a doua canale virtuale v3 si v4.
Rezolvarea coliziunii pachetelor

Pentru transferul unui flit intre doua noduri adiacente sunt necesare:
-buffer sursa continand flitul;
-canal de comunicatie;
-buffer de receptie.
Problema coliziunii pachetelor are urmatoarele solutii de baza:
1) bufferare in rutarea cu fortare virtuala:
2) blocare in rutarea wormhole pura:
3) descarcare si retransmisie: pachetul 2 este abandonat si retransmis ulterior

(exemplu: in reteaua BBN Buterfly).
4) deturnare: pachetul 2 este deturnat pe un alt canal => poate sa duca la o

risipa de resurse (pachetul necesita mai multe canale pentru a ajunge la destinatie
(exemplu Connection Machine, Delcor HEP).
Algoritmi de rutare
Tipuri de comunicatie
In retelele de multicalculatoare exista doua mari categorii de comunicatie:
a) comunicatie unu-la-unu (unicast) se transmit mesaje punct-la punct;
surse pachete
destinatii pachete
cai de rutare
Tipuri:
-comunicatie de pereche singulara (izolata): nu exista probleme de deadlock,
congestie, etc. Se pot utiliza algoritmi de calea cea mai scurta;
-mai multe comunicatii unu-la-unu simultan: mai multe perechi de noduri
schimba informatie simultan;
-permutare: fiecare nod este sursa pentru un mesaj si destinatie pentru alt
mesaj in acelasi timp (impune o permutare intre noduri).
b) comunicatii colective:
-comunicatia unu-la-mai multi sau difuziunea (aceeasi informatie one to
many multicast, iar daca informatia trimisa la noduri difera scatter);
-comunicatia unu-la-toti (broadcast);
-comunicatia mai-multi-la-unul (gather);
-comunicatia mai multi la mai multi (many-to-many conference, many-tomany broadcast, scatter-gather).
Exista si unele operatii speciale :
-compactarea datelor sau impachetarea;
-RAW (random-access write) emuland scrierea concurenta CW de la
modelul teoretic PRAM pentru p procesoare;
-RAR (random-access read) emuland citirea concurenta CR de la modelul
PRAM pentru p procesoare.
Solutii de rutare:
Rutarea distribuita: functia de rutare calculata in routere sau noduri pe masura
ce pachetele se deplaseaza prin retea.
-header-ul contine numai adresa de destinatie utilizata de router pentru
selectarea canalelor de iesire;
-utilizata in topologii regulate si simetrice (toate routerele utilizeaza acelasi
algoritm de rutare).
Rutarea dupa sursa: nodurile sursa predetermina complet caile de rutare

inainte de plasarea pachetelor in retea (sistemele IBM SP-2).
Rutarea hibrida (multifaza): nodul sursa precalculeaza adresele numai pentru
cateva noduri intermediare, iar caile precise dintre ele sunt determinate intr-o maniera
distribuita de catre routere (nCUBE-2).
Rutarea centralizata: functia de rutare determinata de un controlor centralizat
(tipic sistemele SIMD).
Implementarea algoritmilor de rutare: viteza => implementare hardware (mai

ales pentru rutarea distribuita). Abordari:
-masina cu stari finite;
-tabela de translatare : nodurile si/sau routerele sursa pastreaza niste tabele de
rutare. Pentru N noduri in retea => tabela necesita O(N) intrari.
Tabelele de rutare nod sursa: specificarea completa pentru intreaga cale.
Rutarea distribuita: tabelele specifica canalul (canalele) de iesire corespunzand fiecarei
destinatii.
Tabelele de rutare:
-statice;
-dinamice (exemplu: reteaua Myrinet permite recalcularea automata a tabelelor
de rutare de fiecare data cand se modifica reteaua de interconectare, de exemplu prin
stergerea unui nod).
Rutarea pachetelor se poate face pe baza unor algoritmi:

-algoritmi de rutare deterministi: calea de comunicatie este complet
determinata dupa adresele sursei si destinatiei (inca din start), independent de conditiile
retelei. Algoritm de rutare determinist genereaza intotdeauna aceeasi cale intre o sursa si
o destinatie (eventual calea cea mai scurta).
-algoritmi de rutare fara memorare (oblivious), in raport de starea traficului
din retea: este considerata numai adresa de destinatie, la fel ca la rutarea determinista.
Orice rutare determinista este fara memorare, dar nu orice rutare fara memorare este
determinista. De exemplu pot exista mai multe cai de lungime minima intre sursa si
destinatie, iar algoritmul de rutare selecteaza o cale fie aleator fie ciclic. Algoritmii fara
memorare nedeterministi pot distribui uniform traficul in situatiile in care solutiile
adaptive sunt prea scumpe.
-algoritmi de rutare adaptivi: utilizeaza informatii despre traficul in retea si /

sau stari ale canalelor. Calea depinde de conditiile retelei, fiind posibile cai alternative.
Rutarea adaptiva poate fi descompusa in doua functii distincte:
-functia de rutare: furnizeaza un set de canale posibile de iesire;
-functia de selectie a iesirii: selecteaza unul din canalele libere de
iesire pe baza informatiilor locale de stare.
Din p.d.v. al minimalitatii cailor de rutare:

-algoritmi greedy (sau minimali, directi, calea-cea-mai-scurta): fiecare decizie
de rutare aduce pachetul mai aproape de destinatie. De obicei algoritmii deterministi si
algoritmii fara memorare sunt de tip greedy.
-algoritmi nongreedy (sau neminimali, indirecti, misrouting): pot furniza
canale care sa indeparteze pachetul de destinatie. Aici se incadreaza exclusiv algoritmii
adaptivi. In loc sa se astepte in caz de blocare, pachetul este intors in ideea plasarii intro regiune libera, cand poate fi reluat un algoritm greedy. Consuma resurse aditionale.
Rutare pe o retea liniara

Rutare liniara de pachete (pe o linie sau coloana):
Rutare pe retele mesh

Scheme de indexare a procesoarelor in retelele mesh :
1) Sortare pe randuri in ordine crescatoare (row-major)
2) Sortare pe randuri tip sarpe (snakelike row major)
3) Sortare amestecata pe randuri (shuffled row-major)
4) Sortare de proximitate (proximity order).
Solutii de comunicatie intre procesoare in retelele mesh: utilizarea unor registre

virtuale locale.
Algoritm shearsort pentru sortare intr-un mesh cu r randuri.
pentru i=1,log2r executa

sorteaza randurile in ordine tip sarpe
sorteaza coloanele sus-jos
daca (ordonare tip sarpe) atunci
sorteaza randurile in ordine tip sarpe

altfel
sorteaza pe randuri crescator
Timpul necesar pentru executia algoritmului:
Tshearsort
p
p
log 2 r
r
r
r
unde r este numarul de randuri, p este numarul total de noduri din retea (reteaua
poate sa fie si dreptunghiulara), iar pentru o retea mesh de dimensiune
p p
timpul necesar este:
Tshearsort
p log 2 p 1
Exemplu.
Rutarea pe baza tabelei de translatare cu intervale. O tabela simpla de

translatare pentru o retea cu N noduri are dimensiunea O(N).
Dimensiunea tabelei se poate micsora in cazul rutarii cu intervale (o singura
intrare in tabela per canal de iesire: fiecare intrare in tabela contine un interval de adrese
de destinatie, specificat prin doua margini)
Exemplu: tabelele de rutare pentru cateva noduri (1,5,9) intr-o retea mesh:
Rutare XY intr-o retea mesh 2D (o cale dupa dimensiunea X

fiind preferata in raport cu o cale dupa dimensiunea Y), algoritm
determinist bazat pe conceptul de ordonare dupa dimensiune.
Ruta de la o sursa s = (x1, y1) la o destinatie d = (x2, y2) este

data de parcurgerea de-a lungul axei x pana cand se ajunge la coloana
y2, apoi parcurgerea de-a lungul axei y pana se ajunge la nodul
destinatie.
Algoritm: Rutare XY pentru mesh 2-D

Inputs: Coordonatele nodului curent (Xcurrent, Ycurrent)
si nodului destinatie (Xdest, Ydest)
Output: iesirea selectata Channel
Procedure:
Xoffset := Xdest Xcurrent;
Yoffset :=Ydest Ycurrent;
if Xoffset < 0 then
Channel := X;
endif
if Xoffset > 0 then
Channel := X+;
endif
if Xoffset = 0 and Yoffset < 0 then
Channel := Y;
endif
if Xoffset = 0 and Yoffset > 0 then
Channel := Y+;
endif
if Xoffset = 0 and Yoffset = 0 then
Channel := Internal;
endif
Apar situatii de aglomerare (suprasolicitare) a conexiunilor (bufferelor din

anumite noduri).
=> Rezolvare: algoritm de rutare adaptiv => descongestionarea traficului.
Rutare E-cub intr-un hipercub.

-n-cub cu N = 2n noduri;
-fiecare nod fiind codificat binar:
b = bn-1 bn-2 ... b1 b0
-s = sn-1 sn-2 ... s1 s0 -> d = dn-1 dn-2 ... d1 d0

-n dimensiuni sunt notate i = 0, 1, 2, ... , n-1 (i -> bitul i din adresa de nod);
-v nodul curent de pe ruta.
r s d
// calculeaza vectorul de directie
vs
pentru i = 0, n-1 executa
daca ri = 1 atunci
vv
2i
//altfel v ramane neschimbat
Exemplu: rutare E-cub intr-un hipercub 4D.

Se considera n = 4, s = 0110, d = 1101.
r = r3r2r1r0 = s
initial v = s = 0110
d = 0110 1101 = 1011
i = 0 => r0 = 1 => v = v 20 = 0110 0001 = 0111

i = 1 => r1 = 1 => v = v 21 = 0111 0010 = 0101
i = 2 => r2 = 0 => v = v = 0101
i = 3 => r3 = 1 => v = v 23 = 0101 1000 = 1101
Algoritmi de rutare multicast si broadcast
Parametrii de eficienta:
-traficul de canal (la un moment dat sau pe un interval de timp) = numarul de
canale utilizate pentru transferul mesajului implicat;
-latenta de comunicatie = timpul cel mai lung de livrare a unui pachet.
=> pentru trafic minim nu se obtine latenta minima si invers!
Exemplu: multicast pe un sistem retea mesh 3x4: s -> di, i = 1,2,...,5.

Solutii:
a) implementare cu cinci comunicatii unu-la-unu:
=> trafic = 13, latenta (distanta) = 4.
b) multicast cu replicarea pachetului in fiecare nod intermediar (copii multiple ale

pachetului => scaderea semnificativa a traficului).
=> solutie specifica mecanismului store and forward => trafic = 7, latenta =4.
c) multicast pentru mecanism wormhole.
=> trafic = 6, latenta = 5.
Exemplu: broadcast unu-la-toate utilizand un arbore cu 4 niveluri => latenta minima si

trafic minim.
Exemplu: broadcast pe un n-cub utilizand un arbore de acoperire (spanning

tree) pentru a atinge toate nodurile cu o latenta maxima n. Aplicatie pentru n = 4 si
nodul sursa = 0000.
Algoritmul:
Pas 1) de la nivelul 0 se obtin n fii (4 fii) prin inversarea cate unui bit (fiu 0 bit 0,
fiu bit 1, ...).
Pas 2) Fiecare fiu k are k succesori, obtinuti prin inversarea cate unui bit 0, 1,..., k1. Astfel:
fiu 0 => 0 succesori;
fiu 1 => 1 succesor, inversarea bit 0 => fiu 0;
fiu 2 => 2 succesori, inversarea bit 0 => fiu 0;
inversarea bit 1 => fiu 1;
.......
.....................
pana cand pe ultimul nivel un singur nod nu are niciun succesor.
Algoritmi de rutare partial adaptivi

Reprezinta un compromis intre algoritmii de rutare deterministi si algoritmii
adaptivi, ca flexibilitate si cost.
Rutare plan adaptiva ("planar-adaptive routing")
Propusa de Chien si Kim. Permite adaptabilitate in numai doua dimensiuni la

un moment dat, astfel pachetul este rutat adaptiv intr-o succesiune de planuri 2D.
In cazul unei rutari complet adaptive pachetul este rutat intr-un subcub mdimensional definit de nodurile curent (marcat cu gri) si destinatie(marcat cu negru).
Rutarea plan adaptiva restrictioneaza pachetul sa fie rutat in planul A0, apoi in A1, etc
(exemple pentru 3D si 4D).
Un plan Ai este format din doua dimensiuni di si di+1, in total (n-1) planuri. Planurile Ai
si Ai+1 partajeaza dimensiunea di+1. Reguli:
-daca in timpul rutarii in planul Ai offsetul din dimensiunea di se reduce la 0,
atunci rutarea continua imediat in planul Ai+1;
-daca offsetul din dimensiunea di+1 se reduce la 0 in timpul rutarii in planul Ai
rutarea continua exclusiv in dimensiunea di pana se obtine si pentru di offset 0, iar
planul Ai+1 poate fi sarit.
Evitarea blocarilor se realizeaza prin canale virtuale. Se poate arata ca in

cadrul rutarii plan-adaptive sunt necesare pentru evitarea blocarilor:
-in retele mesh: 3 canale virtuale;
-in retele tor: 6 canale virtuale.
Se analizeaza retele mesh.
Se noteaza:
-di,j set canale virtuale j (j = 0, 1, 2) traversand dimensiunea i;
-se descompune in di,j+ si di,j- reprezentand canalele in directia pozitiva,
respectiv negativa;
-fiecare plan Ai se defineste ca o combinatie de seturi de canale virtuale:
Ai = di,2 + di+1,0 + di+1,1
(di+1,2 se gaseste in planul Ai+1)
Pentru a evita blocarea setul de canale virtuale din Ai este impartit in doua
clase: (a) retea de crestere formata din canalele di,2+ si di+1,0 (b) retea de descrestere
formata din canalele di,2- si di+1,1. Pachete traversand dimensiunea di in directia pozitiva
sunt rutate in reteaua de crestere, iar cele in directia negativa sunt rutate in reteaua de
descrestere. Deoarece nu exista cuplari intre retele de crestere si descrestere ale planului
Ai, iar planurile sunt traversate in ordine rezulta ca nu exista dependente ciclice intre
canale, deci rutarea plan-adaptiva este "deadlock-free".
Modelul cotitura ("turn model")

Propus de Glass si Ni. O blocare poate sa apara atunci cand rutele pachetelor
contin cotituri care formeaza un ciclu. Ideea fundamentala: interzicerea numarului
minim de cotituri astfel incat sa fie prevenite ciclurile.
Se considera un mesh 2D, in care sunt posibile 8 cotituri si doua cicluri (a).
Algoritmul de rutare determinist XY previne blocarea prin interzicerea a patru cotituri
(linie intrerupta). Cotiturile permise (linie continua) nu pot forma un ciclu, dar nici nu
permit adaptabilitatea (b).
Totusi, interzicand mai putin de patru cotituri se pot preveni ciclurile, astfel
doar doua cotituri sunt interzise (cotituri spre vest) si sase permise (c).
In cadrul algoritmului se face rutarea mai intai spre vest (daca este necesar), iar apoi
adaptiv sud, est si nord.
Algoritm: MinimalWest-First pentru 2-D

Mesh
Inputs:
coordonatele
nodului
curent
(Xcurrent, Ycurrent)
si nodului destinatie (Xdest, Ydest)
Procedure:
Xoffset := Xdest Xcurrent;
Yoffset :=Ydest Ycurrent;
if Xoffset < 0 then
Channel := X;
endif
if Xoffset > 0 and Yoffset < 0 then
Channel := Select(X+, Y);
endif
if Xoffset > 0 and Yoffset > 0 then
Channel := Select(X+, Y+);
endif
if Xoffset > 0 and Yoffset = 0 then

Channel := X+;
endif
if Xoffset = 0 and Yoffset < 0 then
Channel := Y;
endif
if Xoffset = 0 and Yoffset > 0 then
Channel := Y+;
endif
if Xoffset = 0 and Yoffset = 0 then
endif
unde Select() este functia care returneaza un canal liber (daca exista) din setul de canale
furnizate ca argument.
Exemplu: trei cai de rutare pentru algoritmul west-first. Canalele marcate ca
nedisponibile sunt fie defecte, fie utilizate de alte pachete. O cale este minimala, iar
celelalte doua sunt neminimale, rezultate din rutare in jurul canalelor nedisponibile.
Ciclurile sunt evitate, rutarea west-first este "deadlock-free". Pentru rutare minimala,
algoritmul este complet adaptiv, daca destinatia este in partea dreapta (est) fata de sursa,
altfel este determinista. Daca se permite rutarea nonminimala, algoritmul este adaptiv in
ambele cazuri. Totusi, nu este complet adaptiv.
Rutare P-cub
Pe baza algoritmului "turn-west" se pot dezvolta si alti algoritmi de rutare
partial adaptivi pentru retele mesh n-dimensionale, n-cuburi de baza k si hipercuburi.
Pentru hipercuburi a fost dezvoltat algoritmul de rutare P-cub.
Se considera s = sn-1 sn-2 ... s0 si d = dn-1 dn-2 ... d0 nodurile sursa si destinatie
intr-un hipercub binar n-dimensional. Fie E multimea indicilor de dimensiune prin care
difera s si d astfel, iE daca si di. E este impartit in doua multimi disjuncte E0 si E1,
astfel iE0 daca si = 0 si di = 1 , respectiv jE1 daca sj = 1 si dj = 0. Conceptul
fundamental: rutarea P-cub este impartita in doua faze: in prima faza un pachet este
rutat prin dimensiunile din E0 in orice ordine, iar in faza a doua pachetul este rutat prin
dimensiunile din E1 in orice ordine. Bucla for calculeaza seturile E0 si E1 la fiecare nod
intermediar sau la nodul sursa. Functia digit() calculeaza valoarea bitului intr-o pozitie
data.
Algoritm: Rutare P-Cube minimala pentru hipercuburi

Inputs: adresele nodului current Current si nodului destinatie Dest
Procedure:
E0 := { }; E1 := { };
for i := 0 to n 1 do
if digit(Current, i) = 0 and digit(Dest, i) = 1 then
E0 := E0 + {i};
endif
if digit(Current, i) = 1 and digit(Dest, i) = 0 then
E1 := E1 + {i};
endif
end;
if E0 { } then
Channel := Select(E0);
endif
if E0 = { } and E1 { } then
Channel := Select(E1);
endif
if E0 = { } and E1 = { } then
endif
Arhitectura este determinata de tehnica de comutatie utilizata, majoritatea
multicalculatoarelor utilizand variante "virtual cut-through switching", "wormhole
switching", "buffered wormhole switching".
Chien a dezvoltat un model abstract de router pentru rutare wormhole in ncuburi de baza k.
unde
LC (link controller)
VC (virtual channel controller): controleaza multiplexarea canalelor virtuale in
canale fizice.
In cazul unui numar fix de conexiuni (pini) pentru comunicatia cu routere

vecine exista mai multe solutii de organizare:
-half-duplex bidirectional (a);
-canal unidirectional (b);
-canal full-duplex bidirectional (c).
Observatii.
-(a) si (b) maximizeaza largimea canalului (toate conexiunile utilizate pentru a
transmite date);
-(b) necesita retea tor (sau ceva similar) pentru a asigura comunicatiile intre
toate nodurile;
-(b) dubleaza distanta medie intre noduri (crescand componenta de distanta din
intarzierea mesajului);
-(c) transfer rapid, dar utilizare completa daca se transmit date in ambele
directii.
Exemplu: modul de operare a unui canal fizic la Network Design Frame care
suporta doua canale virtuale. Utilizeaza canale fizice half-duplex.
-Data linii de date bidirectionale 11 biti;

-la punere sub tensiune un router (ex. R1) devine owner, poate sa transmita date
(moment 1);
-cand R2 vrea sa transmita un flit comanda linia de arbitrare ARB high (moment 1), iar
cand R1 transfera controlul comanda ARB low (moment 2) => controlul preluat de R2;
-R1 cere controlul si comanda ARB high (moment 3) => la moment 4 devine owner;
-transferul unui flit se face prin utilizarea unui singur semnal R/A
(request/acknowledge) pentru fiecare canal virtual si fiecare directie (in total patru
semnale R/A): transferul initiat de sursa trecand R/A high, iar cand destinatia poate
accepta date comanda R/A low.
Routere wormhole
Router generic pentru ordonare dupa dimensiune (exemplu rutare XY )

-un mesaj traverseaza complet o dimensiune inainte de a schimba dimensiunea.
=> De aceea nu este necesar sa se furnizeze cai directe intre toate
intrarile si iesirile. Fiecare dimensiune poate fi servita de un crossbar 3x3.
Exemplu: router pentru mesh 2D.
de la procesor
local
catre procesor
local
-Xin conectat la procesorul local;

-Yin permite conectarea la crossbar-ul pentru dimensiunea Y;
-Output iesirea catre procesorul local;
-un mesaj de la procesor furnizat prin Xin crossbarului X, rutat pe dimensiunea X, apoi
furnizat prin Yin crossbarului Y, rutat pe dimensiunea Y si in final prin conexiunea
Output livrat procesorului destinatie;
-AD=address decoder;
-FC=flow control.
Astfel, utilizand o solutie partitionata se poate reduce aria de implementare a
router-ului, prin micsorarea numarului total de switch-uri elementare necesare:
-varianta 2x(3x3) => 18 CS-uri (Crosspoint-Switches);
-varianta 1x(5x5) => 25 CS-uri.
In cazul rutarii adaptive creste complexitatea arhitecturii interne a router-ului,
in mod special cu cresterea numarului de dimensiuni si a numarului de canale virtuale.
Ideea utilizarii cailor de date partitionate poate sa reduca complexitatea implementarii.
Exemplu: rutarea plan-adaptiva permite un echilibru intre complexitatea
implementarii si avantajele unei rutari mai libere. Schema bloc a unui router 2D:
AD = address decoder;
IFC = internal flow control;
PAR = planar-adaptive router;
VC = virtual channel controller;
XFC = external flow control.
-fiecare crossbar furnizeaza comutarea pentru reteaua de crestere sau reteaua de
descrestere, mesajul circuland intr-una sau cealalta.
Tehnica se poate generaliza permitand un grad mai inalt de adaptabilitate sau
marind numarul de dimensiuni in care rutarea adaptiva este permisa (solutia precedenta
permite rutarea adptiva in doua dimensiuni, dar de exemplu se poate realiza
adaptabilitate 3D intr-o retea 5D). Astfel de routere se numesc routere f-flat (f =
numarul de dimensiuni in care rutarea adaptiva este permisa) => complexitatea
routerelor creste cu marirea lui f.
Routerul Intel Teraflops

Sistemul Teraflops este o arhitectura proiectata de Intel pentru realizarea unei
masini cu 1012 operatii v.m. pe secunda si performanta de varf 1.8x1012 op.v.m.pe
secunda
=> chip cu 80 core-uri, la 4 GHz, arie de 10x8 core-uri, retea mesh interna.
Core:
-router cu 5 porturi;
-motor de prelucrare (PE processing engine);
-fisier de registre cu 32 de intrari (6 porturi de citire si 4 porturi de scriere);
-2 K memorie de date / 3 K memorie de instructiuni;
-doua unitati de v.m. (fiecare FPU este un multiplicator accumulator de v.m.
simpla precizie: FMAC single-precision, floating-point multiply-accumulator) cu o
banda de asamblare avand 9 segmente si o rata de 2 Flops/ciclu.
PE:
-implementeaza VLIW ISA, non-x86;
-instructiuni de 96 biti;
-maxim 8 operatii/ciclu.
Reteaua mesh care conecteaza PE-urile: comunicatia bazata pe pachete.
(RIB Router Interface Block).
Pentru economie de energie, fiecare core este impartit in 21 de regiuni

separate, iar pe baza conditionarii ceasului, diferite blocuri functionale pot fi trecute in
stare inactiva in mod dinamic, in functie de incarcarea de lucru. Chiar si routerul poate
fi oprit sau pornit pentru adaptarea la trafic!
=> proiect de testare a solutiilor de organizare, distribuire a ceasului si fabricare a

chipurilor masiv multicore.
Cipul interfata de retea si router, numit Cavallino reprezinta structura de

comunicatie pentru masina. Reteaua este cub 3D de ordin k, cu o baza diferita in fiecare
dimensiune (maxim 8 noduri in dimensiunea Z, 256 noduri in dimensiunea X si 64
noduri in dimensiunea Y). Routerul are sase porturi, iar proiectul interfetei suporta
configuratii 2D unde cele doua porturi din dimensiunea Z sunt conectate la doua noduri
de prelucrare (si nu la alte routere). Arhitectura furnizeaza o baza flexibila pentru o
varietate de topologii.
Caracteristici:
-semnale bidirectionale simultane;
-canale fizice half-duplex;
-canal fizic 16 biti (phit);
-flit mesaje de 64 biti, necesitand patru cicluri de ceas pentru a tranzita canalul;
-trei semnale suplimentare / canal furnizeaza informatii pentru canale virtuale si control
flux;
-canalul fizic opereaza la 200 MHz, cu 400 MB/s in fiecare directie;
-printr-o legatura fizica sunt multiplexate patru canale virtuale.
Structura interna:
-headerul de rutare contine offseturi in fiecare directie (ordinea de rutare Z-X-Y-Z),

permitand decizii rapide de rutare;
-bufferare pe intrare;
-6 intrari x 4 canale virtuale => arbitrare 24:1 pentru fiecare iesire a retelei crossbar;
-arbitrare in doua etape:
-arbitrare 6:1 intre canalele virtuale corespondente de la cele sase intrari;
-arbitrare 4:1 intre canalele cu date valide necesitand aceeasi iesire fizica.
-caile interne de date pe 16 biti.
Schema bloc a interfetei de retea:
-partea catre router din interfata utilizeaza portiuni din arhitectura routerului configurate
ca port triplu: un port pentru receptia si transmisia mesajelor, iar celelalte doua pentru
conectarea la alte routere => flexibilitate permitand realizarea de constructii cu
topologii mai complicate.
-un canal virtual de iesire: 384 biti;
-un canal virtual de intrare: 256 biti;
-RMA ("Remote Memory Access" engine) are acces la o tabela de mapare rezidenta in
memorie care mapeaza adresele procesorului in adrese ale nodurilor la distanta: sunt
create mesaje de cerere pentru acces la distanta, iar pentru servirea cererilor sosite de la
distanta sunt create mesaje de raspuns. RMA furnizeaza suport pentru operatii atomice
accesibile la distanta, exemplu "read&clear" (implementarea operatiilor de
sincronizare);
-interfata DMA: suporta opt canale si cozile corespunzatoare de comanda (cate una
pentru fiecare canal virtual de intrare si iesire). Accesul la controlul DMA este mapat in
memorie, iar accesul utilizatorului este permis pe baza nivelurilor de mesagerie, cu
overhead scazut. Rata prin DMA se apropie de 400 MB/s.
Routerul Cray T3D

Sistemul Cray T3D utilizeaza interconectare cub 3D de ordin k. Exemplu de
configuratie de noduri de elemente de prelucrare PE de dimensiune 4x4x2:
(BTE = block transfer engine; NI = network interface)

Fiecare nod contine doua procesoare DEC Alpha partajand o singura interfata de retea
NI catre routerul local. Numar maxim de noduri: 8 in directiile X si Z si 16 in directia Y,
in total 1024 noduri cu 2048 procesoare.
Arhitectura routerului bazata pe comutare "wormhole" cale fixa ordonare dupa

dimensiune. Organizarea:
Peste o legatura fizica sunt plasate patru canale virtuale

unidirectionale, impartite in doua retele virtuale:
-reteaua de cerere, livreaza pachete de cerere;
-reteaua de raspuns, transporta pachete de raspuns.
Routerele adiacente comunica printr-un canal fizic bidirectional
full-duplex avand 16 biti de date si 8 biti de control.
Routerul este impartit fizic in trei switch-uri: mesajele sunt
rutate mai intai pe dimensiunea X, apoi Y si in final Z.
Formatul pachetelor:
-header: numar intreg de phituri de 16 biti continand informatii de rutare, de control

pentru PE la distanta si eventual informatii despre sursa.
-corpul utilizeaza biti de verificare pentru detectarea erorilor;
-mesajele sunt organizate ca secvente de flit-uri (1 flit = 8 phituri), bufferele pentru
canalele virtuale sunt de adancime 1 flit.
Rutarea:
-utilizeaza rutare sursa ("source routing");
-PE-urile detin fiecare: adresa fizica, adresa logica si adresa virtuala;
-adresele logice sunt bazate pe topologia logica instalata, iar PE-urile pot fi adresate pe
baza adreselor logice, independent de localizarea fizica;
-nodurile defecte pot fi inlocuite cu alte noduri prin asignarea acelorasi adrese logice;
-adresele virtuale sunt interpretate in acord cu partitia alocata: astfel 16 noduri pot
forma o topologie 8x2x1 sau 4x2x2 (2 biti din adresa virtuala sunt alocati offsetului X,
un bit pe Y si un bit pe Z);
-la transmiterea unui mesaj o adresa virtuala de PE este translatata in adresa logica (prin
SO sau hardware), iar adresa logica reprezinta un index intr-o tabela furnizand
offseturile pe fiecare dimensiune pentru ca mesajul sa ajunga la PE destinatie. La
inlocuirea unui nod defect este necesara actualizarea in tabela.
Calea de date pentru prelucrarea mesajelor:
-DTB = "data translation buffer";

-tabelele de rutare implementate hardware:
-translatare adresa PE virtuala la adresa logica;
-"routing tag lookup";
-mesajele receptionate plasate intr-o coada organizata intr-o zona rezervata de memorie
fiind generate acknowledge-uri pozitive sau negative (succes sau insucces),
acknowledge negativ permitand retransmisia mesajului;
-pachetele de cerere si raspuns implementeaza un spatiu partajat de adrese (memorie
partajata necoerenta): cand procesorul genereaza o adresa de memorie hardware-ul
mapeaza adresa intr-o adresa locala sau nelocala (adresa nelocala genereaza pachete de
cerere catre nodurile la distanta).
Routerul Cray T3E
-imbunatatiri fata de T3D, in primul rand prin tehnolgia utilizata crestere

de viteza;
-un singur procesor per nod;
-topologie tor 3D cu maxim 8/32/8 noduri pe X/Y/Z;
-I/F = interface;
-pachetul = 1-10 flituri, 1 flit = 5 phituri;
-canal fizic full duplex 14 biti de date => flit = 70 biti (flitul transporta un
cuvant de 64 biti impreuna cu informatii suplimentare de control);
-pe un canal fizic in fiecare directie sunt multiplexate 5 canale virtuale: 4
canale functioneaza ca in T3D, iar al cincilea este utilizat pentru rutare
complet adaptiva;
-un canal adaptiv poate buffera max 22 flituri, iar un canal obisnuit max 12
flituri;
-arbitrarea canalelor virtuale active pentru accesul la iesirile crossbar-ului
este tip "round-robin";
-arbitrarea canalelor virtuale de iesire pentru accesul la canalul fizic este de
asemenea tip "round-robin", desi canalul adaptiv are prioritatea cea mai
mica;
Routere VCT
Sunt asemanatoare cu routerele wormhole avand caracteristica distinctiva ca
detin spatiu suficient pentru memorarea pachetelor complete de mesaje.
Routerul Chaos
-opereaza in mesh 2D;
-pentru reducerea numarului de pini: fiecare canal 16 biti, half-duplex bidirectional;
-compus: cozi multiple si core-ul care conecteaza cadrele ("frames") de intrare cu cele
de iesire printr-un crossbar switch;
-fiecare cadru poate memora un pachet de 20 flit-uri (un flit = 16 biti, corespunzand
canalului fizic);
-la incarcare usoara a retelei majoritatea traficului are loc prin core (crossbar switch),
optimizat din p.d.v. al performantelor;
-la trafic aglomerat mesajele pot fi mutate din cadrele de intrare in coada multipla, iar
apoi din coada multipla la cadrele de iesire: cand un mesaj asteapta in cadrul de intrare
eliberarea cadrului de iesire, acesta va fi transferat in coada multipla eliberand canalul
pentru a putea fi utilizat de alte mesaje (evitarea blocarii).
Comutarea de circuite
Intel iPSC Direct Connect Module (DCM)
-avantaj: la setarea unei cai datele pot fi transmise la viteza fizica maxima a canalelor,
fara partajare cu alte transmisii, sistemul operand complet sincron.
-in multicalculatoarele iPSC: retea hipercub;
-routerul implementat in modulul numit Direct Connect Module (DCM);
-DCM implementeaza rutarea cu ordonare dupa dimensiune (max 8 dimensiuni);
-porturile routerului:
-un port pentru conectare la dispozitiv extern;
-celelalte porturi suporta topologie cu maxim 128 noduri;
-legaturile fizice sunt seriale de 2.8 MB/s, prin care se multiplexeaza date, informatii de
control si informatii de stare;
-liniile Strobe furnizeaza ceasul de la sursa;
-mesaj gata de transmisie: se transfera la DCM un cuvant de 32 biti, in care octet
inferior contine tagul de rutare (XOR intre adresele sursa si destinatie);
-tagul de rutare: examinat de fiecare element de rutare in ordine ascendenta (bit = 1
mesajul traverseaza dimensiunea respectiva);
-serializatorul de intrare genereaza o cerere catre canalul din dimensiunea corespunzand
bitului l.s.b. pe 1 din tagul de rutare; cereri multiple pentru acelasi canal de iesire sunt
arbitrate in maniera "round-robin";
-informatiile de stare:
-RDY: cand DCM destinatie primeste un header de rutare transmite inapoi
semnalul de stare RDY initiand transferul de date;
-EOM (end of message): se adauga la sfarsitul mesajului => eliberarea
legaturilor.
Operatiile send si receive

Operaiile de comunicaie la nivelul utilizatorului:
-send specific un buffer local de date care trebuie trimis i un proces de
reccepie pe o main la distan;
-receive specific un proces care trimite date i un buffer local n care se vor
plasa aceste date.
Primele maini cu transfer de mesaje -> primitive hardware apropiate de send

i receive la nivel utilizator.
=> un nod era conectat la un set fix de vecini, ntr-o reea regulat de legturi
punct la punct cu buffere FIFO.
Soluie mai perfecionata: dispozitive de acces direct la memorie (DMA

Direct Memory Access) => operaii send fr blocare.
=> suport pentru comunicaia ntre oricare procesoare (nu numai vecine) funcii de rutare n hardware => routere.
IBM SP-2
-main paralel scalabil cu staii de lucru RS6000.
-reteaua de interconectare SP2 utilizeaza comutarea wormhole bufferata, realizata cu

switch-uri crossbar bufferate 4x4, fiecare switch avand 4 intrari bidirectionale si 4 iesiri
bidirectionale, deci poate opera ca un crossbar 8x8;
-doua niveluri de cate patru switchuri formeaza un "frame", suportand maxim16
procesoare;
-mai multe frame-uri pot fi conectate pentru a conecta mai multe procesoare (direct
maxim 5 frame-uri cu 80 procesoare sau prin cascadare solutie in care pe ultimul nivel
se utilizeaza frame-uri de switch-uri, permitand cresterea numarului de legaturi intre
procesoare pe masura ce creste dimensiunea sistemului);
-canalul fizic:
contine 8 biti de date, un bit de tag si un bit token (permite controlul numarului de
flituri transferate);
-schema bloc a routerului (switch-ului) SP2:
-FC = flow control;

-mesajele sunt rutate utilizand rutarea de sursa;
-fliturile sunt receptionate in cozi FIFO de intrare;
-primul flit decodificat pentru selectarea unui port de iesire:
-bitii 6-4 selecteaza portul de iesire din primul switch al unui frame;
-bitii 2-0 selecteaza portul de iesire din al doilea switch al unui frame;
-bit 7 = 0 se utilizeaza bitii 6-4;
-bit 7 = 1 se utilizeaza bitii 2-0 flitul este descarcat => decrementeaza
lungimea de flituri din mesaj;
-se face verificarea CRC;
-daca port de iesire liber flitul este transferat prin crossbar switch;
-daca port de iesire ocupat flitul este memorat in coada centrala;
-interfata switch-ului SP2 controlata de un coprocesor performant de comunicatie Intel
i860 CPU pe 64 biti cu memorie de 8 MB:
-pe un port coprocesorul comunica cu un switch printr-o pereche de cozi FIFO
2 KB;
-pe al doilea port coprocesorul comunica cu RS/6000 CPU Micro Channel Bus
printr-o pereche de canale FIFO de 2 KB;
-mesajele sunt transferate prin DMA intre coprocesor si Micro Channel, iar un
al doilea DMA transfera date intre bufferele FIFO Micro Channel si bufferele FIFO din
interfata switch-ului.
Intel Paragon
nod - multiprocesor simetric (SMP)
IC (input controller), FB (flit buffer).
Protocoale pentru transfer de mesaje

=> operaiile de transfer de mesaje de la nivel utilizator -> primitive main de
tranzacie n reea
1) Protocol sincron pentru transfer de mesaje
2) Protocol asincron (optimist) pentru transfer de mesaje
3) Protocol asincron (conservativ) pentru transfer de mesaje
Soluii de interpretare
a informaiilor din tranzacia prin reea
1) Nu exist interpretare a tranzaciei mesajului: mesajul = secven de bii
care se transfer orb n memorie prin DMA (Direct Memory Access) fizic sub
controlul SO.
Sisteme: nCUBE 10, nCUBE/2, Intel iPSC, iPSC/2, iPSC/860, Delta, Ametek,
IBM SP-1) i majoritatea intefeelor de reea local LAN (Local Area Network).
=>
hardware simplu;
abstractizarea comunicaiei utilizator foarte general;
costuri de prelucrare mai mari.
Exemplu: sistemul nCUBE/2
Configuraia maxim nCUBE/2 -> 8096 de noduri:
2) Transfer de mesaje de la nivel utilizator la nivel utilizator fr intervenia

S.O.
Arhitectura tipic la nivel utilizator:
Exemplu: sistemul Thinking Machine CM-5 (reea - arbore):
3) Interpretarea mesajelor prin software pe un procesor de comunicaie

dedicat (procesor de mesaje).
Exemplu: Intel Paragon.
PROIECTAREA UNUI ROUTER PENTRU TOPOLOGIE 2D

Routerul este proiectat pentru o retea mesh 2D 256x256 noduri, conform
schemei de principiu:
Legaturile pe orizontala si verticala sunt bidirectionale.

Tehnica de rutare: "wormhole".
Routerul suporta doua tipuri de pachete:

-pachete normale pentru transfer de mesaje;
-pachet de initializare pentru configurarea routerului.
Mesaj = mai multe pachete de lungime fixa;
Pachet = 4 flituri de 32 biti fiecare (rutare wormhole, flit 1: header):
Pachet normal:
Flit 0
Flit 1
Flit 2
Flit 3
16 biti
16 biti
32 biti
32 biti
32 biti
Adresa
destinatie
Adresa
sursa
Adresa memorie la
destinatie
Data
Data
Pachet de initializare a adresei de nod:

8 biti
8 biti
Adresa y
Adresa x
Legaturile dintre noduri sunt pe 8 biti => 1 phit = 8 biti, iar 1 flit = 4 phit-uri.
Deciziile de rutare sunt luate local in router pe baza adresei de destinatie din
headerul de pachet si a disponibilitatii canalelor de iesire. In cazul in care canalul de
iesire este ocupat pachetele sunt depuse in coada de asteptare corespunzatoare.
Structura generala a unui element de prelucrare PE cuprinde patru coponente
principale:
Controllerul DMA, memoria locala si procesorul host (poate fi un procesor de scop

general, ex. Pentium) sunt conectate pe o magistrala locala.
Procesorul furnizeaza date si comenzi pentru transmisia de mesaje.
Functiile controllerului DMA:
-configurarea routerului cu informatii furnizate de procesor;
-compunerea pachetelor de lungime fixa in format acceptat de router;
-descompunerea mesajelor receptionate de la alte PE-uri;
-transferul de mesaje intre procesorul host si router;
-accesul direct la memoria locala pentru transmisia mesajelor lungi (fara interventia
procesorului, acesta furnizand adresa de start si lungimea), controllerul DMA
compunand pachete de lungime fixa.
Semnale:
-PUSH_DATA_IN (date de intrare gata);
-FULL_OR_ACK_IN (buffer de intrare plin sau acknowledge pentru citire date de catre
router);
-POP_DATA_OUT (date de iesire gata);
-FULL_OR_ACK_OUT (buffer de iesire plin sau acknowledge pentru transmisia de
date catre routerul urmator).
=> fiecare canal fizic bidirectional de 8 biti are 20 de linii: 8 linii de
date de intrare, PUSH_DATA_IN, FULL_OR_ACK_IN, 8 linii de date de iesire,
POP_DATA_OUT, FULL_OR_ACK_OUT.
=> routerul are in total 5x20+3 pini suplimentari:
-CLOCK (ceas sistem);
-RESETIN (reset sistem);
-INIT (configurare router).
Exemplu de rutare: rutare in ordinea dimensiunilor, incepand cu prima

dimensiune (x), topologie 2-D, canale pe 8 biti, adresa nod local 00000011|00000110 =
3|6 (y|x).
Soseste pachet cu adresa nod destinatie 00000100|00000100 = 4|4.
=> calculeaza diferenta in prima dimensiune 4-6 = -2 (<0) => pachetul rutat la
port corespunzator -x, deci port DATA_OUT_XN => pachet transferat de la nod 3|6 la
nod 3|5.
=> calculeaza diferenta in prima dimensiune 4-5 = -1 (<0) => pachetul rutat la
port corespunzator -x, deci port DATA_OUT_XN => pachet transferat de la nod 3|5 la
nod 3|4.
=> calculeaza diferenta in prima dimensiune 4-4 = 0 => calculeaza diferenta in
a doua dimensiune 4-3 = 1 (>0) pachetul rutat la port corespunzator +y, deci port
DATA_OUT_YP => pachet transferat de la nod 3|4 la nod 4|4.
=> calculeaza diferenta in a doua dimensiune 4-4 = 0 => pachetul a ajuns la
destinatie => pachet transferat la port CPU (DMA).
Observatie. Routerul suporta si rutare toleranta la defecte. Un timer
"watchdog" identifica o conexiune defecta si reruteaza pachetul aleator pe o alta
dimensiune care mai trebuie traversata, sau daca nu, trimite aleator la oricare port
conectat.
Arhitectura routerului
Controllerul. Faza de initializare

Controllerul contine doua registre de adresa curenta (adresa nodului) pe
orizontala si pe verticala NODE_ADR_X[8] si NODE_ADR_Y[8], care se incarca in
faza de initializare (semnalul INIT activ) de la DMA prin liniile IN_DMA[32] cu adresa
locala.
Totodata, in aceasta faza, semnalul DISABLE_PORTS se activeaza pentru a
inhiba orice transfer de date prin router (pentru a evita orice operatie de rutare).
Procesul de initializare este descris in pseudocod:
if (INIT = 1) // Se detecteaza modul de initializare
then
DISABLE_PORTS=1;
READ [16 bits from port IN_DMA]
Local_node_address=16bit Incoming Address;
INIT = 0; Flag_end_of_init = 1;
DISABLE_PORTS=0;
//Initializarea s-a incheiat
else (INIT = 0)
//Operare normala
endif
Portul de intrare
Exista cinci blocuri de intrare identice corespunzatoare conexiunilor x+, x-,

y+, y- si DMA (figura este pentru blocul x+).
Un bloc contine:
-demultiplexor DEMUX pentru preluarea succesiva a celor patru octeti reprezentand un
flit;
-patru registre IN_REG0-3 de 8 biti fiecare pentru memorarea unui flit;
-doua registre DEST_ADR_Y si DEST_ADR_X de 8 biti fiecare pentru memorarea
adresei de destinatie a pachetului, transmisa in cadrul primului flit din pachet;
-doua comparatoare de adresa care compara fiecare adresa de 8 biti pe x/y de destinatie
cu adresa nodului curent de 8 biti pe x/y (adresa destinatie adresa curenta). Furnizeaza
doua iesiri:
-ZERO => adresele sunt egale;
-NEG => adresa destinatie < adresa curenta => rutare catre x-/y-;
-ambele iesiri inactive => adresa destinatie > adresa curenta => rutare catre
x+/y+;
-logica de selectie a portului de iesire OUT_PORT_SELECT, care selecteaza portul de

iesire necesar pe baza iesirilor comparatoarelor. Se bazeaza pe o tabela cu urmatorul
continut (pentru rutarea XY):
ZERO_X
NEG_X
ZERO_Y
NEG_Y
OUT_PORT_ADR
selectie
001
x-
000
x+
011
y-
010
y+
100
dma
-numarator de flituri FLIT_COUNTER pe 2 biti (patru flituri / pachet);

-numarator de octeti BYTE_COUNTER pe 2 biti (patru octeti / flit);
-blocul de control gestioneaza:
-semnalele de dialog cu routerul vecin:
-PUSH_DATA_IN date de intrare pregatite;
-FULL_ACK_IN buffer de intrare plin sau acknowledge pentru citire
date;
-semnale de stare pentru crossbar:
-FIRST_FLIT se activeaza la primul flit pentru a indica crossbarului
memorarea intr-un registru de 3 biti a adresei portului de iesire necesar pachetului;
-LAST_FLIT se activeaza dupa transmiterea ultimului flit din pachet
pentru resetarea adresei portului de iesire;
-semnal de stare catre blocul de iesire selectat:
--INBUF_VALID indicand bufferul de intrare plin (valid).
Operatia de scriere a unui flit in bufferul de intrare:
Crossbar switch
Crossbarul contine doua mari componente:

-reteaua propriu-zisa de comutatoare;
-blocul de control si arbitrare.
Blocul de control si arbitrare:
-contine cinci registre de control de 5 biti fiecare pentru activarea portilor tri-state
(three-state) catre porturile de iesire. La un moment dat din cele 5 linii de control ale
unui registru este activa o singura linie (pentru a selecta un singur port de intrare);
-logica de arbitrare pe baza OUT_PORT_ADR si la activarea FIRST_FLIT pentru un
port de intrare selecteaza pe baza unei logici de prioritati bitii din registrele de control
(pentru a conecta portul de intrare la portul de iesire corespunzator). Prioritatile
porturilor de intrare sunt fixe in ordinea x+, x-, y+, y- si DMA;
-la activarea LAST_FLIT blocul de control elibereaza legatura la portul de iesire care a
fost utilizat.
Tema. Sa se proiecteze in detaliu blocul de control si arbitrare din cadrul

crossbar switch-ului.
Portul de iesire
Fiecare dintre cele cinci porturi de iesire contine urmatoarele resurse:

-patru registre de iesire de 8 biti fiecare OUT_REG0-3 in care se depune prin
intermediul crossbar-ului un flit dintr-un port de intrare. Scrierea se face in paralel in
cele patru registre cu un singur semnal de scriere;
-multiplexor MUX pentru a furniza pe liniile de iesire DATA_OUT de 8 biti, succesiv,
cei patru octeti ai unui flit;
-bloc de control;
-contor de octeti BYTE_COUNTER (nu mai este necesar contor de flit-uri, lungimea
pachetului se masoara in portul de intrare). Orice flit ajuns in portul de iesire trebuie
furnizat mai departe pe liniile de date de iesire DATA_OUT.
Citirea unui flit din portul de intrare si inscrierea acestuia in portul de iesire
Transmiterea unui flit din portul de iesire catre routerul urmator
MULTICALCULATOARE
(2/2)
PROCESOARE MASIV PARALELE (MPP)

SISTEME CU TRANSPUTERE
CLUSTERE DE STATII DE LUCRU
PROCESOARE MASIV PARALELE (MPP)

Procesoarele masiv paralele MPP (Massively Parallel Processors) :
-cost foarte mare (de ordinul milioanelor de dolari);
-utilizari speciale (cercetari tiinifice, industrie pentru calcul intensiv,
prelucrare a unor baze de date imense);
-procesoare standard (Intel Pentium, Sun UltraSparc, DEC Alpha);
-reeaua de interconectare: de firma, foarte performanta, foarte scumpa;
-capacitate enorma de I/E;
-tolerante la erori (defecte): hardware i software speciale pentru monitorizarea
sistemului, detectnd i recupernd erorile.
Cray T3E
-continua linia de supercalculatoare nceputa la mijlocul anilor 60;
-max. 2048 de procesoare;
-DEC Alpha 21164:
-RISC superscalar (4 instruciuni / ciclu de ceas);
-frecvene de 300, 450, 600 MHz;
-64 de bii;
-adresele virtuale pe 43 de bii;
-adresele fizice pe 40 de bii -> 1 TB memorie fizica;
-doua niveluri de memorie cache:
-nivelul 1: 8 kB pentru date i 8 kB pentru cod;
-nivelul 2: 96 kB de memorie cache date i cod;
-memoria locala RAM maxim 2 GB / procesor => 4 TB de memorie;
-procesorul + circuit special shell (memoria, procesorul de comunicaie i
512 registre E speciale);
-reg E: se ncarca cu adrese de memorie la distana -> citire/scriere cuvinte sau
blocuri de memorie la distana - nu cu instruciuni load i store);
-coerena memoriei: datele citite din memoria la distana nu sunt pastrate n
cache.
Conectarea nodurilor:
-tor 3D duplex (exemplu: sistem cu 512 noduri -> cub de 8x8x8 => fiecare nod
avnd sase legaturi cu alte noduri vecine, rata de transfer 480 MB/s );
-subsistem de I/E de banda foarte larga, bazat pe comutarea de pachete, cu
unul sau mai multe inele Giga Ring: pentru comunicaia ntre noduri i cu
echipamentele periferice.
Tipuri de noduri:
-noduri utilizator (nu executa ntregul S.O., ci numai un nucleu simplificat);
-noduri dedicate S.O. (Unix);
-noduri de rezerva: la fiecare 128 de noduri -> un nod de rezerva.
Intel/Sandia Option Red

Departamentele de Aprare i Energie ale SUA -> program supercalculatoare
MPP de 1-100 TFLOPS.
Intel: primul contract la Sandia National Laboratories
Option Red (1TFLOPS)!
(urmtoarele dou contracte: IBM - Option Blue i Option White).
Sistemul Option Red:
-4608 noduri - reea plas 3D;
-dou tipuri de plci:
-plci Kestrel (noduri de calcul);
-plci Eagle (servicii, disc, reea i ca noduri de pornire).
=> 4536 de noduri de calcul, 32 de noduri de servicii, 32 de noduri disc, 6
noduri reea i 2 noduri de pornire.
Placa Kestrel:
-dou noduri, fiecare cu dou procesoare Pentium;
-memorie partajat de 64 MB;
-magistral local de 64 de bii;
-interfa de reea (NIC) -> modulele NIC legate ntre ele, dar numai unul este
conectat la reea.
Placa Eagle:
-dou procesoare Pentium i I/E.
-plcile interconectate n reea de tip gril cu 32x38x2 noduri;

-n fiecare: cip pentru dirijare cu ase legturi (est, vest, nord, sud, cellalt plan
i la o plac Kestrel sau Eagle conectat la punct);
-fiecare legtur: 400 MB/s n fiecare sens.
Partiii (din punct de vedere logic):

-nodurile de servicii: maini universale Unix;
-nodurile de calcul: aplicaiile numerice complexe;
-nodurile de I/E: 640 de discuri:
-set de noduri de I/E pentru aplicaii secrete;
-set pentru aplicaii civile (la un moment dat ataat un singur set);
-nodurile sistem: pornirea sistemului.
Sistemele IBM SP
Arhitectura IBM Power
1990: statiile de lucru superscalare si serverele din familia RISC System/6000

(RS/6000):
-RISC = Reduced Instruction Set Computer;
-Superscalar = unitati multiple in cip (unitati de v.m, v.f., load/store, etc.) care
executa simultan instructiuni in fiecare ciclu de ceas;
-POWER = Performance Optimized With Enhanced RISC.
Initial Power1: 25 MHZ, cate o unitate de v.m. si de v.f., performante de 50 MFLOPS.
SP1
=>primul sistem SP (Scalable POWER parallel). Inovatii:
-suprafata ocupata redusa: masinile POWER1 puse intr-un singur dulap (rack);
-mentenanta redusa: intregul sistem gestionat de administrator de la o singura
consola;
-comunicatie performanta interprocesor printr-o retea interna de comutatoare;
-software Parallel Environment pentru dezvoltarea si rularea de aplicatii
paralele (cu memorie distribuita);
-SP1 POWER1: 62.5 MHz, 125 MFLOPS.
SP2
=> 1993 cu procesoare POWER2. Caracteristici:
- cate doua unitati de v.m. si v.f.;
-marirea cache-ului de date;
-cresterea ratei de transfer memorie cache;
-66.5 MHz, 254 MFLOPS;
-set imbunatatit de instructiuni.
Imbunatatirile SP2 (pentru o mai buna scalabilitate):
-software performant de sistem si de gestiune a sistemului;
-imbunatatirea Parallel Environment;
-rata crescuta in reteaua de comutatoare.
P2SC
=> 1996, POWER2 SuperChip (~POWER2), dar cu 160 MHz si dublul performantelor
POWER2.
PowerPC
=> 1993, parteneriat IBM, Apple, Motorola. Include majoritatea instructiunilor
POWER, in plus instructiuni pentru SMP. Varianta finala 604e. Avantaje:
-CPU-uri multiple;
-frecventa mai mare de ceas;
-cache L2;
-memorie marita, discuri, I/E.
PowerPC 604e: SMP cu 4 procesoare, 332 MHz => realizarea sistemului ASC BluePacific (cel mai puternic sistem la vremea respectiva).
POWER3
=> 1999, fuziune intre POWER2 uniprocesor si PowerPC multiprocesor. Avantaje:
-arhitectura pe 64 biti;
-frecventa mai mare de ceas;
-memorie, cache, disc, I/E marite;
-numar mai mare de procesoare.
=> ASC White (bazat pe POWER3 Nighthawk-2).
POWER4
=> 2001, blocul de baza: cip cu doua procesoare SMP, 4 cipuri = 1 modul cu 8
procesoare. Se pot combina module pentru masini SMP cu 16, 24, 32 procesoare.
Imbunatatiri:
-cresterea numarului de procesoare: maxim 32 de procesoare / nod;
-frecventa de ceas peste 1 GHz;
-cache L2, disc, I/E crescute;
-cache L3 partajata intre module.
POWER5
=> introdus in 2004; asemanator POWER4, dar cateva imbunatatiri:
-maxim 64 procesoare / nod;
-ceas 2.5 GHz;
-cache L3 mai mare, mai rapid si pe cip;
-largime de banda cip-memorie 16 GB/s (4x POWER4);
-multithreading (2 thread-uri simultane per procesor);
-gestiune de putere dinamica (cipurile neutilizate consuma mai putin si degaja
mai putina caldura).
Exemplu: ASC Purple.
POWER6
=> introdus in 2007
POWER7
-februarie 2010;
-proces 45 nm;
-4.04 GHz;
-max 2 cipuri / modul multicip;
-4, 6 sau 8 core-uri / cip;
-4 thread-uri / core;
-cache 32 MB per pastila, nivel 3, partajat de toate corurile de tip
eDRAM (embedded DRAM, DRAM bazat pe capacitate, integrat pe
pastila, nu extern; permite magistrala mai larga, viteza de operare mai mare,
densitate mai mare);
-max 517.1 GFLOPS per modul;
-max 32.3 GFLOPS per core.
Hardware SP
Componentele unui sistem SP:

-frames: o unitate constand dintr-un rack pentru plasarea calculatoarelor,
surse, echipamente de racire, comunicatii;
-nodes: statii de lucru AIX RS/6000 impachetate pentru a fi plasate intr-un
frame SP. Nu dispun de display, tastatura;
-switch: mediul retea interna pentru comunicatie de viteza mare intre noduri.
Fiecare frame are o placa de switch-uri pentru interconectarea nodurilor proprii, dar si
pentru conectarea la placi de switch-uri ale altor frame-uri;
-switch adapter: conecteaza fizic fiecare nod la reteaua de switch-uri;
-control workstation (CWS): este o statie de lucru AIX independenta cu
display si tastatura care controleaza intregul sistem.
Frame-urile
Un sistem SP compus din unul sau mai multe frame-uri, racire cu aer:
-1-16 noduri / frame;
Tipuri de noduri:
-thin: ocupa un slot in frame;
-wide: ocupa 2 sloturi adiacente orizontale;
-high: ocupa 2x2 sloturi;
-mixed.
Nodurile SP
Un nod = masina independenta, plasata intr-o cutie, pusa in frame. Fiecare nod are
hardware propriu:
-I/E, inclusiv discuri;
-adaptoare de retea;
-memorii (placi si memorii cache);
-alimentare si echipament de racire.
Exista o copie a S.O. AIX pentru fiecare nod, chiar si pentru nodurile SMP.
Noduri POWER3
-nod = SMP cu 2-16 procesoare;
-64 biti;
-4 tipuri de noduri POWER3: Winterhawk-1, Winterhawk-2, Nighthawk-1, Nighthawk2;
-frecventa 200-450 MHz;
-cache L1: 64 kB date, 32 kB cod;
-cache L2: 4 sau 8 MB, cu magistrala proprie;
-maxim 64 GB memorie partajata;
-magistrale separate de date si adrese;
-structura superscalara: 8 unitati de executie:
-2 unitati v.m. (FPU);
-3 unitati v.f. (FXU);
-2 unitati load/store (LS);
-unitate de ramificatie;
-unitate registru de conditie.
Noduri POWER4
-nod = SMP cu 8-32 procesoare;
-64 biti;
-frecventa ceas 1-1.9 GHz;
-blocul de baza: modul = 4 cipuri cu cate 2 procesoare (8 procesoare) => 4 module
formeaza un SMP cu 32 procesoare;
- cache L1: 64 kB date, 32 kB instructiuni/procesor;
-L2: 1.5 MB/cip;
-L3: 32 MB/cip => L2 si L3 partajate de toate cipurile din modul;
-rata cip-cip: 35 GB/s;
-memorie partajata de maxim 1024 GB/nod;
-interfata rapida I/E (magistrala rapida Gxx) de 1.7 TB/s;
-superscalar: 2 FPU, 2 FXU, 2 LS, Branch Resolution Unit, Condition Register
Unit.
Comparatie POWER3 POWER4
Noduri POWER5
-dual-core;
-maxim 64 procesoare / nod;
-arhitectura 64 biti;
-superscalar, executie out-of-order, cu unitati functionale multiple (inclusiv doua
unitati v.f. si doua unitati v.m.);
-ceas 2.5 GHz;
-cache:
-controller cache si director L3 pe cip;
-L1 date 32 KB/procesor, bloc (linie) 128 octeti, set asociativ dim. 4;
-L1 cod 64 KB/procesor;
-L2 1.9 MB/cip (partajata intre procesoarele duale);
-L3 36 MB/cip (partajata intre procesoarele duale);
-memorie 1-256 GB;
-largime de banda cip-memorie 16 GB/s (4x POWER4);
-multithreading (2 thread-uri simultane per procesor) => aceeasi idee la Intel IA32
hyperthreading;
-gestiune de putere dinamica (cipurile neutilizate consuma mai putin si degaja mai
putina caldura).
Comparatie privind organizarea memoriei la POWER4 si POWER5:
-module:
-DCM (Dual-chip Module): un cip dual core si cache L3;
-QCM (Quad-chip Module): 2 cipuri dual core si 2 cache-uri L3;
-MCM (Multi-chip Module): 4 cipuri dual core si 4 cipuri cache L3;
-modulele se pot combina pentru a forma SMP-uri mai mari:

-2xMCM => bloc book cu 16 SMP-uri;
-4xbook => 64 SMP-uri;
Reteaua de comutatoare
-este bidirectionala: oricare conexiune intermediara contine doua canale full-duplex;
-interconectare multinivel: pentru sistemele mari (>80 noduri) se adauga switch-uri
intermediare;
-componentele principale:
-placa de comutatoare (o placa / frame) contine 8 cipuri de switch-uri logice,
cu 16 cipuri fizice (pentru toleranta la defecte) => formeaza un crossbar 4x4;
-adaptorul de comunicatii: pentru fiecare nod un adaptor ocupand un slot de

extensie de I/E al nodului, adaptorul cablat la placa de comutatoare in portul
corespunzator.
Exemplu: configuratie de switch-uri pentru 64 de noduri.
-in functie de utilizare placa de comutatoare:

-NSB (Node Switch Board): 16 porturi pentru conectarea nodurilor si 16
porturi pentru conectarea la switch-uri din alte frame-uri;
-ISB (Intermediate Switch Board): toate porturile utilizate pentru conectarea
la alte placi de comutatoare
Sistem cu 96/128 de noduri
Protocoale de comuncatie la switch-uri

-US (User Space Protocol): performante mai bune;
-IP (Internet Protocol): mai lent, utilizat pentru comunicatii de job-uri care implica sisteme
IBM SP multiple.
Performantele comunicatiei:
CWS
-utilizat de administratorul sistemului pentru monitorizare, intretinere si control;
-nu face parte din sistemul SP;
-este un RISC System / 6000;
-se conecteaza la fiecare frame prin:

-linie seriala RS232C;
-LAN Ethernet extern;
CWS: punct singular de cadere pentru intregul sistem SP => HACWS (High
Availibility CWS), cu doua CWS (primar si backup) !
Software
-S.O. AIX (Unix System V);
-fiecare nod SP -> copia sa AIX (o singura copie partajata de toate procesoarele SMP
ale nodului);
-Parallel Environment (IBM) => mediul de dezvoltare pentru sistemele IBM SP
(C/C++ si Fortran);
-biblioteci matematice:
-ESSL (Engineering Scientific Subroutine Library);
-PESSL (Parallel ESSL, subset cu partea paralela a bibliotecii);
-MASS (Math Acceleration Subsystem, continand versiunile de mare
performanta ale celor mai multe functii intrinseci, cu versiune scalara si versiune
vectoriala).
Blue Gene/L
Blue Gene = supercalculator masiv paralel bazat pe tehnologia IBM sistem-peun-cip (SoC: system-ona-chip).
-configuratie maxima : 65536 noduri biprocesor, performanta de 360 TFLOPS.
-tehnologie de integrare de nivel foarte inalt;
-experienta altor sisteme de scop special (exemplu: QCDSP quantum
chromodynamics on digital signal processors): foarte bun raport performanta/cost
pentru un domeniu restrans de probleme.
Criterii avute in vedere la proiectare:

1) consum scazut de putere.
Eficienta pe unitatea de putere consumata:
(albastru=IBM, negru=alte masini SUA, rosu=masini Japonia)
Un supercalculator cu procesoare conventionale de 360 Tflops => consuma aproximativ

10-20 MW.
2) reteaua de interconectare => scalare eficienta (din p.d.v. al performantei si

impachetarii). Reteaua:
-mesaje foarte mici (pana la 32 de octeti);
-suport hardware pentru operatii colective (broadcast, reducere, etc.)
3) sistemul software si monitorizarea => modelul de programare transfer de
mesaje, cu memorie distribuita (biblioteca MPI, disponibila in limbajele C, C++ si
Fortran).
Sistemul destinat in mod special unor aplicatii:
-simularea fenomenelor fizice;
-prelucrarea datelor in timp real;
-analiza offline de date.
Componentele sistemului
-maxim 65536 de noduri, fiecare nod = ASIC cu doua procesoare si 9 DDRSDRAM-uri (maxim 18);
-nodurile interconectate prin cinci retele (c. m. importanta: retea tor
tridimensionala 64x32x32);
-interconectarea este virtual simetrica (un nod poate comunica cu nodurile
vecine de pe aceeasi placa sau intr-un alt dulap cu aceeasi rata si aproape aceeasi
latenta).
-impachetarea sistemului: 512 noduri de prelucrare cu o rata de varf de 5.6
Gflops pe o placa de 20x25 in (midplane).
Cele doua procesoare dintr-un nod pot opera intr-unul din doua moduri:
-virtual node mode: fiecare procesor isi gestioneaza comunicatiile proprii;
-communication coprocessor mode: un procesor este dedicat pentru
comunicatii si celalalt pentru calcule.
-noduri de I/E pentru comunicatia cu sistemul de fisiere;

-calculator host extern (sau chiar doua): pentru sistemul de fisiere, compilare,
diagnostic, analiza si service.
-gestionarea de utilizatori multipli simultan: partitionarea spatiului masinii astfel

incat fiecare utilizator sa dispuna de un set dedicat de noduri pentru aplicatia sa,
inclusiv resurse dedicate de retea. Partitionarea: prin cipuri de legatura (link chips).
Cip de legatura = ASIC cu doua functii:
-comanda semnalele prin cabluri intre placi, refacand forma semnalelor
distorsionate de cablurile lungi;
-redirectioneaza semnalele intre diferite porturi => partitionarea sistemului BG/L in
mai multe sisteme logice separate.
Link chip: 6 porturi;

-porturile A si B conectate direct la nodurile dintr-un midplane;
-porturile C, D, E si F conectate la cabluri => se pot conecta oricare doua
porturi intre ele.
O posibila partitionare a sistemului:
(liniile = cabluri conectand midplane-urile prin intermediul cipurilor de legatura,

partitiile utilizatorilor prin culori diferite)
Retelele Blue Gene/L

Tor 3D : pentru majoritatea aplicatiilor de transfer de mesaje (comunicarea
oricarui nod cu oricare nod). Fiecare nod conectat la sase vecini imediati.
Latenta hardware: 100 ns/nod => in configuratie max. 64K noduri (64x32x32)
in cazul c.m.defavorabil se tranziteaza 32+16+16 = 64 noduri => latenta = 6.4 s.
Retea colectiva ("collective network") se extinde peste intreaga masina BG/L:

-un nod -> toate (broadcast) sau un nod -> subset de noduri (latenta<5 s);
-fiecare legatura are o rata de 2.8 Gb/s (atat pentru transmisie cat si pentru
receptie).
-operatii intregi de reducere (min, max, suma, sau-biti, si-biti, sau-ex-biti)
implementate cu hardware aritmetic si logic inclus in reteaua colectiva => cresterea
vitezei de executie (intarzieri < de zeci-100 de ori decat in alte supercalculatoare tipice)
a aplicatiilor cu operatii colective (exemplu: insumare globala).
Reteaua colectiva:
-pentru broadcast (mai performant decat daca s-ar utiliza reteaua tor);
-operatie de adunare in virgula mobila, dar in doua treceri (necesita 10 s): la

primul pas se obtine maximul dintre exponenti, iar la al doilea pas se insumeaza toate
mantisele deplasate;
-transferarea fisierelor catre nodurile de I/E (identice cu nodurile procesor, cu
diferenta ca reteaua Gigabit Ethernet este conectata in exterior la plasa de switch-uri
externe utilizate pentru conectivitatea sistemului de fisiere);
-routarea este statica (fiecare nod contine o tabela statica de routare);
-hardware-ul suporta doua canale virtuale permitand operatii de evitare a
blocarii intre doua comunicatii independente.
Reteaua bariera (barrier network):

-micsoreaza considerabil intarzierea in cadrul operatiilor globale;
-contine patru canale independente -> functie logica globala peste toate
nodurile;
=> semnalele individuale de la noduri sunt preluate in hardware si
propagate in cadrul unei structuri de tip arbore catre radacina, iar rezultatul este
propagat inapoi la noduri:
-operatie SI globala = bariera globala;
-operatie SAU globala = intrerupere globala cand intreaga masina sau
numai un subset trebuie oprit (exemplu: pentru diagnostic);
-pentru 64 k noduri intarzierea 1.5 s.
Reteaua sistem de control (control system network):

-in configuratia de 64 k noduri contine peste 250.000 de dispozitive terminale
(ASIC-uri, senzori de temperatura, surse de curent, diode luminiscente, ventilatoare,
etc) => trebuie monitorizate.
-monitorizarea cu un calculator extern (nod de serviciu), parte a calculatorului
gazda;
-accesul nodului de serviciu la dispozitivele terminale: prin retea intranet
bazata pe Ethernet. Cu un FPGA pachetele Ethernet sunt convertite in format serial
JTAG pentru accesul la fiecare nod => control simplu si eficient. JTAG permite accesul
chiar si la registrele fiecarui procesor prin rularea pe host a software-ului IBM Risc
Watch.
JTAG (Joint Test Action Group) este standardul IEEE 1149.1 (standard numit
si Standard Test Access Port and Boundary-Scan Architecture).
Interfata JTAG : 4/5 pini adaugati unui cip => cipuri multiple de pe o placa avand
inlantuite liniile lor JTAG pot fi testate pe baza unui protocol serial prin conectarea
numai la un singur port JTAG a dispozitivului de test. Pinii portului sunt:
-TDI (Test Data In)
-TDO (Test Data Out)
-TCK (Test Clock)
-TMS (Test Mode Select)
-TRST (Test Reset) optional.
Reteaua Ethernet Gigabit

-nodurile de I/E au interfata Ethernet Gigabit -> accesul la switch-urile
Ethernet externe;
-switch-urile: conectivitate noduri de I/E - sistem de fisiere extern;
-numarul de noduri de I/E este configurabil, cu un raport maxim:
(noduri de I/E) / (noduri de calcul) = 1:8
-daca se configureaza sistemul la un raport de 1:64 => 1024 noduri de I/E =>
rata de transfer > 1 Tb/s.
Nodul Blue Gene/L

-se bazeaza pe BLC ASIC (SoC cu proces 130 nm CMOS), continand: doua
core-uri IBM PowerPC 440 (PPC440), un core virgula mobila pentru fiecare procesor,
controller integrat de memorie DDR externa, adaptor Gigabit Ethernet si toate
controalele si bufferele retelelor colectiva si tor;
-cele doua procesoare sunt simetrice (ca design, performanta si acces la

resurse);
-in aplicatii cu transfer simplu de mesaje se pot utiliza ambele procesoare
(aplicatii cu raport crescut calcule/I-E sau cele avand comunicatii cu vecinii imediati);
-in alte aplicatii un procesor dedicat transferului de mesaje, iar celalalt pentru
calcule.
-Double hummer FPU = doua unitati FPU => performanta de varf de patru
operatii v.m./ciclu;
-PPC440 = implementare performanta superscalara a arhitecturii de 32 biti
Book-E Enhanced PowerPC Architecture, la 700 MHz (1.4 G operatii/sec) si 2.8
Gflops. Caracteristici:
-microarhitectura in banda de asamblare 7 segmente;
-fetch instructiuni dual;
-planificare out-of-order;
-predictie dinamica a ramificatiilor pe baza unei tabele BHT (branch
history table);
-trei benzi de asamblare independente: banda load/store, banda simpla
intregi si banda combinata intregi, sistem si ramificatie;
-fisier 32x32 de registre de scop general (GPR), cu 6 porturi de citire
si 3 porturi de scriere;
-unitati de inmultire si inmultire-adunare cu rata de un singur ciclu;
-cache-uri L1 independente de 32 KB de date si cod, avand linie
(bloc) de 32 octeti si asociativitate de dimensiune 64, suportand functionare in mod
write-back si write-through;
-trei interfete independente de 128 de biti pentru citire instructiuni,
citire date si scriere date (processor local bus PLB).
PPC440
Sistemul de memorie
-ierarhia de cache pe-cip, memorie principala externa cipului si suport pe-cip
pentru comunicatia intre cele doua procesoare. Pentru BG/L de 64 k noduri fiecare nod
are 512 MB de memorie fizica (partajata intre cele doua procesoare), in total 32 TB.
-cache-ul L1 in core-ul PPC440;

-L2 (L2R si L2W) este foarte mic (2KB): serveste ca buffere prefetch si write-back
pentru datele L1;
-L3 este mare (4MB) => rata mare si latenta de acces mica;
-memoria principala:DDR-SDRAM .
Software
Schema arhitecturala de nivel inalt:
-65536 noduri de calcul si 1024 noduri de I/E;

-reteaua Gigabit Ethernet (functionala) conecteaza blocul de calcul la:
-un nod de serviciu (pentru controlul masinii);
-nodurile front-end (unde utilizatorii compileaza, lanseaza si interactioneaza cu
aplicatiile lor);
- servere paralele de fisiere;
-reteaua Gigabit Ethernet (control): nod de serviciu - bloc de calcul (control direct al
hardware-ului);
-nodurile de calcul: impartite in 1024 seturi logice de prelucrare ( psets - processing
sets);
-pset = un nod de I/E (Linux) si 64 noduri calcul (ruland un nucleu CNK custom
compute node kernel);
-asignarea nodurilor de calcul la un nod de I/E este flexibila si chiar raportul noduri I/E
/ noduri calcul poate varia intre 1:8 si 1:128.
Din p.d.v. software masina se poate imparti in : volum de calcul, arie functionala si arie
de control, fiecare cu hardware dedicat (asemanator cu ASCI Red).
Volumul de calcul:
-implementat prin nuclee si biblioteci runtime pentru nodurile de calcul
(executia aplicatiilor utilizator);
-nodurile de calcul vazute ca atasate la nodul de I/E (coordonator pset).
Aria functionala:
-compilarea aplicatiilor, lansarea si controlul joburilor, depanarea aplicatiilor si
operatiile de I/E la rularea aplicatiilor;
-implementarea ariei functionale: software de sistem ruland pe nodurile de I/E,
nodurile front-end si nodul de serviciu.
Aria de control:
-implementata exclusiv in nodul de serviciu;
-executa operatii de tipul: lansarea masinii (booting), monitorizarea datelor
de mediu (temperatura, tensiune), raportarea erorilor critice.
Software-ul sistem pentru nodurile de I/E

-nodurile de I/E ruleaza Linux -> roluri importante in sistem:
-lansarea joburilor si controlul in pset-urile lor;
-reprezinta dispozitivele de incarcare primare pentru majoritatea serviciilor
sistem cerute de rularea aplicatiilor;
-Linux pentru procesoarele PPC440 (modificari in secventa de boot, gestionarea

intreruperilor, planul de memorie, suportul de FPU si drivere de dispozitive);
-pe fiecare nod de I/E ruleaza un daemon CIOD (control and I/O daemon):
lansarea programelor, semnalizarea, terminarea si transferul de fisiere prin intermediul
mesajelor punct la punct prin reteaua colectiva.
Software-ul sistem pentru nodurile de calcul

-nodurile de calcul: ruleaza un nucleu minim single-user, dual-threaded (cate
un fir de executie per procesor) CNK (compute node kernel);
-CNK prezinta o interfata POSIX (Portable Operating System Interface
Standard);
-suport pentru apelurile sistem privind transferurile I/E de fisiere;
-operatiile de I/E nu sunt executate direct de CNK: acestea sunt transferate
catre CIOD din nodul de I/E a pset-ului, iar rezultatele sunt primite inapoi.
Software-ul de transfer de mesaje pentru comunicarea intre procesele de
aplicatie ruland pe noduri de calcul -> trei niveluri:
-nivelul pachet: o biblioteca mica furnizand functii pentru accesul direct la
hardware-ul de retele BG/L;
-nivelul mesaj: sistem de livrare de mesaje punct la punct cu intarziere mica si
banda larga de transfer;
-nivelul aplicatie: MPI.
Software sistem pentru nodurile front-end

-nodurile front-end: singurele la care se pot loga utilizatorii;
-contin compilatoare si depanatoare;
-furnizarea joburilor (lansarea - de catre nodul de serviciu);
-disponibil setul de tool-uri GNU;
-suport de optmizari avansate pentru Fortran 90, C si C++;
-compilatoarele suporta generarea automata de cod pentru exploatarea FPU
SIMD cu doua cai (atasata fiecarui procesor din nodul de calcul).
Software-ul sistem din nodul de serviciu
-nodul de serviciu: sistem de operare global CMCS (core management and

control system). Functii:
-ia toate deciziile globale si colective;
-interfateaza cu module de politica externa (ex: planificatorul de
joburi);
-executa o varietate de servicii de gestiune a sistemului (bootarea
masinii, monitorizarea sistemului si lansarea joburilor).
CMCS contine doua procese majore:
-MMCS (midplane monitoring and control system): utilzeaza reteaua de control
pentru manipularea directa a hardware-ului pentru configurare, initializare si operare;
-CIOMAN (control and I/O manager): utilizeaza Ethernetul functional pentru
interfatarea cu sistemele de operare locale in vederea executiei joburilor.
Operatiile MMCS peste reteaua de control:
-operatii hardware de nivel scazut: pornirea surselor, monitorizarea

senzorilor de temperatura si reactia corespunzatoare (inchiderea unei masini
daca temperatura trece de un anumit prag);
-configurarea si initializarea FPGA-ului de control, a cipurilor de
legatura si a cipurilor BG/L (cu procesoare).
-citirea si scrierea registrelor de configurare, SRAM si resetarea coreurilor unui cip BG/L
SISTEME CU TRANSPUTERE
-procesoare de tip transputer de la firma INMOS;
-familia de transputere: dispozitive VLSI -> sisteme de prelucrare concurente;

-limbaj occam;
-exemple:
-IMS T222 procesor pe 16 bii;
-IMS T414 i IMS T425 procesoare pe 32 de bii;
-IMS T800 procesor rapid pe 32 de bii (v.m.);
-IMS M212 controlor de periferice inteligent (procesor pe 16 bii, memorie pe
cip i legturi de comunicaie, cu logic pentru interfaarea de discuri sau periferice
generale);
-IMS C011 i IMS C012 adaptoare de legturi permind conectarea
legturilor seriale INMOS la porturi paralele sau magistrale
-IMS C004 comutator de legturi programabil ( reea gril de comutatoare cu
32 de intrri i 32 de ieiri).
Arhitectura simplificat a unui transputer
Interfaarea unei memorii

=> conectarea unei memorii la transputerul T414 (magistral pe 32 de bii, multiplexat
pentru date i adrese i un spaiu de adrese de 32 GB);
Semnalele asociate cu interfaa de memorie:
-notMemWrB0-3 (ieiri): comanda operaia de scriere;
-notMemRd (ieire): comand operaia de citire;
-notmemRf (ieire): comand operaia de remprosptare la DRAM;
-notMemS0-4 (ieiri): linii de strob configurabile (temporizare programabil);
-MemNotWrD0 (bidirecional): indicator de scriere / bitul 0 de date;
-MemNotRfD1 (bidirecional): indicator de remprosptare / bitul 1 de date;
-MemAD2-31 (bidirecionale): liniile de adrese i date;
-MemReq (intrare): linie de cerere extern;
-MemGranted (ieire): linie de acceptare a cererii externe;
-MemWait (intrare): permite introducerea de stri suplimentare de ateptare;
-MemConfig (intrare): permite introducerea informaiilor de configurare a
semnalelor cu temporizare programabil.
Schema de principiu pentru conectarea unei memorii la transputerul T414:
Conectarea legturilor INMOS

O legtur INMOS (link) = implementarea hardware a unui canal occam
(fiecare legtur bidirecional -> o pereche de canale occam, cte unul n fiecare sens).
-mesaj -> secven de octei;

-dup un octet de date, transmitorul ateapt o confirmare;
Protocolul legturii:
Exemplu: placa multitransputer IMS B003.
Reele de interconectare
=> comutatoare gril;
Exemplu: circuitul IMS C004 (crossbar switch 32x32).
-programare: legtur serial separat (legtur de configurare).
Tipuri de mesaje:
[0] [input] [output] : conecteaz input la output;
[1] [link1] [link2] : conecteaz LinkIn1 la LinkOut2 i LinkIn2 la LinkOut1;

[2] [output] : cere numrul intrrii care este conectat la output (IMS C004
rspunde cu numrul intrrii, iar bitul cel mai semnificativ indic conectat/deconectat);
[3] : ncheie o secven de configurare, iar circuitul este gata s accepte date pe
intrrile sale;
[4] : reseteaz circuitul, care astfel poate fi reprogramat;
[5] [output] : ieirea output este deconectat i inut la nivel logic cobort;
[6] [link1] [link2] : deconectez ieirea lui link1 i ieirea lui link2.
Soluia general de conectare a trei comutatoare (dimensiuni N-M/2, N-M/2 i

M) => un comutator de dimensiune N (N>M) :
Comutator de capacitate foarte mare <= mai multe comutatoare de capacitate M:
Condiie: existena a cel puin M ci ntre oricare comutator de intrare i

oricare comutator de ieire.
Soluia: bloc logic de interconectare = n comutatoare de dimensiune M.
=> comutator de dimensiune nM (nM).
Comutatoare de dimensiune M => comutatoare de dimensiune max. M2.

In general => comutator de dimensiune n(M-M mod n).
Utilizarea comutatoarelor IMS C004 pentru realizarea de comutatoare de
capacitate mare (3n comutatoare IMS C004 => comutator de dimensiune n(32-32 mod
n)) :
Reea de transputere complet conectat
Transputerul T9000
Caracteristici:
-a fost ultimul procesor din familie;
-superscalar pe 32 biti si unitate de v.m. pe 64 biti;
-procesor dedicat de comunicatie cu 4 legaturi (link-uri);
-interfata de memorie externa;
-16 KB de memorie pe cip;

-performanta de 200 MIPS si 25 MFLOPS.
Interfata de memorie (exemplu: 8 MB DRAM):
Interconectarea :
circuitul crossbar C104 (32x32) -> ruterul procesorului
T9000:
-conexiunile lucreaza la 100 Mb/s;
-permite rutarea "wormhole" (cand header-ul pachetului a ajuns la un link,
ruterul C104 determina link-ul de destinatie inainte sa receptionezez corpul principal al
mesajului);
Sistem MIMD cu transputere T9000

-propus de Barnaby, May si Nicole;
-complet interconectat, bazat pe o arhitectura Clos;
-doua niveluri de crossbar-uri => nu numai interconectare completa, dar chiar si cai
multiple intre procesoare.
MULTICALCULATOARE COW
Multicalculatoarele COW (Cluster Of Workstation) - clustere de staii de lucru.
Cluster = multe PC-uri / staii de lucru (sute) conectate ntr-o reea comercial.
Multicalculatoarele COW:
Sisteme COW centralizate:
-PC-urile montate ntr-un dulap, ntr-o singur camer;
-mainile sunt omogene;
-echipamente periferice: discuri i interfee de reea;
-calculatoare fr proprietar.
Sisteme COW descentralizate:

-PC-urile rspndite ntr-o cldire sau campus;
-calculatoarele sunt heterogene;
-set complet de periferice;
-cu proprietar.
Reele de interconectare comerciale pentru sistemele COW:

Ethernet, cu tipurile:
- clasic de 10 Mbps / 1.25 MB/s;
- fast de 100 Mbps/ 12.5 MB/s;
-gigabit de 1 Gbps/ 125 MB/s;
ATM (Asynchronous Transfer Mode):
-proiectat pentru sistemul telefonic;
-viteze de 155 Mbps i 622 Mbps;
-pachete de 53 de octei (5 octei informaii de identificare i 48 de
octei de date);
Myrinet:
-fiecare plac se conecteaz la un comutator;
-comutatoarele -> topologie oarecare;
-legturi duplex de 1.28 Gbps pe fiecare sens;
PCI Memory Channel:
-dezvoltat de Digital Equipment.
Reea Myrinet
Se consider un multicalculator COW cu staii de lucru UltraSparc

interconectate ntr-o reea Myrinet, dupa o topologie LAN arbitrara. Switch-urile pot fi
conectate la interfetele nodurilor si la alte switch-uri conducand la o topologie arbitrara:
Organizarea unui nod:

-placa de interfa de reea NIC (Network Interface Card) cu procesor Lanai
(controleaza fluxul de mesaje ntre procesorul principal i reea);
-SRAM : stocarea temporar a mesajelor, cod i date procesor Lanai;
-placa NIC : trei module DMA (intrare din reea, ieire n reea i transferuri
ntre procesorul principal i memoria NIC);
-comenzile pentru procesorul Lanai : scrise de procesorul principal n memoria
NIC;
-magistral intern a cipului Lanai.
PCI Memory Channel

-dezvoltat de Digital Equipment Corporation
-interfaa de comunicaie : plac de interfa de reea inserat ntr-un nod pe o
extensie de magistral de I/E;
-ideea memoriei reflective: stabilirea unei conexiuni ntre o regiune a spaiului
de adres a unui proces (regiune de transmisie) i o regiune de recepie din spaiul
altui proces => datele scrise n regiunea de transmisie s se reflecte (s se scrie i) n
regiunea de recepie a destinaiei !
-Memory Channel = NIC bazat pe magistala PCI, -> sistem multiprocesor
simetric cu procesoare Alpha. Module:
-cozi FIFO de transmisie i recepie;
-tabel de control a paginilor PCT (Page Control Table);
-mecanism DMA pentru recepie;
-controloare de transmisie i recepie.
Clustere Beowulf
-clusterele Beowulf = sisteme din categoria high performance parallel
computing;
-dezvoltat de Thomas Sterling si Donald Becker la NASA.
Cluster Beowulf = grup de PC-uri identice ruland un sistem de operare free
open source tip Unix (Linux, Solaris). Caracteristici:
-calculatoarele echipate cu placa de retea Ethernet cu protocol TCP/IP, legate
intr-o retea locala separata;
-dispun de programe si biblioteci (cele mai utilizate MPI, PVM) -> permit
partajarea lucrului;
-pe calculatoare ruleaza copii ale aceluiasi program (model SPMD);
-comunicatia: prin transfer de mesaje.
Beowulf: arhitectura multicalculator -> un nod server si unul sau mai multe noduri
client conectate prin retea Ethernet. Nu contine niciun hardware special!
Nodul server:
-controleaza intregul cluster;
-furnizeaza fisiere nodurilor client;
-este consola sistem si conexiune catre exterior.
Nodurile client:
-configurate si controlate de nodul server;
-executa numai actiunile comandate de server;
-in cazul unei configuratii fara disc, nodurile client nu cunosc adresele IP decat
dupa ce le-au fost furnizate de server.
Diferenta principala intre Beowulf si un sistem COW:

-Beowulf opereaza ca o singura masina, nu ca un set de statii de lucru;
-Beowulf dispune de propria sa retea locala dedicata pentru comunicatia intre
noduri;
-nodurile client nu au tastatura si nici monitor si pot fi accesate numai prin
retea din nodul server.
In cazul sistemelor mari: mai multe noduri server si eventual noduri cu functii dedicate
(monitorizare sistem, consola, etc):
PROGRAMAREA MULTICALCULATOARELOR
OCCAM
Aplicatii paralele pe hipercub
MPI
PVM
32LB5700
CARACTERISTICI ALE PROGRAMARII

MULTICALCULATOARELOR
-nu exista spatiu unic de adresa (programarea fara memorie partajata);
-programul paralel se executa ca o multime de procese concurente, numai cu
memorie locala;
-comunicatia intre procese se face prin transfer de mesaje (operatie send
dintr-un proces <-> operatie receive a altui proces);
-nu exista variabile partajate (fara mecanisme de protectie a accesului la
acestea).
Limbaje de programare in transfer de mesaje:
-limbaje secventiale (Pascal, C, Fortran) cu extensii pentru transmisia si
receptia mesajelor;
-limbaje de programare paralela speciale: Ada, Occam, Linda, Orca, SR,
Parlog, Emerald, etc.
Biblioteci de comunicatie:
-PVM: Parallel Virtual Machine;
-MPI: Message Passing Interface.
LIMBAJUL OCCAM
-realizat de INMOS pentru programarea transputerelor;
-bazat pe limbajul CSP (Communicating Sequential Processes);
-algoritm paralel -> colectie de procese asincrone, care comunica prin canale;
-canalul = entitate abstracta de comunicatie, punct la punct, directionata,
sincrona si fara buffer intre doua procese paralele.
Procese fundamentale:
-asignare:
variabila := expresie
-citire dintr-un canal de comunicatie:
canal ? variabila
-scriere intr-un canal de comunicatie:
canal ! expresie
-orice alt proces = structura ierarhica de subprocese;

-subproces = colectie de procese mai simple executate in serie sau in paralel pe acelasi
transputer sau pe transputere diferite;
-procesele: create static (nu se pot crea dinamic) in momentul compilarii.
Operatori de constructie (constructori) pentru definirea proceselor complexe:

-SEQ creaza un proces complex dintr-un numar de procese minore care se vor
executa secvential:
SEQ
proces_1
proces_2
proces_3
........
proces_n
-PAR creaza un proces complex care lanseaza executia paralela a mai multor
procese:
PAR
proces_1
proces_2
proces_3
........
proces_n
-IF creaza un proces complex care lanseaza in executie unul din procesele
componente, corespunzand primei conditii adevarate (testarea se face in ordinea scrierii
conditiilor):
IF
conditie_1
proces_1
conditie_2
proces_2
conditie_3
proces_3
........
conditie_n
proces_n
-ALT creaza un proces complex care lanseaza in executie un singur proces

corespunzand primului canal de intrare care este gata de comunicatie:
ALT
canal_1 ? x
proces_1
canal_2 ? x
proces_2
canal_3 ? x
proces_3
...........
canal_n ? x
proces_n
Ordinea specificarii canalelor nu conteaza, selectia se face in functie de momentul de

timp cand canalul este gata de comunicatie.
-nu se pot defini variabile partajate intre doua procese (chiar daca procesele se
executa pe acelasi transputer).
=> Canalele de comunicatie Occam sunt sincrone si fara buffer:
(procesele A si B fac parte din componentele unei constructii PAR).
Aplicatie: calculul unei aproximatii a numarului :
4
0 1 x 2 dx 4(arctg (1) arctg (0))
=> prin integrare numerica (inaltimea fiecarui dreptunghi este valoarea functiei in
mijlocul subintervalului respectiv).
Algoritmul secvential:
#define n . . . . .
sum = 0.0;
w = 1/n;
for (i=0; i<n; i++) {
x = (i+0.5)*w;
sum += 4/(1+x*x);
}
sum *=w;
=> Timpul de calcul este O(n).
Se considera o retea de p transputere inlantuite, primul transputer fiind conectat la

calculatorul gazda:
=>fiecarui transputer: n/p subintervale pentru suma ariilor dreptunghiurilor. Etape:
1)fiecare transputer calculeaza secvential si insumeaza n/p arii;

2)fiecare transputer primeste de la vecinul dreapta suma partiala, o insumeaza
cu propria valoare si o trimite la vecinul stanga, astfel incat se obtine rezultatul in nodul
0.
VAL
VAL
[p]
INT
SEQ
INT p IS 8:
INT n IS 1024:
CHAN OF REAL chan:
s:
--vector de canale
s:=n/p
PAR i=0 FOR p-1
--vector de procese paralele
REAL x, partial_sum, w:
SEQ
partial_sum:=0.0
w:=1/n
x:=((i*s)+0.5)*w
SEQ j=0 FOR s-1
SEQ
partial_sum:=partial_sum+(4/(1+x*x))
x:=x+w
partial_sum=partial_sum*w
--transferul sumelor partiale si acumulare in procesorul 0

IF
i=p-1
chan[p-1] ! partial_sum
i<p-1
SEQ
REAL sum:
chan[i+1] ? sum
chan[i] ! sum+partial_sum
APLICATII PARALELE PE UN HIPERCUB

Algoritmi pe un hipercub
Structura hipercub -> implementarea unui numar mare de algoritmi necesitand

comunicatii all-to-all.
Sablon: un formular de program care poate fi completat cu informatii specifice
aplicatiei pentru implementarea unui algoritm paralel.
Hipercubul conecteaza fiecare din toate cele P taskuri (procesoare) la log2P alte taskuri.
-model SPMD;
-initial: o variabila de stare <- o data furnizata la intrare;
-log2P pasi;
-la fiecare pas fiecare task:
-schimba starea locala cu unul din vecini;
-combina mesajul primit de la vecin cu starea curenta -> starea urmatoare;
=> rezultatul: starea generata la pasul final.
procedure hypercube (myid, input, logp, output)

begin
state=input
//starea locala init cu input
for i=0,logp-1
//repeta de logp ori
dest=myid XOR 2i
//determina vecinul
send state -> dest
//schimba datele
receive message <- dest
state=OP(state,message) //executa operatia
endfor
output=state
//rezultatul final
end
Implementarea unui algoritm particular: prin definirea operatiei OP.
Reducere de vector
Algoritmul pecedent se poate utiliza pentru o reducere de vector utilizand orice
operator comutativ asociativ (ex: adunare, maxim, inmultire).
Reducerea a patru vectori de lungime N=4 distribuiti la patru taskuri => algoritmul in
log24=2 pasi. La fiecare pas fiecare task:
-executa schimbul a N date cu un vecin;
-realizeaza N operatii de combinare.
In cazul general de reducere vectoriala fiecare task dintre P taskuri:

-furnizeaza un vector de N valori;
-executa N operatii separate de reducere;
=> vector de N rezultate. Reducerea: in log2P pasi.
Timpul necesar:
Treducere = log2P (ts + N (tw + top))
unde
-top = timpul cerut de operatia de reducere;
-tw = timpul de comunicatie;
-ts = timpul de lansare (start-up).
Algoritmul este eficient pentru valori mici ale lui N (cand predomina timpul de lansare).
Varianta a algoritmului: algoritm recursiv cu injumatatire => reducerea semnificativa a

volumului mesajelor comunicate. Algoritmul aplicat de doua ori: in faza de reducere
fiecare procesor comunica si combina N/2 date in prima iteratie, apoi jumatate N/4 in a
doua, etc. => fiecare procesor comunica in total N(P-1)P date in log2P pasi. Se obtine
suma globala, iar vectorul rezultat de N componente este uniform distribuit la cele P
procese.
Timpul consumat:
Treducere recursiva t s 2 log 2 P (t w 2 top ) N
P 1
P
Solutia trimite de doua ori mai multe mesaje, dar cu mai putine date si face mai putine
calcule => mai eficient pentru anumite valori ale lui N si P, si pe anumite masini.
Broadcast
Similar: se poate defini un algoritm eficient de broadcast. N valori localizate in nodul
radacina sunt transmise la toate cele P-1 noduri, utilizand un arbore binar de
comunicatie.
Timpul necesar:
Tbroadcast = log2P (ts + twN)
Algoritmul: eficient pentru valori mici ale lui N si P.
Pentru valori mari ale lui N si P multe procesoare sunt inactive cea mai mare parte a
timpului si Tbroadcast este dominat de log2P twN.
=> mai eficient sa se sparga mesajul in componente mai mici si sa se routeze
componentele separat prin reteaua hipercub. Timpul necesar :
Tbroadcast = 2(ts log2P + twN)
Transpunerea de matrici.
Matricea A de transpus si transpusa A' sunt distribuite printre procese => executia
algoritmului implica comunicatii.
Se considera o descomunere pe coloane a celor doua matrici repartizate proceselor
=> comunicatii all-to-all.
Algoritmul comun: P-1 pasi. La fiecare pas fiecare task: interschimba N2/P2 date cu un
alt task.
Timpul necesar:
Ttranspunere simpla
N2
t s ( P 1) t w ( P 1) 2
P
N=P=8 => log2P pasi. Fiecare proces are o singura coloana din A, iar in final fiecare va
avea o singura linie din A'.
La fiecare pas fiecare proces: schimba din datele sale (reprezentate umbrit in desen).
In partea a doua a desenului: sursele componentelor detinute de procesul 0, la fiecare
pas al algoritmului.
Procesele sunt partitionate in doua seturi: taskurile corespunzatoare din cele doua seturi
interschimba dintre datele lor: taskurile 0p/2-1 comunica jumatatea inferioara a
datelor lor, iar taskurile P/2P-1 comunica jumatatea superioara. Aceasta partitionare
si interschimb se repeta pana cand fiecare set contine un singur task.
Daca fiecare dintre cele log2P mesaje are dimensiunea N2/(2P) timpul necesar este:
N2
Ttranspunere hipercub t s log 2 P t w log 2 P
2P
Algoritmul hipercub transmite aprox. P/log2P mai putine mesaje, dar de (log2P)/2 ori
mai multe date.
Algoritmul hipercub: eficient in probleme mici cu timp de lansare mare si timp de
transfer mic!
Sortare
Algoritm de sortare "mergesort" pentru N valori (multiplu al numarului de procesoare
P=2d). Algoritmul secvential:
daca lungimea secventei de intrare <2 atunci return
partitioneaza secventa de intrare in doua jumatati
sorteaza cele doua subsecvente utilizand acelasi algoritm
fuzioneaza cele doua subsecvente sortate => secventa de iesire
Exemplu:
Timpul necesar: O(N log2N).

Solutia paralela: necesita doi algoritmi: "compare-exchange" si "parallel merge".
Compare-exchange:
-ambele taskuri A si B contin M valori si in final, toate elementele din A sunt
elementele din B;
-fiecare task trimite datele sale la celalalt task;
-taskul A identifica M elemente cele mai mici, iar restul le descarca (necesitand intre
M/2 pana la M comparatii);
-taskul B identifica M elemente cele mai mari, iar restul le descarca .
Exemplu: M=4.
Parallel Merge. Un algoritm parallel merge" executa o operatie de fuzionare

peste doua secvente de lungime M2d, fiecare distribuita peste 2d taskuri pentru a
produce o secventa singulara sortata de lungime M2d+1 distribuita peste 2d+1 taskuri.
Aceasta se obtine prin utilizarea sablonului de comunicatie hipercub.
Exemplu: algoritmul paralel merge-sort in hipercuburi:
Intr-un hipercub de dimensiune d fiecare task executa d operatii de comparatie si

interschimb. Sagetile orientate de la taskul "high" catre taskul "low" in fiecare
interschimb.
Fiecare din cele 2d+1 taskuri se implica in d+1 pasi compara-interschimba, cate un pas
cu fiecare vecin. Fiecare nod executa algoritmul general, aplicand la fiecare pas i
urmatorul operator:
if ( myid AND 2i > 0 ) then ////daca eticheta are 1 in pozitia i
state = compare_exchange_high(state,message)
else
state = compare_exchange_low(state,message)
endif
Operatorul logic AND este utilizat pentru a determina daca taskul este "high" sau "low"
intr-un interschimb particular, iar myid si i sunt ca in algoritmul general.
Mergesort. Algoritmul parallel mergesort" (fiecare task):

procedure parallel_mergesort(myid, d, data, newdata)
begin
data = sequential_mergesort(data)
for dim = 1 to d
data = parallel_merge(myid, dim, data)
endfor
newdata = data
end
-fiecare task sorteaza secventa sa locala utilizand mergesort secvential;
-utilizand structura de comunicatie hipercub: fiecare dintre cele P=2d taskuri executa
algoritmul mergesort paralel de d ori pentru subcuburi de dimensiune 1..d;
-fuziunea paralela numarul i: ia doua secvente fiecare distribuita peste 2i-1 taskuri si
genereaza o secventa sortata distribuita peste 2i taskuri;
-dupa d astfel de fuziuni se obtine o singura lista distribuita peste 2d taskuri.
Analiza performantei. Numarul total de operatii comparatie-interschimb este:
d (d 1)
i
2
i 1
d
Fiecare operatie de comparatie-interschimb necesita un mesaj continand N/P date

=> timpul necesar de comunicatie per procesor:
Tcomunicatie
d (d 1)
N d (d 1)
ts
tw
2
P
2
sunt cuprinse sortarea initiala din procesor (implica Nlog2(N/P) comparatii) si

comparatiile executate in timpul fazei de comunicatie (cel putin Nd(d+1)/2 comparatii)
=> timpul total pentru cele P procesoare:
N d (d 1)
d (d 1)
Tcomp tc N log 2
tc N log 2 N
P
2
2
Algoritmul perfect echilibrat

=> se presupune ca timpii inactivi sunt neglijabili. Astfel:
Tcomp
P
Tcomunicatie
N
d (d 1)
d (d 1)
N d (d 1)
tc log 2 N
tw
ts
P
2
2
P
2
N (log 2 P) 2
N
tc
ts tw
P
2
2P
daca (log 2 P) 2 log 2 N
Programarea aplicatiilor paralele pe nCUBE-2

nCUBE-2 ( de la nCUBE Corporation) cu 8192 de noduri (procesor RISC, 32
biti, 64 MB memorie) conectate in retea hipercub.
Primitivele de transfer de mesaje in reteaua hipercub -> C si Fortran.
Transmisia (neblocanta) de mesaje:
int nwrite (char * buffer, int dim, int address, int type);
unde:
type: tipul de transfer de mesaje (sincron sau asincron);
buffer: adresa de memorie (in procesul care executa functia) de unde se
transmite mesajul;
dim: lungimea mesajului;
address: adresa de destinatie a mesajului (un nod, grup de noduri la
"multicast", toate nodurile la "broadcast").
Receptia (blocanta):
int nread (char * buffer, int dim, int source, int type);
Identificarea nodului curent (in care se desfasoara executia functiei):

void whoami (int * node, int * res1, int *res2, int *cube);
unde:
node: pointer la variabilele in care whoami depune numarul (eticheta) nodului;

cube: pointer la variabila in care se depune dimensiunea subcubului alocat
programului curent;
res1, 2: nu se utilizeaza.
Proiectarea algoritmului:
-se partitioneaza programul intr-un numar de procese;
-se distribuie aceste procese nodurilor sistemului.
Exemplu: calculul aproximatiei numarului .

/*functia de transfer de mesaje in hipercub*/
void fan_in (float *value, int node, int d) {
int dest, i, source, type;
float temp;
type=FANIN;
for (i=d-1; i>=0; i--)
if (node<(1<<i)) {
//00..00XX..X 0 in pozitia i
source=node^(1<<i);
nread (&temp, sizeof(float), &source, &type);
*value+=temp;
}
else
if (node<(1<<(i+1))) {
//00..01XX..X
dest=node^(1<<i);
nwrite(value,sizeof(float),dest, type);
}
}
/*functia principala a programului*/

void main (int argc, char *argv[]) {
#define n 1024
int i;
int d;
/*dimensiunea hipercubului*/
int p;
/*numar de noduri*/
int node; /*eticheta nodului curent*/
int s; /*numar de subintervale/procesor*/
float x;
/*mijloc dreptunghi pe axa x*/
float w=1/n;
/*latimea intervalului*/
int res1, res2;
float sum;
whoami (&node, &res1, &res2, &d);
p=1<<d; /*2 la puterea d*/
s=n/p; /*se presupune n divizibil cu p*/
sum=0.0;
x=((node*s)+0.5)*w;
for (i=node*s; i<(node+1)*s; i++) {
sum+=4/(1+x*x);
x+=w;
}
fan_in (&sum, node, d);
if (node==0)
/*rezultat nodul 0*/
printf ("Aproximatia numarului pi este %f\n", sum);
}
Etape:
-fiecare nod calculeaza un rezultat partial pentru n/p subintervale (n = numar
total de subintervale, p = numar de procesoare);
-etapa de comunicatie pentru calcularea sumei finale.
Fiecare nod:
-executa functia main (fiecare nod are o copie) -> calcule locale;
-apeleaza functia de transfer de mesaje fan_in.
p procesoare => subcub d-dimensional (apel functie whoami: p = 2d).
Rezultatul final (suma rezultatelor partiale in p noduri) => nodul 0 (00...0).
Comunicatia in hipercub:
Performante. Fiecare procesor executa n/p pasi pentru rezultatul partial, iar
comunicatia necesita log2p pasi:
-timpul de executie:
n
T p O ( log 2 p )
p
-accelerarea:
S O
1 p log 2 p
-eficienta:
E O
1 p log 2 p
BIBLIOTECA MPI
-biblioteca de functii C sau subrutine Fortran => comunicatia
intre procese;
Avantaje:
-portabilitatea codului sursa;
-implementari eficiente pe o varietate de platforme
(inclusiv Unix si Windows NT/XP);
-functionalitate (tipuri diferite de comunicatie, tipuri
de date definite de utilizator, topologii definite de utilizator);
Forma generala a unui program MPI:

include fisiere header MPI
declaratii variabile
initializarea mediului MPI
executa operatii si transfer de mesaje
incheie mediu MPI
=> functiile MPI: rezultat intreg = cod succes / insucces;

daca cod MPI_SUCCESS => eroare!
Comunicatori
-transferul de mesaje intre procese: in cadrul unor comunicatori.
-comunicator initial predefinit: MPI_COMM_WORLD (cuprinde toate procesele)
-se pot defini noi comunicatori;

-in cadrul unui comunicator fiecare proces are un identificator (rank);
-un proces poate sa apartina la mai multi comunicatori in acelasi timp, cu
identificatori diferiti.
Functii pentru gestiunea mediului MPI

MPI_Init (&argc,&argv)
initializeaza mediul MPI, unde parametrii functiei reprezinta argumentele liniei de

comanda.
MPI_Comm_size (comm,&size)
furnizeaza pentru comunicatorul comm numarul de procese componente size.

MPI_Comm_rank (comm,&rank)
furnizeaza identificatorul procesului care a apelat-o (rank) in cadrul
comunicatorului (comm).
MPI_Finalize ()
incheie mediul de executie MPI.
Exemplu: utilizarea unor functii de gestiune a mediului MPI.
#include "mpi.h"
#include <stdio.h>
int main(int argc,char *argv)
{
int numtasks, rank, rc;
rc = MPI_Init(&argc,&argv);
if (rc != MPI_SUCCESS) {
printf ("Error starting MPI program. Terminating.\n");
MPI_Abort(MPI_COMM_WORLD, rc);
}
MPI_Comm_size(MPI_COMM_WORLD,&numtasks);
MPI_Comm_rank(MPI_COMM_WORLD,&rank);
printf ("Number of tasks= %d My rank= %d\n", numtasks,rank);
/******* do some work *******/
MPI_Finalize();
return 0;
}
Comunicatii punct-la-punct
=> comunicatie punct-la-punct: un proces transmite (executa send) si al

doilea receptioneaza (executa receive).
Functiile utilizate pentru transmisie sunt:
Functiile utilizate pentru receptie sunt:
Pentru comunicatia blocanta standard se utilizeaza la transmisie:

MPI_Send (&buf,count,datatype,dest,tag,comm)
care, transmite din zona buf, count date de tipul datatype la procesul destinatie dest,
din cadrul comunicatorului comm, mesajul avand identificatorul tag.
Pentru receptie:
MPI_Recv (&buf,count,datatype,source,tag,comm,&status)
datele fiind recptionate in zona buf la procesul care a apelat functia, in lungime
count de tipul datatype, de la procesul sursa source din cadrul comunicatorului comm,
mesajul avand identificatorul tag. Informatii de stare pentru mesajul receptionat sunt
depuse la status.
Exemplu: utilizarea functiilor de transmisie / receptie blocante.

#include "mpi.h"
#include <stdio.h>
int main(int argc,char *argv[]) {
int numtasks, rank, dest, source, rc, count, tag=1;
char inmsg, outmsg='x';
MPI_Status Stat;
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (rank == 0) {
dest = 1;
source = 1;
rc = MPI_Send(&outmsg, 1, MPI_CHAR, dest, tag, MPI_COMM_WORLD);
rc = MPI_Recv(&inmsg, 1, MPI_CHAR, source, tag, MPI_COMM_WORLD, &Stat);
}
else if (rank == 1) {
dest = 0;
source = 0;
rc = MPI_Recv(&inmsg, 1, MPI_CHAR, source, tag, MPI_COMM_WORLD, &Stat);
rc = MPI_Send(&outmsg, 1, MPI_CHAR, dest, tag, MPI_COMM_WORLD);
}
rc = MPI_Get_count(&Stat, MPI_CHAR, &count);
printf("Task %d: Received %d char(s) from task %d with tag %d \n",
rank, count, Stat.MPI_SOURCE, Stat.MPI_TAG);
MPI_Finalize();
return 0;
}
Transmisia si receptia neblocante:

-faza de initiere a operatiei;
-faza de asteptare pentru terminarea operatiei.
Initierea transmisiei:
MPI_Isend (&buf,count,datatype,dest,tag,comm,&request)
Initierea receptiei:
MPI_Irecv (&buf,count,datatype,source,tag,comm,&request)
(parametrii asemanatori cu functiile blocante).
Pentru incheierea unei operatii de transmisie sau receptie fara blocare:
MPI_Wait (&request,&status)
functie blocanta si
MPI_Test (&request,&flag,&status)
functie neblocanta pentru o singura cerere transmisie / receptie
MPI_Waitall
functie blocanta si
(count,&array_of_requests,&array_of_statuses)
MPI_Testall
(count,&array_of_requests,&flag,&array_of_statuses)
functie neblocanta pentru mai multe cereri.
Exemplu: comunicatie punct-la-punct neblocanta.
#include "mpi.h"
#include <stdio.h>
int main(int argc,char *argv) {
int numtasks, rank, next, prev, buf[2], tag1=1, tag2=2;
MPI_Request reqs[4];
MPI_Status stats[4];
prev = rank-1;
next = rank+1;
if (rank == 0) prev = numtasks - 1;
if (rank == (numtasks - 1)) next = 0;
MPI_Irecv(&buf[0], 1, MPI_INT, prev, tag1, MPI_COMM_WORLD, &reqs[0]);
MPI_Irecv(&buf[1], 1, MPI_INT, next, tag2, MPI_COMM_WORLD, &reqs[1]);
MPI_Isend(&rank, 1, MPI_INT, prev, tag2, MPI_COMM_WORLD, &reqs[2]);

MPI_Isend(&rank, 1, MPI_INT, next, tag1, MPI_COMM_WORLD, &reqs[3]);
{
executa secventa de operatii
MPI_Waitall(4, reqs, stats);

MPI_Finalize();
return 0;
}
Comunicatii colective
-un numar mai mare de procese comunica intre ele in diferite moduri;
-avantaje in raport cu operatiile punct-la-punct:
-reducerea posibilitatii de eroare;

-reducerea numarului de linii de program;
-sursa este mai lizibila pentru depanare si modificare;
-viteza de executie creste.
Broadcast: un singur proces trimite cate o copie a unei date la toate celelalte
procese dintr-un grup.
MPI_Bcast (&buffer,count,datatype,root,comm)
Procesul root trimite blocul de date din buffer de lungime count si tip datatype la toate
procesele din cadrul comunicatorului, fiecare proces plasand datele in memoria sa in
zona buffer.
Scatter: un bloc de date (un tablou de un anumit tip) de la un proces este

impartit in bucati si distribuit uniform la diferite procese.
MPI_Scatter (&sendbuf,sendcnt,sendtype,&recvbuf,
recvcnt,recvtype,root,comm)
Procesul root trimite din zona sendbuf de lungime sendcnt si tip sendtype la fiecare
proces al comunicatorului comm cate un set de date depus in zona recvbuf, de lungime
recvcnt si tip recvtype.
Gather colecteaza blocuri de date de la un grup de procese si le reasambleaza

in ordinea corecta la un singur proces.
......
MPI_Gather (&sendbuf,sendcnt,sendtype,&recvbuf,
recvcount,recvtype,root,comm)
Procesul root receptioneaza in recvbuf de lungime recvcount si tip recvtype cate un bloc
de date de la fiecare proces al comunicatorului comm din zona sendbuf lungime sendcnt
si tip sendtype.
Reducere: un singur proces (procesul radacina) colecteaza datele de la celelalte

procese dintr-un grup si le combina pe baza unei operatii intr-o singura data.
MPI_Reduce (&sendbuf,&recvbuf,count,datatype,op,root,comm)
Datele de la toate procesele comunicatorului comm din zona sendbuf lungime count si
tip datatype sunt prelucrate cu operatia de reducere op si rezultatul inscris la procesul
root in zona recvbuf.
Operatia poate sa fie:
Sincronizare: prelucrarile pot continua numai daca toate procesele au ajuns

intr-un anumit punct al prelucrarilor.
MPI_Barrier (comm)
Blocheaza procesele comunicatorului comm pe masura ce functia este apelata de
catre acestea pana cand toate procesele comunicatorului au apelat aceasta functie. La
revenirea din functie toate procesele sunt sincronizate.
Exemplu: operatie scatter pentru liniile unei matrici.

#include "mpi.h"
#include <stdio.h>
#define SIZE 4
int main(int argc,char *argv[]) {
int numtasks, rank, sendcount, recvcount, source;
float sendbuf[SIZE][SIZE] = {
{1.0, 2.0, 3.0, 4.0},
{5.0, 6.0, 7.0, 8.0},
{9.0, 10.0, 11.0, 12.0},
{13.0, 14.0, 15.0, 16.0} };
float recvbuf[SIZE];
if (numtasks == SIZE) {
source = 1;
sendcount = SIZE;
recvcount = SIZE;
MPI_Scatter(sendbuf,sendcount,MPI_FLOAT,recvbuf,recvcount,
MPI_FLOAT,source,MPI_COMM_WORLD);
printf("rank= %d Results: %f %f %f %f\n",rank,recvbuf[0],

recvbuf[1],recvbuf[2],recvbuf[3]);
}
else
printf("Must specify %d processors. Terminating.\n",SIZE);
MPI_Finalize();
return 0;
}
Biblioteca PVM
-functii portabile de nivel inalt pentru C si Fortran -> comunicatia in cadrul
unui grup de procese;
-compozitia grupului de procese este dinamica => cost suplimentar destul de
ridicat;
-un multicalculator (o retea de calculatoare) -> calculator virtual paralel, prin
transfer de mesaje;
-permite controlul proceselor, transmiterea si receptia mesajelor, sincronizarea
intre procese.
Masina virtuala paralela PVM :

-procesele server PVM (demonii PVM);
-biblioteca de functii PVM.
Initializarea masinii virtuale PVM: prin lansarea procesului server master cu functia:
pvm_start_pvmd
urmata de apelul functiei de setare a optiunilor de comunicatie:
pvm_setopt
Pe procesorul server master : hostfile (numele statiilor, caile de fisiere executabile, caile
pentru procesele server (demonii) din fiecare statie, contul utilizatorului, parola etc.).
Adaugare statii noi:
pvm_addhosts
Excludere statii:
pvm_delhosts
Oprirea masinii virtuale:

pvm_halt
Atasarea la masina virtuala PVM :
pvm_mytid
=> identificator de task (tid), numar intreg pe 32 de biti.
Crearea dinamica de procese:
pvm_spawn
Exemplu:
numt=pvm_spawn ("my_task", NULL, PvmTaskDefault, 0, n_task, tids);
creaza n_task procese care executa programul "my_task". Rezultatul functiei este
numarul efectiv de procese create (numt). Identificatorul fiecarui task creat este depus
intr-un element al vectorului tids.
Un proces poate parasi configuratia masinii PVM:
pvm_exit
sau poate fi terminat de alt proces:

pvm_halt (tid)
Exemplu: program "Hello World!":

main()
{
int cc, tid, msgtag;
char buf[100];
printf("i'm t%x\n", pvm_mytid());
cc = pvm_spawn("hello_other", (char**)0, 0, "", 1, &tid);

if (cc == 1) {
msgtag = 1;
pvm_recv(tid, msgtag);
pvm_upkstr(buf);
printf("from t%x: %s\n", tid, buf);
} else
printf("can't start hello_other\n");
pvm_exit();
}
Modele de programare ale interfetei PVM

-SPMD (Single Program Multiple Data): n instante ale aceluiasi program sunt
lansate ca n taskuri ale unei aplicatii paralele, folosind comanda spawn de la consola
PVM sau manual in cele n statii simultan. Initializarea mediului de programare:
specificarea statiilor pe care se executa cele n taskuri (nu se apeleaza pvm_spawn).
-MPMD (Multiple Program Multiple Data): unul sau mai multe taskuri sunt
lansate in diferite statii si acestea creaza dinamic alte taskuri.
Comunicatia punct-la-punct
Mesaj: proces A -> proces B => procesul A initializeaza bufferul de transmisie:
int pvm_initsend (int encode);

(encode stabileste tipul de codare a datelor in buffer) => identificator al bufferului de
transmisie in care se depun datele impachetate cu:
pvm_pack
Transmiterea mesajului:
int pvm_send (int tid, int msgtag);
(functie blocanta) tid = identificatorul mesajului de receptie, msgtag = tipul mesajului
(specifica prelucrari la receptie) => valoarea 0 pentru transmisie corecta si 1 la eroare.
Receptia:
int pvm_recv (int tid, int msgtag);
(functie blocanta) tid = identificatorul procesului sursa. Receptia: si pentru orice

transmitator (tid = -1) si orice tip de mesaj (msgtag = -1). => identificatorul bufferului
de receptie (bufid), de unde datele sunt extrase cu:
pvm_unpack
Receptia neblocanta:
pvm_nrecv
Comunicatia colectiva:
Atasarea unui proces la un grup (daca grupul nu exista, el este creat):
int pvm_joingroup (char *group_name);
=> 0 pentru procesul care creaza grupul si valoarea cea mai mica disponibila in grup
pentru fiecare proces urmator (un proces poate sa apartina la unul sau mai multe
grupuri).
Parasirea unui grup de catre un proces:

int pvm_lvgroup (char *group_name);
Obtinerea de informatii despre grup:

pvm_getinst
=> identificatorul instantei procesului in grup;
pvm_getid
=> identificatorul procesului;
pvm_gsize
=> dimensiunea grupului.
Comunicatiile colective (intre procesele membre ale unui grup) :
int pvm_bcast (char *group_name, int msgtag);

difuzeaza asincron mesajul cu flagul msgtag din bufferul de transmisie al procesului
apelant catre toate procesele membre ale grupului group_name (procesul apelant poate
sa fie sau nu membru al grupului).
int pvm_gather (void *g_arrray, void *myarray, int dim, int type, int msgtag,
char *group_name, int root);
colecteaza mesajele cu flagul msgtag, de la toate procesele grupului, in procesul
radacina (definit de utilizator) root, colectarea facandu-se in vectorul g_array, de
dimensiune dim si tip type. Fiecare proces trebuie sa apeleze pvm_gather.
int pvm_scatter (void *myarray, void *s_arrray, int dim, int type, int msgtag,
char *group_name, int root);
distribuie uniform tuturor proceselor din grup un vector de date de tipul type, cu numele
s_array si de dimensiune dim, aflat in spatiul de adresa al procesului radacina root.
Fiecare proces apeleaza pvm_scatter. Receptia se face in vectorul my_array.
int pvm_reduce (int operation, void *myvals, int dim, int type, int msgtag, char
*group_name, int root);
efectueaza operatia de reducere paralela intre toate procesele membre ale unui grup.
Argumentul operation defineste operatorul de reducere (PvmMin, PvmMax, PvmSum,
PvmProduct). Fiecare proces efectueaza operatia de reducere a datelor din vectorul
local de date myvals, de tipul type, de dimensiune dim, iar valoarea rezultata este
transferata procesului radacina root, care obtine valoarea de reducere finala.
int pvm_barrier (char *group_name, int ntasks);

sincronizeaza procesele membre ale unui grup (procesul este blocat pana cand un numar
ntasks procese din grupul group_name au apelat aceasta functie).
Exemplu: operatia de reducere paralela in masina virtuala PVM.
#include ........
#include "pvm3.h"
#define NTASKS 4
int main () {
int mytid, tids[NTASKS-1], groupid, sum, info;
/*crearea grupului de comunicatie*/
mytid=pvm_mytid();
groupid=pvm_joingroup("summax");
sum=groupid;
/*primul proces creaza celelalte NTASK-1 procese*/
if (groupid==0) {
info=pvm_spawn("summax",NULL,PvmTaskDefault," ", NTASKS-1,
tids);
printf("GroupId=%d spawned %d tasks\n", groupid, info);
}
/*bariera prin inghetare pana ce NTASKS procese s-au alaturat grupului*/

pvm_freezgroup("summax", NTASKS);
/*calculul sumei in grup*/
pvm_reduce (PvmSum, &sum, 1, PVM_INT, 1, "summax", 0);
/*procesul 0 tipareste rezultatul*/
if (groupid==0) {
printf("sum=%d\n", sum);
}
/*sincronizare pentru ca toate procesele sa execute operatia
inainte de parasirea grupului*/
pvm_barrier ("summex", NTASKS);
pvm_lvgroup ("summax");
pvm_exit();
return 0;
}

Curs SM

Î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

Curs SM

Încărcat de

Drepturi de autor:

Formate disponibile

STRUCTURI MULTIPROCESOR

Cipuri cu procesoare multiple

Multiprocesoare cu acces neuniform la memorie (NUMA)

NOIUNI INTRODUCTIVE DESPRE

1. MASINI PARALELE SI MODELE DE PROGRAMARE

Calculator paralel = colectie de elemente de prelucrare

Cadrul de organizare intr-o masina paralela:

O arhitectura paralela generala:

Exemplu de aplicatie paralela: calcularea sumei

Se disting doua seturi de date:

1) Modelul 1 de programare: spatiu partajat de adrese.

Coordonarea firelor de executie prin operatii de sincronizare:

Masina paralela corespunzatoare modelului 1: masina cu memorie partajata

Exemple: sisteme de la Sun, DEC, Intel (Millennium), SGI Origin.

Variante ale acestui model:

b) masina cu spatiu partajat de adrese (memoriile cache inlocuite cu memorii

O posibila solutie pentru rezolvarea problemei:

Este necesara sincronizarea threadurilor pentru accesul la variabilele partajate !

2) Modelul 2 de programare: transfer de mesaje.

Exista biblioteci standard (exemple: MPI si PVM).

Masina corespunzatoare modelului 2 este multicalculatorul (sistem cu

O posibila solutie a problemei in cadrul modelului in transfer de mesaje

3) Modelul 3 de programare: paralelism al datelor.

Comunicatia: implicita, in modul de deplasare a datelor.

Eficienta numai pentru anumite probleme (exemplu: prelucrari de tablouri)!

Masina corespunzatoare modelului 3: sistem SIMD - Single Instruction

Exemple: CM2, MASPAR, sistemele sistolice VLSI

4) Modelul 4 de masina: cluster de SMP-uri sau CLUMP (mai multe SMP-uri

Modele teoretice de calculatoare paralele

Optiunile de acces concurent al procesoarelor la memoria partajata:

Variante ale modelului PRAM:

Rezolvarea conflictelor de scriere:

Algoritm secvential pentru inmultire de matrici

for (i=0; i<n; i++)

Algoritm CRCW-PRAM cu n3 procesoare pentru inmultire de matrici

Etapa 1: fiecare procesor Pi,j,k calculeaza in paralel produsul a[i][k]*b[k][j].

Algoritm CREW-PRAM cu n3 procesoare pentru inmultire de matrici

Procesoarele ~ tablou 3D tablou suplimentar v cu n*n*n elemente in

Operatia de reducere paralela (exemplu pentru 16 procesoare si 4 pasi):

2. CLASIFICAREA CALCULATOARELOR PARALELE

3. TIPURI DE CALCULATOARE PARALELE

Calculatoare n band de asamblare

Calculatoare n band de asamblare

Execuia instruciunilor ntr-un calculator secveial.

Procesor n band de asamblare

Execuia instruciunilor ntr-un calculator n band de asamblare.

Structura funcional a unui calculator n band de asamblare.

Structura funcional a unui calculator de masive.

Structura funcional a unui sistem multiprocesor.

Calculatoare n flux de date

Graful i abloanele n flux de date.

Mecanismul de execuie al unui program n flux de date.

(RDRAM = Rambus DRAM)

Sisteme sistolice VLSI

Reea liniar pentru calcularea convoluiilor.

4. PERFORMANE ALE CALCULATOARELOR

Gradul de paralelism DOP (degree of parallelism) = numarul de procesoare

Profilul paralelismului = graficul DOP in functie de timp (pentru un anumit

Se considera un sistem paralel cu n procesoare identice.

Volumul de lucru W (work)

= capacitatea de calcul pentru un procesor, aproximata cu rata MIPS (million

Volumul de lucru este proportional cu aria de sub graficul profilului:

iar in cazul discret:

Procesoarele ~ tablou 3D tablou suplimentar v cu nnn elemente in