InstructionLevelParallelism

Planificare dinamic a instruciunilor:

Algoritmul lui Tomasulo
Exemple i figuri preluate i prelucrate dup:
D.A. Petterson and J. L. Hennessy, Computer Architecture A Quantitative Approach,
4th ed., Morgan Kaufmann, 2007
Montek Singh, Computer Architecture and Implementation, University of North
Carolina at Chapel Hill
2
Introducere
Algoritmul lui Tomasulo a fost implementat prima oar pentru unitatea
de virgul mobil a calculatorului IBM 360/91
Algoritmul inventat de Robert Tomasulo:
urmrete cnd operanzii instruciunilor sunt disponibili pentru a minimiza
hazardurile RAW
introduce re-numirea registrelor pentru a minimiza hazardurile WAW i WAR.
Exist multe variante ale implementrii algoritmului
Se pstreaz conceptele generale cu privire la recunoaterea dependenelor
instruciunilor, pentru a permite execuia imediat ce operanzii sunt disponibili,
respectiv re-numirea registrelor
3
Introducere
Scop iniial al algoritmului: nalt performan operaii FP, fr
compilatoare speciale
Arhitectura 360 conine doar 4 registre FP dubl precizie, ceea ce limiteaz
eficiena unei planificri efectuate de ctre compilator
IBM 360/91 avea un timp de acces mare la memorie (nainte de apariia
memoriilor cache!) i ntrzieri mari la operaiile FP
Algoritmul, n contextul setului de instruciuni specific MIPS, se
focalizeaz pe unitatea FP i pe unitatea load store,
Chiar dac 360 utiliza uniti funcionale de tip conduct, dar nu folosea
uniti funcionale multiple, n descrierea algoritmului vom presupune
uniti funcionale multiple i implementate pipelined
4
Diferene
ntre algoritmul lui Tomasulo i Scoreboard
Controlul distribuit la uniti funcionale spre deosebire de sistemul
centralizat la scoreboard
Buffer-e distribuite la unitile funcionale; procedeul folosete
reservation stations (RS)
Operaiile Load i Store tratate ca i uniti funcionale, cu staii de
rezervare pentru stocri
Registrele (cmp operand) din instruciuni sunt nlocuite prin pointeri n
staiile de rezervare
Aceast tehnic este numit re-denumire registre
Re-denumirea ajut la nlturarea hazardurilor WAR i WAW
Mai multe staii de rezervare dect registre; permite astfel operaii pe care
compilatoarele optimizatoare nu le pot face
Tranzacii ale rezultatelor prin Bus de date comun (Common Data Bus -
CDB) ctre toate unitile funcionale (forwarding!)
5
Dependene care produc hazarduri
WAR i WAW
Se consider secvena de cod urmtoare, care include att hazard WAR ct i
WAW:
DIV.D F0,F2,F4
ADD.D F6,F0,F8
S.D F6,0(R1)
SUB.D F8,F10,F14
MUL.D F6,F10,F8
Exist o anti-dependen (WAR) ntre ADD.D i SUB.D, la utilizarea
registrului F8 de ADD.D
Exist o dependen de ieire (WAW) ntre ADD.D i MUL.D, pentru c
ADD.D se poate termina mai trziu dect MUL.D
6
Hazard de tip RAW
DIV.D F0,F2,F4
ADD.D F6,F0,F8 ;RAW pentru F0
S.D F6,0(R1) ;RAW pentru F6
SUB.D F8,F10,F14
MUL.D F6,F10,F8 ;RAW pentru F8
Exist de asemenea trei dependene reale (RAW) de date:
ntre DIV.D i ADD.D
ntre SUB.D i MUL.D
ntre ADD.D i S.D (F6 este surs pentru operaia de stocare)
7
Re-denumire registre
Cele dou dependenele de nume (WAR i WAW) pot fi eliminate prin
re-numirea registrelor.
Considerm, pentru simplificare, existena a dou registre temporare, S
i T.
Utiliznd S i T, secvena anterioar poate fi rescris, cu eliminarea
dependenelor, astfel:
DIV.D F0,F2,F4
ADD.D S,F0,F8
S.D S,0(R1)
SUB.D T,F10,F14
MUL.D F6,F10,T
DIV.D F0,F2,F4
ADD.D F6,F0,F8
S.D F6,0(R1)
SUB.D F8,F10,F14
MUL.D F6,F10,F8

8
Re-denumire - alte probleme
Dac registrul F8 este folosit de vreo instruciune ulterioar, acesta
trebuie nlocuit cu T
n segmentul de cod exemplificat procesul de re-numire poate fi realizat
static de ctre compilator
Descoperirea utilizrii lui F8 n codul ce urmeaz secvenei analizate
necesit fie o analiz complicat din partea compilatorului fie un suport
hardware, pentru c pot interveni ramificri ntre segmentul de cod luat
ca exemplu i utilizarea ulterioar a lui F8
Algoritmul lui Tomasulo poate rezolva re-numirea i n cazul acestor
ramificri
9
Staii de rezervare
n schema lui Tomasulo re-numirea registrelor se face prin staii de
rezervare
Staia de rezervare:
Memoreaz temporar operanzii instruciunilor ce ateapt s fie emise /
lansate
Aduce i memoreaz temporar operandul, imediat ce acesta este disponibil
Se elimin astfel necesitatea de a citi operandul dintr-un registru
Instruciunile (ntrziate) i staiile de rezervare care le vor furniza
intrrile (operanzii)
Imediat ce instruciunile sunt emise, specificatorii de registre pentru
operanzi n ateptare sunt re-numii cu numele staiei de rezervare
Dac, n execuie, se suprapun mai multe scrieri succesive ntr-un registru,
doar ultima scriere este folosit pentru actualizarea coninutului
registrului
Pentru c pot exista mai multe staii de rezervare dect registre reale,
tehnica elimin hazardurile ce provin din dependene de nume, care nu
ar putea fi eliminate de compilator
10
Staii de rezervare
Utilizarea staiilor de rezervare, n locul unei bnci centralizate de registre,
conduce la dou proprieti importante:
1. Detecia hazardului i controlul execuiei sunt distribuite:
Informaia meninut n staiile de rezervare pentru fiecare unitate funcional
determin cnd o instruciune poate ncepe execuia utiliznd acea unitate
2. Rezultatele sunt transmise direct din staiile de rezervare unde sunt memorate
temporar ctre unitile funcionale, fr a mai trece prin registre
Acest lucru se face cu ajutorul magistralei comune de rezultate care permite
tuturor unitilor s atepte ncrcarea simultan a unui operand (la 360/91
magistrala e numit common data bus CDB)
n cazul conductelor de execuie cu uniti multiple de execuie i cu emitere
de mai multe instruciuni pe ceas, sunt necesare mai multe magistrale de
rezultat
11
Organizare unitate FP ce implementeaz algoritmul
lui Tomasulo
12
Organizare unitate FP legend figur
Instruciunile sunt transmise din unitatea de instruciuni ctre coada de
instruciuni de unde acestea sunt emise n ordine (FIFO)
Staiile de rezervare includ operaiile, operanzii cureni i informaiile
utilizate pentru detectarea i rezolvarea hazardurilor
Toate rezultatele de la unitile FP i de load sunt depuse pe CDB, care
le transfer ctre:
fiierul (banca) de registre FP
staiile de rezervare
tampoanele de store
FP adder implementeaz operaii de adunare i scdere
FP multiplier efectueaz operaii de nmulire i mprire
13
Organizare unitate FP legend figur
Tampoanele de load:
pstreaz componentele adresei efective pn cnd aceasta este calculat
urmresc operaiile de load care ateapt accesul la memorie
pstreaz rezultatul operaiilor de load terminate care ateapt accesul la
CDB
Tampoanele de store:
pstreaz componentele adresei efective pn cnd aceasta este calculat
urmresc operaiile de store care ateapt accesul la memorie
pstreaz adresa destinaie de memorie pentru operaiile de store care
ateapt valorile datelor ce trebuie stocate
pstreaz valoarea de stocat pn cnd unitatea de memorie este
disponibil
14
Mai multe detalii ale organizrii Tomasulo
Entitilor care produc valori li se atribuie etichete de 4 bii
1, 2, 3, 4, 5, 6 pentru load buffers
8, 9 pentru staii de rezervare la nmulitor
10, 11, 12 pentru staii de rezervare la sumator
Eticheta 0 indic prezena datelor valide
Registrele FP au bii de ocupat ( busy bits)
0 semnific c registrul conine date valide
1 semnific c se ateapt recepionarea de valori de la sursa identificat
prin cmpul su etichet
15
Staii de rezervare - cmpuri componente
Op Operaia de realizat asupra operanzilor surs S1 i S2
Qj, Qk - Staii de rezervare ce produc operanzii surs corespunztori
Observaie: Valoarea zero (Qj,Qk=0) indic operanzi disponibili n Vj i
Vk, sau faptul c operanzii nu sunt necesari
Vj, Vk: Valorile operanzilor surs
Observaie: doar unul din cmpurile V sau Q este valid pentru fiecare
operand. Pentru loads cmpul Vk este utilizat pentru meninerea cmpului
offset (indic unde se stocheaz rezultatul)
A utilizat pentru meninerea informaiei pentru calculul adresei de
memorie pentru un load sau un store.
Iniial, aici se stocheaz cmpul imediat al instruciunii; dup calculul
adresei aici se stocheaz adresa efectiv
Busy - Indic faptul c staia de rezervare i unitatea funcional
corespunztoare sunt ocupate
16
Componentele staiei de rezervare
Fiierul (banca) de registre are un cmp Qi:
Qi - Numrul staiei de rezervare ce conine operaia al crui rezultat va fi stocat
n acel registru.
Dac valoarea lui Qi este goal (sau 0), nu exist nici o instruciune activ care
s calculeze un rezultat destinat acelui registru, nelegnd c valoarea este pur
i simplu coninutul registrului
Register result statusIndic modul n care fiecare unitate funcional
va scrie fiecare registru, dac este cazul.
Intrare goal cnd nici o instruciune nu ateapt s scrie acel registru
17
Tomasulo: Reprezentarea dependenelor de
date
Intrri
Operandul este un registru cu bitul busy = 0
Data copiat imediat (prin magistrala registrelor) n staia de rezervare
Cmpul etichet al RS (reservation station) setat la 0
Operandul este un registru cu bitul busy = 1
Cmpul etichet al RS primete o copie a cmpului etichet a registrului
Operandul este un buffer de load care conine date valide
Date copiate n RS
Operandul este un buffer de load care ateapt date
Cmpul etichet al RS recepioneaz eticheta bufferului de load
Ieiri
Ieirea este un registru
Bitul Busy e setat la 1, eticheta setat la eticheta RS
Ieirea este un buffer de stocare
Eticheta setat la eticheta RS, adresa destinaie setat.
18
Trei etaje ale algoritmului lui
Tomasulo
Issue
Execute
Write Result
19
ISSUE
Issue primete urmtoarea instruciune din coada de
instruciuni (FIFO).
Dac exist o staie de rezervare liber, emite instruciunea ctre staia cu
valorile operanzilor, dac operanzii se gsesc n registre la acel moment
Dac nu exist o staie de rezervare liber, atunci exist un hazard
structural iar instruciunea este oprit pn cnd staia sau buffer-ul se
elibereaz
Dac operanzii nu sunt n registre, se urmrete traseul unitilor
funcionale care vor produce operanzii
Etajul issue re-numete registrele, eliminnd hazardurile WAR i WAW.
(La procesoare cu planificare dinamic acest etaj este numit uneori
dispatch expediere)
20
EXECUTE
Dac toi operanzii sunt disponibili, operaia poate fi executat n
unitatea funcional corespunztoare.
Dac unul sau mai muli operanzi nu sunt disponibili se monitorizeaz
magistrala comun de date (CDB) pentru rezultat
Cnd un operand devine disponibil, el va fi plasat n orice staie de
rezervare ce ateapt acest lucru
Prin ntrzierea execuiei instruciunii pn operanzii sunt disponibili,
hazardurile RAW sunt eliminate
Unele procesoare cu planificare dinamic numesc acest pas issue, dar aici
utilizm numele execute
21
EXECUTE
De observat c mai multe instruciuni pot deveni gata n acelai impuls de
ceas pentru aceeai unitate funcional
Pentru uniti funcionale independente execuia diferitelor instruciuni poate
ncepe n acelai impuls de ceas
Pentru o singur unitate funcional, dac mai multe instruciuni sunt gata pentru
execuie, se va alege doar una dintre instruciuni
Pentru staiile de rezervare FP, alegerea poate fi fcut arbitrar
Complicaii suplimentare la operaii load i store:
Operaiile load i store cer doi pai pentru procesul de execuie
1. calculeaz adresa efectiv dac registrul de baz este disponibil, plaseaz n buffer-ul de
load sau store adresa efectiv
2. Execuie load / store
Operaiile de load din tamponul-de-load se execut imediat ce unitatea de
memorie este disponibil
Operaiile de store din tamponul-de-store ateapt ca valorile s fie stocate nainte
ca s fie transmise ctre unitatea de memorie
22
EXECUTE
Nu se permite iniierea execuiei instruciunilor pn cnd toate ramificrile
care preced instruciunea, n ordinea programului, nu au fost terminate
Aceast restricie garanteaz c o instruciune care produce o excepie n timpul
execuiei va fi ntr-adevr executat
ntr-un procesor care utilizeaz predicia ramificrilor (aa cum fac toate
procesoarele cu planificare dinamic), aceasta nseamn c procesorul trebuie
s tie c predicia ramificrilor a fost corect nainte de a permite ca o
instruciune de dup ramificare s nceap execuia
Dac procesorul nregistreaz producerea unei excepii, dar nc nu a trecut la
servirea ei, o instruciune poate porni execuia i nu va fi oprit pn cnd intr
n Write Result
23
Write Result
Termin execuia
Cnd un rezultat este disponibil, se scrie pe CDB i de acolo n registre
i n orice staie de rezervare care ateapt acel rezultat
Dup terminare, staia de rezervare se marcheaz ca disponibil
Stocrile se fac ntr-un buffer de stocare pn cnd valoarea ce trebuie
stocat i adresa de stocare sunt disponibile, apoi rezultatul este scris
imediat ce unitatea de memorie este liber
24
Observaii la algoritmul lui Tomasulo
Instruciunile se mut din decodificatorul de instruciuni n staii de
rezervare
n ordinea din program
Dependenele pot fi nregistrate corect
Fluxul de date urmrit: Graficul pointerilor de conectare la RS,
registre i buffere de memorie
Ajut la realizarea secvenei out-of-order de instruciuni
Re-numirea permite nlturarea dependenelor de nume (la scoreboarding se
produceau blocaje)
Costurile principale ale acestei scheme: hardware asociativ de mare
vitez
Hardware RS trebuie s caute etichetele atunci cnd CDB transmite unele valori
cu eticheta sa
Este suportat load bypassing complet spre deosebire de scoreboarding
Bufferele de load i store sunt tratate ca i unitile funcionale
25
Tomasulo Example Cycle 0
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 Load1 No
LD F2 45+ R3 Load2 No
MULTF0 F2 F4 Load3 No
SUBD F8 F6 F2
DIVD F10 F0 F6
ADDDF6 F8 F2
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 No
0 Add3 No
0 Mult1 No
0 Mult2 No
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
0 FU
26
Tomasulo Example Cycle 1
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 Load1 No 34+R2
LD F2 45+ R3 Load2 No
MULTF0 F2 F4 Load3 No
SUBD F8 F6 F2
DIVD F10 F0 F6
ADDDF6 F8 F2
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 No
Add3 No
0 Mult1 No
0 Mult2 No
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
1 FU Load1
Yes
27
Tomasulo Example Cycle 2
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 Load1 Yes 34+R2
LD F2 45+ R3 2 Load2 Yes 45+R3
MULTF0 F2 F4 Load3 No
SUBD F8 F6 F2
DIVD F10 F0 F6
ADDDF6 F8 F2
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 No
Add3 No
0 Mult1 No
0 Mult2 No
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
2 FU Load2 Load1
28
Tomasulo Example Cycle 3
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 Load1 Yes 34+R2
LD F2 45+ R3 2 Load2 Yes 45+R3
MULTF0 F2 F4 3 Load3 No
SUBD F8 F6 F2
DIVD F10 F0 F6
ADDDF6 F8 F2
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 No
Add3 No
0 Mult1 Yes MULTD R(F4) Load2
0 Mult2 No
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
3 FU Mult1 Load2 Load1
Note: registers names are removed ( renamed ) in Reservation Stations;
29
Tomasulo Example Cycle 4
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 Load2 Yes 45+R3
MULTF0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4
DIVD F10 F0 F6
ADDDF6 F8 F2
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 Yes SUBD M(34+R2) Load2
0 Add2 No
Add3 No
0 Mult1 Yes MULTD R(F4) Load2
0 Mult2 No
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
4 FU Mult1 Load2 M(34+R2) Add1
Load2 completing
30
Tomasulo Example Cycle 5
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4
DIVD F10 F0 F6 5
ADDDF6 F8 F2
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
2 Add1 Yes SUBD M(34+R2) M(45+R3)
0 Add2 No
Add3 No
10 Mult1 Yes MULTDM(45+R3) R(F4)
0 Mult2 Yes DIVD M(34+R2) Mult1
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
5 FU Mult1 M(45+R3) M(34+R2) Add1 Mult2
31
Tomasulo Example Cycle 6
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4
DIVD F10 F0 F6 5
ADDDF6 F8 F2 6
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
1 Add1 Yes SUBD M(34+R2) M(45+R3)
0 Add2 Yes ADDD M(45+R3) Add1
Add3 No
9 Mult1 Yes MULTDM(45+R3) R(F4)
0 Mult2 Yes DIVD M(34+R2) Mult1
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
6 FU Mult1 M(45+R3) Add2 Add1 Mult2
32
Tomasulo Example Cycle 7
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 7
DIVD F10 F0 F6 5
ADDDF6 F8 F2 6
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 Yes SUBD M(34+R2) M(45+R3)
0 Add2 Yes ADDD M(45+R3) Add1
Add3 No
8 Mult1 Yes MULTDM(45+R3) R(F4)
0 Mult2 Yes DIVD M(34+R2) Mult1
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
7 FU Mult1 M(45+R3) Add2 Add1 Mult2
Add1 completing
33
Tomasulo Example Cycle 8
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 Load3 No
SUBDF8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDDF6 F8 F2 6
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
2 Add2 Yes ADDD M()-M() M(45+R3)
0 Add3 No
7 Mult1 Yes MULTDM(45+R3) R(F4)
0 Mult2 Yes DIVD M(34+R2) Mult1
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
8 FU Mult1 M(45+R3) Add2 M()-M() Mult2
34
Tomasulo Example Cycle 9
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDDF6 F8 F2 6
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
1 Add2 Yes ADDD M()M() M(45+R3)
0 Add3 No
6 Mult1 Yes MULTDM(45+R3) R(F4)
0 Mult2 Yes DIVD M(34+R2) Mult1
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
9 FU Mult1 M(45+R3) Add2 M()M() Mult2
35
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDDF6 F8 F2 6 10
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 Yes ADDD M()M() M(45+R3)
0 Add3 No
5 Mult1 Yes MULTDM(45+R3) R(F4)
0 Mult2 Yes DIVD M(34+R2) Mult1
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
10 FU Mult1 M(45+R3) Add2 M()M() Mult2
Tomasulo Example Cycle 10
Add2 completing;
36
Tomasulo Example Cycle 11
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTDF0 F2 F4 3 Load3 No
SUBDF8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDDF6 F8 F2 6 10 11
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 No
0 Add3 No
4 Mult1 Yes MULTDM(45+R3) R(F4)
0 Mult2 Yes DIVD M(34+R2) Mult1
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
11 FU Mult1 M(45+R3) (M-M)+M() M()-M() Mult2
Write result of ADDD here vs. scoreboard?
37
Tomasulo Example Cycle 12
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 6 7
DIVD F10 F0 F6 5
ADDDF6 F8 F2 6 10 11
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 No
0 Add3 No
3 Mult1 Yes MULTDM(45+R3) R(F4)
0 Mult2 Yes DIVD M(34+R2) Mult1
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
12 FU Mult1 M(45+R3) (M-M)+M() M()M() Mult2
Note: all quick instructions complete already
38
Tomasulo Example Cycle 13
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDDF6 F8 F2 6 10 11
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 No
Add3 No
2 Mult1 Yes MULTDM(45+R3) R(F4)
0 Mult2 Yes DIVD M(34+R2) Mult1
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
13 FU Mult1 M(45+R3) (MM)+M() M()M() Mult2
39
Tomasulo Example Cycle 14
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDDF6 F8 F2 6 10 11
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 No
0 Add3 No
1 Mult1 Yes MULTDM(45+R3) R(F4)
0 Mult2 Yes DIVD M(34+R2) Mult1
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
14 FU Mult1 M(45+R3) (MM)+M() M()M() Mult2
40
Tomasulo Example Cycle 15
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 15 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDDF6 F8 F2 6 10 11
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 No
Add3 No
0 Mult1 Yes MULTDM(45+R3) R(F4)
0 Mult2 Yes DIVD M(34+R2) Mult1
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
15 FU Mult1 M(45+R3) (MM)+M() M()M() Mult2
Mult1 completing
41
Tomasulo Example Cycle 16
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 15 16 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDDF6 F8 F2 6 10 11
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 No
Add3 No
0 Mult1 No
40 Mult2 Yes DIVD M*F4 M(34+R2)
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
16 FU M*F4 M(45+R3) (MM)+M() M()M() Mult2
Note: Just waiting for divide
42
Skip some cycles .....
43
Tomasulo Example Cycle 55
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 15 16 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5
ADDDF6 F8 F2 6 10 11
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 No
Add3 No
0 Mult1 No
1 Mult2 Yes DIVD M*F4 M(34+R2)
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
55 FU M*F4 M(45+R3) (MM)+M() M()M() Mult2
44
Tomasulo Example Cycle 56
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 15 16 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5 56
ADDDF6 F8 F2 6 10 11
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 No
Add3 No
0 Mult1 No
0 Mult2 Yes DIVD M*F4 M(34+R2)
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
56 FU M*F4 M(45+R3) (MM)+M() M()M() Mult2
Mult 2 completing
45
Tomasulo Example Cycle 57
Instruction status Execution Write
Instruction j k Issue complete Result Busy Address
LD F6 34+ R2 1 3 4 Load1 No
LD F2 45+ R3 2 4 5 Load2 No
MULTF0 F2 F4 3 15 16 Load3 No
SUBD F8 F6 F2 4 7 8
DIVD F10 F0 F6 5 56 57
ADDDF6 F8 F2 6 10 11
Reservation Stations S1 S2 RS for j RS for k
Time Name Busy Op Vj Vk Qj Qk
0 Add1 No
0 Add2 No
Add3 No
0 Mult1 No
0 Mult2 No
Register result status
Clock F0 F2 F4 F6 F8 F10 F12 ... F30
57 FU M*F4 M(45+R3) (MM)+M() M()M() M*F4/M
Again, in-oder issue,
out-of-order execution, completion
46
Motiv adoptare algoritm Tomasulo
Algoritmul lui Tomasulo a fost adoptat n procesoarele cu emitere de mai
multe instruciuni ncepnd cu anii 1990, dei nu a fost utilizat muli ani dup
360/91. Motive:
1. Permite obinerea de performane ridicate fr s solicite compilatorului s
particularizeze codul pentru o anumit structur specific a conductei de
execuie
2. Dei a fost conceput nainte de apariia memoriilor cache, apariia acestora,
cu ntrzierile nepredictibile inerente, a devenit o motivaie major pentru
planificarea dinamic
3. Execuia out-of-order permite procesoarelor s continue execuia
instruciunilor, n timp ce se ateapt rezolvarea unui cache miss, mascnd
astfel, parial sau total, dezavantajul ratrilor la memoria cache
4. Tehnicile de re-numire a registrelor i planificarea dinamic au fost
implementate n cele mai multe din procesoarele moderne
5. Pentru c planificarea dinamic este o component cheie a speculaiei, a fost
adoptat pentru speculaia prin hardware, ncepnd cu anii 1990
47
Paralelism realizat de compilator
(planificare, loop unrolling, software
pipelining)
48
Planificare pipeline i desfacere bucle
(Loop Unrolling)
Paralelismul ntre instruciuni trebuie exploatat pentru meninerea plin a
conductei de execuie.
Aceasta se face prin gsirea secvenelor de instruciuni fr inter-dependene,
care pot fi suprapuse n conducta de execuie
Pentru a preveni blocarea conductei, o instruciune dependent trebuie separat
de instruciunea surs la o distan egal cu latena instruciunii surs, distan
calculat n impulsuri de ceas
Abilitatea compilatorului de a realiza aceast planificare depinde att de
cantitatea de ILP existent n program ct i de latena unitilor funcionale din
conducta de execuie
49
Planificare pipeline i desfacere bucle
Pipelining are eficien maxim cnd exist paralelism ntre instruciuni
Instruciunile i i j pot fi executate n paralel dac nici una nu este
dependent de cealalt
Problem: paralelismul n cadrul blocurilor de baz din program este
limitat
Trebuie s privim dincolo de blocurile de baz
Soluie: exploatarea paralelismului la nivel de bucl
Descoperirea paralelismului ntre iteraiile buclei
Pentru a converti paralelismul la nivel de bucl n ILP, trebuie s desfacem
bucla
Dinamic, prin hardware
Static, cu ajutorul compilatorului
Prin utilizare de instruciuni vectoriale: aceeai operaie aplicat la toate
elementele vectorului
50
Planificare pipeline i desfacere bucle
(Loop Unrolling)
Figura urmtoare indic latenele unitii FP pe care le vom presupune n
continuare, cu excepia cazului cnd nu se specific explicit altfel
Presupunem o conduct de ntregi standard cu cinci etaje, astfel c ramificrile
au o penalitate de 1 impuls de ceas
Presupunem c unitile funcionale sunt realizate complet ca i conducte de
execuie (pipelined) sau multiplicate de un numr de ori egal cu adncimea
conductei, astfel nct se poate porni (issue) o operaie de orice tip, la fiecare
impuls de ceas, fr ca s existe hazarduri structurale
51
Exemplu de pipeline
52
Principiu: Loop Unrolling
Vom ncerca s demonstrm modul cum compilatorul poate crete cantitatea de
paralelism prin transformarea buclelor.
Ne vom baza pe urmtorul segment de cod, care adun un scalar la un vector:
for (i =1000; i>0; i =i-1)
x [ i ] =x [ i ] +s;
53
Cod pentru MIPS
n segmentul de cod de mai jos R1 conine adresa iniial a
elementului din vector, cu cea mai mare adres, iar F2
conine valoarea scalar s.
Vectorul x ncepe la adresa de memorie 0
Loop: L.D F0,0(R1) ;F0=array element
ADD.D F4,F0,F2 ;add scalar in F2
S.D F4,0(R1) ;store result
DADDUI R1,R1,#-8 ;decrement pointer 8 bytes (per DW)
BNEZ R1,Loop ;branch R1!=0
54
Observaii la codul re-ordonat
3 din cele 5 instruciuni lucreaz cu FP
Putem crete performanele prin desfacerea buclei?
Presupunem c numrul de iteraii este multiplu de 4 i desfacem
corpului buclei de 4 ori
Desfacerea buclei (loop unrolling) copiaz pur i simplu corpul buclei
de mai multe ori
Ca urmare pot fi planificate instruciuni din iteraii diferite
Putem astfel elimina blocrile datorit dependenei de date prin crearea
de instruciuni suplimentare independente din corpul buclei
La desfacere diversele iteraii tind s foloseasc acelai registru pentru
instruciuni. Vom crete numrul necesar de registre pentru a nltura
aceast dependen
55
Unrolling: ncercare 1
Am rezolvat dependena de
control dar va rezulta o
dependen de date prin R1
Putem nltura dependena, dac
observm c R1 este decrementat
de fiecare dat cu 8
Ajustare specificatori de adres
tergem primele 3 DADDUI
La a patra instruciune DADDUI
constanta va fi 32
Sunt inferene dificile de fcut de
un compilator
LOOP: L.D F0,0(R1)
ADD.D F4,F0,F2
S.D F4,0(R1)
DADDUI R1, R1,-8
L.D F0, 0(R1)
ADD.D F4, F0, F2
S.D F4,0(R1)
DADDUI R1, R1,-8
L.D F0, 0(R1)
ADD.D F4, F0, F2
S.D F4,0(R1)
DADDUI R1, R1,-8
L.D F0, 0(R1)
ADD.D F4, F0, F2
S.D F4,0(R1)
DADDUI R1, R1,-8
BNEZ R1, LOOP
NOP
LOOP: L.D F0,0(R1)
ADD.D F4,F0,F2
S.D F4,0(R1)
DADDUI R1, R1,-8
L.D F0, 0(R1)
ADD.D F4, F0, F2
S.D F4,0(R1)
DADDUI R1, R1,-8
L.D F0, 0(R1)
ADD.D F4, F0, F2
S.D F4,0(R1)
DADDUI R1, R1,-8
L.D F0, 0(R1)
ADD.D F4, F0, F2
S.D F4,0(R1)
DADDUI R1, R1,-8
BNEZ R1, LOOP
NOP
56
Unrolling: ncercare 2
Performana mai este limitat
doar de dependena WAR cu
F0
Este o dependen de nume
Putem utiliza diferite registre
pentru iteraii diferite (dac
mai exist registre)
LOOP: L.D F0, 0(R1)
ADD.D F4, F0, F2
S.D F4, 0(R1)
L.D F0, -8(R1)
ADD.D F4, F0, F2
S.D F4, -8(R1)
L.D F0, -16(R1)
ADD.D F4, F0, F2
S.D F4, -16(R1)
L.D F0, -24(R1)
ADD.D F4, F0, F2
S.D F4, -24(R1)
DADDUI R1, R1,-32
BNEZ R1, LOOP
NOP
LOOP: L.D F0, 0(R1)
ADD.D F4, F0, F2
S.D F4, 0(R1)
L.D F0, -8(R1)
ADD.D F4, F0, F2
S.D F4, -8(R1)
L.D F0, -16(R1)
ADD.D F4, F0, F2
S.D F4, -16(R1)
L.D F0, -24(R1)
ADD.D F4, F0, F2
S.D F4, -24(R1)
DADDUI R1, R1,-32
BNEZ R1, LOOP
NOP
57
Unrolling: ncercare 3
LOOP: L.D F0, 0(R1)
ADD.D F4, F0, F2
S.D F4, 0(R1)
L.D F6, -8(R1)
ADD.D F8, F6, F2
S.D F8, -8(R1),
L.D F10, -16(R1)
ADD.D F12, F10, F2
S.D F12, -16(R1),
L.D F14, -24(R1)
ADD.D F16, F14, F2
S.D F16, -24(R1)
DADDUI R1, R1, -32
BNEZ R1, LOOP
NOP
LOOP: L.D F0, 0(R1)
ADD.D F4, F0, F2
S.D F4, 0(R1)
L.D F6, -8(R1)
ADD.D F8, F6, F2
S.D F8, -8(R1),
L.D F10, -16(R1)
ADD.D F12, F10, F2
S.D F12, -16(R1),
L.D F14, -24(R1)
ADD.D F16, F14, F2
S.D F16, -24(R1)
DADDUI R1, R1, -32
BNEZ R1, LOOP
NOP
Timp necesar pentru 4 iteraii:
14 cicluri instruciune
4 blocri din L.DADD.D
8 blocri din ADD.DS.D
1 blocare DADDUIBNEZ
1 blocare la ramificare (NOP)
28 ciclii pentru 4 iteraii, sau o
medie de 7 ciclii pe iteraie
Mai lent dect versiunea
iniial a buclei cu planificare
(6 ciclii)
Facem i aici re-ordonare
58
Unrolling: ncercare 4
Codul ruleaz fr blocri
14 ciclii pentru 4 iteraii
3.5 ciclii pe iteraie n medie
Timp suplimentar pentru
controlul buclei = o dat la
fiecare 4 iteraii
De observat c bucla
original avea 3 instruciuni
FP care nu erau independente
Desfacerea buclei
evidenieaz instruciuni
independente din mai multe
iteraii ale buclei
LOOP: L.D F0, 0(R1)
L.D F6, -8(R1)
L.D F10, -16(R1)
L.D F14, -24(R1)
ADD.D F4, F0, F2
ADD.D F8, F6, F2
ADD.D F12, F10, F2
ADD.D F16, F14, F2
S.D F4, 0(R1)
S.D F8, -8(R1)
DADDUI R1, R1, -32
S.D F12, 16(R1)
BNEZ R1, LOOP
S.D F16, 8(R1)
LOOP: L.D F0, 0(R1)
L.D F6, -8(R1)
L.D F10, -16(R1)
L.D F14, -24(R1)
ADD.D F4, F0, F2
ADD.D F8, F6, F2
ADD.D F12, F10, F2
ADD.D F16, F14, F2
S.D F4, 0(R1)
S.D F8, -8(R1)
DADDUI R1, R1, -32
S.D F12, 16(R1)
BNEZ R1, LOOP
S.D F16, 8(R1)
59
Ce are de fcut compilatorul ?
S determine dac este corect s se mute S.D dup DADDUI i BNEZ
S determine mrimea cu care trebuie ajustat offset la S.D
S determine dac desfacerea buclei este util, prin determinarea independenei
iteraiilor buclei
S re-numeasc registrele pentru eliminarea dependenelor de date
S elimine testele i ramificrile suplimentare
S determine modul cum instruciunile L.D i S.D pot fi inter-schimbate. n
exemplul dat specificatorii de adres: 0(R1), -8(R1), -16(R1), -24(R1) se refer la
locaii diferite de memorie
S planifice (re-ordoneze) codul
60
Limitri ale ctigului prin desfacerea
buclelor
Limitri ale dimensiunii codului
Pentru bucle mari creterea dimensiunii codului poate fi o limitare n
special n domeniul embedded
Crete rata de ratare a cache, la aducerea instruciunilor
Limitri arhitecturale / compilator
Este nevoie de mai multe registre
Devine mai dificil n cazul arhitecturilor super-scalare cu lansri multiple
de instruciuni
61
Software Pipelining
Observaie
Dac iteraiile din bucle sunt independente, atunci paralelismul se poate obine
prelund instruciuni din diferite iteraii
Software pipelining
Re-organizarea buclelor astfel nct fiecare iteraie este realizat din instruciuni
selectate din diferite iteraii ale buclei originale
i4
i3
i2
i1
i0
Software Pipeline
Iteration
62
Emitere multipl de instruciuni (static):
VLIW
Verificarea prin hardware a dependenelor i emiterea pachetelor
de instruciuni constituie o operaie complex i scump
Compilatorul poate examina instruciunile i decide care dintre
ele pot fi planificate n paralel gruparea instruciunilor n
pachete VLIW
Ca urmare hardware poate fi simplificat
Procesorul are mai multe uniti funcionale i fiecare cmp al
VLIW este alocat unei uniti funcionale
De exemplu VLIW poate conine 5 cmpuri: unul conine instruciune
ALU, dou se refer la operaii FP, iar dou sunt referiri la memorie
63
VLIW
Planificarea execuiei instruciunilor este static (compilator)
Instruciunile sunt formate ntr-una din variantele:
o instruciune foarte lung
ca un pachet fix de instruciuni cu paralelismul dintre instruciuni specificat
explicit chiar de instruciuni (Intel / HP Itanium)
Fiecare instruciune are o codare explicit pentru mai multe operaii
n IA-64 gruparea de operaii e numit pachet
La Transmeta, gruparea e numit molecul (cu atomi ca operaii)
64
Instruciuni lungi
Cuvntul lung de instruciune permite includerea mai multor operaii
Prin definiie, toate operaiile pe care compilatorul cuvntul lung de
instruciune sunt independente se execut n paralel.
Fiecare operaie este codat pe 16 24 bii, iar o instruciune lung
poate avea ntre 112 168 bii
Sunt necesare tehnici compilator pentru planificarea (static) peste mai
multe ramificri