Professional Documents
Culture Documents
MUX
>>2
RegDst
RegW ZERO
Alusrc
32
ALUctr
W_src
32
rs
+ LRA
5
32 rt BusA
4 LRB
5
32 32
WR
MUX
32 BusB M
5
Registros U
instrucción rd WE
M X
BusW de 32
PC
32 U
Memoria de bits
32 X
Instrucciones 32 @
Memoria
de Datos
CLK
CLK
32 32
Inm1 CLK
EXtension
6
Recordatorio
Control
RegWrite de ALU
0
PC
MUX
Instrucción [25-21] Zero
RA
MUX
ADDR
A
busA 1
Banco de
Instrucción [20-16]
registros
Memoria
ALUout
RB
ALU
1
0
IR
DR
MUX
RW
busB 0
B
DW Instrucción [15-11] busW
MUX
1 4 1
2
0 3
MUX
MemRead
MDR
1
BWrite
ALUSrcB
Extensión
de signo
Instruc. [15-0]
<<2
MDRWrite
MemtoReg
Camino de datos y control: implementación multiciclo
1 2 3 4 5 6 7 8 9 10
Tiempo
Escribir dato
Calcular dirección de Leer dato residente en
Leer instrucción Calcular dirección del dato: memoria (dirección dada desde MDR
ramificación: en banco de
Calcular PC+4 A + ext_signo(IR[15..0]) por ALUOut)
PC+ext_signo(IR[15..0]<<2) registros
Leer
registros
PC apunta a fuente Dato leído de la
Instrucción grabada Dirección grabada memoria y Dato grabado
dirección en en registro rd
en IR en ALUOut grabado en MDR
memoria de la
instrucción PC incrementado
grabado en PC Registro rs grabado en A
Registro rt grabado en B
Dirección de ramificación
grabada en ALUOut
Camino de datos y control: implementación multiciclo
1 2 3 4 5 6 7 8
Tiempo
Escribir dato
Calcular dirección de
Leer instrucción Calcular operación R: desde ALUOut
ramificación:
Calcular PC+4 A op B en banco de
PC + ext_signo(IR[15..0]<<2)
registros
Leer registros
fuente
PC apunta a la Resultado grabado Dato grabado
Instrucción grabada
dirección en en registro rd
en IR en ALUOut
memoria de la 66
instrucción 6 PC incrementado
grabado en PC Registro rs grabado en A
Registro rt grabado en B
Dirección de ramificación
grabada en ALUOut
Camino de datos y control: implementación multiciclo
1 2 3 4 5 6
Tiempo
Leer registros
fuente
PC apunta a Si A=B, grabar
dirección en Instrucción grabada contenido de
memoria de la en IR ALUOut en PC
instrucción PC incrementado
grabado en PC Registro rs grabado en A
Registro rt grabado en B
Dirección de
ramificación grabada
en ALUOut
Recordatorio
Diagrama de estados del controlador multiciclo
de instrucción
Búsqueda
0
IR Memoria( PC )
PC PC + 4
1
Decod.
A BR( rs )
REG
B BR( rt )
op = ‘lw’
Ejecución
7 5 9
2 Zero = 0
ALUout A funct B ALUout A + SignExt( inmed ) ALUout A + SignExt( inmed ) A -B
Zero = 1
memoria
Acceso a
3 6
MDR Memoria( ALUout ) Memoria( ALUout ) B
Write-back
8 10
4
BR( rd ) ALUout BR( rt ) MDR PC PC + 4·SignExt( inmed )
Total 8
Analogía
6M 7 8 9 10 11 12 1 2T
O 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30
R Tiempo
D
A
E
N B
C
T
A D
R
E
A
S
Para realizar la tarea de 4 cargas, en forma secuencial se
necesitan 8 hs.
La misma tarea segmentada
6M 7 8 9 10 11 12 1 2T
3030 30 30 30 30 30 Tiempo
O
R
A
D
E
B
N
C
T
A D
R
E
A La misma tarea segmentada de 4 cargas de trabajo
S lleva 3.5 hs!
Definiciones Generales
● La velocidad, o frecuencia con que una instrucción sale del pipeline (cauce)
está limitada por el tiempo de proceso de la etapa más lenta.
Secuenciade
instrucciones tck
Tiempo
Implementación multiciclo:
La ejecución de la instrucción se divide en etapas: cada etapa 1ck.
El CPI de cada instrucción depende del número de etapas que necesite
ejecutar
La frecuencia de reloj depende de la etapa más lenta: balancear etapas
Secuenciade
instrucciones tck
Tiempo 2
Representación de ejecución con segmentación
Tiempo
IFtch Dcd Exec Mem WB
IFtch Dcd Exec Mem WB
IFtch Dcd Exec Mem WB
IFtch Dcd Exec Mem WB
IFtch Dcd Exec Mem WB
IFtch Dcd Exec Mem WB
rd
instruction
memory
PC
registers
memory
rs
Data
ALU
rt
+4 imm
I$ Reg D$ Reg
Representación gráfica de la segmentación
En Reg, se resalta la mitad derecha en la lectura y la
la mitad izquierda cuando se escribe
Tiempo (ciclos de reloj)
O
r
ALU
I$ Reg D$ Reg
d Load
e
ALU
I$ Reg D$ Reg
n Add
ALU
I$ Reg D$ Reg
I Store
n
ALU
I$ Reg D$ Reg
s Sub
t
ALU
I$ Reg D$ Reg
r. Or
Segmentación
Etapas de una instrucción (Load)
Ciclo 1 Ciclo2 Ciclo3 Ciclo4 Ciclo5
Segmentación
Tiempo
IFetch Reg/d Ejecu Mem Escri
IFetch Reg/d Ejecu Mem Escri
IFetch Reg/d Ejecu Mem Escri
IFetch Reg/d Ejecu Mem Escri
IFetch Reg/d Ejecu Mem Escri
Programa IFetch Reg/d Ejecu Mem Escri
Segmentación
Ciclo 1 Ciclo2 Ciclo 3 Ciclo 4 Ciclo 5 Ciclo 6 Ciclo 7 Ciclo 8 Ciclo9 Ciclo10
Clk
Multiciclo
Load Store R-type
Ifetch Reg Exec Mem Wr Ifetch Reg Exec Mem Ifetch
Segmentado
Load Ifetch Reg Exec Mem Wr
10 ns 5 ns 10 ns 10 ns 5 ns 10 ns 5 ns 10 ns 10 ns 5 ns 10 ns 5 ns
Tiempo
Reg
Reg
MI ALU MD
Reg
Reg
40 ns MI ALU MD
CC 1
Reg
40 ns MI
CC 2
40 ns
Instrucciones
CC 3
CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8 CC 9 CC 10 CC 11 CC 12
10 ns 10 ns 10 ns 10 ns 10 ns 10 ns 10 ns 10 ns 10 ns 10 ns 10 ns 10 ns Tiempo
Reg
Reg
MI ALU MD
Reg
Reg
MI ALU
Reg
MI ALU MD
Instrucciones
lw (5ck) add (4ck) sw (4ck)
Reg
Reg
MI ALU MD
Reg
Reg
MI ALU MD
Reg
Reg
MI ALU MD
Instrucciones
Reg
Reg
MI ALU MD
Implementación monociclo:
• Latencia = 40 ns
• Throughput = N / Tcpu = N/N x 40ns = 1/40 x 10-9 seg = 25 MIPS.
Implementación multiciclo:
• Latencia = 40 ns - 50 ns(depende de la instrucción)
• Throughput = N/ Tcpu= N/N x 42 ns = 1/42 x 10-9 seg = 23.8 MIPS.
Implementación segmentada:
• Latencia = 50 ns
• Throughput = N/ Tcpu = N/(N+4) x 10ns = N/(N+4) x 10 x 10-9seg 100 MIPS. si N >> 4
Aceleración » 4.
Tipos:
Estructurales. Se producen cuando dos instrucciones tratan
de utilizar el mismo recurso en el mismo ciclo.
CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8
Tiempo
Reg
Reg
Mem ALU Mem
Instrucciones
Reg
Reg
Mem ALU Mem
Reg
Reg
Mem ALU Mem
Reg
Reg
Mem ALU Mem
Reg
Mem ALU Mem
Sumador
Sumador
<<2
+4
RA Zero
PC
instrucciones
busA
Banco de
registros
ADDR
Memoria
RB
DR ADDR DR
Memoria
0
ALU
RW
datos
MUX
busB 0
busW
MUX
1
DW
1
Con la duplicación de
Extensión
de signo
32
IF/ID ID/EX EX/MEM MEM/WB
32
+ PC [IF/ID]
32 PC+4
4
>>2
RegDst
RegW
ALUctr
rs Alusrc W_src
5 LRA A
rt WE
LRB
5
Memoria IR WR
32 rt’
S Memoria
PC
5 Registros @
de rd’ B
inst BusW de
Instrucc.
Datos
Inm16
CLK Ext
rt || rd
10
Ejemplo de ejecución en el DLX
Ciclo 1
LW R10,40(R1)
4
M
u
Add x Salto
Cero?
tomado
IR 21...25
Rs1
M
IR16...20 u
Dir. Rs2
PC x
Memoria Registros
de ALU Dir.
Instrucciones Memoria
Rd
M de M
u Datos u
valor x Dato x
IR0...15
Ext. IR11..15
de
M
16 signo 32 IR16..20 u
IR11...20
x
lw BI
add
sw
sub
beqz
sw
Ejemplo de ejecución en el DLX
Ciclo 2
ADD R1,R2,R3 LW R10,40(R1)
4 M
u
Add x Salto
Cero?
[ R1] tomado
IR 21...25
Rs1
M
IR16...20 u
Dir. Rs2
PC x
Memoria Registros
de ALU Dir.
Instrucciones Memoria
Rd
M de M
u Datos u
valor x Dato x
IR0...15
Ext. 40 IR11..15
de
M
16 signo 32 IR16..20 u
IR11...20
x
lw BI DI
add BI
sw
sub
beqz
sw
Ejemplo de ejecución en el DLX
Ciclo 3
SW 0(R4),R5 ADD R1,R2,R3 LW R10,40(R1)
4
M
u
Add x Salto
Cero?
tomado
[R2]
IR 21...25
Rs1
M R1
IR16...20 u
Rs2
PC Dir. x
[R3]
Memoria Registros
de ALU Dir.
Instrucciones
Rd Memoria
M de M
40 u
u Datos
x x
valor Dato
lw BI DI EJ
add BI DI
sw BI
sub
beqz
sw
Ejemplo de ejecución en el DLX
Ciclo 4
SUB R2,R2,R6 SW 0(R4),R5 ADD R1,R2,R3 LW R10,40(R1)
4
M
u
Add x Salto
Cero?
tomado
[R4]
IR 21...25
Rs1 R2
M
IR16...20 u
Rs2
PC Dir. x
[R5] Registros
Memoria
de ALU Dir.
Instrucciones
Rd Memoria
R3
M de M
u Datos u
x x
valor Dato
IR0...15 +0
Ext. IR11..15
de M
16 signo 32 IR16..20 u
IR11...20 x [R1] [R10]
lw BI DI EJ ME
add BI DI EJ
sw BI DI
sub BI
beqz
sw
Ejemplo de ejecución en el DLX
Ciclo 5
BEQ R1, dest SUB R2,R2,R6 SW 0(R4),R5 ADD R1,R2,R3 LW R10 ....
4
M
u
Add x Salto
Cero?
tomado
[R2]
IR 21...25 R4
Rs1
M
IR16...20 u
Rs2
PC Dir. x
Memoria [R6] Registros
de ALU Dir.
Instrucciones
Rd Memoria
[R10] M M
+0 de
u Datos u
R5
x x
valor Dato
IR0...15
Ext. R2+R3
IR11..15
de M
16 signo 32 u
IR16..20
IR11...20 x [ R1]
lw BI DI EJ ME WB
add BI DI EJ ME
sw BI DI EJ
sub BI DI
beqz BI
sw
Ejemplo de ejecución en el DLX
Ciclo 6
SW 40(R1),R10 BEQ R1, dest SUB R2,R2,R6 SW 0(R4),R5 ADD R1...
4
M
u
Add x Salto
Cero?
tomado
[R1]
IR 21...25 R2
Rs1
M
IR16...20 u
Rs2
PC Dir. x
Memoria Registros
de ALU Dir.
Instrucciones
Rd R6 Memoria
[R1] M de M
u Datos u
x R5 x
valor Dato
IR0...15
Ext.
-20
IR11..15 [R2]
de M
16 signo 32 u
IR16..20
IR11...20 x
lw BI DI EJ ME WB
add BI DI EJ ME WB
sw BI DI EJ ME
sub BI DI EJ
beqz BI DI
sw BI
Que información se guarda en los Registros de Segmentación …
IR IF/ID
ID/EX
A Ext(inm16) B
EX/MEM
S B
MEM/WB
Que información se guarda en los Registros de Segmentación …
IR PC + 4 IF/ID
ID/EX
A Ext(inm16) B PC + 4
Z Dst EX/MEM
MEM/WB
Registros de Segmentación (todas las instrucciones)
Reg. Segm.
IR PC+4 IF/ID
ID/EX
A B Irrd Irrt ext(inm16) PC +4
Reg. Segm.
IR PC+4 IF/ID
ID/EX
A B Irrd Irrt ext(inm16) PC +4
S Reg M MEM/WB
Diseño del control
• Ruta de datos del DLX con las ordenes de control necesarias
MUX PcSrc
1 PC [ID/EX]
Sumador
IF/ID ID/EX EX/MEM MEM/WB
Sumador
PC [IF/ID] Dst.
Branch
+4 Reg Write
SX
<<2
MemWrite
RA Zero MentoReg
PC
busA A
instrucciones
Banco de
ADDR
IR
RB registros AluScr
Memoria
ADDR DR 0
ALU
DR RW
B S M
MUX
busB
Memoria
0
datos
busW
MUX
1
ALUctr
1
DW
B1
El Pc y los diferentes
Extensión
de signo
Control
registros de desacoplo
Ins. [15-0] 3
S1
ALU
6
Tipo R Lw Sw Beq
S <– A funct B; S <– A + SigExt( Inme); S <– A + SigExt( Inme); Evaluar Cond
B1 <– B Dst <– PC[ID/EX]+SX
If Cond
S1 <– S M <– Mem[S] Mem[S] <- B1
PC <– Dst
MemtoReg
MemRead
MemWrite
100011 (lw) 00 010
RegWrite
ALUSrc
RegDst
Branch
ALUop
101011 (sw) XXXXXX 00 010 op
000100 (beq) 01 110
100000 (add) 10 010
100010 (sub) 10 110 100011 (lw) 0 1 00 1 0 0 1 0
000000 (tipo-R) 100100 (and) 10 000 101011 (sw) X 1 00 0 1 0 0 X
100101 (or) 10 001 000100 (beq) X 0 01 0 0 1 0 X
101010 (slt) 10 111 000000 (tipo-R) 1 0 10 0 0 0 1 1
El control de la alu se determina por ALUop
que depende del tipo de instrucción y el campo EX: Ejecución/ WB Escribe
function en las instrucciones de tipo-R Calculo de Dir Reg
WB MEM: Acceso
principal
instrucción A Memoria
Control
M WB
EX M WB
Control segmentado
estacionario en los datos
MemtoReg
MemRead
MemWrite
RegWrite
ALUSrc
RegDst
Branch
ALUop
op
100011 (lw) 0 1 00 1 0 0 1 0
101011 (sw) X 1 00 0 1 0 0 X
000100 (beq) X 0 01 0 0 1 0 X
000000 (tipo-R) 1 0 10 0 0 0 1 1
0
MUX ID/EX
EX/MEM
principal
Control
1 MEM/WB
IF/ID
Sumador
Sumador
Branch
MentoReg
+4 Reg Write
<<2
MemWrite
RA Zero
PC
busA
instrucciones
Banco de
registros
ADDR RB
Memoria
AluScr
ADDR DR 0
ALU
DR RW
MUX
busB
Memoria
0
datos
busW
MUX
1
1
DW
Extensión
de signo
Control
Ins. [15-0]
ALU
6
ALUop MemRead
Ins. [20-16]
MUX
Ins. [15-11]
Reg Dst
• Riesgos
Si dos o más
instrucciones
comparten un dato
- LDE (RAW)
Dependencia de - EDL (WAR)
Datos
- EDE (WAW)
Existe dependencia de datos entre dos instrucciones i y j
(supondremos que i precede a j) cuando ambas acceden a un mismo
operando (registro o posición de mem.)
Tipos de dependencias:
Operandos en memoria:
• i es un lw que lee una posición de memoria y j es un sw que escribe en
la misma posición. Aunque hay una antidependencia entre i y j, no hay
riesgo porque i lee primero y j escribe luego
ck 1 ck 2 ck 3 ck 4 ck 5 ck 6 ck 7 ck 8
tiempo
Mulf f2, f4, f5 BI DI MF1 MF2 MF3 MF4 M PE
f 2 incorrecto! guarda
Escribe f 2 un valor “obsoleto”
Addf f2,f3,f5 BI DI SF1 SF2 M PE
Operaciones multiciclo
Riesgos de Datos: EDE...
Posibles soluciones:
1) Detención de addf hasta que mulf escriba en el ciclo 8...
addf escribiría luego en el ciclo 9
ck 1 ck 2 ck 3 ck 4 ck 5 ck 6 ck 7 ck 8 ck 9
mulf f2, f4, f5 tiempo
BI DI MF1 MF2 MF3 MF4 M PE
Escribe f 2
Escribe f 2
addf f2, f3, f5
BI DI SF1 SF2 M PE
Tiempo(ciclos)
ALU
i add r1 ,r2,r3 Im Reg Dm Reg
ALU
Im Reg Dm Reg
i+1 sub r4, r1 ,r3
Debe esperar dos ciclos
ALU
Im Reg Dm Reg
i+2 and r6, r1 ,r7
Debe esperar un ciclo
ALU
Im Reg Dm Reg
i+3 or r8, r1 ,r9
¿ Puede progresar?
ALU
Im Reg Dm Reg
i+4 xor r10, r1 ,r11
ALU
i add r1 ,r2,r3 Im Reg Dm Reg
ALU
Im Reg Dm Reg
i+1 sub r4, r1 ,r3
ALU
Im Reg Dm Reg
i+2 and r6, r1 ,r7
ALU
Im Reg Dm Reg
i+3 or r8, r1 ,r9
ALU
Im Reg Dm Reg
i+4 xor r10, r1 ,r11
Program
execution order
WB
EX/MEM
Control
Instrucción
MEM/WB
M WB
EX EX: Ejecución/ M WB
Calculo de Dir. MEM: Acceso a
Memoria
ID: Decodificación/
MUX
Lectura de Reg A
AluScr
RA busA ADDR DR 0
ALU
Anticipar A
MUX
1
Ex.IR[15:0]
Memoria
Banco de
registros
datos
RB
MUX 1
MUX
RW B
0
busW busB DW
Rs
Rt Anticipar B
Rt
EX/MEM Rd MEM/WB Rd
MUX
Rd
Unidad de
Cortocircuito
o Forwarding
unit
• Hardware para manejar Riesgo de Datos (esquema más detallado…)
Hazard ID/EX.MemRead
detection
unit ID/EX
IF/ID Write
WB
EX/MEM
M
Control u M WB
x MEM/WB
0
IF/ID EX M WB
PC Write
M
Instruction
u
x
Registers
Instruction Anticipar A Data
PC ALU
memory memory M
u
M x
u
x
IF/ID.RegisterRs
Anticipar B
IF/ID.RegisterRt
IF/ID.RegisterRt Rt M EX/MEM.RegRd
IF/ID.RegisterRd Rd u
x
ID/EX.RegisterRt Rs Forwarding MEM/WB.RegRd
.
Rt unit
Detección y resolución de riesgos de datos
1a Riesgo “EX”
IF (EX/MEM.EscrReg
And (EX/MEM.RegistroRd 0)
And (EX/MEM.Registro Rd=ID/EX.RegistroRs))
anticipar A=10
1b Riesgo “EX”
IF (EX/MEM.EscrReg
And (EX/MEM.RegistroRd 0)
And (EX/MEM.Registro Rd=ID/EX.RegistroRt))
anticipar B=10
Detección y resolución de riesgos de datos
IF ID/RF EX MEM WB
ALU
Reg Reg
lw $3,0($1) I D
ALU
sub $5,$3,$2 I Reg D Reg
lw $2, 20($1) IM R eg DM R eg
IF (ID/EX.LeerMem
And ((ID/EX.RegistroRt =IF/ID.RegistroRs) or
(ID/EX.RegistroRt =IF/ID.RegistroRt)) Bloquear pipeline
Bloqueo
• Podemos bloquear el pipeline manteniendo una instrucción en la
misma etapa, tanto en ID como en IF. Evitando que cambien el PC
y el IF/ID
bubble
Hazard ID/EX.MemRead
detection
unit ID/EX
WB
I F /I D Writ e
EX/MEM
M
Control u M WB
x MEM/WB
0
IF/ID EX M WB
P CW rite
M
Instruction
u
x
Registers
Instruction Data
PC ALU
memory memory M
u
M x
u
x
IF/ID.RegisterRs
IF/ID.RegisterRt
IF/ID.RegisterRt Rt
M EX/MEM.RegisterRd
IF/ID.RegisterRd Rd u
x
ID/EX.RegisterRt Rs Forwarding MEM/WB.RegisterRd
Rt unit
Unidad detección y anticipación de riesgos
Detector de riesgos
Debe actuar en ID impidiendo la carga y lectura de una nueva instrucción
Condiciones : Que la instrucción en EX sea un load
Registros fuentes de la instrucción siguiente Rs y Rt
Detector
de riesgos Registro destino del load Rt
ID/EX
Rt
WB
No cargar
EX/MEM
Control
MUX
No cargar
M WB MEM/WB
0
Instrucción EX: Ejecución/
E Calculo de Dir WB WB Escribe
M MEM: Acceso a
X Reg
Memoria
ID: Decodificación/
Memoria de instrucciones
MUX
Lectura de Reg
AluScr
ADDR
ALU
RA DR 0
MUX
bus
Banco de
Memoria
1
registros
datos
RB A
MUX
PC
1
MUX
RW
busB 0
busW DW
Rs
Rt
Rt
MUX
Rd
Unidad
Cortocircuito
Riesgos de Datos...
Ejemplo:
...
I1 load R1, -4($R8)
NOP
...
NOP
I1 load R1, -4($R8)
I2 add R3,R2,R1
I2 add R3,R2,R1
NOP
I3 mul R5,R4,R3
NOP
I4 add R3,R3,#1
I3 mul R5,R4,R3
...
I4 add R3,R3,#1
...
Riesgos de Datos...
Prevención de la Dependencia de Datos: Solución SW2
Ejemplo
... ...
I1 load R7,0($R8) I2 add R3,R1,R2
I2 add R3,R1,R2 I1 load R7,0($R8)
I3 mul R5,R3,R4 I4 load R1,-4($R8)
I4 load R1,-4($R8) I3 mul R5, R3,R4
I5 load R2,10(R6) I5 load R2,10(R6)
... ...
Si no se pueden reordenar las instrucciones sin alterar la lógica del
programa,(ver ejemplo anterior) el compilador elimina los riesgos
insertando “nops”.
Riesgo de Datos: Solución Software
23
gcc 54
0 20 40 60 80
Riesgos de Control:
Aparecen cuando surge la necesidad de tomar una
decisión basada en los resultados de una instrucción
mientras las otras se están ejecutando.
Soluciones:
Primera opción: detener el cauce hasta que se toma la decisión.
Después se reanuda la ejecución segmentada. Esto produce un
bloqueo, llamado burbuja o stall.
Soluciones:
ALU
e Im Reg Mem Reg
Add
n
ALU
d Im Reg Mem Reg
Beq
e
ALU
i Load Pérdida
Im Reg Mem Reg
n de ciclos
s
t.
equivaldría
a hacer Tiempo (ciclos)
ALU
Sub r1,r2,r3 Im Reg Mem Reg
ALU
Beq r1, loop Im Reg Mem Reg
ALU
Load Im Reg Mem Reg
ALU
Im Reg Mem Reg
Solo se espera un ciclo para iniciar
la instrucción que sigue al salto
Riesgos de control
El salto se resuelve
Tal y como está diseñado “hasta ahora” el DLX..
en la etapa MEM
“tomar salto”
0
MUX
PcSrc
“dirección de salto”
1
Sumador
Branch
MentoReg
+4 Reg Write
<<2
RA Zero
PC
instrucciones
busA
Banco de
registros
ADDR RB
Memoria
AluScr
ADDR DR
ALU
0
DR RW
MUX
busB
Memoria
0
datos
busW
MUX
1
1
DW
Extensión
de signo
Control
Ins. [15-0]
ALU
6
ALUop MemRead
Ins. [20-16]
MUX
Ins. [15-11]
Riesgos de control
soluciòn nº 1 “mejorada”...
1 Mover bloque HW
Sumador
Sumador
+4
<<2
RA Zero
PC
bus
instrucciones
Banco de
registros
ADDR RB A
Memoria
D
ADDR
ALU
0
DR RW R
MUX
Memoria
busB 0
datos
busW
MUX
1
1 D
W
Extensión
de signo
Riesgos de control
Segunda opción o solución nº2: Predicción de saltos
PREDICCIÓN ESTÁTICA
Dos altennativas: Lo más sencillo es suponer que
Suponer que siempre se toma el salto no se tomará (PC+4 ya
la bifurcación (hay situaciones está calculado). Se continúa
en las que casi siempre se salta) en el cauce con la instrucción
Suponer que nunca se toma la siguiente en la secuencia.
bifurcación (hay situaciones en Si el salto se toma, se
las que casi nunca se salta) descartan las instrucciones en
ejecución.
PREDICCIÓN DINÁMICA
Programa
0
MUX
1
ID/EX
Sumador
Problema de Forwarding:
Sumador
IF/ID
Usar circuito similar al de
las dependencias LDE
+4
<<2
RA
PC
bus
instrucciones
Banco de
ADDR registros A
RB
Memoria
ALU
DR RW
MUX
busB 0
busW
MUX
1
=?
1
Branch
NOP
Extensión
de signo
Riesgos de control
Tomado
No tomado
Predecir tomado Predecir tomado
Tomado
Tomado No tomado
No tomado
Predecir no tomado Predecir no tomado
Tomado
No tomado
Riesgos de control
ALU
e Im Reg Mem Reg
n
Add
ALU
Beq Im Reg Mem Reg
d
e
ALU
Cq. inst. no Im Reg Mem Reg
i depend. del salto
n
ALU
s Load Im Reg Mem Reg
t.
0
MUX
1
ID/EX
Sumador
Sumador
IF/ID
+4
<<2
RA
PC
bus
instrucciones
Banco de
ADDR registros A
RB
Memoria
ALU
DR RW
MUX
busB 0
busW
MUX
1
=?
1
Branch
NOP
Extensión
de signo
Llenado
del
hueco
add $s1,$s2,$s3
Hazard
detection
unit
M ID/EX
u
x
WB
EX/MEM
M
Control u M WB
x MEM/WB
0
IF/ID EX M WB
4 Shift
left 2
M
u
x
Registers = Data
Instruction ALU
PC memory M
memory
u
M x
u
x
Sign
extend
M
u
x
IF Flush Forwarding
unit
Excepciones: una segunda mirada…
Cuando una instrucción produce una excepción hay dos formas de tratarla:
• Excepciones Precisas
Se atienden las excepciones respetando el orden de las instrucciones que las
provocan (no en el orden en que se producen las propias excepciones). Esto
garantiza que el proceso que se interrumpe continuará correctamente después
del tratamiento de la excepción. Para ello:
- Todas las instrucciones anteriores deben completarse
- La que produce la interrupción y las siguientes deben quedar como si no
hubieran empezado
• Excepciones Imprecisas
Se tratan las excepciones en el orden en que se producen (esto no agrega
ninguna complejidad al hardware)
Excepciones en el DLX
etapa causa
LW R1,0(R0) IF ID EX M WB
IF ID EX M WB
ADD R4,R3,R5
Overflow IF ID Ex Mem WB
Flujo del prog
12
10
Muy importante:
8
Las instrucciones empiezan Paradas por saltos
y terminan en orden 6 Paradas por LW
0
compress eqntott espresso. gcc li
• Pipeline Optimo
• Cada etapa en cada ciclo de reloj ejecuta una parte de una instrucción
• En cada ciclo de reloj finaliza una instrucción.
• En promedio la ejecución se acelera proporcionalmente al número de
etapas.
• Características que permiten su funcionamiento
• Similitud entre los formatos de las instrucciones permite usar las
mismas etapas para todas las instrucciones.
• Cada etapa utiliza la misma cantidad de tiempo que el resto: hay un
tiempo desperdiciado.
Resumen: Procesador segmentado vs uniciclo
40 nseg
lw Ins R Alu Mem W
Ciclo 1 Ciclo2
Clk
Monociclo
No
Load Store usado
Ciclo 1 Ciclo2 Ciclo 3 Ciclo 4 Ciclo 5 Ciclo 6 Ciclo 7 Ciclo 8 Ciclo9 Ciclo10
Clk
Multiciclo
Load Store
Ifetch Reg Exec Mem escr Ifetch Reg Exec Mem Ifetch
100 instrucciones en:
Segmentado • Monociclo
40ns/ciclo x100 = 4000ns
Load Ifetch Reg Exec Mem escr • Multiciclo (CPI(lw)=5, CPI(resto)=4, para
20% de lw es CPI = 0.2x5 + 0.8x4 CPI=4.2)
Store Ifetch Reg Exec Mem escr 10ns/ciclo x 4.2 CPI x 100 =4200ns
• Segmentado
. . . . . . 10ns x (1CPI x100+4ciclos llenado)=1040 ns
Implementación monociclo:
• Latencia = 40 ns
• Rendimiento = 1 / Tcpu = 1/40 x 109= 25 MIPS.
Implementación multiciclo:
• Latencia = 40 ns a 50 ns (depende de la instrucción)
• Rendimiento = 1/ Tcpu= 1/42 x 109= 23.8 MIPS.
Implementación segmentada:
• Latencia = 50 ns
• Rendimiento = 1/ Tcpu = 1/10 x 109= 100 MIPS.
• Supongamos:
• CPI base=1
• Freq branch=20%, freq load=30%
• Supongamos que los saltos siempre causan 1 ciclo de bloqueo
• Supongamos que los load provocan 100 ciclos de bloqueo el 1% del
tiempo
• Entonces CPI = 1 + (10.20)+(100 0.300.01)=1.5
Fin resumen…
Segmentación.
Conclusiones
Conclusiones
3.0
Performance relativa
2.5
2.0
1.5
1.0
0.5
0.0
1 2 4 8 16
Profundidad del Pipeline