data memory

Prosty procesor dla framgentu listy
rozkazów MIPSa
(rysunki pochodza˛ z ksiażki
˛ Hennessy’ego i Pattersona)
– p. 1/33
Wst˛ep
Naszym celem bedzie
˛
zaprojektowanie prostego procesora
realizujacego
˛
fragment listy rozkazów MIPS:
rozkazy komunikacji z pamieci
˛ a:
˛ lw, sw
rozkazy arytmetyczno-logiczne: add, sub, and, or, slt
skoki beq, j
Obejrzymy trzy rozwiazania:
˛
Implementacja jednocyklowa
Implementacja wielocyklowa
Przetwarzanie potokowe
– p. 2/33
Implementacja jednocyklowa – wst˛ep
Wykonanie każdego z naszych rozkazów zaczyna sie˛ tak samo:
Wysłanie licznika rozkazów (PC) do jednostki pamieci
˛ i
odczytanie stamtad
˛ odpowiedniego rozkazu.
Odczytanie wartości jednego lub dwóch rejestrów
(specyfikowanych przez pieciobitowe
˛
pola rozkazu)
Dalsze czynności zależa˛ od rozkazu, chociaż sa˛ one podobne,
szczególnie dla rozkazów z jednej grupy. Każdy rozkaz (oprócz j)
użyje np. ALU.
W naszej pierwszej implementacji wykonanie każdego rozkazu
bedzie
˛
zajmowało jeden cykl zegarowy.
Zapis (do pamieci
˛ lub do rejestrów) nastepuje
˛
raz w całym cyklu
(na zboczu opadajacym).
˛
Odczyt jest możliwy w każdym momencie.
– p. 3/33
Ogólny schemat połaczeń
˛
4
Add
Add
Data
PC
Address Instruction
Instruction
memory
Register #
Registers
Register #
ALU
Address
Data
memory
Register #
Data
– p. 4/33
Pobranie rozkazu
Zakładamy, że mamy dwie jednostki pamieci:
˛ osobna˛ dla rozkazów
(instruction memory) oraz dla danych (data memory).
Add
4
PC
Read
address
Instruction
Instruction
memory
– p. 5/33
Rejestry i ALU
5
Register
numbers
5
5
Data
Read
register 1
4
Read
data 1
Read
register 2
Write
register
ALU operation
Zero
Data
Registers
ALU ALU
result
Read
data 2
Write
Data
RegWrite
a. Registers
b. ALU
– p. 6/33
Pami˛eć danych i rozszerzanie danych
MemWrite
Address
Read
data
16
Write
data
Data
memory
Sign
extend
32
MemRead
a. Data memory unit
b. Sign-extension unit
– p. 7/33
Skok warunkowy
Wykonanie rozkazu skoku warunkowego polega na:
Odczytaniu dwóch rejestrów
Porównaniu ich przez ALU (operacja˛ odejmowania)
Przekształceniu stałej: rozszerzenie stałej 16-bitowej do
32-bitowej i przesuniecie
˛
o dwa bity w lewo
Dodaniu stałej do PC+4
– p. 8/33
Skok warunkowy
PC+4 from instruction datapath
Add Sum
Branch
target
Shift
left 2
Instruction
Read
register 1
Read
data 1
Read
register 2
Write
register
4
ALU operation
ALU Zero
Registers
To branch
control logic
Read
data 2
Write
data
RegWrite
16
Sign
extend
32
– p. 9/33
Uwaga o opóźnionych skokach
MIPS realizuje tzw. opóźnione skoki (delayed branches) – rozkaz
znajdujacy
˛ sie˛ w pamieci
˛ bezpośrednio za rozkazem skoku wykonuje
sie˛ niezależnie od tego, czy skok nastepuje,
˛
czy nie.
Nie implementujemy tego rozwiazania.
˛
Podobnie zreszta˛ jak SPIM
(chociaż tam można je wymusić, uruchamiajac
˛ program z
odpowiednim parametrem).
– p. 10/33
Układ dla rozkazów arytm.-log. oraz lw, sw
Read
register 1
Instruction
4
Read
data 1
Read
register 2
Registers Read
Write
data 2
register
MemWrite
ALUSrc
0
M
u
x
1
Write
data
MemtoReg
Zero
ALU ALU
result
Address
Write
data
RegWrite
16
ALU operation
Sign
extend
32
Read
data
1
M
u
x
0
Data
memory
MemRead
– p. 11/33
PCSrc
M
u
x
Add
Add
4
ALU
result
Shift
left 2
PC
Read
address
Instruction
Instruction
memory
Read
register 1
ALUSrc
Read
data 1
ALU operation
MemWrite
Read
register 2
Registers Read
Write
data 2
register
MemtoReg
Zero
M
u
x
Write
data
ALU ALU
result
Address
Write
data
RegWrite
16
4
Sign
extend
32
Read
data
M
u
x
Data
memory
MemRead
– p. 12/33
Formaty rozkazów – przypomnienie
Typ R:
6 bitów – kod operacji (bity 31:26)
5 bitów – numer rejestru źródłowego 1, rs (bity 25:21)
5 bitów – numer rejestru źródłowego 2, rt (bity 20:16)
5 bitów – numer rejestru wynikowego, rd (bity 15:11)
5 bitów – shamt (my je ignorujemy)
6 bitów – rodzaj operacji, funkcja (bity 5:0)
Typ I, lw, sw:
6 bitów – kod operacji (bity 31:26)
5 bitów – numer rejestru bazowego adresu (bity 25:21)
5 bitów – numer rejestru (źródłowego dla sw, wynikowego dla lw (bity
20:16)
16 bitów – stała (bity 15:0)
Typ I, beq: jak wyżej, oba numery rejestów to rejestry źródłowe do
porównania.
– p. 13/33
PCSrc
0
M
u
x
Add
Add
4
Instruction [25:21]
PC
Read
register 1
Instruction [20:16]
Instruction
[31:0]
Instruction
memory
Instruction [15:11]
0
M
u
x
1
RegDst
Instruction [15:0]
Read
register 2
Write
register
Write
data
16
1
Shift
left 2
RegWrite
Read
address
ALU
result
MemWrite
Read
data 1
ALUSrc
Read
data 2
0
M
u
x
1
Registers
Sign
extend
MemtoReg
Zero
ALU ALU
result
Address
Read
data
1
M
u
x
0
Data
Write memory
data
32
ALU
control
MemRead
Instruction [5:0]
ALUOp
– p. 14/33
Sterowanie
Na podstawie bitów 31:26 (kod operacji) generowane sa˛
odpowiednie sygnały sterujace
˛ (prosty układ kombinacyjny)
Sygnał ALUOp jest dwubitowy: 00 – lw lub sw (dodawaj), 01 - beq
(odejmuj), 10 - typu R
Rodzaj operacji dla ALU przy kodzie 10 dospecyfikowywany
przez bity funkcyjne 5:0
– p. 15/33
Pełny układ (ale jeszcze bez skoku j)
0
M
u
x
Add
Add
4
Control
Instruction [25–21]
PC
Read
address
Instruction [20–16]
Instruction
[31–0]
Instruction
memory
0
M
u
Instruction [15–11] x
1
Read
register 1
Read
register 2
Write
register
Write
data
Instruction [15–0]
16
1
Shift
left 2
RegDst
Branch
MemRead
MemtoReg
ALUOp
MemWrite
ALUSrc
RegWrite
Instruction [31–26]
ALU
result
Read
data 1
Zero
Read
data 2
Registers
Sign
extend
0
M
u
x
1
ALU ALU
result
Address
Read
data
1
M
u
x
0
Data
Write memory
data
32
ALU
control
Instruction [5–0]
– p. 16/33
add $t0, $t1, $t2
0
M
u
x
Add
Add
4
Control
Instruction [25–21]
PC
Read
address
Instruction [20–16]
Instruction
[31–0]
Instruction
memory
0
M
u
Instruction [15–11] x
1
Read
register 1
Read
register 2
Write
register
Write
data
Instruction [15–0]
16
1
Shift
left 2
RegDst
Branch
MemRead
MemtoReg
ALUOp
MemWrite
ALUSrc
RegWrite
Instruction [31–26]
ALU
result
Read
data 1
Zero
Read
data 2
Registers
Sign
extend
0
M
u
x
1
ALU ALU
result
Address
Read
data
1
M
u
x
0
Data
Write memory
data
32
ALU
control
Instruction [5–0]
– p. 17/33
lw $t0, 8($t2)
0
M
u
x
Add
Add
4
Control
Instruction [25–21]
PC
Read
address
Instruction [20–16]
Instruction
[31–0]
Instruction
memory
0
M
u
Instruction [15–11] x
1
Read
register 1
Read
register 2
Write
register
Write
data
Instruction [15–0]
16
1
Shift
left 2
RegDst
Branch
MemRead
MemtoReg
ALUOp
MemWrite
ALUSrc
RegWrite
Instruction [31–26]
ALU
result
Read
data 1
Zero
Read
data 2
Registers
Sign
extend
0
M
u
x
1
ALU ALU
result
Address
Read
data
1
M
u
x
0
Data
Write memory
data
32
ALU
control
Instruction [5–0]
– p. 18/33
beq $t0, $t1, 8
0
M
u
x
Add
Add
4
Control
Instruction [25–21]
PC
Read
address
Instruction [20–16]
Instruction
[31–0]
Instruction
memory
0
M
u
Instruction [15–11] x
1
Read
register 1
Read
register 2
Write
register
Write
data
Instruction [15–0]
16
1
Shift
left 2
RegDst
Branch
MemRead
MemtoReg
ALUOp
MemWrite
ALUSrc
RegWrite
Instruction [31–26]
ALU
result
Read
data 1
Zero
Read
data 2
Registers
Sign
extend
0
M
u
x
1
ALU ALU
result
Address
Read
data
1
M
u
x
0
Data
Write memory
data
32
ALU
control
Instruction [5–0]
– p. 19/33
Dodajemy skok bezwarunkowy
Instruction [25–0]
26
Shift
left 2
Jump address [31–0]
28
PC + 4 [31–28]
Add
Add
4
Control
Instruction [25–21]
PC
Read
address
Instruction [20–16]
Instruction
[31–0]
Instruction
memory
0
M
u
Instruction [15–11] x
1
Read
register 1
Read
register 2
Write
register
Write
data
Instruction [15–0]
16
1
M
u
x
M
u
x
1
0
Shift
left 2
RegDst
Jump
Branch
MemRead
MemtoReg
ALUOp
MemWrite
ALUSrc
RegWrite
Instruction [31–26]
ALU
result
0
Read
data 1
Zero
Read
data 2
Registers
Sign
extend
0
M
u
x
1
ALU ALU
result
Address
Read
data
1
M
u
x
0
Data
Write memory
data
32
ALU
control
Instruction [5–0]
– p. 20/33
Wady i zalety implementacji jednocyklowej
Przedstawiona implementacja nie jest używana w praktyce
Konieczność duplikacji sprz˛etu – dodatkowe sumatory
Cykl zegarowy dopasowany do najwolniejszego rozkazu (operacje
na pamieci)
˛
Zaleta: prostota
Inne rozwiazania:
˛
zmienna długość cyklu – skomplikowane
technicznie, implementacja wielocyklowa – o tym za chwile,
˛
przetwarzanie potokowe – o tym za tydzień, ...
– p. 21/33
Wady i zalety implementacji jednocyklowej
Przykładowe czasy działania naszych podukładów i wykonywania
rozkazów:
IMem 200 ps, RegRead 100, ALU 200, DMem 200, RegWrite 100
Rozkaz typu R: 200 + 100 + 200 + 0 + 100 = 600
lw: 200 + 100 + 200 + 200 + 100 = 800
sw: 200 + 100 + 200 + 200 + 0 = 700
Skok warunkowy: 200 + 100 + 200 + 0 + 0 = 500
Skok bezwarunkowy: 200 + 100 + 0 + 0 + 0 = 300
Potrzebujemy zatem cyklu długości 800 ps.
Rozważmy nastepuj
˛ acy
˛ zestaw rozkazów: 25% odczytów pamieci,
˛
10% zapisów, 45% rozkazów typu R, 15% skoków warunkowych,
5% skoków bezwarunkowych
Średni czas wykonania instrukcji:
0, 25 · 800 + 0, 10 · 700 + 0, 45 · 600 + 0, 15 · 500 + 0, 05 · 300 = 630 ps.
– p. 22/33
Implementacja wielocyklowa
Krótszy cykl zegarowy
rozkazy dzielone na fazy (kroki), każda faza – jeden cykl.
Rozkazy moga˛ mieć różne liczby faz.
Jedna ALU (bez żadnych dodatkowych sumatorów).
Wspólna pamieć
˛ programu i danych.
Kilka dodatkowych rejestrów przechowujacych
˛
dane potrzebne w
kolejnych fazach
PC
Address
Instruction
register
A
Register #
Registers
Register #
Instruction
Memory or data
Data
Data
Memory
data
register
ALU
ALUOut
B
Register #
– p. 23/33
Implementacja wielocyklowa – cd.
Każdy z rejestrów MDR, A, B, ALUOut przechowuje dane z fazy k
dla fazy k + 1
Rejestr IR przechowuje rozkaz przez wszystkie fazy jego
wykonania.
Dlatego tylko IR potrzebuje sygnału zezwolenia na zapis.
Niektóre układy bed
˛ a˛ używane wiecej
˛
niż raz na rozkaz, dlatego
musimy dodać kilka multiplekserów (i rozszerzyć wcześniejsze) –
np.:
mamy teraz dwa źródła adresów dla pamieci
˛
ALU wylicza adresy skoków
– p. 24/33
Implementacja wielocyklowa (bez skoków j)
PC
0
M
u
x
1
Address
Memory
MemData
Write
data
Instruction
[25–21]
Read
register 1
Instruction
[20–16]
Read
register 2
Registers
Write
Read
register
data 2
Instruction
[15–0]
Instruction
register
Instruction
[15–0]
Memory
data
register
0
M
Instruction u
x
[15–11]
1
Read
data 1
A
Zero
ALU ALU
result
B
4
Write
data
0
M
u
x
1
0
M
u
x
1
ALUOut
0
1M
u
2 x
3
16
Sign
extend
32
Shift
left 2
– p. 25/33
Pełna implementacja wielocyklowa
PCSource
PCWriteCond
PCWrite
ALUOp
Outputs
IorD
MemRead
ALUSrcB
Control
ALUSrcA
MemWrite
MemtoReg
Op
[5–0]
RegWrite
IRWrite
0
RegDst
26
Instruction [25-0]
PC
0
M
u
x
1
Instruction
[31–26]
Address
Memory
MemData
Write
data
Instruction
[25–21]
Read
register 1
Instruction
[20–16]
Read
register 2
Registers
Write
Read
register
data 2
Instruction
[15–0]
Instruction
register
Instruction
[15–0]
Memory
data
register
0
M
Instruction u
x
[15–11]
1
Read
data 1
A
16
Sign
extend
B
4
32
28
Shift
left 2
M
1 u
x
2
PC [31–28]
Zero
ALU ALU
result
Write
data
0
M
u
x
1
0
M
u
x
1
Shift
left 2
Jump
address
[31–0]
ALUOut
0
1M
u
2 x
3
ALU
control
Instruction [5–0]
– p. 26/33
F1 - Pobranie rozkazu
IR <= Memory[PC]
PC <= PC + 4
Powyższe operacje moga˛ wykonywać sie˛ równolegle. Sygnały
sterujace:
˛
MemRead - 1
IRWrite - 1
IorD - 0
ALUSrcA - 0 (PC)
ALUSrcB - 01 (stała 4)
ALUOp – 00 (dodawanie)
PCSource – 0
PCWrite – 1
– p. 27/33
F2 - Dekodowanie oraz odczytu rejestrów
A <= Reg[IR[25:21]]
B <= Reg[IR[20:16]]
ALUOut <= PC + (sign-extend (IR[15-0] « 2)
Powyższe operacje wykonujemy przy każdej instrukcji - niezależnie od
kodu operacji. Zauważmy, że nawet jeśli konkretna instrukcja tego nie
wymaga, to wykonane operacje w niczym nie zaszkodza.
˛ Sygnały
sterujace:
˛
ALUSrcA - 0 (PC)
ALUSrcB - 11 (przesunieta
˛ i rozszerzona stała z rozkazu)
ALUOp - 00 (dodawanie)
– p. 28/33
F3 - Wykonanie, obliczenie adresu lub skok
Pierwszy cykl, który zależy od kodu operacji. ALU wykonuje jedna˛ z
czterech możliwych akcji (na danych przygotowanych w poprzednich
cyklach):
Obliczenie adresu: ALUOut <= A + sign-extend
(IR[15:0])
ALUSrcA - 1, ALUSrcB - 10, ALUOp - 00 (dodawanie)
Operacja arytmetyczno-logiczna (typu R): ALUOut <= A op B
ALUSrcA - 1, ALUSrcB - 00, ALUOp - 10 (decyduje pole funk.)
Skok warunkowy: if (A==B) PC <=ALUOut
ALUSrcA - 1, ALUSrcB - 00, ALUOp - 01 (odejmowanie),
PCWriteCond - 1, PCSource - 01
Skok: PC <= konkatenacja(PC[31:28], IR[25:0], 00)
PCWrite - 1, PCSource - 10
– p. 29/33
F4 - Dost˛ep do pami˛eci lub dokończenie Rrozkazu
Dostep
˛ do pamieci:
˛ MDR <= Memory [ALUOut] lub Memory
[ALUOut] <= B
MemRead lub MemWrite - 1, IorD - 1
Dokończenie rozkazu arytmetyczno-logicznego:
Reg[IR[15-11]] <= ALUout
RegDst - 1, RegWrite - 1, MemtoReg - 0,
– p. 30/33
F5 - Dokończenie odczytu pami˛eci
Reg[IR[20-16]] <= MDR
RegDst - 0, RegWrite - 1, MemtoReg - 1,
– p. 31/33
Jednosta sterujaca
˛
Tym razem jednostaka sterujaca
˛ bedzie
˛
układem sekwencyjnym,
dokładniej automatem Moore’a. Wejście – kod operacji, stany to fazy,
wyjścia – sygnały sterujace.
˛
Instruction fetch
Instruction decode/
Register fetch
MemRead
ALUSrcA = 0
IorD = 0
IRWrite
ALUSrcB = 01
ALUOp = 00
PCWrite
PCSource = 00
0
Start
1
ALUSrcA = 0
ALUSrcB = 11
ALUOp = 00
')
Memory-reference FSM
(Figure 5.33)
R-type FSM
(Figure 5.34)
Q'
)
(O
p
=
R
'BE
'LW
Branch FSM
(Figure 5.35)
(Op = 'J')
(
e)
p
-ty
p=
=
Op
p
(O
(O
r
') o
SW
='
Jump FSM
(Figure 5.36)
– p. 32/33
Instruction fetch
Instruction decode/
register fetch
MemRead
ALUSrcA = 0
IorD = 0
IRWrite
ALUSrcB = 01
ALUOp = 00
PCWrite
PCSource = 00
0
Start
1
ALUSrcA = 0
ALUSrcB = 11
ALUOp = 00
')
SW
ALUSrcA = 1
ALUSrcB = 10
ALUOp = 00
= 'B
(Op
p
(O
6
8
ALUSrcA = 1
ALUSrcB = 00
ALUOp = 10
Jump
completion
9
ALUSrcA = 1
ALUSrcB = 00
ALUOp = 01
PCWriteCond
PCSource = 01
PCWrite
PCSource = 10
p
(O
=
')
W
'S
(Op = 'LW')
Branch
completion
Execution
2
(Op = 'J')
)
=
R-
ty
') o
'LW
(O
Memory address
computation
pe
r (O
p=
EQ
')
'
p=
Memory
access
3
Memory
access
5
MemRead
IorD = 1
R-type completion
7
MemWrite
IorD = 1
RegDst = 1
RegWrite
MemtoReg = 0
Memory read
completon step
4
RegDst = 1
RegWrite
MemtoReg = 0
– p. 33/33