¿Qué es la segmentación?

Es una Técnica de Implementación:

– Persigue aumentar las prestaciones.

– Divide la ejecución de una instrucción en etapas.
– Cada etapa utiliza diferentes recursos.
– Permite solapar la ejecución de distintas
instrucciones en diferentes etapas.
– Permite comenzar una instrucción en cada ciclo
de reloj.
 Recordatorio

 Arquitectura MIPS (DLX)

 Todas las instrucciones del repertorio del MIPS tienen 32 bits de
anchura, repartidas en 3 formatos de instrucción diferentes:
31 26 21 16 11 6 0
Tipo R: op rs rt rd shamt funct
aritmético-lógicas
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
Tipo I: 31 26 21 16 0
con memoria op rs rt inmediato
salto condicional
6 bits 5 bits 5 bits 16 bits
31 26 0
Tipo J:
salto incondicional op dirección
6 bits 26 bits

 El significado de los campos es:

 op: identificador de instrucción
 rs, rt, rd: identificadores de los registros fuentes y destino
 shamt: cantidad a desplazar (en operaciones de desplazamiento)
 funct: selecciona la operación aritmética a realizar
 inmediato: operando inmediato o desplazamiento en direccionamiento a registro-base
 dirección: dirección destino del salto
 Recordatorio
 Ruta de datos ( uniciclo )
Pcsrc

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

 Ruta de datos ( multiciclo )

PCWrite IorD MemWrite IRWrite RegDst AWrite ALUSrcA ALUop OutWrite

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

Ejecución de instrucciones multiciclo: Lw

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

Ejecución de instrucciones multiciclo: tipo R

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

Ejecución de instrucciones multiciclo: beq

1 2 3 4 5 6
Tiempo

Calcular dirección de Comparar si A=B

Leer instrucción ramificación: haciendo
Calcular PC+4 PC + ext_signo(IR[15..0]<<2) una resta en la UAL

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

° Ann, Brian, Cathy, Dave

cada uno tiene una carga de ropa
A B C D
para lavar, secar, planchar, y
ordenar

° Lavar lleva 30 minutos

° Secar lleva 30 minutos

° Planchar lleva 30 minutos

° Ordenar, colocar la ropa en su lugar

lleva 30 minutos
 El trabajo secuencial

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

 Latencia: tiempo para completar una determinada tarea

o Por ejemplo, el tiempo para leer un sector de un disco es el
tiempo de acceso de disco o latencia del disco.

 Productividad (Throughput): cantidad de trabajo que se

puede hacer en un período de tiempo.
 Segmentación
 La segmentación no mejora
la latencia una sola tarea,
6 PM 7 8 9 mejora la productividad
throughput de la carga de

O Tiempo trabajo completa.

R
30 30 30 30 30 30 30  Multiples tareas operan
D
E A simultaneamente usando
N diferentes recursos
B
T
C  Aceleración Potencial =
A Numero de etapas de la
R D segmentación
E
A
 Tiempo para “llenar” el
S
pipeline y tiempo para
“limpiarlo” reduce la
aceleración:
2.3X v. 4X en este ejemplo
 Segmentación
 Supongamos que un nuevo
6 7 8 9 lavarropa necesita 20 minutos,
un secarropas nuevo necesita
O Tiempo 20 minutos. ¿El pipeline es
R ahora mas rápido?
30 30 30 30 30 30 30
D
E A  La velocidad del Pipeline esta
N limitada por la etapa mas lenta
B
T
A C  La duración de las etapas del
R pipe deben estar balanceadas
D sino se reduce la aceleración
E
A esperada.
S
 Segmentación

● No reduce la latencia de una instrucción, sino que ayuda a incrementar la

productividad de toda la tarea.

Productividad: nº de instrucciones que se ejecutan por unidad de tiempo

Latencia: tiempo necesario para ejecutar completamente una instrucción

● Permite que los recursos se utilizen óptimamente.

● 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.

● Idealmente, la mejora en velocidad debida a la segmentación es igual al

número de etapas.

Las etapas pueden no estar equilibradas  tiempo de inactividad

● El diseñador debe equilibrar la duración de las etapas.

● Obviamente la segmentación tiene un costo de diseño e implementación

 Pasos de ejecución en MIPS

1) Ifetch (IF) : Búsqueda de la Instrucción, Incremento del PC

2) Decode (ID): Decodificar Instrucción, Leer Registros

3) Execute (EX) : Mem-ref: Calcular dirección

Arith-log: Realizar Operación

4) Memory (MEM) : Load: Leer Datos de la Memoria

Store: Escribir Datos a la Memoria

5) Write Back (WB) : Escribir Datos a los registros

Representación de Ejecución en Implementaciones no segmentadas
Implementación monociclo:
Toda instrucción consume 1ck
El CPI de todas las instrucciones es 1
La frecuencia de reloj depende del camino crítico: instrucción más larga

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

 Cada instrucción toma el mismo número de pasos, denominadas

“etapas”, que algunas veces estarán ociosas.
 Revisión: Camino de datos en MIPS

rd

instruction
memory
PC

registers

memory
rs

Data
ALU
rt

+4 imm

1. Instruction 2. Decode/ 5. Write

3. Execute 4. Memory
Fetch Register Read Back
 Usamos el camino de datos para representar la segmentación

IFtch Dcd Exec Mem WB

ALU

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

Ifetch Reg/Dec Ejecu Mem Escri

° Ifetch ( búsqueda). Lee una instrucción desde la memoria

° Reg/dec. Decodifica la instrucción y lee registros
° Ejecuta. Calcula dirección de memoria
° Mem. Lee el dato de la memoria
° Escri. Escribe el dato en el registro

 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

 Monociclo, multiciclo, segmentado

Ciclo 1 Ciclo2
Clk
Monociclo
Load Store No usado

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

Store Ifetch Reg Exec Mem Wr

R-type Ifetch Reg Exec Mem Wr

Comparación de rendimientos de las tres
implementaciones
Implementación monociclo del DLX
Supongamos los siguientes tiempos:
Caches de instrucciones y datos: 10ns (se usa en BI y M)
Banco de registros: 5ns (se usa en DE y PE)
Operación aritmética en la ALU: 10ns (se usa en EJ)

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

Tcpu= N x CPI x tck tck = 40ns CPI = 1 Tcpu = N x 40 ns

 Implementación multiciclo del DLX
El tck = 10ns (F=100MHz).
El CPI depende del tipo de instrucciones.
Supongamos: CPI(lw) = 5, CPI(resto) = 4

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)

Supongamos un programa con 20% de lw.

CPI = 0.2 x 5 + 0.8 x 4 CPI = 4.2
Tcpu= N x CPI x tck Tcpu = N x 4.2 x 10ns = N x 42ns
 Implementación segmentada del DLX
El tck = 10ns (F=100MHz).
El CPI  1
CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8
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 MD

Reg

Reg
MI ALU MD
Instrucciones

Reg

Reg
MI ALU MD

Tcpu = N x CPI x tck + 4 x tck = (N x CPI + 4) x tck  Tcpu = (N + 4) x 10ns

.
Cálculo del Throughput (número de instrucciones que se terminan de ejecutar por
unidad de tiempo)
Throughput = N / Tcpu

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

Cálculo del Speedup:

Speedup = Aceleración debido a la seg = Tcpu sin segment. / Tcpu con segment.
En el caso ideal: Aceleración = número de etapas = 5
 Veamos tres ejemplos para distinto número de instrucciones:

Para 4 instrucciones (ejemplo graficado)

Monociclo: Tcpu = N x 40 ns = 4 x 40 ns = 160 ns
Multiciclo: Tcpu = N x 42 ns = 4 x 42 ns = 168 ns
Segmentada: Tcpu = (N + 4) x 10 ns = 8 x 10 ns = 80 ns

Speedup = 160ns / 80ns = 2 (monociclo vs segmentada)

Speedup = 168ns / 80ns = 2.1 (multiciclo vs segmentada)

Para 100 instrucciones

Monociclo: Tcpu = N x 40 ns = 100 x 40 ns = 4000 ns
Multiciclo: Tcpu = N x 42 ns = 100 x 42 ns = 4200 ns
Segmentada: Tcpu = (N + 4) x 10 ns = 104 x 10 ns = 1040 ns

Speedup = 4000ns / 1040ns = 3.84 (monociclo vs segmentada)

Speedup = 4200ns / 1040ns = 4.04 (multiciclo vs segmentada)
 Para 1000 instrucciones
Monociclo: Tcpu = N x 40 ns = 1000 x 40 ns = 40000 ns
Multiciclo: Tcpu = N x 42 ns = 1000 x 42 ns = 42000 ns
Segmentada: Tcpu = (N + 4) x 10 ns = 1004 x 10 ns = 10040 ns

Speedup = 40000ns / 10040ns = 3.98 (monociclo vs segmentada)

Speedup = 42000ns / 10040ns = 4.18 (multiciclo vs segmentada)

Aceleración » 4.

En el caso ideal: Aceleración = número de etapas = 5

Razones para no alcanzar ideal:

•Etapas desbalanceadas: las etapas DI y PE consumen 10ns de los
que son útiles sólo 5ns
•Coste de la segmentación: retardos (aun no contemplados)
debidos a la circuitería adicional
•Riesgos entre instrucciones: en ocasiones hay que retrasar la
ejecución de algunas instrucc.
 Segmentación
 Riesgos
 Situaciones que impiden que en cada ciclo se inicie la ejecución de
una nueva instrucción

 Tipos:
 Estructurales. Se producen cuando dos instrucciones tratan
de utilizar el mismo recurso en el mismo ciclo.

 De datos. Conflictos por el acceso a datos (registros o

posiciones de memoria). Se intenta utilizar un dato antes de
que esté preparado. Mantenimiento del orden estricto de
lecturas y escrituras.

 De control. Intentar tomar una decisión sobre una condición

todavía no evaluada. Consecuencia de la ejecución de
instrucciones que modifican el PC: saltos, saltos condicionales,
salto subrutina.

 Los riesgos se deben detectar y resolver

Segmentación… Riesgos estructurales

Posibles conflictos en el acceso a los recursos:

• Accesos simultáneos a la misma memoria
• Accesos simultáneos al banco de registros
• Acceso a unidades funcionales no segmentadas que utilicen
más de un ciclo de reloj (por ejemplo, unidades en punto flotante)

Solución de bajo costo (pero ineficiente)

Detener el flujo de instrucciones hasta que se resuelva el riesgo
(inserción de burbujas)

Soluciones eficientes (pero más caras):

• Usar caches particionadas para datos e instrucciones
• Cada instrucción deberá usar una determinada etapa del
procesador en un determinado ciclo o fase de su ejecución
• Aumentar el número de puertos de acceso al banco de registros
• Replicar o segmentar unidades funcionales que usan más de un
ciclo.
 Operaciones multiciclo no segmentadas
Acceso a unidades funcionales no segmentadas que utilicen
más de un ciclo de reloj (por ejemplo, unidades en punto flotante)
Operaciones multiciclo segmentadas
 Segmentación… Riesgos estructurales

 Comparamos las instruciones: Load (lw) y tipo-R

 Load. Tiene 5 fases (utiliza las 5 etapas)

Ciclo 1 Ciclo2 Ciclo 3 Ciclo4 Ciclo5
Clock

lw Ifetch Reg/Dec Ejec Mem Escr

lw Ifetch Reg/Dec Ejec Mem Escr

 Tipo-R. Tiene 4 fases y no usa la memoria de datos

Ciclo 1 Ciclo2 Ciclo 3 Ciclo4
Clock

Tipo-R Ifetch Reg/Dec Ejec Escr

Si lo implementamos así aparece un conflicto (Riesgo estructural)

Ciclo 1 Ciclo2 Ciclo 3 Ciclo4 Ciclo5
Clock Sólo hay una puerta de
Escritura en el bloque de
lw Ifetch Reg/Dec Ejec Mem Escr registros

Tipo-R Ifetch Reg/Dec Ejec Escr

Segmentación… Riesgos estructurales

 Importante. ¿ como evitar dicho conflicto ?

 Cada etapa del procesador puede ser usada (en cada ciclo) por
una sola instrucción.
 Cada instrucción debe usar la misma etapa del procesador en un
mismo ciclo o fase de ejecución.
 Solución.
 Incluir la etapa (Mem) aunque Tipo-R no la use.
Ciclo 1 Ciclo2 Ciclo 3 Ciclo4 Ciclo5 Ciclo6
Clock

lw Ifetch Reg/Dec Ejec Mem Escr

Tipo-R Ifetch Reg/Dec Ejec Mem Escr

 Store y Branch ambas con cuatro etapas activas

Ciclo 1 Ciclo2 Ciclo 3 Ciclo4 Ciclo5
Clock
Sw, Beq Ifetch Reg/Dec Ejec Mem Escr
store
Branch
Segmentación… Riesgos estructurales

Para evitar escrituras y lecturas simultáneas en el banco de

registros, las lecturas se realizan en la segunda mitad de un
ciclo y las escrituras en la primer mitad.

lw Ins R Alu Mem W

lw Ins R Alu Mem W

10 nseg
lw 10 nseg Ins R Alu Mem W

10 nseg Ins R Alu Mem W

10 nseg 10 nseg 10 nseg 10 nseg 10 nseg

 Acceso simultáneo a la misma memoria
Supongamos que tenemos las caches de instrucciones y datos
unificadas
La primera instrucción es un lw (usa la cache en las fases BI y ME)
La BI de la instrucción 3 colisiona con el lw en el acceso a ME (CC4)

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

Solucion: Usar caches particionadas para datos e instrucciones

 Segmentación..
• Ruta de datos del DLX para ejecución segmentada (idea inicial)

IF:Búsqueda de instrucción ID: Decodificación/ EX: Ejecución/ MEM: Acceso a WB Escribe

Lectura de Reg. Calculo de Dir. Memoria Reg.
0
MUX

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

recursos hecha no deben

aparecer riesgos
estructurales
 Registros de Segmentación

• Entre cada etapa y la siguiente guardaremos la

Pcsrc información que debe acompañar a cada instrucción
MUX
en su marcha por el camino de datos.

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)

BI/DI DI/EJ EJ/M EM MEM/WB

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)

BI/DI DI/EJ EJ/MEM MEM/WB

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)

BI/DI DI/EJ EJ/MEM MEM/WB

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

IR0...15 Ext. IR11..15

de M [R10]
16 signo 32 IR16..20 u
IR11...20 x

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)

BI/DI DI/EJ EJ/M EM MEM/WB

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 ....

BI/DI DI/EJ EJ/MEM MEM/WB

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...

BI/DI DI/EJ EJ/MEM MEM/WB

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 …

Para Instrucción Tipo R

• Transferencias Físicas
IR<---MEM[PC]; PC<--PC+ 4;
BusA<---R[rs]; BusB<---R[rt]
BusS<---BusA+BusB
R[rd]<--BusS
Reg. Segm.

Inf. a guardar, para Tipo R, entre etapas IF e ID

IR IF/ID

entre ID y EX guardar ID/EX

A B IRrd
entre EX y MEM guardar EX/MEM
S IRrd
entre MEM y WB guardar MEM/WB
S IRrd
Que información se guarda en los Registros de Segmentación …

Para Instrucción Load

• Transferencias Físicas
IR<---MEM[PC]; PC<--PC+ 4;
BusA<---R[rs];
BusS<---BusA+ext(inm16);
Dato<--Mem[busS];
R[rt]<--Dato Reg. Segm.

Inf. a guardar, para Load, entre etapas IF e ID

IR IF/ID
entre ID y EX guardar
A Ext(inm16) IRrt ID/EX

entre EX y MEM guardar EX/MEM

S IRrt
entre MEM y WB guardar MEM/WB
Dato IRrt
Que información se guarda en los Registros de Segmentación …

Para Instrucción Store

• Transferencias Físicas
IR<---MEM[PC]; PC<--PC+ 4;
BusA<---R[rs];
BusS<---BusA+ext(inm16);
Mem[busS]<--BusB;
Reg. Segm.

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 …

Para Instrucción Beq

• Transferencias Físicas
IR<---MEM[PC]; PC<--PC+ 4;
BusA<--R[rs]; BusB<--R[rt];
dst<--- PC+4+ Signext(inm16)*4; Z<-- (BusA=BusB) ;
si (Z) entonces PC<---dst;
Reg. Segm.

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

S Irrd Irrt B Z Dst EX/MEM

S Irrd Irrt M MEM/WB

Registros de Segmentación (mejor)

Reg. Segm.

IR PC+4 IF/ID

ID/EX
A B Irrd Irrt ext(inm16) PC +4

S Reg B Z Dst EX/MEM

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

(IF/ID ..etc) se deben 2 MemRead

cargar con cada ciclo, Ins. [20-16] ALUop
MUX

por tanto no necesitan Ins. [15-11]

una orden especifica Reg Dst

64b 128+2x5b 97+5b 64+5b

 Diseño del control
• Diagrama de ejecución de instrucciones:

IR <- Mem[PC]; PC <– PC+4;

A <- R[rs]; B<– R[rt]

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

R[rd] <–S1; R[rt] <– M;

 Diseño del control: Señales de control

Control de la ALU Control principal

op funct ALUop ALUctr

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

IF/ID ID/EX EX/MEM MEM/WB

64b 128+2x5+9b 97+5+5b 64+5+2b

 Lógica de Control

• El secuenciamiento de control debe viajar con la instrucción a través

del Camino de Datos.
• Cada ciclo de reloj se realizan escrituras en el PC, por lo tanto no hay
señal especial de escritura para él.
• Los 4 registros de segmentación también se actualizan en cada ciclo.
• Dividimos las señales de control en 3 grupos, de acuerdo a la etapa en
la que actúan.

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

EX: Ejecución/ WB Escribe

Calculo de Dir Reg
MEM: Acceso
A Memoria
 Diseño del control
• Ruta de datos con las ordenes de control
PcSrc

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

64b 128+2x5+9b 97+5+5b 64+5+2b

Segmentación

• Riesgos

1 Riesgos estructurales: El HW no soporta que

distintas instrucciones pretendan usar un mismo
recurso, en el mismo momento (Si dos instrucciones intentan
acceder a una misma unidad funcional en el mismo ciclo conflicto)

2 Riesgos por dependencia de datos: Se producen

cuando hay instrucciones que dependen de los
resultados de otras instrucciones en el pipe (Conflictos
al manipular datos en registros o en memoria)

3 Riesgos Control : Ocurren con las instrucciones de

salto, en el intento de realizar una decisión antes de
que se evalue la correspondiente condición.
 Dependencias de Datos..

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.)

Al usar segmentación, el orden de LECTURA de los operandos y la

ESCRITURA de resultados no debe modificarse respecto al
especificado por el programa. Por ello diremos que existe un Riesgo
de Datos cuando existe dependencia entre instrucciones que se
ejecutan concurrentemente.
 Segmentación : Riesgos de datos

 Se produce cuando por la segmentación, el orden de

LECTURA de los operandos y la ESCRITURA de
resultados se modifica respecto al especificado por el
programa.
 Se produce un riesgo si existe dependencia entre
instrucciones que se ejecutan concurrentemente.

Dominio: operandos de la instrucción

Rango: resultado de la instrucción
Si a=b+c
……. Situaciones: i precede a j
Sj c=a+e
……. D( i )  D( j )   no RIESGO
Sk a=d+e D( i )  R( j )   riesgo EDL (WAR)
R( i )  D( j )   riesgo LDE (RAW)
R( i )  R( k )   riesgo EDE (WAW)
 Dependencias de Datos..

Tipos de dependencias:

•Dependencia verdadera: i escribe un operando que j lee

Una instrucción j intenta leer un
R( i )  D( j )    riesgo LDE (RAW) operando que aún no fue modificado
por una instrucción previa

•Antidependencia: i lee un operando que j escribe

Una instrucción j intenta escribir
D( i )  R( j )    riesgo EDL (WAR) un destino antes de que éste sea leído
por una instrucción previa i

•Dependencia de salida: i y j escriben el mismo operando

Una instrucción j intenta escribir
R( i )  R( j )    riesgo EDE (WAW) un operando antes de que lo haga
una instrucción previa i

Dominio: operandos de la instrucción; Rango: resultado de la instrucción

Riesgos de Datos: EDL (WAR)

En el DLX no se producen riesgos EDL, aunque exista una

antidependencia entre dos instrucciones i y j .
La instrucción i siempre leerá sus operandos antes de que j escriba.
Post Escritura
o Write Back

i add r3, r1, r2 BI DI EJ M PE i lw r3, 4(r1)

j Sub r1, r5, r2 BI DI EJ M PE j sw 4(r1), r5

Operandos en registros: i lee r1 y j escribe en r1.

• La instrucción i lee en DI y j escribe en PE 4 ciclos más tarde

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

En otras arquitecturas si pueden aparecer riesgos WAR, como sucede, por

ejemplo, en arquitecturas con ejecución fuera de orden.
 Riesgos de Datos: EDE (WAW)

Aunque exista dependencia de salida entre i y j, si no existen UFs multiciclo

no hay riesgos EDE en el DLX. Las escrituras de i y j se realizarán en orden
(primero i y luego j)
Post Escritura o
Write Back
add r1, r3, r2 i BI DI EJ M PE

Sub r1, r5, r2 j BI DI EJ M PE

Si existen UF multiciclo si pueden aparecer riesgos EDE

Ejemplo: una multiplicación PF (4ck) seguida de una suma PF (2ck)

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

2) Descartar la escritura de mulf (no escribir f2 en el ciclo 8) ya que

de todos modos dicha escritura será “sobre-escrita” por addf
 Riesgos de datos

 Riesgo R( i )  D( i+? )   LDE (RAW)

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

¿ Cuando esta listo el operando ?

 Riesgos de datos
Solución Hardware: Anticipación, Cortocircuito o Forwarding

 Riesgo R( i ) D( i+? )   LDE (RAW).

 Cortocircuito. Enviar el dato a las etapas que lo necesitan, cuanto
esta listo
Tiempo(ciclos)

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

Se pueden ejecutar todas las instrucciones sin problemas

 Anticipación (considerando los registros de segmentación)

Time (in clock cycles)

CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8 CC 9
Valor del Reg.$2 10 10 10 10 10 /– 20 – 20 – 20 – 20 – 20
Valor en Reg.EX/MEM X X X – 20 X X X X X
Valor en Reg.MEM/WB X X X X – 20 X X X X

Program
execution order

sub $2, $1, $3 IM Reg DM Reg

and $12, $2, $5 IM Reg DM Reg

or $13, $6, $2 IM Reg DM Reg

add $14, $2, $2 IM Reg DM Reg

sw $15, 100($2) IM Reg DM Reg

Anticipación

Leer los datos que ingresan a la ALU desde cualquier

registro de segmentación, no sólo del ID/EX.

Añadir multiplexores adicionales a la entrada de la ALU.

Añadir lógica de control.

Ubicar el control de anticipación en la etapa EX, ya que

la ALU y sus entradas se encuentran en ella.

¡OJO! La anticipación no puede ir hacia atrás en el tiempo.

Riesgos de Datos LDE.. Solución Hardware:

Detección de riesgos LDE

Existen cuatro posibilidades:

1a. EX/MEM.Registro Rd=ID/EX.RegistroRs

1b. EX/MEM.Registro Rd=ID/EX.RegistroRt
2a. MEM/WB.Registro Rd=ID/EX.RegistroRs
2b. MEM/WB.Registro Rd=ID/EX.RegistroRt
 Diseñando el control con riesgos
• Riesgos de datos LDE: Implementación de la Unidad de cortocircuito
 En azul Cortocircuitos de datos (anticipación)
 En verde Información de control para cortocircuito
ID/EX Indica si se escribe Reg

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

2a Riesgo “MEM”

IF (MEM/WB.EscrReg
And (MEM/WB.RegistroRd  0)
And (MEM/WB.Registro Rd=ID/EX.RegistroRs))
anticipar A=01

2b Riesgo “MEM”

IF (MEM/WB.EscrReg
And (MEM/WB.RegistroRd  0)
And (MEM/WB.Registro Rd=ID/EX.RegistroRt))
anticipar B=01
Riesgos LDE: Loads

Las dependencias hacia atras en el tiempo son riesgos

IF ID/RF EX MEM WB

ALU
Reg Reg
lw $3,0($1) I D

ALU
sub $5,$3,$2 I Reg D Reg

Este caso no se puede resolver con anticipación

El hardware debe crear en el pipeline , un stall, ranura o burbuja

 No siempre se puede anticipar
• La instrucción Load puede causar un riesgo:
Una instrucción trata de leer un registro a continuación de una
instrucción de carga que escribe ese mismo registro.

Time (in clock cycles)

Program
execution CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8 CC 9
order
(in instructions)

lw $2, 20($1) IM R eg DM R eg

and $4, $2, $5 IM R eg DM Reg

or $8, $2, $6 IM R eg DM Reg

add $9, $4, $2 IM R eg DM Reg

slt $1, $6, $7 IM Reg DM Reg

Se Necesita una unidad de detección para bloquear el pipeline.

Detección de riesgo para instrucciones de carga

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

Program Time (in clock cycles)

execution CC 1 CC 2 CC 3 CC 4 CC 5 CC 6 CC 7 CC 8 CC 9 CC 10
order
(in instructions)

lw $2, 20($1) IM Reg DM Reg

and $4, $2, $5 IM Reg Reg DM Reg

or $8, $2, $6 IM IM Reg DM Reg

bubble

add $9, $4, $2 IM Reg DM Reg

slt $1, $6, $7 IM Reg DM Reg

 Unidad detección y anticipación de riesgos

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...

Siempre podemos resolver los riesgos esperando (waiting)

el control del pipeline debe detectar los riesgos y tomar acciones
para resolver o manejar dichos riesgos

sub $2, $1, $3 Riesgo LDE (RAW)

and $12, $2, $5 .
or $13, $6, $2 .
add $14, $2, $2 .
sw $15, 100($2)

Solución Software: Prevención de la Dependencia de Datos

El compilador puede garantizar la eliminación de riesgos, insertando nops.
Problema: aumenta el tiempo de ejecución.
 Riesgos de Datos...
Prevención de la Dependencia de Datos: Solución SW1

El compilador resuelve los riesgos insertando “nops”

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

Una alternativa más eficiente es que el compilador retrase la etapa

de ejecución de la instrucción dependiente reordenando las
instrucciones (planificación estática de inst.)

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

Caso del load

Solución SW : Anticipar el Load en la planificación de

instrucciones que hace el compilador
Antes: Despues:
LW Rb,b
LW Rc,c LW Rb,b
ADD Ra,Rb,Rc
a := b + c SW a,Ra
LW Rc,c
LW Re,e
d := e - f LW Rf,f
LW Re,e
SUB Rd,Re,Rf ADD Ra,Rb,Rc
SW d,Rd
LW Rf,f
SW a,Ra
benchmarks
sin planificar planificado SUB Rd,Re,Rf
tex
25
65
SW d,Rd
14
spice 42

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.

Segunda opción: aplicar una técnica de predicción. La más simple:

predecir saltos como no tomados.

Tercera opción: salto retardado o ranura de retardo. Se ejecuta la

instrucción secuencialmente posterior a la del salto, se tome éste
o no.
 Riesgos de Control:

Se intenta hacer una decisión antes de que se evalue una

condición. Se presentan en Instrucciones de bifurcación o salto

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.

Segunda opción: aplicar una técnica de predicción. La más simple es

predicción estática: Ej. predecir los saltos como no
tomados.

Tercera opción: salto retardado o ranura de retardo. Se ejecuta la

instrucción secuencialmente posterior a la del salto, se
tome éste o no (compilador llena ranuras).
 Riesgos de control
Primera opcion o soluciòn no 1: detener el cauce (Stall o burbuja)
• Se debe evaluar la condición y obtener el nuevo valor del PC
La evaluación de la condición y el cálculo del nuevo PC se
realizan en la etapa de ejecución
o
Tiempo (clock cycles)
r
d

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.

Stall: Esperar hasta que se defina la decisión >> se pierden 2 ciclos.

 Riesgos de control
soluciòn nº 1 “mejorada”
• Mejora: Desplazar el cálculo de la dirección y la evaluación de
la condición a la etapa ID

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

IF/ID ID/EX EX/MEM MEM/WB

Sumador

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”...

Desplazar el cálculo de la dirección y la evaluación de la condición

a la etapa ID implica:

• Mover el comparador que evalúa la condición a la etapa de

decodificación.

• Inmediatamente después que la instrucción es decodificada

(Opcode permite determinar que es un salto) se realiza la
decisión y se cambia el valor del PC (si se cumple la
condición)

• Beneficio: como el salto se completa en la etapa de

decodificación, solo se buscó una instrucción innecesaria
(solo se necesita una no-op).
 soluciòn nº 1 “mejorada”… sólo un ciclo de parada

Desplazar a la etapa ID:

 Calculo de la dirección. Operandos necesarios ( Pc y desplazamiento)
 Calculo de la condición. Unidad de detección de cero

IF:Busqueda de instrucción ID: Decodificación/ EX: Ejecución/ MEM: Acceso a WB Escribe

Lectura de Reg Calculo de Dir Memoria Reg
0
MUX

1 Mover bloque HW

Sumador
Sumador

IF/ID ID/EX EX/MEM MEM/WB

+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:
Suponer que siempre se toma
la bifurcación (hay situaciones
en las que casi siempre se salta)
Suponer que nunca se toma la
bifurcación (hay situaciones en
las que casi nunca se salta)
Lo más sencillo es suponer que
el salto no se tomará (PC+4 ya
está calculado). Se continúa
en el cauce con la instrucción
siguiente en la secuencia.
Si el salto se toma, se
descartan las instrucciones en
ejecución.

PREDICCIÓN DINÁMICA

Mejor es que el hardware Se predice que el salto se

(es decir el procesador)
conozca -y use- la “historia”
de ejecución de cada salto
tomará o no dependiendo
del resultado de las últimas
predicciones.
 Riesgos de control
Soluciòn no 2: Predicción estática ...
...cuando se decide el salto ya hay otra instruccion en el pipeline
Time (in clock cycles)

Programa

40 beq $1, $3, 7 IM Reg DM Reg

44 and $12, $2, $5 IM Reg DM Reg

48 or $13, $6, $2 IM Reg DM Reg

52 add $14, $2, $2 IM Reg DM Reg

72 lw $4, 50($7) IM Reg DM Reg

Predecimos que el salto no se producirá “branch not taken”

• 0 ciclos de pérdida por salto cuando se acierta
• 1 ciclos de pérdida por salto si la predicción es equivocada
• Se agrega hardware para limpiar el pipe cuando la predicción no se cumpla sigue
 Riesgos de control
Soluciòn no 2: Predicción estática ...
Predecir que el salto no se toma: Si la predicción es falsa, la instrucción
siguiente se aborta (se cambia por NOP)
IF:Busqueda de ID: Decodificación/ EX: Ejecución/
instrucción Lectura de Reg Calculo de Dir

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

Segunda opción o solución nº2: Predicción dinámica de saltos

Se utiliza un Buffer de predicción de saltos, que consiste en

una pequeña memoria indexada por la parte menos
significativa del PC (no es una cache ya que diferentes
saltos pueden tener la misma parte baja del PC).
Dicha memoria contiene información de la ultima ejecución
del salto (codificada en uno o más bits).
• Un bit de predicción.
Para los bucles se fallará en la predicción tanto la primera
vez como la última vez (cuando inevitable es solamente la
última falla)

• Dos bits de predicción.

La predicción ha de ser incorrecta dos veces seguidas para
que dicha predicción cambie.
 Riesgos de control

Predicción dinámica de los saltos

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

Tercera opcion o soluciòn no 3: Saltos retardados.

Se ejecuta la instrucción secuencialmente posterior a la del

salto, se tome éste o no. Para ello es necesario redefinir los
saltos.

•En la definition clásica Si el salto se toma ninguna de las

instrucciones después del salto se ejecuta.
•En la nueva definición se tome o no el salto, la instrucción
inmediata siguiente siempre se ejecutará (se la denomina
ranura del salto branch-delay slot). Se puede mejorar el
rendimiento al introducir una instrucción no dependiente del
salto en dicha ranura.
•Responsabilizar al compilador para llenar el hueco o ranura
con alguna instrucción útil (siempre que sea posible).
 Riesgo de control
Soluciòn no 3: Salto retardado...
o
r Tiempo (clock cycles)
d

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.

• Salto retardado: Se redefine el salto. El salto tiene lugar después de la

siguiente instrucción, la cual se ejecuta siempre.

• Impacto: 0 ciclos de reloj si se puede encontrar una instrucción para

colocar en el hueco (>50% de las veces)
 Riesgos de control
Tercera soluciòn: salto retardado…
…se ejecuta la instrucción secuencialmente posterior a la del salto, se
tome éste o no (*).
IF:Busqueda de ID: Decodificación/ EX: Ejecución/
instrucción Lectura de Reg Calculo de Dir

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

(*) Esta parte del

hardware no es
necesaria ahora
 Riesgos de control
Tercera soluciòn: salto retardado…
Optimizacion Compilador:
Pone en el hueco Pone en el hueco Pone en el hueco
una Inst. Anterior destino Anterior destino Posterior

add $s1,$s2,$s3 sub $t4,$t5,$t6 add $s1,$s2,$s3

si $s2=0 entonces
si $s1=0 entonces
Hueco de salto
add $s1,$s2,$s3 Hueco de salto
si $s1=0 entonces
-----
Hueco de salto sub $t4,$t5,$t6

Llenado
del
hueco
add $s1,$s2,$s3

si $s2=0 entonces si $s1=0 entonces

add $s1,$s2,$s3
sub $t4,$t5,$t6
add $s1,$s2,$s3
si $s1=0 entonces
----- sub $t4,$t5,$t6 -----
 Eliminación de instrucciones (Flushing Instructions)
IF.Flush

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…

 Interrupciones, Excepciones, Fallos

Son más difíciles de tratar que en los procesadores secuenciales, ya que
cuando se produce una excepción siempre hay otras instrucciones que
se están ejecutando.

 Cualquier instrucción en el pipeline puede provocar una excepción

 El sistema debe resolver la excepción y recomenzar la ejecución.

 Excepciones problemáticas: ( por ejemplo un fallo de página)

- Ocurren en el medio de una instrucción
- Deben ser recomenzables

 Interrupciones externas ( I/O)

o Vaciar el pipeline y entrar NOPs

o Almacenar el PC con la dirección de interrupción
 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)

 Cuando usar tratamiento Preciso o Impreciso ?

Depende del tipo de excepción. Por ejemplo un código de operación inválido u
overflow reciben tratamiento impreciso (porque el proceso interrumpido no
podrá continuar). En cambio una llamada al S.O. o una interrupción de E/S
requiere tratamiento Preciso.
 Excepciones: una segunda mirada…

Excepciones en el DLX
etapa causa

IF Fallo de pagina de instrucción; Acceso no alineado; Violación de protección

ID Instrucción ilegal
Ex Excepción aritmética
Mem Fallo de pagina de datos; Acceso no alineado; Violación de protección
WB Ninguna

En la siguiente secuencia de instrucciones se pueden producir excepciones

prácticamente en cualquier etapa.

LW R1,0(R0) IF ID EX M WB

IF ID EX M WB
ADD R4,R3,R5

En un procesador segmentado, para atender las excepciones en el orden

de las instrucciones (tratamiento preciso) se asocia un vector de estado
a cada instrucción.
 Excepciones: una segunda mirada…

Excepciones precisas: vector de estado

Tiempo

TLB Datos IF ID Ex Mem WB

Translation
Lookaside Inst Ilegal IF ID Mem WB
Buffer Ex
TLB Inst IF ID Ex Mem WB

Overflow IF ID Ex Mem WB
Flujo del prog

 Problema: excepciones fuera de orden o simultáneas

Por ej. fallo de página en MEM , instrucción ilegal en ID y fallo de página en IF
¡Las excepciones de la segunda y tercera instrucción aparecen antes !
 Solución:
Vector de estado, un bit por cada etapa donde es posible una excepción.
Una excepción se marca en el vector de estado asociado con la instrucción
y se impide la escritura en memoria y registros. El vector se chequea al final de
MEM (inicio de WB) y si ha habido alguna excepción se procede a tratarla. De
este modo se respeta el orden de las instrucciones al tratar las excepciones.
 Resumen: Procesador segmentado

 Todas las instrucciones tienen igual duración

 Rendimiento ideal, una instrucción por ciclo CPI=1
 Riesgos estructurales y de datos EDE y EDL se resuelven por
construcción (diseño)
 Riesgo LDE en instrucciones tipo-R se solucionan con el
cortocircuito.
 Riesgos LDE en instrucciones de carga (LW) implican paradas del
procesador. Ayuda del compilador planificando las instrucciones.
 Riesgos de control. Paradas y saltos retardados con ayuda del
compilador. 14

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

¿ Que ocurre si las instrucciones tienen diferentes duración?

(Instrucciones de aritmética en punto flotante)
 Resumen: Procesador segmentado

• 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

lw Ins R Alu Mem W

lw Ins R Alu Mem W

40 nseg
lw Ins R Alu Mem W

lw Ins R Alu Mem W

lw Ins R Alu Mem W

10 nseg
lw 10 nseg Ins R Alu Mem W

10 nseg 10 nseg 10 nseg 10 nseg 10 nseg

 Resumen: comparación Monociclo, multiciclo, segmentado

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

“Ideal” Ver continuación …

 Comparando las tres implementaciones del DLX ...

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.

Aceleración debido a la segmentación = Tcpu sin seg. / Tcpu con seg.

En el caso ideal: Aceleración = número de etapas = 5
En el ejemplo del DLX: Aceleración  4

Razones para no alcanzar ideal:

• Etapas desbalanceadas: las etapas DI y WB consumen 10ns pero son útiles sólo 5ns.
• Costo de la segmentación: retardos debidos a la circuitería adicional.
• Riesgos: en ciertas ocasiones hay que retrasar la ejecución de algunas instrucciones.
 Recordar CPI

• Comenzamos con un CPI base

• Agregamos bloqueos (stalls)
CPI = CPI base + CPI stall
CPI stall = STALL ´ freq + STALL ´ freq
tipo1 tipo1 tipo2 tipo2

• 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 + (10.20)+(100  0.300.01)=1.5

Fin resumen…
Segmentación.

Conclusiones

Se debe tener en cuenta que el diseño del Repertorio de instrucciones

puede afectar negativamente a la segmentación.
Instrucciones de distinta longitud y tiempos de ejecución variables,
pueden llevar a un desequilibrio entre las etapas de segmentación.
Modos de direccionamiento muy sofisticados también generan
problemas.
Incrementar la longitud del cauce segmentado no siempre
incrementará el rendimiento.
La sobrecarga por los registros de segmentación puede limitar el
aumento de velocidad que se consigue con una segmentación más
avanzada.
Segmentación.

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

Longitud de la segmentación vs. incremento obtenido en la velocidad

Segmentación.
Conclusiones

El hardware del camino de datos y de control es más

complicado:
Caminos de anticipación.
Lógica para detección de conflictos de datos.
Lógica para predicción de saltos.
La segmentación mejora la productividad, pero no el tiempo
de ejecución (o latencia) de cada instrucción.
Desde 1986 se ha mantenido un 60% de incremento anual
en el rendimiento de los procesadores utilizando técnicas
basadas en la segmentación.