Architetture dei Calcolatori
(Lettere j-z
)
Il Processore
Ing. Davide D’Amico
Architettura a Livelli: Livelli 1 e 2
 Livello 2: Livello del Linguaggio Macchina (ISA)
 Macchina nuda come appare al programmatore di sistema.
Le istruzioni del suo linguaggio sono interpretate ed
eseguite dai microprogrammi del processore
 Moduli: Programmi
 L2: Linguaggio macchina
 R2: Registri, spazio di memoria
 Livello 1: Macchina Firmware – Microarchitettura
 Interpreta ed esegue le istruzioni del linguaggio macchina
 E’ direttamente realizzato con i componenti della
macchina hardware
 Moduli - Unita’ di Elaborazione: CPU, Memoria, Unita’ di
I/O
 L1: Linguaggio di Microprogrammazione
 R1: Reti combinatorie e sequenziali
CPU
2
Organizzazione di un Calcolatore
Processore
Unità di
controllo
Unità di
elaborazione
dati
Bus
Dispositivi
di I/O
Dispositivi
di I/O
Interfaccia
di I/O
Interfaccia
di I/O
Memoria
dati
indirizzi
controllo
CPU
3
Processore - Central Processing Unit (CPU)
 Provvede all’esecuzione delle istruzioni macchina
 Ciclo di Esecuzione
1.
2.
3.
Prelievo Istruzione dalla Memoria
Decodifica Istruzione
Esecuzione Istruzione
 Processore e’ composto da due sottosistemi:
1. Unità di Controllo (Control) – Parte di Controllo

Controlla il sequenziamento e l’esecuzione delle istruzioni generando
i segnali di controllo
2. Unita’ di Elaborazione Dati (Datapath) – Parte Operativa

Esegue le istruzioni
ALU

Banco di Registri (Register File)

Program Counter (PC)

Instruction Register (IR)

 Esegue operazioni logico aritmetiche sui dati
 Memoria interna CPU
– Indirizzo Prossima Istruzione
– Codice Istruzione da eseguire
CPU
4
Processore - Central Processing Unit (CPU)

Implementazione set ridotto del MIPS





Lunghezza formato: 32 bit; i tre formati delle istruzioni:




Istruzioni di accesso alla memoria: lw e sw
Istruzioni logico-aritmetiche: add, sub, and, or e slt
Istruzioni di branch: beq
Istruzioni di jump: j
Tipo R
Tipo I
Tipo J
I campi






31
26
op
31
6 bits
rs
26
op
31
6 bits
op
6 bits
21
5 bits
rs
26
5 bits
16
rt
21
11
rd
5 bits
16
5 bits
6
shamt
5 bits
0
funct
6 bits
0
immediate
rt
5 bits
16 bits
0
target address
26 bits
op: operazione dell’istruzione
rs, rt, rd: registri sorgente (due) e destinazione
shamt: shift amount
funct: seleziona la variante dell’operazione nel campo op
address/immediate: offset dell’indirizzo o valore immediato
target address: indirizzo dell’istruzione di jump
CPU
5
Passi di Progetto
1.
Analizzare il set di Istruzioni: Requisiti del Dapapath

Analizzare la semantica di ogni istruzione
 Espressa intermini di trasferimenti e operazioni tra registri

Il datapath deve includere il banco dei registri (register file)
 Sono necessari altri registri, non visibili a livello ISA, e.g., PC


Il datapath deve fornire i cammini per permettere tutti i
trasferimenti tra registri necessari, e gli accessi in memoria
Includeremo la memoria nel progetto (per semplicita’)
2. Selezionare i Componenti del Datapath
3. Assemblare il Datapath secondo i requisiti aggiungendo i
segnali di controllo
4. Analizzare l’implementazione di ogni istruzione per
determinare quali segnali di controllo devo essere affermato
o meno per permetterne l’esecuzione
5. Realizzare la Parte di Controllo (Control) in accordo a quanto
stabilito al punto 4
CPU
6
Semantica Istruzioni e RTL
 RTL (Register-Transfer Language): Linguaggio per esprimere
i trasferimenti tra registri (e memoria),



Permette di definire la semantica di ogni istruzione
M[x] contenuto della memoria indirizzo x
R[y] contenuto registro y
 Es: add rd, rs, rt

R[rd]=R[rs]+R[rt], PC=PC+4;
 Es:load rt, offset(rs)

R[rt]=M[R[rs]+sign_ext(offset)], PC=PC+4;
 Es: beq rs, rt, address

If(R[rs]==R[rt])
then PC=PC+4+sign_ext(address)<<2;
else PC=PC+4;
 Tutte richiedono come passo preliminare il prelievo
dell’istruzione dalle memoria (fetch)

Istruzione=M[PC]
CPU
7
Implementazione del set ridotto
 I primi due passi da implementare sono comuni a tutte
le istruzioni,indipendentemente dalla classe di
istruzione:


Inviare l’uscita del Program Counter (PC) alla memoria che
contiene il programma e caricare l’istruzione (Fetch) ed
aggiornare PC
Decodifica dell’Istruzione (Decode) (e lettura registri)
 La fase di esecuzione (Execute) dipende dall’istruzione
 Sono comunque raggruppabili per classi di istruzioni
 Dopo aver letto i registri, tutte le istruzioni usano
l’ALU (eccetto j)



Le istruzioni di accesso alla memoria per calcolare l’indirizzo
Le istruzioni logico-aritmetiche per effettuare l’operazione
L’istruzione beq per verificare l’uguaglianza fra registri
CPU
8
Implementazione del set ridotto (2)
 Poi il comportamento delle istruzioni si differenzia
 Istruzioni di accesso alla memoria
 Devono accedere alla memoria per leggere/scrivere il dato

Istruzioni logico-aritmetiche
 Devono accedere ad un registro per scrivere il risultato

Istruzioni di branch e jump
 Devono modificare il Program Counter
 Vantaggio della semplicità nella progettazione
 Pochi formati di istruzione facilitano l’implementazione
dell’unità di elaborazione
CPU
9
I cinque passi delle istruzioni
 I cinque passi delle istruzioni da effettuare
Fetch (caricamento) dell’istruzione dalla memoria
2. Decode dell’istruzione e fetch dei registri
3. Execute
1.

Uso della ALU (esecuzione dell’operazione o calcolo
dell’indirizzo)
4. Memory Access
 Accesso ad un operando in memoria
5. Write-back
 Scrittura del risultato in un registro
CPU
10
Una visione astratta
5: write-back
1: fetch
2: decode e register fetch 3: execute
4: mem.
CPU
11
Progettazione dell’unità di elaborazioni dati e
prestazioni
 Le prestazioni di un calcolatore sono determinate da:
CPI
 Numero di istruzioni
 Instruction Count (IC)


Durata del ciclo di clock (TCLOCK)
Cicli di clock per istruzione
 Clock cycle Per Instruction (CPI)
IC
TCLOCK
 La progettazione del processore (unità di
elaborazione e unità di controllo) determina


Durata del ciclo di clock
Cicli di clock per istruzione (CPI)
CPU
12
Implementazione del Processore: Approcci
 Singolo Ciclo
 Esecuzione di ogni istruzione richiede 1 ciclo di clock
Il ciclo di clock deve essere abbastanza lungo da permettere il
completamento dell’istruzione piu’ lenta
 Svantaggio: velocita’ limitata dall’istruzione piu’ lenta
supportata, alcune risorse devono essere replicate
 Multi-Ciclo
 Suddividere l’esecuzione in piu’ passi
 Eseguire un passo per ciclo
 Vantaggio: ogni istruzione richiede il solo numero di cicli
(tempo) richiesto
 Tclock(Singolo Ciclo)> Tclock (Multiplo Ciclo)
 Pipelined
 Suddividere l’esecuzione in piu’ passi
 Eseguire un passo per ciclo
 Processare piu’ istruzioni in parallelo
 Elaborazione in contemporanea di step diversi di istruzioni
consecutive (linea di assemblaggio)
CPU
13
Implementazione Singolo Ciclo
 Prima implementazione impiega in singolo ciclo
di clock per ogni istruzione

Ogni istruzione inizia sul fronte attivo di un ciclo di
clock e termina sul fronte attivo del ciclo di clock
successivo
 Approccio non pratico e inefficiente rispetto ad una
implementazione multiciclo

Ogni istruzione richiede esattamente tanto tempo
quanto il tempo di esecuzone dell’istruzione piu’ lenta
 Nell’implementazioni multiciclo questo problema si evita
permettendo alle istruzioni piu’ veloci di essere
eseguite in un numero inferiore di cicli
 Tuttavia e’ semplice e utile da un punto di vista
didattico
 Nota: Implementeremo il jump solo alla fine
della trattazione
CPU
14
I Blocchi della Progettazione
1.
Fase di Fetch
 Accedere all’istruzioni in memoria ed aggiornare PC
2. Decode, Accesso ai registri ed esecuzione
istruzioni formato R
 Istruzioni logico-aritmetiche
3. Decode, Accesso ai registri ed operazioni di
accesso alla memoria
 Istruzioni load/store
4. Decode, Accesso ai registri per i branch
 Istruzione beq
CPU
15
Datapath: Fetch Istruzione e aggiornamento
PC
Instruction = M[PC]
PC = PC + 4
Instruction
address
Add
PC
Instruction
Add Sum
4
Instruction
memory
PC
a. Instruction memory
b. Program counter
Read
address
c. Adder
Instruction
Instruction
memory
CPU
16
Datapath: Fetch Istruzione e aggiornamento
PC
Instruction = M[PC]
PC = PC + 4
ADD
4
PC
ADDR
Memory
RD
Instruction
CPU
17
Datapath: Istruzioni formato R
add rd, rs, rt
R[rd] =R[rs] + R[rt];
Register
numbers
5
Read
register 1
5
Read
register 2
Registers
Write
register
5
Data
Write
data
3
ALU control
Read
data 1
Data
ALU
Zero
ALU
result
Read
data 2
Instruction
Read
register 2
Registers
Write
register
Write
data
RegWrite
3
Read
register 1
ALU operation
Read
data 1
Zero
ALU ALU
result
Read
data 2
RegWrite
a. Registers
b. ALU
CPU
18
Datapath: Istruzioni formato R
add rd, rs, rt
Instruction
op
rs
rt
5
rd
5
5
shamt funct
R[rd] =R[rs] + R[rt];
Operation
3
RN1
RN2
WN
RD1
Register File
ALU
Zero
WD
RD2
RegWrite
CPU
19
Datapath:
Istruzioni Load/Store
lw rt, offset(rs)
Register
numbers
5
Read
register 1
5
Read
register 2
Registers
Write
register
5
Data
Write
data
ALU control
3
R[rt] =M[R[rs] + sign_ext(offset)];
Read
data 1
Data
ALU
Zero
ALU
result
Read
data 2
3
Read
register 1
RegWrite
a. Registers
b. ALU
Instruction
Read
register 2
Registers
Write
register
Write
data
MemWrite
MemWrite
Read
data 1
Zero
ALU ALU
result
Write
data
Read
data
Data
memory
16
Sign
extend
32
Write
data
16
Read
data
Address
Read
data 2
RegWrite
Address
ALU operation
Sign
extend
Data
memory
32
MemRead
MemRead
a. Data memory unit
b. Sign-extension unit
CPU
20
Datapath: Istruzione Load
lw rt, offset(rs)
R[rt] =M[R[rs] + sign_ext(offset)];
CPU
21
Datapath: Istruzione Store
sw rt, offset(rs)
M[R[rs] + sign_extend(offset)]=R[rt]
CPU
22
Datapath: Istruzione di Salto
beq rs, rt, offset
PC + 4 from instruction datapath
if (R[rs] == R[rt]) then
PC = PC+4 + sign_ext(offset)<<2
Add Sum
Branch target
Shift
left 2
Instruction
3
Read
register 1
Read
register 2
Registers
Write
register
Write
data
ALU operation
Read
data 1
ALU Zero
To branch
control logic
Read
data 2
RegWrite
16
Sign
extend
32
CPU
23
Datapath: Istruzione di Salto beq
beq rs, rt, offset
if (R[rs] == R[rt]) then
PC = PC+4 + sign_ext(offset)<<2
CPU
24
Composizione dei blocchi
 Uniamo il blocco relativo alle istruzioni di accesso alla
memoria con quello per le istruzioni di tipo R
Multiplexer per scegliere se
il secondo operando è un
indirizzo (tipo I) oppure il
dato in un registro (tipo R)
Multiplexer per scegliere se ai registri va
il dato dalla memoria (tipo I) oppure il
risultato dell’operazione (tipo R)
CPU
25
Datapath: Istruzioni formato R
add rd,rs,rt
Instruction
32
5
5
RN1
RN2
16
Operation
5
3
WN
RD1
Register File
ALU
Zero
WD
RD2
RegWrite
16
E
X
T
N
D
32
M
U
X
ALUSrc
MemWrite
MemtoReg
ADDR
Data
Memory
WD
RD
M
U
X
MemRead
CPU
26
Datapath: Istruzione Load
lw rt,offset(rs)
Instruction
32
5
5
RN1
RN2
16
Operation
5
3
WN
RD1
Register File
ALU
Zero
WD
RD2
RegWrite
16
E
X
T
N
D
32
M
U
X
ALUSrc
MemWrite
MemtoReg
ADDR
Data
Memory
WD
RD
M
U
X
MemRead
CPU
27
Datapath: Istruzione Store
sw rt,offset(rs)
Instruction
32
5
5
RN1
RN2
16
Operation
5
3
WN
RD1
Register File
ALU
Zero
WD
RD2
RegWrite
16
E
X
T
N
D
32
M
U
X
ALUSrc
MemWrite
MemtoReg
ADDR
Data
Memory
WD
RD
M
U
X
MemRead
CPU
28
Composizione dei blocchi
 Aggiungere il blocco che esegue il fetch
Add
ALU e Adder Separati perche’ entrambi devono
Poter essere usati nello stesso ciclo
4
PC
Read
address
Instruction
Instruction
memory
Registers
Read
register 1
Read
Read
data
1
register 2
3
Write
data
Memoria Istruzioni e
dati Separate per
Poter leggere e scrivere
nello stesso ciclo
M
u
x
Zero
ALU ALU
result
Address
Write
data
RegWrite
16
MemWrite
MemtoReg
ALUSrc
Read
data 2
Write
register
ALU operation
Sign 32
extend
Read
data
Data
memory
M
u
x
MemRead
CPU
29
Composizione dei blocchi
Multiplexer per
scegliere indirizzo
della prossima
istruzione
 Aggiungiamo il blocco per il beq
PCSrc
M
u
x
Add
Add ALU
result
4
Adder addizionale
Shift
left 2
PC
Read
address
Instruction
Instruction
memory
Registers
Read
register 1
Read
Read
data 1
register 2
Write
register
Write
data
RegWrite
16
ALUSrc
Read
data 2
M
u
x
3
ALU operation
Zero
ALU ALU
result
MemtoReg
Address
Write
data
Sign
extend
MemWrite
Read
data
Data
memory
M
u
x
32
MemRead
CPU
30
Datapath: add
ADD
M
U
X
ADD
ADD
4
PC
<<2
Instruction
ADDR
Instruction
Memory
RD
32
5
16
5
PCSrc
Operation
5
3
RN1
RN2
WN
RD1
Register File
ALU
Zero
WD
RD2
RegWrite
16
add rd, rs, rt
E
X
T
N
D
32
M
U
X
ALUSrc
MemWrite
ADDR
Data
Memory
MemtoReg
RD
WD
M
U
X
MemRead
CPU
31
Datapath: lw
ADD
M
U
X
ADD
ADD
4
PC
<<2
Instruction
ADDR
Instruction
Memory
RD
32
5
16
5
PCSrc
Operation
5
3
RN1
RN2
WN
RD1
Register File
ALU
Zero
WD
RD2
RegWrite
16
lw rt,offset(rs)
E
X
T
N
D
32
M
U
X
ALUSrc
MemWrite
ADDR
Data
Memory
MemtoReg
RD
WD
M
U
X
MemRead
CPU
32
Datapath: sw
ADD
M
U
X
ADD
ADD
4
PC
<<2
Instruction
ADDR
Instruction
Memory
RD
32
5
16
5
PCSrc
Operation
5
3
RN1
RN2
WN
RD1
Register File
ALU
Zero
WD
RD2
RegWrite
16
sw rt,offset(rs)
E
X
T
N
D
32
M
U
X
ALUSrc
MemWrite
ADDR
Data
Memory
MemtoReg
RD
WD
M
U
X
MemRead
CPU
33
Datapath: beq
ADD
M
U
X
ADD
ADD
4
PC
<<2
Instruction
ADDR
Instruction
Memory
RD
32
5
16
5
PCSrc
Operation
5
3
RN1
RN2
WN
RD1
Register File
ALU
Zero
WD
RD2
RegWrite
16
beq r1,r2,offset
E
X
T
N
D
32
M
U
X
ALUSrc
MemWrite
ADDR
Data
Memory
MemtoReg
RD
WD
M
U
X
MemRead
CPU
34
Controllo
 L’Unita di Controllo deve generare:
 I segnali di controllo dell’ALU
Opcode
 I segnali di controllo dei vari multiplexer
 I segnali di abilitazione alla scrittura/lettura dei
6
diversi elementi di memoria
 Basandosi su…
Istruzione di tipo R
Istruzione di load o
store
Istruzione beq
31
31
Controllo MUX
6
Controllo ALU
11 10
6 5
0
rd
shamt
funct
5 bit
5 bit
6 bit
26 25
21 20
16 15
35 o 43
rs
rt
6 bit
5 bit
5 bit
0
4
6 bit
26 25
rs
5 bit
rs
5 bit
21 20
Controllo
16 15
0
6 bit
26 25
Memorie
Funct
 I segnali in ingresso all’unita’ di Controllo
 I bit del campo opcode (e funct nel caso del
formato R) dell’istruzione
31
Read/Write
21 20
rt
5 bit
rt
5 bit
16 15
address
16 bit
address
16 bit
0
CPU
35
Suddivisione in Main Control e ALU Control
 Per semplificare la progettazione/circuito
 Bit di funct (formato R) servono solo per il controllo dell’ALU
 Specificano l’operazione da eseguire: add,sub,and,or, o slt
 ALUOp serve per specificare il tipo di istruzione lw/sw beq o
formato R)
Opcode
Read/Write
Memorie
6
Controllo
Opcode
Controllo MUX
Read/Write
Memorie
6
Controllo MUX
Controllo
Funct
6
Controllo ALU
 Opcode ed ALUOp
 load/store
ALUOp=00
 beq
ALUOp=01
 Formato R
ALUOp=10
ALUOp
2
ALU
Funct
Controllo ALU
Control
6
CPU
36
Controllo dell’ALU
 Istruzioni ed Operazioni Richieste



Load/store
beq
Formato R
ALUOp=00
ALUOp=01
ALUOp=10
somma
sottrazione
spec. dal campo funct
 Linee di controllo Ainvert (1 bit), Bnegate (1 bit) e Operation (2
bit) dell’ALU
0000
0001
0010
0110
0111
1100
=
=
=
=
=
=
and
or
add
sub
slt
nor
ALUOp
2
ALU
Funct
Controllo ALU=ALU operation
Control
6
 Poiche’ manca nor nel set ristetto ignoriamo Ainvert

Il controllo dell’ALU richiede solo gli ultimi 3 bit
CPU
37
Controllo dell’ALU (2)
Instruction AluOp
opcode
Instruction Funct Field Desired
operation
ALU action
LW
SW
Branch eq
R-type
R-type
R-type
R-type
R-type
load word
store word
branch eq
add
sub
AND
OR
set on less
00
00
01
10
10
10
10
10
Tabella di Verita’
dell’ ALU Control
ALUOp
2
ALU
Funct
6
Control
Controllo ALU
xxxxxx
xxxxxx
xxxxxx
100000
100010
100100
100101
101010
add
add
sub
add
sub
and
or
set on less
ALUOp
ALUOp1 ALUOp0
0
0
0*
1
1
X
1
X
1
X
1
X
1
X
Input
F5
X
X
X
X
X
X
X
ALU control
010
010
110
010
110
000
001
111
Funct field
F4 F3 F2 F1
X X X X
X X X X
X 0 0 0
X 0 0 1
X 0 1 0
X 0 1 0
X 1 0 1
Output
F0
X
X
0
0
0
1
0
ALU
Control
010
110
010
110
000
001
111
CPU
38
Controllo dell’ALU: Implementazione
Input
Tabella di Verita’
dell’ ALU Control
ALUOp
ALUOp1 ALUOp0
0
0
0*
1
1
X
1
X
1
X
1
X
1
X
F5
X
X
X
X
X
X
X
Funct field
F4 F3 F2 F1
X X X X
X X X X
X 0 0 0
X 0 0 1
X 0 1 0
X 0 1 0
X 1 0 1
Output
F0
X
X
0
0
0
1
0
ALU
Control
010
110
010
110
000
001
111
ALUOp
ALU control block
ALUOp0
ALUOp1
F3
F2
F (5– 0)
Operation2
Operation1
Operation
F1
Operation0
F0
CPU
39
Progettazione dell’Unita’ di Controllo
R-type
opcode
31-26
Load/store
or branch
opcode
31-26
rs
25-21
rt
20-16
rs
rt
25-21
20-16
rd
15-11
shamt
10-6
funct
5-0
addres
s15-0
 Osservazioni sul formato Istruzioni MIPS
 Il codice operativo (campo opcode) e’ sempre nei bit 31-26
 I due registri da leggere sono sempre rs (bit 25-21) e rt
(bit 20-16)
 Il registro base per load e store e’ sempre il registro rs
(bit 25-21)
 L’offset a 16-bit per beq,load e store e’ sempre nei bit 15-0
 Il registro di destinazione e’
 bit 20-16 (rt) per load
 bits 15-11 (rd) per le istruzioni R
Occorre un ulteriore multiplexer per indicare quale campo
CPU
dell’istruzione indica il registro destinazione
40
Datapath e Controllo I
PCSrc
Add
ALU
Add result
4
Shift
left 2
RegWrite
Instruction [25– 21]
PC
Read
address
Instruction
[31– 0]
Instruction
memory
Registro da
scrivere viene da rt
o da rd
Instruction [20– 16]
0
M
u
Instruction [15– 11] x
1
RegDst
Instruction [15– 0]
Read
register 1
Read
register 2
Read
data 1
MemWrite
ALUSrc
Read
Write
data 2
register
Write
Registers
data
16
Sign
extend
0
M
u
x
1
0
M
u
x
1
Zero
ALU ALU
result
MemtoReg
Address
Write
data
32
ALU
control
Read
data
Data
memory
1
M
u
x
0
MemRead
Instruction [5– 0]
ALUOp
CPU
41
I segnali di controllo ad 1 bit
Segnale
Effetto quando vale 0
Effetto quando vale 1
RegDst
Registro destinazione = rt
Registro destinazione = rd
RegWrite
Nessuno
Nel registro indicato sull’ingresso
Write register viene scritto il
valore Write data
ALUSrc
Il secondo operando di ALU
viene da Read data 2
Il secondo operando di ALU viene
dall’estensione di segno
PCSrc
Scrittura di PC con PC+4
Scrittura di PC con l’output del
sommatore per il branch
MemRead
Nessuno
Lettura della locazione di memoria
indicata da Address
MemWrite
Nessuno
Scrittura della locazione di
memoria indicata da Address
MemtoReg
Il valore in Write data (registri) Il valore in Write data (registri)
viene dalla ALU
viene dalla memoria dati
CPU
42
Datapath e Controllo II
0
M
u
x
ALU
Add result
Add
4
Instruction [31 26]
Control
Instruction [25 21]
PC
Read
address
Instruction
memory
Instruction [15 11]
Shift
left 2
RegDst
Branch
MemRead
MemtoReg
ALUOp
MemWrite
ALUSrc
RegWrite
PCSrc
Read
register 1
Instruction [20 16]
Instruction
[31– 0]
1
0
M
u
x
1
Read
data 1
Read
register 2
Registers Read
Write
data 2
register
0
M
u
x
1
Write
data
Zero
ALU ALU
result
Address
Write
data
Instruction [15 0]
16
Sign
extend
Read
data
Data
memory
1
M
u
x
0
32
ALU
control
Instruction [5 0]
CPU
43
0
M
u
x
ALU
Add result
Add
4
Instruction [31 26]
Control
Instruction [25 21]
PC
Read
address
Instruction
memory
Datapath con
Controllo II
Instruction [15 11]
Shift
left 2
RegDst
Branch
MemRead
MemtoReg
ALUOp
MemWrite
ALUSrc
RegWrite
PCSrc
Read
register 1
Instruction [20 16]
Instruction
[31– 0]
1
0
M
u
x
1
Read
data 1
Read
register 2
Registers Read
Write
data 2
register
0
M
u
x
1
Write
data
Zero
ALU ALU
result
Address
Write
data
Instruction [15 0]
PCSrc non dipende dal
solo opcode
PCSrc=1 se l’istruzione
e’ beq e Zero=1
16
Sign
extend
Read
data
Data
memory
1
M
u
x
0
32
ALU
control
Instruction [5 0]
Opcode Istruzione e Segnali di Controllo
Memto- Reg Mem Mem
Instruction RegDst ALUSrc
Reg Write Read Write Branch ALUOp1 ALUp0
R-format
1
0
0
1
0
0
0
1
0
lw
0
1
1
1
1
0
0
0
0
sw
X
1
X
0
0
1
0
0
0
beq
X
0
X
0
0
0
1
0
1
CPU
44
Segnali di Controllo: Istruzioni Formato R
ADD
0
M
U
X
ADD
ADD
4
rs
rt
rd
I[25:21] I[20:16] I[15:11]
PC
Instruction
ADDR
RD
Instruction
Memory
I
32
5
0
5
5
RN1
RN2
RegDst
1
5
Register File
immediate/
offset
I[15:0]
Value depends on
funct
3
ALU
0
Zero
0
M
U
X
RD2
RegWrite
1
Control signals
shown in blue
???
Operation
WN
RD1
WD
PCSrc
0
1
MUX
16
1
<<2
16
E
X
T
N
D
1
32
ALUSrc
0
0
MemWrite
ADDR
Data
Memory
MemtoReg
1
RD
M
U
X
WD
MemRead
0
0
CPU
45
Segnali di Controllo: Istruzione lw
ADD
0
M
U
X
ADD
ADD
4
rs
rt
rd
I[25:21] I[20:16] I[15:11]
PC
Instruction
ADDR
RD
Instruction
Memory
I
32
5
0
5
5
RN1
RN2
RegDst
0
5
010
Operation
WN
RD1
Register File
WD
immediate/
offset
I[15:0]
3
ALU
0
Zero
0
M
U
X
RD2
RegWrite
1
Control signals
shown in blue
PCSrc
0
1
MUX
16
1
<<2
16
E
X
T
N
D
1
32
ALUSrc
1
1
MemWrite
ADDR
Data
Memory
MemtoReg
1
RD
M
U
X
WD
MemRead
0
1
CPU
46
Segnali di Controllo: Istruzione sw
ADD
0
M
U
X
ADD
ADD
4
rs
rt
rd
I[25:21] I[20:16] I[15:11]
PC
Instruction
ADDR
RD
Instruction
Memory
I
32
5
0
5
5
RN1
RN2
RegDst
X
5
WN
RD1
WD
3
ALU
1
Zero
0
M
U
X
RD2
RegWrite
0
Control signals
shown in blue
010
Operation
Register File
immediate/
offset
I[15:0]
PCSrc
0
1
MUX
16
1
<<2
16
E
X
T
N
D
1
32
ALUSrc
1
X
MemWrite
ADDR
Data
Memory
MemtoReg
1
RD
M
U
X
WD
MemRead
0
0
CPU
47
Segnali di Controllo: Istruzione beq
ADD
0
M
U
X
ADD
ADD
4
rs
rt
rd
I[25:21] I[20:16] I[15:11]
PC
Instruction
ADDR
RD
Instruction
Memory
I
32
5
0
5
5
RN1
RN2
RegDst
X
5
110
Operation
WN
RD1
Register File
WD
immediate/
offset
I[15:0]
3
ALU
0
Zero
0
M
U
X
RD2
RegWrite
0
Control signals
shown in blue
PCSrc
1 if Zero=1
1
MUX
16
1
<<2
16
E
X
T
N
D
1
32
ALUSrc
0
X
MemWrite
ADDR
Data
Memory
MemtoReg
1
RD
M
U
X
WD
MemRead
0
0
CPU
48
Implementazione dell’unita’ di Controllo Principale
Tabella di verita’ dell’unita’ di Controllo
Outputs
Inputs =Opcode
Segnale
Op5
Op4
Op3
Op2
Op1
Op0
RegDst
ALUSrc
MemtoReg
RegWrite
MemRead
MemWrite
Branch
ALUOp1
ALUOP0
form. lw
R
0
0
0
0
0
0
1
0
0
1
0
0
0
1
0
1
0
0
0
1
1
0
1
1
1
1
0
0
0
0
sw
beq
Rete Combinatoria realizzabile
tramite PLA
Inputs
Op5
1
0
1
0
1
1
x
1
x
0
0
1
0
0
0
0
0
0
1
0
0
x
0
x
0
0
0
1
0
1
Op4
Op3
Op2
Op1
Op0
Outputs
R-format
Iw
sw
beq
RegDst
ALUSrc
MemtoReg
RegWrite
MemRead
MemWrite
Branch
ALUOp1
ALUOpO
CPU
49
Controllo a Singolo Ciclo
 Controllo a singolo ciclo
 Definito da una coppia di tabelle di verita’
Zero
 Controllo Principale e Controllo ALU

PCSrc
Rete Combinatoria
Inputs
Op5
Op4
ALUOp
Op3
ALU control block
Op2
ALUOp0
Op1
ALUOp1
Op0
F3
Operation2
Outputs
R-format
Iw
sw
beq
F2
RegDst
F (5– 0)
Operation
F1
Operation0
ALUSrc
MemtoReg
Operation1
F0
RegWrite
MemRead
MemWrite
Branch
ALUOp1
ALUOpO
CPU
50
Controllo a Singolo Ciclo
 Il Controllo della CPU a singolo ciclo e’ una rete
combinatoria
 Il Datapath e’ una rete sequenziale



L’output dipende dagli ingressi e dai valori dagli elementi
di memoria (Registri e PC)
Il ciclo di clock deve durare abbastanza da stabilizzare le
uscite di tutte le reti combinatorie prima del fronte di
discesa del clock
Clock in AND con i segnali di controllo di scrittura
 I Valori in ingresso vengono scritti solo se i segnali sono
affermati

Ciclo di Clock determinato sulla base del percorso piu’
lungo
CPU
51
Diagramma a blocchi della CPU (Datapath e Control) e
Memoria
Addr
rs,rt,rd,Imm
Mem.
Istr.
Opcode
<5:0>
<31:26>
Istruzione
Funct
Operation=f(ALUOp,funct)
RegDst
CONTROLLO
PCRsr=Branch∙Zero
ALUSrc MemtoReg
MemWr MemRd
RegWr
Zero
PC
Addr
ALU
DATAPATH
Register
file
Mem.
Dati
CPU
52
Datapath e Controllo III: Istruzione j
Jump
address
opcode
31-26
Calcolo dell’indirizzo
di salto
Instruction [25– 0]
26
Shift
left 2
25-0
Ulteriore multiplexer con
Segnale di controllo jump
Jump address [31– 0]
28
0
1
M
u
x
M
u
x
ALU
Add result
1
0
Zero
ALU ALU
result
Address
PC+4 [31– 28]
Add
4
Instruction [31– 26]
Control
Instruction [25– 21]
PC
Read
address
Instruction
memory
Read
register 1
Instruction [20– 16]
Instruction
[31– 0]
Instruction [15– 11]
Shift
left 2
RegDst
Jump
Branch
MemRead
MemtoReg
ALUOp
MemWrite
ALUSrc
RegWrite
0
M
u
x
1
Read
data 1
Read
register 2
Registers Read
Write
data 2
register
0
M
u
x
1
Write
data
Write
data
Instruction [15– 0]
16
Instruction [5– 0]
Sign
extend
Read
data
Data
memory
1
M
u
x
0
32
ALU
control
CPU
53
Datapath e Controllo III: Istruzione j
CPU
54
Ciclo di Clock dell’Implementazione a singolo ciclo
 L’implementazione singolo ciclo e’ inefficiente

Una istruzione per ciclo, CPI=1, ma…
 Il tempo di ciclo e’ determinato dall’istruzione piu’
lunga
 Quale?
CPU
55
Ciclo di Clock dell’Implementazione a singolo ciclo
 Calcolo del tempo di ciclo assumendo ritardi nulli
per multiplexer, unita’ di controllo, estensione del
segno, accesso PC, shift left, linee) eccetto :



Memoria Istruzione e Dati (2ns)
ALU ed addizionatori (2ns)
Accesso al banco dei registri (1ns)
Instr.
Mem I
Reg Rd
ALU Op
Mem D
R-type
2
1
2
load
2
1
2
2
store
2
1
2
2
beq
2
1
2
jump
2
Reg Wr
Total
1
6
1
8
7
5
2
CPU
56
Problemi con l’Implementazione a Singolo Ciclo
 Il tempo di ciclo e’ determinato dall’istruzione piu’
lenta


Nel nostro caso e’ load, ma cosa succederebbe se
considerassimo anche istruzioni floating point?
Perdita di tempo
 moltre istruzioni possono essere eseguite in un tempo minore
 Le risorse che devono essere usate piu’ di una volta
nello stesso ciclo devono essere duplicate

Spreco di hardware/chip area
CPU
57
Problemi con l’Implementazione a Singolo Ciclo
 Possibili soluzioni
1. Usare un periodo di clock variabile per ogni tipo di
istruzione

Soluzione non pratica
2. Approccio Multiciclo
 Usare un tempo di ciclo piu’ piccolo…
 Ma permettere l’esecuzione di istruzioni diverse sia
completata in piu’ cicli
 Dividendo l’esecuzione in passi
 Eseguendo un singolo passo per ciclo
CPU
58