Sunteți pe pagina 1din 14

Arhitectura calculatoarelor

CAPITOLUL VIII

CAPITOLUL VIII
PROCESOARE CU INSTRUCIUNI EXTRALUNGI (VLIW)
n capitolul anterior am prezentat o parte din problematica procesoarelor superscalare, aa c acum
suntem n msur s extragem cteva dintre particularitile pozitive i negative caracteristice acestor arhitecturi.
Punctele tari ale unei arhitecturi superscalare constau mai ales n faptul c toate problemele legate de
execuia paralel sunt rezolvate de ctre hardware i n asigurarea compatibilitii binare. Primul aspect se refer
la faptul c potenialele paralelisme ntre instruciuni sunt detectate prin hard. Tot hardul decide i asupra
numrului maxim posibil al unor astfel de paralelisme, alegnd corespunztor fereastra de execuie sau
redenumind registrele.
Compatibilitatea binar este asigurat atunci cnd programele scrise pentru o anumit arhitectur pot
beneficia de potenialul adiional de paralelism care se obine fie prin adugarea unei noi uniti funcionale, fie
prin efectuarea oricrei alte mbuntiri structurale a procesorului (fr a-i schimba ns setul de instruciuni).
Procesoarele superscalare dein aceast proprietate, cu alte cuvinte un nou hardware va fi apt s determine cea
mai potrivit secven de execuie i pentru vechile instruciuni.
Procesoarele superscalare au evident i anumite puncte slabe. n primul rnd, ele sunt foarte complexe,
pentru a fi capabile s detecteze cele mai potrivite ci de tratare ale secvenelor de instruciuni. De asemenea,
asigurarea unei ferestre de execuie ct mai largi impune un hard din ce n ce mai sofisticat.
Pornind de la considerentele de mai sus, specialitii propun ca o soluie alternativ la procesoarele
superscalare arhitecturile VLIW (Very Large Instruction Word), sau ntr-o ncercare de traducere fidel
arhitecturile cu instruciuni extralungi.

Figura 8.1. Construcia instruciunilor extralungi

115

Arhitectura calculatoarelor

CAPITOLUL VIII

Principiul de lucru al procesoarelor VLIW se bazeaz pe detecia paralelismului n timpul compilrii.


Compilatorul va analiza programul i va detecta operaiile care pot fi executate n paralel. Acestea vor fi
"mpachetate" ntr-o unic instruciune "lung". Citirea unei astfel de instruciuni va permite astfel tratarea n
paralel a tuturor operaiilor pe care le conine. n toate situaiile, detecia paralelismului i mpachetarea operaiilor
n instruciuni extralungi sunt efectuate de ctre compilator
off-line.
Arhitectura VLIW rezolv astfel dou probleme care erau critice n cazul soluiilor superscalare: pe
parcursul tratrii secvenelor de instruciuni nu mai este implicat hard-ul n detecia paralelismului, iar fereastra de
execuie poate cuprinde chiar ntreg programul, deoarece compilatorul are potenialul de a analiza i detecta toate
operaiile care se preteaz la prelucrarea paralel.
Procedura de obinere a instruciunilor VLIW este prezentat schematic n figura 8.1. n figura 8.2 este
prezentat principiul de funcionare al unui procesor VLIW.
Avantajele arhitecturii VLIW constau n simplificarea hardware-ului, deoarece nu trebuie mrit dect
numrul unitilor de citire a instruciunilor, fr a mai fi necesare circuite sofisticate pentru detecia paralelismului,
aa cum se ntmpl n cazul superscalar. n plus, un compilator bun poate detecta paralelismul pe baza analizei
globale a programului, eliminndu-se fereastra de execuie i problemele legate de de asigurarea originii de
tratare n interiorul acesteia.

Figura 8.2. Structura unui procesor VLIW

Totui, implementarea arhitecturii de tip VLIW ridic unele probleme:


necesitatea utilizrii unui numr mare de regitri, care sunt necesari pentru stocarea operanzilor i

rezultatelor aferente tuturor unitilor de execuie;


necesitatea asigurrii unei capaciti de transport ridicate, pe de o parte ntre unitile de execuie i

registre, iar pe de alta ntre registre i memorie;


asigurarea unei benzi de trecere largi pentru magistrala de transport dintre memoria cache de

instruciuni i unitatea de citire a acestora. Spre exemplu, dac o instruciune conine 7 operaii, fiecare
dintre acestea codificate pe 24 de bii, trebuie transferai 168 de bii/instruciune;
obinerea unei instruciuni cu un cod foarte lung, parial datorat i unor operaii neutilizate, aa cum vom

vedea n exemplele ce vor urma n acest capitol;


incompatibilitatea binar, datorat spre exemplu faptului c dac ntr-o nou versiune a procesorului se
introduc noi uniti de execuie (astfel nct numrul operaiilor executabile n paralel crete), cuvntul
binar al instruciunii se va modifica, iar codurile binare ale vechilor programe nu vor mai putea fi
executate pe acest procesor.
116

Arhitectura calculatoarelor

CAPITOLUL VIII

8.1. Desfacerea buclelor de program


Aa cum ne-am obinuit, vom incerca s ilustrm unele aspecte menionate mai sus printr-un exemplu.
S considerm urmtoarea secven de cod, scris n limbjalul C:
for

(i=959; i=0; i--)

x [i] = x [i] + s;
Presupunem c x este o matrice ale crei elemente sunt numere reprezentate n virgul mobil, iar s
este o constant n virgul mobil.
n urma compilrii pe un procesor obinuit, presupunem c rezult urmtoarea secven n limbaj de
asamblare:
Loop:

LDD

F0, (R1) F0x[i]; (ncrcare dubl)

ADF

F4, F0, F2

STD

(R1), F4 x[i]F4; (stocare dubl)

SBI

R1, R1, 8

F4F0+F2; (virgul flotant)


R1R1-8

BGEZ R1, Loop


Secvena de mai sus s-a obinut presupunnd c: R1 conine iniial adresa ultimului element n x,
celelalte elemente avnd adrese mai mici; x[0] are adresa 0; registrul n virgul flotant F2 conine valoarea s, iar
toate valorile n virgul flotant au lungimea de 8 bytes.
LDD
F0, (R1)

ADF
F4, F0, F2

SBI
R1, R1, 8
STD
8(R1), F4

BGEZ
R1, Loop

Figura 8.3. Execuie secvenei de instruciuni fr paralelism


S considerm acum un procesor VLIW avnd urmtoarele caracteristici: n fiecare ciclu de ceas pot
lucra simultan dou uniti de acces la memorie, dou uniti de execuie a operaiilor n virgul flotant i o
unitate de execuie a operaiilor cu ntregi sau a salturilor; ntrzierea pentru ncrcarea unui dublu cuvnt este de
un ciclu de ceas; operaiile cu ntregi nu necesit cicluri adiionale de ceas.
Aa cum se observ din figura 8.3, atunci cnd nu se apeleaz la paralelism, o iteraie necesit 6 cicluri
de ceas, astfel nct execuia ntregii bucle a programului va dura 960 iteraii x 6 = 5760 cicluri. Din figur se
observ c mai multe cmpuri ale instruciunilor sunt goale (dou cicluri sunt chiar complet goale). Deplasamentul
cu 8 (n 8(R1)) este necesar din cauz c anterior deja se sczuse 8 din R1.
S rescriem acum exemplul nostru astfel:
for

(i=959; i=0; i-=)


x[i] = x[i] + s;
x[i-1] = x[i-1] + s;

Dac i aceast secven va fi compilat - de asemenea pe un procesor obinuit - obinem secvena


echivalent n limbaj de asamblare:
117

Arhitectura calculatoarelor
Loop:

CAPITOLUL VIII

LDD

F0, (R1) F0x[i]; (ncrcare dubl)

ADF

F4, F0, F2

STD

(R1), F4 x[i]F4; (stocare dubl)

LDD

F0, -8(R1)

F0x[i-1]; (ncrcare dubl)

ADF

F4, F0, F2

F4F0+F2; (virgul flotant)

STD

-8(R1), F4

x[i-1]F4; (stocare dubl)

SBI

R1, R1, 16

R1R1-16

BGEZ

R1, Loop

F4F0+F2; (virgul flotant)

Dup cum se poate observa din figura 8.4, aceast modificare crete gradul de paralelism al prelucrrii,
cu toate c i n acest caz avem cmpuri de operaii i chiar cicluri complete de ceas goale. Totui, se obine o
spectaculoas cretere a vitezei de execuie: acum nu una, ci dou iteraii necesit 6 cicluri, rezultnd c execuia
ntregii bucle va dura 480 iteraii x 6 = 2880 cicluri.
LDD
F0, (R1)

LDD
F6, -8(R1)

ADF
F4, F0, F2

ADF
F8, F6, F2

SBI
R1, R1, 16
STD
16(R1), F4

STD
8(R1), F8

BGEZ
R1, Loop

Figura 8.4. Execuie secvenei de instruciuni fr paralelism, cu desfacerea buclei n dou iteraii
Tehnica de mai sus se numete desfacerea buclei (loop unrolling) i este utilizat de ctre
compilatoare pentru a crete potenialul de paralelism al programului. Desfacerea buclelor permite o mai eficient
generare a codului obiect pentru programele executate de ctre procesoarele ce dispun de un anumit nivel de
paralelism n execuia instruciunilor.
Dac vom continua desfacerea buclei din exemplu, n cazul a trei iteraii ea va avea urmtoarea form:
for

(i=959; i=0; i--)


x [i] = x[i] + s;
x [i-1] = x[i-1] + s;
x [i-2] = x[i-2] + s;

Dup compilare, obinem urmtoarea secven n limbaj de asamblare:


Loop:

LDD

FO, (R1) FOx[i]; (ncrcare dubl)

ADF

F4, FO, F2

STD

(R1), F4 x[i]F4; (stocare dubl)

LDD

FO, -8(R1)

FOx[i-1]; (ncrcare dubl)

ADF

F4, FO, F2

F4FO+F2; (virgul flotant)

STD

-8(R1), F4

x[i-1]F4; (stocare dubl)

LDD

FO, -16(R1)

FOx[i-2]; (ncrcare dubl)

ADF

F4, FO, F2

F4FO+F2; (virgul flotant)

F4FO+F2; (virgul flotant)

118

Arhitectura calculatoarelor

CAPITOLUL VIII

STD

-16(R1), F4

x[i-2]F4; (stocare dubl)

SBI

R1, R2, 24

R1R1-24

BGEZ R1, Loop


Aa cum se poate observa i din figura 8.5, gradul de paralelism este n continuare mbuntit. Cele trei
iteraii necesit n total 7 cicluri de ceas, ceea ce nseamn c ntreaga execuie a buclei va dura 320 x 7 = 2240
cicluri. Totui observm c optimul nu a fost atins, deoarece i n acest caz se mai pstreaz nc cicluri i
operaii goale.
LDD
FO, (R1)

LDD
F6, -8(R1)

LDD
F10, -16(R1)
ADF
F4, F0, F2

ADF
F8, F6, F2

ADF
F12, F10, F12

STD
(R1), F4

STD
-8(R1), F8

SBI
R1, R1, 24

STD
8(R1), F12

BGEZ
R1, Loop

Figura 8.5. Execuie secvenei de instruciuni fr paralelism, cu desfacerea buclei n dou iteraii
Acest ultim impediment va fi eliminat numai atunci cnd bucla se descompune n opt iteraii:
for

(i=959; i=0; i- =8)


X[i] = x[i] + s; x[i-1] = x[i-1] + s;
X[i-2] = x[i-2] + s; x[i-3] = x[i-3] + s;
X[i-4] = x[i-4] + s; x[i-5] = x[i-5] + s;
x[i-6] = x[i-6] + s; x[i-7] = x[i71] + s;

LDD
F0, (R1)
LDD
F10, -16(R1)
LDD
F16, -32(R1)
LDD
F26,-48(R1)

LDD
F6, -8(R1)
LDD
F14, -24(R1)
LDD
F22, -40(R1)
LDD
F30,-56(R1)

STD
(R1), F4
STD
-16(R1), F12
STD
-32(R1), F20
STD
16(R1), F28

STD
-8(R1), F8
STD
-24(R1), F16
STD
-40/(R1), F24
STD
8(R1), F32

ADF
F4, F0, F2
ADF
F12, F10, F2
ADF
F20, F18, F2
ADF
F28, F26, F2

ADF
F8, F6, F2
ADF
F16, F14, F2
ADF
F24, F22, F2
ADF
F32, F30, F2

SBI
R1,R1,64
BGEZ
R1, Loop

Figura 8.6. Desfacerea complet a unei bucle


119

Arhitectura calculatoarelor

CAPITOLUL VIII

Conform ilustrrii din figura 8.6 a acestei ultime situaii, cele opt iteraii necesit 9 cicluri de ceas,
obinndu-se un timp total de execuie al buclei considerabil mult mai bun: 120 x 9 = 1080 cicluri.
Pentru un set dat de resurse - practic pentru o anumit arhitectur a procesorului - i o pentru o bucl de
program definit, exist o limit superioar optim a numrului de iteraii n care aceasta poate fi desfcut. Peste
aceast limit nu se mai obine nici un fel de mbuntire a performanei. n consecin, un bun compilator
trebuie s fie capabil s gseasc acest nivel optim de desfacere, pentru fiecare bucl n parte.
Trebuie de asemenea menionat c desfacerea buclelor mrete spaiul de memorie necesar stocrii
unui program. n plus, utilizarea eficient a unei arhitecturi VLIW (concretizat prin meninerea unui flux de
prelucrare ct mai compact, fr cicluri goale) presupune i satisfacerea unor cerine de suport hardware
pretenioase, materializate n numr mare de registre i trafic apreciabil registre - memorie i registre - uniti
funcionale.

8.2. Planificarea traseelor de tratare


O alt tehnic utilizat de compilatoare n scopul de a mbuntii paralelismul execuiei instruciunilor,
atunci cnd n programe se execut salturi condiionate, este planificarea traseelor (trace scheduling) pe care
se va face tratarea. Ideea de baz pleac de la constatarea c pentru o detecie eficient a instruciunilor
independente care pot fi tratate n paralel este nevoie s fie analizat o secvende program suficient de lung. n
plus, dac se poate gsi o metod de ntreptrundere a blocurilor de instruciuni analizate, eficiena deteciei se
mbuntete.
Planificarea traseelor reprezint de fapt o predicie a salturilor efectuat n faza de compilare i implic
trei etape:
selecia traseului de tratat;

planificarea instruciunilor;

nlocuirea i compensarea.

Ca de obicei, propunem s continum discuia pe un exemplu. S alegem urmtoarea secvena de cod scris n
limbajul C:
if
(c ! = 0)
b = a/c;
else
b = 0; h = 0;
f = g+h;
Dup compilare, pentru un procesor obinuit, se obine urmtoarea secven echivalent n limbaj de
asamblare:

Else:
Next:

R0c; (ncarc cuvnt)

LD

R0, c

BZ

R0, Else

LD

R1, a

R1a (ncarc ntreg);

DV

R1, R1, R0

R1R1/R0; (ntreg)

ST

b, R1

bR1; (stocheaz cuvnt)

BR

next

STI

b, 0

b0

STI

b, 0

h0

LD

R0, g

R0g; (ncarc cuvnt)

LD

R1, h

R1h; (ncarc cuvnt)

AD

R1, R1, R0

R1R1+ R0; (ntreg)

ST

f, R1

fR1; (stocheaz cuvnt)

End: ............................
n figura 8.7 este prezentat schema logic de execuie a acestei secvene.

120

Arhitectura calculatoarelor

CAPITOLUL VIII

LD R0; C

BZ R0, Else
STI
STI

LD R1, a
DV R1, R1, R0
ST b, R1

b, 0
h, 0

LD R0, g
LD R1, h
AD R1, R1, R0
ST f, R1

END

Figura 8.7. Schema logic a execuiei secvenei cu planificarea traseului


Pentru a efectua o selecie a traseului n cazul compilrii pentru un procesor VLIW, din acest masiv de
instruciuni se alege o secven de blocuri de baz, care va fi executat n continuare, fr a ine cont de
rezultatul condiiilor de salt. Aceast secvena de instruciuni aleas se numete traseu de tratare (trace).
Selecia acestui traseu se bazeaz pe o predicie a salturilor efectuat de ctre compilator. Calitatea prediciei
poate fi foarte bun dac se utilizeaz programe care execut numai anumite secvene tipice de intrare sau sunt
consultate colecii de statistici privind modul n care s-au efectuat salturile anterioare.
n etapa urmtoare - cea de planificare a instruciunilor - instruciunile din traseul selectat sunt organizate
sub forma unor operaii paralele destinate prelucrrii de ctre procesorul VLIW.
Dac selecia urmei s-a fcut, pentru exemplul nostru, ca n figura 8.7 i presupunem c procesorul are
aceleai caracteristici ca i cel ales pentru ilustrarea desfacerii buclelor, execuia paralel a operaiilor se va face
pentru ca n figura 8.8.
LD R0, c
LD R2, g
Next

LD R1, a
LD R3, h

BZ R0, Else
DV R1, R1, R0
AD R3, R3 R2
BR End

ST b, R1
ST f, R3

Figura 8.8. Planificarea instruciunilor pentru traseul ales n figura 8.7

121

Arhitectura calculatoarelor

CAPITOLUL VIII

n faza de nlocuire, traseul de tratare ales iniial va fi nlocuit cu secvena de prelucrare paralel
generat n etapa de planificare. n acest secven este posibil ca ordinea instruciunilor de pe ramura selectat
s fi fost modificat. n consecin, pentru a pstra codul corect al ramurii, n aceast faz va trebui adugat un
anumit cod de compensare.

LD R0, c
LD R2, g
Next:

ST b, R1
ST f, R3

Else:
End:

STI b, 0

LD R1, a
LD R3, h

BZ R0, Else
DV R1, R1, R0
AD R3, R3 R2
BR End

STI h, 0

BR Next

Figura 8.9. Schimbarea ordinii de execuie datorat planificrii traseului


Astfel, n exemplul nostru, traseul de tratare ales n figura 8.7 va duce la ncrcarea mai devreme,
naintea saltului condiionat, a valorilor g i h din secvena next. De asemenea, ncrcarea valorii a se va face n
aceast situaie tot naintea saltului, iar stocarea valorii b dup efectuarea mpririi devine acum parte a
secvenei next. De aceea, pentru pstrarea corectitudinii execuiei programului, numai simpla adugare a codului
secvenei else dup cel al secvenei next nu va fi suficient. Din figura 8.9 se mai poate observa c dup
stocarea ST b, R1 din secvena next, valoarea lui b va fi suprascris (STI, b,) n secvena else, tot din cauza
faptului c stocarea lui b a fost deplasat mai jos, n aceast secven. Tot n figura 8.9 se observ c valoarea
asignat lui h n secvena else este ignorat de adunarea AD R3,R3,R2, pentru c ncrcarea lui h a fost
deplasat n sus n secvena next.
Pentru corectitudine, se impune deci modificarea secvenei prin introducerea unui cod de compensare.
Acesta va fi STI R3,0, introdus ca n figura 8.10. Introducerea acestei instruciuni suplimentare anuleaz efectul
mutrii mai sus a instruciunii LD R3,h, care a fost efectuat n faza de planificare a execuiei.
LD R0, c
LD R2, g
Next:
Else:

ST b, R1
ST f, R3
STI R1, 0
STI R3, 0

LD R1, a
LD R3, h

BZ R0, Else
DV R1, R1, R0
AD R3, R3 R2
BR End

STI h, 0
BR Next

End:
Figura 8.10. Introducerea codului de compensare la execuia prin planificarea traseului
Se poate remarca faptul c tehnica planificrii traseului de tratare este diferit de cea a execuiei
speculative, utilizat - spre exemplu - de ctre procesoarele superscalare. Facem aceast afirmaie deoarece, n
esen, ea este o tehnic de optimizare a compilatorului cu ajutorul creia acesta ncearc la rndul su s
optimizeze execuia codului de program n cazul apariiei salturilor condiionate. Va fi astfel aleas pentru tratare
ramura de program care este considerat mai plauzibil de a fi executat ct mai repede.
Preul care trebuie pltit atunci cnd se alege aceast tehnic este probabilitatea de apariie n execuie
a unor instruciuni adiionale, atunci cnd va fi executat ramura mai puin probabil a programului. i n aceste
cazuri, execuia ramurii va fi totdeauna corect, ns n cazul n care aceasta nu a fost cea predictat de ctre
compilator, execuia va fi mai lent, datorit introducerii codului de compensare.
Pe baza acestor considerente, putem concluziona c, la nivel hardware, un procesor VLIW poate utiliza
att predicia salturilor ct i execuia speculativ a instruciunilor, dup cum una sau alta din cele dou tehnici
aduce un ctig mai mare relativ la mbuntirea randamentului de lucru al unitilor pipeline ale sale.
La ora actual pot fi gsite pe pia cteva procesoare VLIW de succes. Astfel, Philips produce
TriMedia, iar Texas Instruments ofer gama TMS 320C6x, amndou destinate pieei multimedia. n ultimul timp,
122

Arhitectura calculatoarelor

CAPITOLUL VIII

cercetrile pentru proiectarea procesoarelor cu arhitecturi ale setului de instruciuni pe 64 de bii - aa-numitele
arhitecturi IA-64 - desfurate de ctre Intel i Hewlett-Pakard tind s adopte multe din ideile VLIW.
Procesoarele IA-64 nu nu numai c vor avea ample capabiliti de prelucrare a datelor multimedia, ci
tind s defineasc o nou generaie arhitectural, utilizabil att pentru servere, ct i pentru staii de lucru.
Planificat pentru a fi lansat pe pia n lunile n care aceast lucrare se afl sub tipar, definitoriu pentru aceast
nou arhitectur este procesorul Intel botezat iniial Merced, iar ulterior Itanium.

8.3. Principiile arhitecturale ale procesorului Itanium


Acest nou procesor cu arhitectur IA 64 nu este un VLIW pur, dar mprumut multe din caracteristicile
tipice ale unitilor centrale cu instruciuni extralargi.
Conceptele de baz Itanium sunt:

paralelismul instruciunilor fixat la nivelul compilatorului;

cuvnt al instruciunii extralung;

predicia salturilor;

ncrcarea speculativ a instruciunilor.

Primele dou sunt caracteristici VLIW tipice, pe cnd ultimele sunt caracteristici hardware suplimentare,
specifice numai arhitecturilor IA-64. Datorit acestor caracteristici circuitul Itanium mai este numit de ctre
productorul su i procesor cu calcul paralel explicit al instruciunilor (EPIC - Explicitly Parallel Instruction
Computing), tocmai datorit faptului c paralelismul operaiilor este explicitat prin formatul cuvntului instruciunii.
Organizarea general a procesorului Itanium este prezentat n figura 8.11. Registrele pentru operaii cu
ntregi sau n virgul flotant au cte 64 de bii, pe cnd registrele - predicat au cte un bit. Numrul unitilor
funcionale FU este de minimum 8.
n figura 8.11 este prezentat i formatul instruciunii. Observm c ea are o lungime de 128 bii i este
mprit n patru cmpuri.
Primele trei, fiecare cu lungimea de cte 40 de bii, definesc cele trei operaii care pot fi executate n
paralel de ctre procesor. Menionm ns c aceste trei operaii nu trebuie n mod necesar s fie tratate
simultan. Ultimul cmp - numit ablon (template) - indic modul cum se va face execuia paralel. Codul de 8 bii
al ablonului arat care dintre operaiile din instruciune se pot executa n paralel, realiznd n acelai timp
conexiuni cu instruciunile nvecinate. Aceste conexiuni se refer la operaiile din aceste instruciuni care se pot
executa n paralel cu cele ale instruciunii curente. Folosirea abloanelor permite mrirea flexibilitii execuiei i
rezolv unele din problemele care apar la procesoarele VLIW clasice.
Astfel, numrul operaiilor care pot fi executate n paralel nu mai este restricionat de dimensiunea
cuvntului instruciunii. Este posibil acum ca generaiile succesive ale procesorului s poat avea un numr diferit
de uniti funcionale, fr a fi necesar i modificarea cuvntului instruciunii. n consecin, se mbuntete
compatibilitatea binar.
O alt situaie care este rezolvat prin utilizarea cmpului ablon este aceea cnd acesta indic
posibilitatea de execuie n paralel a mai multor operaii dect numrul unitilor funcionale disponibile. Apariia
acestei depiri de capacitate este semnalat i permite procesorului s adopte o strategie de planificare a
secvenialitii unor instruciuni.
Fiecare operaie de calcul poate fi referit ntr-o arhitectur IA - 64 printr-un registru predicat.
Subcmpul omolog din cmpul unei operaii indic numrul acestui registru (cuprins ntre 0 i 63). Respectiva
operaie va fi terminat - i rezultatul ei va deveni vizibil - numai dac respectivul predicat este logic adevrat,
adic registrul predicat corespunztor are valoarea 1. Cu alte cuvinte, dac valoarea predicatului este cunoscut
atunci cnd operaia este selectat, operaia va fi executat numai dac aceast valoare este adevrat. Dac dimpotriv - n momentul seleciei operaiei valoarea predicatului nu este cunoscut, operaia este declanat.
Ulterior, cnd valoarea predicatului poate fi determinat i dac aceast valoare este fals, operaia va fi
abandonat. Dac n cmpul operaiei registrul predicat nu este indicat, operaia va fi executat necondiionat.
Modalitatea de tratare a instruciunilor descris mai sus se numete execuie cu predicate.
Asignarea predicatelor se efectueaz pe baza relaiei R=Pj, Pk ce se stabilete ntre predicatele
registrelor j i k (notaiile Pj, Pk). Dac evaluarea logic a relaiei are valoarea adevrat, atunci valoarea
123

Arhitectura calculatoarelor

CAPITOLUL VIII

predicatului registrului j va fi setat pe 1, iar cea a predicatului k, pe 0. n caz contrar, atunci cnd rezultatul
evalurii logice a lui R este fals, Pj va fi setat pe 0, iar Pk pe 1.

Figura 8.11. Arhitectura procesorului Itanium i formatul instruciunii sale


Alocarea prediciei predicatelor este o relaie de tipul R=Pi Pj, Pk, unde i, j i k sunt registre predicat
(cu valori ntre 0 i 63). n relaia R, predicatele j i k vor fi actualizate dac i numai dac registrul predicat i este
adevrat.
Predicarea salturilor este o tehnic de compilare foarte agresiv, care genereaz cod de program cu
paralelism la nivelul instruciunii (adic un cod cu operaii paralele). Aceast tehnic nu trebuie confundat cu
predicia salturilor, deoarece aceasta din urm presupunea tratarea n avans a unei ramuri rezultate dintr-un salt
condiionat, prin planificarea traseului. Alegerea ramurii se fcea printr-o metod oarecare, iar n caz de eec al
prediciei se renuna la ntreaga secven executat pe acea ramur.
Predicarea salturilor reprezint un pas nainte fa de planificarea traseelor de tratare. Cu scopul de a
valorifica ntregul potenial de paralelism al mainii, se ncearc execuia n acelai timp a operaiilor aferente
124

Arhitectura calculatoarelor

CAPITOLUL VIII

ambelor ramuri de program generate de saltul condiionat, nainte ca rezultatul evalurii condiiei de salt s fie
cunoscut. n momentul cnd acest rezultat este accesibil (iar registrele predicat vor fi setate corespunztor), vor fi
terminate operaiile de pe ramura corect i vor fi ignorate cele care au fost deja executate pe ramura incorect.
n acest fel se elimin timpul consumat cu execuia unor operaii rezultate din predicii false, aa cum se ntmpl
la predictarea salturilor.
Se observ c prin aceast tehnic, salturile din program sunt nlocuite de execuii condiionate. Trebuie
subliniat ns c predictarea execuiei de ctre un compilator optimizat necesit i un suport hardware adecvat,
capabil s decid terminarea numai a acelor instruciuni ce corespund ramurii corecte.
Exemplul urmtor ilustraz tehnica predicrii salturilor. Fie secvena de program scris n limbajul C:
if (a && b)
j = j+1;
else
if (c)
k = k+1;
else
k = k-1;
m = k * 5
i = i+1
Presupunem c valorile sunt stocate n regitri astfel: a n R0, b n R1, j n R2, c n R3, k n R4, m n R5
i i n R6. n acest caz, secvena compilat pentru un procesor obinuit va fi:
BZ
R0,R1 salt dac a=0
BZ
R1,L1 salt dac b=0

L1:

ADI

R2,R2,#1 R2R2+1;(ntreg)

BR
BZ

L4
R3,L2

ADI

R4,R4,#1 R4R4+1;(ntreg)

salt dac c=0

BR

L3

L2:

SBI

R4,R4,#1 R4R4-1;(ntreg)

L3:

MPI

R5,R4,#5 R5R4*5;(ntreg)

L4:

ADI

R6,R6,#1 R6R6+1;(ntreg)

Aceast secven poate fi citit i astfel:


if not(a=0)
if not(not (a=0) and not (b=0)) and not(c=0)
if not(not (a=0) and not (b=0)) and not(not (c=0))
if not(not(a=0)
and not(b=0))

ADI
SBI

ADI
R2,R2,#1
R4,R4,#1
R4,R4,#1
MPI
R5,R4,#5
ADI
R6,R6,#1

ntr-o transcriere cu predicarea execuiei, secvena de mai sus va avea urmtoarea form, lund n
considerare valoarea predicatelor:
(1)

P1,P2 = EQ (R0, #0)

(2)

P2 P1, P3 = EQ (R1, #0)

(3)

P3 ADI R2,R2,#1

(4)

P1 P4, P5 = NEQ (R3, #0)

(5)

P4 ADI R4,R4,#1

(6)

P5 SBI R4,R4,#1

(7)

P1 MPI R5,R4,#5

(8)

ADI R6,R6,#1

125

Arhitectura calculatoarelor

CAPITOLUL VIII

Compilatorul poate planifica execuia n paralel a instruciunilor de mai sus, cu excepia celor cu
numerele (5) i (6), care sunt supuse unei dependen de date. De asemenea, execuia instruciunilor poate fi
nceput chiar dac un predicat particular de care depinde tratarea lor nu este cunoscut. Atunci cnd acest lucru
se va ntmpla, respectiva instruciune va fi teminat sau nu (va fi abandonat).
Referitor la o alt caracteristic arhitectural a procesorului Itanium - ncrcarea speculativ a
instruciunilor - aceasta are la baz ideea ncrcrii ntrziate discutat n capitolul VII. S considerm urmtorul
exemplu:
LOAD R1, x
ncarc de la adresa x n R1
ADD

R2, R1

R2R2+R1

ADD

R4, R3

R4R4+R3

SUB

R2, R4

R2R2+R4

Cu scopul de a se evita ntrzierea (latena) memoriei datorat instruciunii LOAD, secvena poate fi
scris i altfel, mutnd mai jos execuia instruciunii care cere valoarea din registrul R1:
LOAD

R1, x

ncarc de la adresa xn R1

ADD

R4, R3

R4R4+R3

ADD

R2, R1

R2R2+R1

SUB

R2, R4

R2R2+R4

S considerm acum i un alt exemplu care s ilustreze aceast tehnic:

L1:
L2:

ADI

R0, 1

BZ

R0, L1

R0R0+1;

(ntreg)

ADI

R2, R2, 1

BR

L2

R2R2+1;

(ntreg)

LD

R3, x

R3x

ADI

R3, R3, 1

R3R3+1;

(ntreg)

SBI

R4, R4, 1

R4R4-1;

(ntreg);

Cu scopul de a evita i de aceast dat latena memoriei, ncrcarea valorii x este mutat de ctre
compilator astfel:
LD

R3, x

R3x

ADI

R0, 1

R3R0+1;

(ntreg)

BZ

R0, L1

ADI

R2, R2, 1

R2R2+1;

(ntreg)

BR

L2

L1:

ADI

R3, R3, 1

R3R3+1;

(ntreg)

L2:

SBI

R4, R4, 1

R4R4-1;

(ntreg);

Se poate observa cu uurin c ncrcarea a fost mutat n afara ramurii condiionale L1. n consecin,
ncrcarea se va executa indiferent ce ramur de salt va fi tratat. Dac sunt disponibile resurse paralele, acest
fapt nu pune nici un fel de problem. Nu acelai lucru se poate spune dac - spre exemplu - n urma accesului la
memorie se genereaz o eroare de pagin, tiut fiind c rezolvarea unei asemenea situaii necesit extrem de
mult timp i resurse. O soluie ar fi ca rezolvarea erorii de pagin s se fac numai atunci cnd ncrcarea din
memorie este efectiv necesar, adic numai dac trebuie s se execute ramura L1.
Cum execuia paralel a celor dou ramuri se declaneaz totui simultan i nu vom putea ti apriori
dac L1 este sau nu ramura bun, problema poate fi rezolvat tot prin tehnica ncrcrii speculative. O astfel de
soluie pornete de la ideea c instruciunea de ncrcare propriu-zis din programul original poate fi nlocuit prin
dou instruciuni echivalente:
126

Arhitectura calculatoarelor

CAPITOLUL VIII

o ncrcare speculativ (LD.s), care efectueaz citirea din memorie i detecteaz dac are loc o
excepie tip eroare de pagin (de obicei, aceast excepie nu este semnalat de ctre sistemul de
operare). Dac se dorete reducerea latenei memoriei, instruciunea LD.s va fi cea care este mutat n
cadrul secvenei de program.

o instruciune de verificare (CHK.s), care semnaleaz excepia tip eroare de pagin, dac aceasta a fost

detectat de LD.s. n caz contrar, CHK.s nu va avea nici un efect. Aceast instruciune rmne
ntotdeauna pe loc n secvena de execuie, neputnd fi mutat de ctre compilator.
Prin desfacerea n dou, ca mai sus, a instruciunii LOAD, chiar dac ncrcarea este mutat n afara
granielor secvenei de salt, nu vor fi tratate excepiile mari consumatoare de timp dect numai pe ramura care
efectiv are nevoie de valoarea citit din memorie.
Folosind tehnica ncrcrii speculative, secvena modificat din ultimul exemplu considerat va fi
transformat astfel:

L1:
L2:

LD.s

R3, x

ADI

R0, 1

BZ

R0, L1

ADI

R2, R2, 1

BR
CHK.s

L2
R3

ADI

R3, R3, 1

SBI

R4, R4, 1

R3x

Compilatorul procesorului Itanium poate utiliza simultan att predictarea salturilor ct i ncrcarea
speculativ. n secvena de mai sus am ilustrat numai cea a doua tehnic.
n sintez, subliem nc o dat c arhitecturile VLIW au aprut ca o ncercare de a evita complexitatea
hard a celor superscalare. mbuntirea performanelor n ceea ce privete detectarea paralelismului
instruciunilor la procesorul VLIW se datoreaz n totalitate compilatorului, care expliciteaz acest paralelism la
nivelul de operaii al instruciunilor.
Neavnd de-a face cu detectarea hard a paralelismelor, procesoarele VLIW pot avea un mare numr de
uniti funcionale, ceea ce impune un numr ridicat de registre i o band larg de trecere pentru magistral. Ca
ntr-un cerc vicios, pentru ca aceste uniti funcionale numeroase s fie ct mai mult timp ocupate, se cere
compilatoarelor destinate aceste procesoare s practice tehnici din ce n ce mai agresive n detectarea
paralelismului. Am ncercat s prezentm cteva dintre acestea.
Desfacerea buclelor, constnd n transformarea acestora ntr-un numr de iteraii, care apoi sunt tratate
n paralel, permite introducerea paralelismului n bucle. Pentru salturile condiionate, paralelismul tratrii este
asigurat prin planificarea traseelor de tratare, care implic o predicie din partea compilatorului referitoare la
ramura cea mai probabil de a fi selectat. Aceasta este urmat de o planificare a operaiilor, astfel nct aceast
secven s fie executat ct mai rapid. Pentru pstrarea corectitudinii programului trebuie uneori adugat un cod
suplimentar de compensaie. Adugarea se poate face la nceputul celeilalte ramuri a saltului.
Tehnicile VLIW sunt utilizate n proiectarea unei noi generaii de sisteme cu mare vitez de prelucrare,
familia de procesoare cu arhitecturi de 64 de bii IA - 64. Primul membru planificat al familiei Intel IA-64 este
procesorul Itanium. Pe lng cteva caracteristici VLIW tipice, arhitectura Itanium utilizeaz predicarea salturilor
i ncrcarea speculativ.
Predicarea salturilor - diferit de tehnica predictrii salturilor - se bazeaz pe execuia cu predicate,
tehnic ce implic conectarea procedurii de execuie a instruciunii la un numr de regitri predicat. Instruciunea
va fi terminat numai atunci cnd un registru predicat specificat devine "adevrat". Predicarea salturilor
presupune ca instruciuni de pe ramuri de salt diferite s poat fi startate n paralel, urmnd ca, n final, s fie
terminate numai acelea situate pe ramur corect.
ncrcarea speculativ ncearc s reduc ntrzierile care apar la execuia instruciunilor de transfer al
datelor din memorie n regitri, prin mutarea acestora n afara granielor ramurilor de salt. Totui, excepiile de tip
eroare de pagin nu vor fi tratate dect atunci cnd este necesar. Pentru aceasta, instruciunea este mprit n
127

Arhitectura calculatoarelor

CAPITOLUL VIII

dou: o instruciune de ncrcare speculativ propriu-zis, care este mutat i o instruciune de verificare, care
rmne pe loc.

128