11 - II

Przetwarzanie potokowe
(pipelining)
– p. 1/30
Przypomnienie - implementacja jednocyklowa
4
Add
Add
Data
PC
Address Instruction
Instruction
memory
Register #
Registers
Register #
ALU
Address
Data
memory
Register #
Data
– p. 2/30
Wst˛ep
W implementacjach prezentowanych tydzień temu w jednym
momencie wykonuje sie˛ tylko jednen rozkaz.
Jego wykonanie przebiega w kilku fazach.
W każdej fazie używana jest tylko cz˛eść układów logicznych.
Pomysł: w momencie gdy pierwszy rozkaz rozpoczyna druga˛ faz˛e,
drugi zaczyna pierwsza;
˛ gdy pierwszy zaczyna trzecia,
˛ drugi
zaczyna druga,
˛ a trzeci pierwsza,
˛ itd.
W efekcie w jednym momencie wykonuje sie˛ tyle rozkazów ile jest
faz. Każdy wykonywany rozkaz znajduje sie˛ w innej fazie.
Taka˛ technik˛e nazywamy przetwarzaniem potokowym (ang.
pipelining).
W przetwarzaniu potokowym nie przyspieszamy wykonania
pojedynczego rozkazu (wrecz
˛ przeciwnie!).
Zysk dzieki
˛ urównolegleniu wykonywanie operacji.
– p. 3/30
MIPS - fazy wykonania rozkazu
Wykonanie rozkazu podzielimy na 5 faz:
Pobranie rozkazu z pamieci
˛ (IF, instruction fetch) - 200ps
Dekodowanie rozkazu i odczyt rejestrów (ID, instruction
decode) - 100 ps
Wykonanie operacji typu R lub wyliczenie adresu (EX, execute)
- 200 ps
Operacja na pamieci
˛ (MEM, memory) - 200 ps
Zapis do rejestru (WB, write back) - 100 ps
– p. 4/30
Porównanie
Program
execution
Time
order
(in instructions)
lw $1, 100($0)
200
Instruction
Reg
fetch
lw $2, 200($0)
400
600
Data
access
ALU
800
1000
1200
1400
ALU
Data
access
1600
1800
Reg
Instruction
Reg
fetch
800 ps
lw $3, 300($0)
Reg
Instruction
fetch
800 ps
800 ps
Program
execution
Time
order
(in instructions)
200
400
600
Instruction
fetch
Reg
lw $2, 200($0) 200 ps
Instruction
fetch
Reg
200 ps
Instruction
fetch
lw $1, 100($0)
lw $3, 300($0)
ALU
800
Data
access
ALU
Reg
1000
1200
1400
Reg
Data
access
ALU
Reg
Data
access
Reg
200 ps 200 ps 200 ps 200 ps 200 ps
– p. 5/30
Projektowanie listy rozkazów
Lista rozkazów MIPS została zaprojektowana z myśla˛ o
przetwarzaniu potokowym.
Stała długość rozkazów ułatwia ich pobieranie.
Mała liczba formatów rozkazów. Rejestry źródłowe w tych samych
miejscach - rejestry można odczytywać równolegle z
dekodowaniem rozkazu.
Operacje na pamieci
˛ wykonuja˛ tylko rozkazy lw, sw (i ich
warianty).
– p. 6/30
Hazardy
Hazardy strukturalne
Dwa rozkazy chca˛ w tej samej chwili skorzystać z tego samego
zasobu (np. ALU, pamieć,
˛ rejestry)
W zasadzie problem nie wystepuje
˛
w przypadku MIPS.
Pojawiłby sie,
˛ gdybyśmy nie rozdzieli pamieci.
˛
Hazardy danych.
Rozkaz potrzebuje rejestru, który zapisuje poprzedni rozkaz.
Np. add $s0, $t0, $t1
add $t2, $s0, $t3
Hazardy sterowania.
W przypadku rozkazu skoku nie wiadomo, który rozkaz należy
pobrać jako nastepny.
˛
Szczególnie trudne w przypadku skoków warunkowych.
– p. 7/30
Hazardy danych
Np. add $s0, $t0, $t1
add $t2, $s0, $t3
$s0 jest zapisywany dopiero w piatej
˛ fazie pierwszego rozkazu
Drugi rozkaz potrzebuje go już dwa cykle wcześniej!
Rozwiazanie
˛
kiepskie: opóźnić (jakoś) wykonanie drugiego
rozkazu o dwa cykle (dodać dwa „babelki”).
˛
Rozwiazanie
˛
programowe: reorganizacja kodu (np. przez
kompilator) - trudne.
Rozwiazanie
˛
sprz˛etowe: forwarding (bypassing)
Program
execution
Time
order
(in instructions)
add $s0, $t0, $t1
sub $t2, $s0, $t3
400
200
IF
600
800
ID
EX
MEM
IF
ID
EX
1000
WB
MEM
WB
– p. 8/30
Hazardy danych - cd.
Forwarding nie eliminuje wszystkich hazardów danych.
Program
execution
Time
order
(in instructions)
lw $s0, 20($t1)
400
200
IF
ID
bubble
sub $t2, $s0, $t3
800
600
EX
bubble
IF
MEM
bubble
ID
1000
1200
1400
WB
bubble
EX
bubble
MEM
WB
– p. 9/30
Hazardy danych - reorganizacja kodu
lw
lw
add
sw
lw
add
sw
$t1,
$t2,
$t3,
$t3,
$t4,
$t5,
$t5,
0($t0)
4($t0)
$t1, $t2
12($t0)
8($t0)
$t1, $t4
16($t0)
lw
lw
lw
add
sw
add
sw
$t1,
$t2,
$t4,
$t3,
$t3,
$t5,
$t5,
0($t0)
4($t0)
8($t0)
$t1, $t2
12($t0)
$t1, $t4
16($t0)
Z lewej strony 2 hazardy (rozkazy add) – pozostałe eliminowane
przez forwarding.
Z prawej – brak hazardów.
– p. 10/30
Hazardy sterowania
Załóżmy, że potrafimy w drugiej fazie wykonywania beq porównać
rejestry, wyliczyć adres i ustawić nowy PC
Nawet wtedy musimy opóźnić potok:
Program
execution
Time
order
(in instructions)
add $4, $5, $6
beq $1, $2, 40
200
Instruction
fetch
200 ps
400
Reg
600
ALU
Instruction
fetch
Reg
800
Data
access
ALU
1000
1200
Reg
Data
access
Reg
bubble bubble bubble bubble
or $7, $8, $9
400 ps
Instruction
fetch
1400
Reg
ALU
bubble
Data
access
Reg
– p. 11/30
Hazardy sterowania - przewidywanie skoków
Jedno z rozwiaza
˛ ń: przewidywanie skoków
Np. zakładamy, że skoki sie˛ nie wykonuja˛
Program
execution
Time
order
(in instructions)
add $4, $5, $6
beq $1, $2, 40
200
Instruction
fetch
200 ps
lw $3, 300($0)
beq $1, $2, 40
Reg
200
Instruction
fetch
200 ps
600
Reg
Reg
ALU
Instruction
fetch
Reg
ALU
1000
400 ps
Instruction
fetch
Reg
1200
1400
Reg
Data
access
Reg
bubble bubble bubble bubble
or $7, $8, $9
1400
Reg
Data
access
ALU
800
Data
access
1200
Reg
Reg
600
1000
Data
access
ALU
Instruction
fetch
400
800
Data
access
ALU
Instruction
fetch
200 ps
Program
execution
Time
order
(in instructions)
add $4, $5, $6
400
Reg
ALU
bubble
Data
access
Reg
– p. 12/30
Hazardy sterowania - przewidywanie skoków
Można zakładać, że niektóre skoki sie˛ wykonuja˛ (np. te skaczace
˛
wstecz), a inne nie.
Przewidywanie może być też dynamiczne – jeśli podczas
poprzedniego przejścia przez rozkaz skok sie˛ wykonał, to teraz też
zakładamy, że sie˛ wykona. Można prowadzić historie˛ kilku
ostatnich wykonań. Potrzebne oczywiście dodatkowe układy
logiczne.
Dobrze zorganizowane przewidywanie dynamiczne daje ponad
90% skuteczność!
Inne rozwiazanie:
˛
skoki opóźnione (stosowane naprawde˛ w MIPS,
ale niewidoczne dla programisty asemblerowego).
– p. 13/30
Model procesora potokowego
Rozważamy liste˛ rozkazów taka˛ jak tydzień temu, ale bez j.
Nowość - rejestry rozdzielajace
˛ poszczególne fazy.
Na poczatek
˛
nie przejmujemy sie˛ hazardami.
IF/ID
ID/EX
EX/MEM
MEM/WB
Add
Add Add
result
4
Shift
left 2
PC
Address
Instruction
memory
Instruction
0
M
u
x
1
Read
register 1
Read
data 1
Read
register 2
Registers
Read
Write
data 2
register
Write
data
0
M
u
x
1
Zero
ALU ALU
result
Read
data
Address
Data
memory
0
M
u
x
1
Write
data
16
32
Sign
extend
– p. 14/30
Model procesora potokowego – poprawka
Skad
˛ bierzemy numer rejestru do zapisania (dla lw)?
IF/ID
ID/EX
EX/MEM
MEM/WB
Add
Add Add
result
4
0
M
u
x
1
PC
Address
Instruction
memory
Instruction
Shift
left 2
Read
register 1
Read
data 1
Read
register 2
Registers
Read
Write
data 2
register
Write
data
0
M
u
x
1
Zero
ALU ALU
result
Read
data
Address
Data
memory
0
M
u
x
1
Write
data
16
Sign 32
extend
– p. 15/30
Model procesora potokowego - sygnały sterujace
˛
PCSrc
IF/ID
ID/EX
EX/MEM
MEM/WB
Add
Add Add
result
4
Shift
left 2
RegWrite
PC
Address
Instruction
memory
Instruction
0
M
u
x
1
Branch
Read
register 1
Read
data 1
Read
register 2
Registers
Read
Write
data 2
register
MemWrite
ALUSrc
0
M
u
x
1
Write
data
Zero
Add ALU
result
MemtoReg
Read
data
Address
Data
memory
1
M
u
x
0
Write
data
Instruction
(15–0)
Instruction
(20–16)
Instruction
(15–11)
16
32
Sign
extend
6
0
M
u
x
1
ALU
control
MemRead
ALUOp
RegDst
– p. 16/30
Model procesora potokowego – sterowanie
Sygnały sterujace
˛ podobne jak w rozwiazaniu
˛
jednocyklowym
Brak specjalnych sygnałów dla dwóch pierwszych faz (niezależne
od rozkazu)
WB
Instruction
Control
IF/ID
M
WB
EX
M
WB
ID/EX
EX/MEM
MEM/WB
– p. 17/30
PCSrc
ID/EX
Control
IF/ID
WB
EX/MEM
M
WB
EX
M
MEM/WB
WB
Add
Add Add
result
4
Instruction
memory
Read
register 1
Read
data 1
Read
register 2
Registers
Read
Write
data 2
register
Zero
ALU ALU
result
0
M
u
x
1
Write
data
MemtoReg
Address
Branch
ALUSrc
MemWrite
RegWrite
PC
Instruction
0
M
u
x
1
Shift
left 2
Read
data
Address
Data
memory
0
M
u
x
1
Write
data
Instruction
[15–0]
16
32
Sign
extend
6
Instruction
[20–16]
Instruction
[15–11]
0
M
u
x
1
ALU
control
MemRead
ALUOp
RegDst
– p. 18/30
Hazardy danych i forwarding
Time (in clock cycles)
CC 1
CC 2
Value of
register $2:
10
10
IM
Reg
CC 3
CC 4
CC 5
CC 6
CC 7
CC 8
CC 9
10
10
10/–20
–20
–20
–20
–20
DM
Reg
Program
execution
order
(in instructions)
sub $2, $1, $3
and $12, $2, $5
or $13, $6, $2
add $14, $2, $2
sw $15, 100($2)
IM
Reg
IM
DM
Reg
IM
Reg
DM
Reg
IM
Reg
DM
Reg
Reg
DM
Reg
– p. 19/30
Forwarding
Rejestry rozdzielajace
˛ fazy potoku przechowuja˛ m.in. numery
rejestów źródłowych (rs, rt) oraz przeznaczenia (rd) bioracych
˛
udział w operacji.
Cztery sytuacje:
EX/MEM.RegRd = ID/EX.RegRs
EX/MEM.RegRd = ID/EX.RegRt
MEM/WB.RegRd = ID/EX.RegRs
MEM/WB.RegRd = ID/EX.RegRt
– p. 20/30
ID/EX
EX/MEM
Registers
MEM/WB
ALU
Data
memory
M
u
x
a. No forwarding
ID/EX
EX/MEM
MEM/WB
M
u
x
Registers
ForwardA
ALU
M
u
x
Data
memory
M
u
x
ForwardB
Rs
Rt
Rt
Rd
EX/MEM.RegisterRd
M
u
x
Forwarding
unit
MEM/WB.RegisterRd
b. With forwarding
– p. 21/30
Sterowanie dla forwardingu
ID/EX
WB
Control
PC
Instruction
memory
Instruction
IF/ID
EX/MEM
M
WB
MEM/WB
EX
M
WB
M
u
x
Registers
ALU
Data
memory
M
u
x
IF/ID.RegisterRs
Rs
IF/ID.RegisterRt
Rt
IF/ID.RegisterRt
Rt
IF/ID.RegisterRd
Rd
M
u
x
EX/MEM.RegisterRd
M
u
x
Forwarding
unit
MEM/WB.RegisterRd
– p. 22/30
Hazardy nieusuwalne
lw $2, 20($1)
add $4, $2, $5
Dana jest potrzebna na jeden cykl przed odczytem z pamieci
˛
Musimy stracić jeden cykl - dodajemy pojedynczy „babelek”
˛
Time (in clock cycles)
CC 1
CC 2
CC 3
CC 4
CC 5
Reg
DM
Reg
CC 6
CC 7
CC 8
CC 9
CC 10
Program
execution
order
(in instructions)
lw $2, 20($1)
IM
bubble
and becomes nop
add $4, $2, $5
or $8, $2, $6
add $9, $4, $2
IM
Reg
IM
DM
Reg
IM
Reg
DM
DM
Reg
IM
Reg
Reg
Reg
DM
Reg
– p. 23/30
Hazard
detection
unit
IF/DWrtite
ID/EX.MemRead
ID/EX
WB
M
u
x
PCWrite
Control
PC
IF/ID
Instruction
Instruction
memory
0
EX/MEM
M
WB
MEM/WB
EX
M
WB
M
u
x
Registers
ALU
M
u
x
Data
memory
M
u
x
IF/ID.RegisterRs
IF/ID.RegisterRt
IF/ID.RegisterRt
Rt
IF/ID.RegisterRd
Rd
M
u
x
ID/EX.RegisterRt
Rs
Rt
Forwarding
unit
– p. 24/30
Hazardy sterowania
Przesuwamy wyliczanie adresu skoku oraz sprawdzanie, czy skok
sie˛ wykona do drugiej fazy.
Zakładamy, że skok sie˛ nie wykona – pobieramy do potoku kolejny
rozkaz.
Jeśli skok sie˛ jednak wykonał musimy wstawić jeden „babelek”
˛
oraz wyczyścić rejestr IF/ID
– p. 25/30
and $12, $2, $5
beq $1, $3, 7
sub $10, $4, $8
before<1>
before<2>
IF.Flush
Hazard
detection
unit
ID/EX
WB
Control
28
+
IF/ID
44
+
M
u
x
0
Shift
left 2
44
72
MEM/WB
EX
M
WB
M
u
x
$1
Registers
PC
WB
72
48
4
M
u
x
EX/MEM
M
$4
=
ALU
$3
Instruction
memory
M
u
x
7
M
u
x
$8
Data
memory
Sign
extend
10
Forwarding
unit
Clock 3
bubble (nop)
lw $4, 50($7)
beq $1, $3, 7
sub $10, . . .
before<1>
IF.Flush
Hazard
detection
unit
ID/EX
WB
M
u
x
Control
IF/ID
+
4
+
0
72
76
PC
76
72
Instruction
memory
WB
MEM/WB
EX
M
WB
M
u
x
Shift
left 2
Registers
M
u
x
EX/MEM
M
$1
=
ALU
M
u
x
$3
Data
memory
M
u
x
Sign
extend
10
Forwarding
unit
– p. 26/30
Krok dalej: superskalarność
Nowoczesne procesory maja˛ zazwyczaj po kilka równoległych
potoków. Takie procesory nazywamy superskalarnymi.
Maja˛ wobec tego po kilka jednostek wykonawczych (np. kilka kopii
ALU)
Układy zarzadzaj
˛
ace
˛ przydziałem rozkazów do poszczególnych
potoków oraz wykrywajace/usuwaj
˛
ace
˛ hazardy robia˛ sie˛ bardzo
skomplikowane.
– p. 27/30
VLIW
Inny pomysł – zrzucić problem rozdzielania rozkazów do potoków
na kompilator
Very Large Instruction Word: długa „paczka rozkazów” składajaca
˛
sie˛ z kilku prostych rozkazów
Kompilator zapewnia, że rozkazy z jednej paczki moga˛ być
wykonane równolegle (czasem oczywiście nie uda sie˛ wypełnić
całej paczki i trzeba zostawić wolne pola).
Przykładem sa˛ procesory Itanium (architektura IA-64), chociaż
intel klasyfikuje je jako EPIC (Explicitly Parallel Instruction
Computers).
– p. 28/30
Potoki w procesorach Intela
potok pojawia sie˛ w modelu 486
Pentium jest już superskalarny: dwa 5-etapowe potoki
(wczytywanie, dekodowanie, generowanie adresu, wykonanie,
zapisanie); za zapełnienie obydwu potoków odpowiadał kompilator.
Pentium II miało już 12 etapów potoku, Pentium III - 14, a Pentium
IV - 24.
dla odmiany 64-bitowy procesor Itanium ma tylko 10 etapów
potoku;
– p. 29/30
Itanium 2
Dużo rejestrów.
Potrafi wykonywać jednocześnie do 6 rozkazów
Rozkazy 128-bitowe (3 sloty po 41 bitów + 5 bitów dodatkowych)
Potoki 8-etapowe
Jednostki wykonawcze:
6 jednostek ALU całkowitoliczbowych, 1 przesuwajaca
˛
2 * 2 jednostki zmiennopozycyjne (dod/mnoż , inne)
6 jednostek wektorowych dla rozkazów multimedialnych
3 jednostki skoków.
Itanium 2 taktowany zegarem 1,5GH jest szybszy od procesorów
superskalarnych taktowanych dwukrotnie szybszym zegarem!
– p. 30/30