Segmentación

• Riesgos

1. Riesgos estructurales
2. Riesgos por dependencia de datos
a. LDE (RAW)
b. EDL (WAR)
c. EDE (WAW)
3. Riesgos Control
 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
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.

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

 Registros fuentes
de la instrucción Registro
siguiente Rs y Rt Condición: que la
destino del instrucción en EX sea
Load Rt un Load

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
 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
LW Rc,c
a := b + c SW a,Ra
LW Re,e LW Re,e
d := e - f LW Rf,f
SUB Rd,Re,Rf
ADD Ra,Rb,Rc
SW d,Rd LW Rf,f
SW a,Ra
benchmarks SUB Rd,Re,Rf
SW d,Rd
 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

U
AL
e Im Re Me Re
Add g m g
n

U
AL
d Im Re Me Re
Beq g m g
e

U
AL
i Load Pérdida
Im Re Me Re
n de g m g
s ciclos
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
en la etapa MEM
Tal y como está diseñado “hasta ahora” el DLX..

“tomar salto”
0
MUX
PcSrc
“dirección de salto”
1

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

Sumador

Sumador
Branch

MentoRe
+4 Reg Write

g
<<2
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

Ins. [15-0] Control

6 ALU

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

tomará o no dependiendo
(es decir el procesador) del resultado de las últimas
conozca -y use- la “historia” predicciones.
de ejecución de cada salto
 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

Bra
NOP
nch
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 definición 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