Está en la página 1de 67

Pipelining o Segmentación

Cecilia Hernández
Pipelining o Segmentación
 Idea viene de línea de ensamblaje
 Dividir un trabajo en n partes secuenciales del mismo tamaño
(p1, p2, p3, …, pn), donde cada parte p se realiza en
aproximadamente en el mismo tiempo
 Cada parte p, se procesa en una estación distinta (usando
distintos recursos) o equivalentemente pasa a través de una
serie de etapas
 Distintas etapas de distintos trabajos pueden ejecutarse
simultáneamente dado que los recursos que ellas utilizan son
distintos
 Ejemplo
 Trabajo A: compuesto por etapas A1, A2, A3 en donde cada una requiere
de recursos R1, R2, R3 respectivamente
 Trabajo B: compuesto por etapas B1, B2, B3 en donde cada una requiere
de recursos R1, R2, R3 respectivamente
 Luego, A2 y B1, A3 y B2 pueden ejecutarse simultáneamente
Analogía: lavado de ropa
 Ana, Berta, Claudio y
Darío tienen una carga de
ropa cada uno, las que A B C D
deben lavar, secar y
doblar

 Lavado dura 30 minutos

 Secado dura 40 minutos

 Doblado dura 20 minutos


Lavado secuencial
6 PM 7 8 9 10 11 Medianoche
Tiempo

O
R
30 40 20 30 40 20 30 40 20 30 40 20
D
E
N
A
E
J
E
B
C
U
C
I
C
Ó
N
D
Cada persona demora 1.5 horas en estar lista.
Lavado secuencial toma 6 horas para 4 cargas.
Esto es equivalente a procesador multiciclo. ¿Cómo acelerar la cosa?
Lavado segmentado (pipelined)

6 PM 7 8 9 10 11 Medianoche
Tiempo

O
30 40 40 40 40 20
R
D
E
A
N

E B
J
E
C
U C
C
I
Ó D
N
Cada persona todavía demora 1.5 horas en estar lista.
Pero ahora las 4 cargas están listas en sólo 3.5 horas. Aceleración = 1.7
En general, 1 carga de ropa lista cada 40 minutos. Aceleración = 1.5hrs/40min. = 2.25
¿Cuál sería la aceleración si lavar = secar = doblar?
Problemas con reutilizar
esquema de multiciclo

 Problema es que hay conflictos con el uso de recursos.


Cuáles?
 Solución?, se separan Memorias para I y D, se agregan
sumadores
Pasando de multiciclo a
pipeline
 Si podemos agregar recursos a nuestro
esquema multiciclo podemos usarlos en
forma más eficiente
 Paralelismo a nivel de instrucciones
 Cómo lo hacemos?
 Tomamos como base las mismas etapas del multiciclo
de la ejecución de una instrucción
 Busqueda Inst, Decodificación, Ejecución, Acceso a
Memoria de datos, escritura en registros
 A medida que vamos desocupando recursos en cada
ciclo en la ejecución de una instrucción, los vamos
ocupando para la ejecución de la siguiente instrucción
Ejecutando instrucciones en pipeling

 Implementación multiciclo
IF ID EX MEM WB

IF ID EXE MEM WB
Instr. i

Instr. i+1
 In pipeline mode Tiempo
Instr. i IF ID EXE MEM WB ocioso

Instr. i+1 IF ID EXE MEM WB


Instr. i+2 IF ID EXE MEM WB
Desempeño de pipelining
 CPU Uniciclo : CPI = 1 largo ciclo de reloj
 CPU Multiciclo : CPI > 1, ciclo reloj más corto
 Pipeline : CPI Ideal = 1 con ciclo reloj corto
 Latencia, de una sola instrucción puede ser mayor
 Cada etapa se demora tanto como la más lenta
 Todas las instrucciones deben pasar a través de todas las etapas
incluso si instrucción no la requiere
 Productividad (throughput) es mejor
 Cantidad de instrucciones por unidad de tiempo
 Idealmente la tasa de ejecución de instrucciones es de 1 por tiempo
ocupada por etapa, asumiendo que el pipeline esta lleno todo el tiempo
 En el caso ideal la productividad es n veces mejor si hay n etapas
 Sin embargo, una instrucción podría requerir menos etapas para
completarse
Uniciclo, Multiciclo, Pipelining
Ciclo 1 Ciclo 2
Clk

Uniciclo:

Load Store Ocio

Ciclo 1 Ciclo 2 Ciclo 3 Ciclo 4 Ciclo 5 Ciclo 6 Ciclo 7 Ciclo 8 Ciclo 9 Ciclo 10
Clk

Multiciclo:
Load Store R-type
IF DEC EX MEM WB IF DEC EX MEM IF

Segmentación (pipeline):

Load IF DEC EX MEM WB

Store IF DEC EX MEM WB

R-type IF DEC EX MEM WB


Paralelismo en Pipeline
 Note que una vez que pipeline está lleno hay 5
instrucciones en ejecución, aunque cada instrucción
por separado tiene una mayor latencia
t t+1 t +2 t+3 t+4 t+5 t +6 t+7 t+8 t+9
Instr. i IF ID EXE MEM WB
Instr. i+1 IF ID EXE MEM WB

Instr. i+2 IF ID EXE MEM WB

Instr. i+3 IF ID EXE MEM WB

Instr. i+4 IF ID EXE MEM WB


Instr. i+5 IF ID EXE MEM WB

5 instrucciones en ejecución simulatneamente


Requerimientos de implementación

 5 etapas para la ejecución de instrucciones


 A partir de instrucción más larga en multiciclo (load)
 Etapas correspondientes a las definidas en load
 Todas las etapas son independientes y aisladas
entre sí. Esto significa que la información reunida en
la etapa i+1, i+2 deben guardarse para pasarse a la
siguiente
 Para ello se necesitan recursos adicionales los que se
implementan en los denominados “registros pipeline”
ubicados entre las distintas etapas
Qué se almacena en los “registros del
pipeline”

 Número de registro donde se almacenará resultado


 Se sabe en etapa ID (2) y se utiliza en etapa WB (5)
 Número de registro que contiene dato a ser
almacenado en memoria en store
 Se conoce en etapa ID (2) y se ocupa en MEM(4)
 Valores inmediatos para instrucciones aritméticas y
lógicas y para instrucciones de acceso a memoria
(cálculo de direcciones de memoria) load/store y
direcciones de branchs
 Se conocen en etapa ID y se usan en etapa ALU (3)
Sección de datos en Pipeline

IF/ID ID/EXE EXE/MEM MEM/WB

IF ID EXE MEM WB
Visión alternativa, usando recursos

Ciclo 1 Ciclo 2 Ciclo 3 Ciclo 4 Ciclo 5 Ciclo 6 Ciclo 7

tiempo
instr1 MI Reg MD

instr2 MI Reg MD

instr3 MI Reg MD
Instrucciones

instr4
MI Reg MD
Usando como base uniciclo
 Donde debería ir los registros pipeline
Notación
 Registros pipeline nombrado con los nombres de etapas
 Información fluye de izquierda a derecha excepto en
 Cuando se escribe en registros
 Modificando PC
Qué información se almacena en
registros pipeline

 Datos
 Instrucción, registros A y B, ALUout, MDR, PC +
4, Inmediato,
 Con traspaso de datos entre etapas cuando se
requiera
 Control
 Señales de control
 RegDst, Branch, MemRead, MemtoReg, ALUop,
MemWrite, ALUSrc, RegWrite
 Se van consumiendo en etapas a medida que se
requieran
Conflictos
 Evitan que sea ideal
 3 tipos
 Estructurales donde dos instrucciones en diferentes
etapas quieren usar el mismo recurso. Resuelto usando
más recursos
 Separación de memoria de instrucciones de la de datos, y
agregar ALUs
 Haciendo que todas las instrucciones se ejecuten en el
mismo número de etapas, aunque se desperdicien ciclos
 Datos cuando una instrucción en el pipeline es
dependiente de otra instrucción todavía en el pipeline
 Control cuando un branch exitoso o procedimiento
Conflicto estructural: una sola memoria
Tiempo (ciclos de reloj)

ALU
Sec. Mem Mem Reg
Instr. Load Reg

ALU
Mem Reg Mem Reg
Instr 1

ALU
Mem Reg Mem Reg
Instr 2

ALU
Mem Reg Mem Reg
Instr 3

ALU
Mem Reg Mem Reg
Instr 4

Soluciones: - detener el pipeline (stall)


- replicar la memoria (memoria de datos separada de memoria de instrucciones)
Solución 1: Detención del pipeline (stalling)

Tiempo (ciclos reloj)

ALU
Sec. Mem Mem Reg
Instr Load Reg

ALU
Mem Reg Mem Reg
Instr 1

ALU
Mem Reg Mem Reg
Instr 2

ALU
Mem Reg Mem Reg
Instr 3

ALU
Mem Reg Mem Reg
Instr 4
Si 1 de cada 4 instrucciones es un load:
CPI = 1.25  100% utilización de puerta de lectura de la memoria
 CPI no puede ser menor que 1.25 a menos que tengamos memoria
de datos e instrucciones separadas
Solución 2: Replicar hardware
 Memoria de datos separada de memoria de instrucciones
 Conocida como “Arquitectura de Harvard”
 Procesadores reales implementan esta solución a nivel de memoria
cache de primer nivel (cache de instrucciones y cache de datos)
 Cache de nivel 2, 3 y DRAM son unificadas
Tiempo (ciclos de reloj)

F
L
U IMem ALU DMem Reg
J
LW Reg

O
IMem Reg ALU DMem Reg
D
ADD
E
ALU
IMem Reg DMem Reg
P
SUB
R
ALU
IMem Reg DMem Reg
O LW
G
R
ALU
IMem Reg DMem Reg
A LW
M
A
Conflictos estructurales: Acceso banco de
registros
Tiempo (ciclos de reloj)

ALU
Sec. Mem Mem
Instr Load Reg Reg

ALU
Mem Reg Reg
Instr 1
Solución 1: Detener el pipeline
(stalling)
Tiempo (ciclos de reloj)
F
L
U

ALU
J Mem Mem Reg
O
LW Reg

ALU
Mem Reg Reg
D ADD
E

burbuja

ALU
Mem Reg Reg
P SUB
R
O

ALU
Mem Reg Reg
G LW Mem
R

ALU
Mem Mem Reg
LW Reg

Soluciona el conflicto, pero introduce una “burbuja”(ciclo ocioso) en el pipeline


 CPI > 1
Ej. Si el conflicto se produce en una de cada 4 instrucciones, CPI = 1.25
Solución 2: Regularizar el pipeline
 Todas las instrucciones pasan por todas las etapas
 Como cada etapa usa diferentes recursos hardware, no hay conflictos
estructurales
Tiempo (ciclos de reloj)

F
L

ALU
Mem
U LW Reg Mem Reg
J
O

ALU
Mem Reg Mem Reg
ADD
D

ALU
E Mem Reg Mem Reg
SUB
P

ALU
Mem Reg Mem Reg
R LW
O
G

ALU
Mem Reg Mem Reg
R LW
A
M
A

Latencia de instrucciones ALU aumenta de 4 a 5, pero CPI = 1


Siguiendo la ejecución de una
instrucción en las 5 etapas (1)
 Etapa 1: Búsqueda de instrucción e incremento de
PC ( lo mismo para todas las instrucciones)
 Instrucción es extraída de memoria de instrucciones
desde la dirección apuntada por PC. Como la instrucción
se necesita para las siguientes etapas se almacena en
registro pipeline IF/ID
 PC = PC + 4
 Necesitado para la siguiente instrucción o cálculo de branch,
tambien se almacena en registro pipeline IF/ID
 Recursos usados: Memoria Instrucciones y ALU
 Registro pipeline: contiene instrucción y PC incrementado
Etapa 1: IF
lw
IF
1
M MEM/WB
EX/MEM
U IF/ID ID/EX
X
0

Add

4 Add
Desp.
Izq.
Instrucción [25-21]
P Leer
C Leer registro 1
dirección Instrucción [20-16] Lect.
Leer dato 1
Instrucción registro 2 Zero Leer
0 ALU dirección Lect.
[31-0] Lect. dato 1
Escribir 0
dato 2 result
Memoria de Instrucción M registro M Escribir
M
U U dirección
Instrucciones [15-11] X Escribir X
U
dato Registros X
1 Escribir Memoria
1 dato de 0
Datos

Instrucción [15-0] 16 32
Ext
Signo
Siguiendo la ejecución de una
instrucción en las 5 etapas (2)
 Etapa 2: Se decodifica instrucción y se leen los
registros (lo mismo para todas las instrucciones)
 Tenemos en IF/ID todo lo que se necesita en las
siguientes etapas:
 La instrucción y el PC incrementado
 Se usan los identificadores de registros para extraer los
datos que contienen
 Se obtiene campo inmediato si instrucción lo posee y se
extiende en signo o no según instrucción
 Se utiliza instrucción para definir señales de control
 Recursos utilizados: Banco de registros y unidad de
control
 ID/EX contiene PC, instrucción, contenido de rs y rt,
inmediato extendido,señales de control generadas por
unidad de control
Etapa 2 : ID
lw
ID
1
M MEM/WB
EX/MEM
U IF/ID ID/EX
X
0

Add

4 Add
Desp.
Izq.
Instrucción [25-21]
P Leer
C Leer registro 1
dirección Instrucción [20-16] Lect.
Leer dato 1
Instrucción Zero Leer
0 registro 2 dirección Lect.
ALU 1
[31-0] Escribir Lect. 0 dato
dato 2 result
Memoria de Instrucción M registro M Escribir
M
U U dirección
Instrucciones [15-11] X Escribir X
U
dato Registros X
1 Escribir Memoria
1 dato de 0
Datos

Instrucción [15-0] 16 32
Ext
Signo
Siguiendo la ejecución de una
instrucción en las 5 etapas (3)
 Etapa 3: Depende del tipo de instrucción que se está ejecutando. Por
ejemplo load. Entonces en esta etapa se calcula dirección de
memoria
 Los operandos fuentes a ALU vienen de ID/EX (rs e Inmmediato
extendido en signo)
 Resultado de ALU se almacena en EX/MEM
 Contenidos de rs e Inmediato ya no se necesitarán más
 PC se continúa almacenando por posibles exepciones ( caso que se
deba interrumpir la ejecución de la instrucción, por ejemplo, la dirección
de memoria este incorrecta)
 Se necesita mantener la información respecto al identificador de rt
 Recursos necesitados: ALU para cálculo de dirección de memoria en
caso de load,store. Se necesitan 2 ALUs para caso de branch (uno para
cálculo de condición y otro para cálculo dirección de salto)
 EX/MEM almacena
 Resultado de ALU (loads/stores y aritméticas/lógicas)
 Identificación rt (addi, load) y rd (aritméticas/lógicas), contenido rs (stores)
 PC para caso excepcional
Etapa 3: EX
lw
EX
1
M MEM/WB
EX/MEM
U IF/ID ID/EX
X
0

Add

4 Add
Desp.
Izq.
Instrucción [25-21]
P Leer
C Leer registro 1
dirección Instrucción [20-16] Lect.
Leer dato 1
Instrucción registro 2 Zero Leer
0 ALU dirección Lect.
[31-0] Lect. dato 1
Escribir 0
dato 2 result
Memoria de Instrucción M registro M Escribir
M
U U dirección
Instrucciones [15-11] X Escribir X
U
dato Registros X
1 Escribir Memoria
1 dato de 0
Datos

Instrucción [15-0] 16 32
Ext
Signo
Siguiendo la ejecución de una
instrucción en las 5 etapas (4)
 Etapa 4: Acceso a memoria de datos.
 Accesar memoria con dirección calculada en
etapa anterior y almacenada en EX/MEM
 Almacenar resultado de load en MEM/WB
 Recursos usados: Memoria de datos
 MEM/WB almacena
 Dato leído de memoria (loads)
 Resultado de ALU (instr aritméticas/lógicas)
almacenados en EX/MEM
 Identificador de registro a escribir (rt para loads, rd
para aritméticas/lógicas)
 No se necesita almacenar PC por más tiempo
Etapa 4: MEM
lw
MEM
1
M MEM/WB
EX/MEM
U IF/ID ID/EX
X
0

Add

4 Add
Desp.
Izq.
Instrucción [25-21]
P Leer
C Leer registro 1
dirección Instrucción [20-16] Lect.
Leer dato 1
Instrucción registro 2 Zero Leer
0 ALU dirección Lect.
[31-0] Lect. dato 1
Escribir 0
dato 2 result
Memoria de Instrucción M registro M Escribir
M
U U dirección
Instrucciones [15-11] X Escribir X
U
dato Registros X
1 Escribir Memoria
1 dato de 0
Datos

Instrucción [15-0] 16 32
Ext
Signo
Siguiendo la ejecución de una
instrucción en las 5 etapas (5)
 Etapa 5: WB (Write back a registro) usado
en loads y aritméticas/lógicas
 Identificador de registro de escritura (rt o rd) y
dato a escribir vienen en MEM/WB
 No se necesita guardar nada porque es el último
paso en la ejecución de la instrucción
 Recurso usado: Banco de registros
 Conflicto estructural por uso de banco de registros
eliminado con la normalización en que cada
instrucción se ejecuta en 5 etapas (independiente si la
requiere o no)
Etapa 5: WB
lw
WB
1
M MEM/WB
EX/MEM
U IF/ID ID/EX
X
0

Add

4 Add
Desp.
Izq.
Instrucción [25-21]
P Leer
C Leer registro 1
dirección Instrucción [20-16] Lect.
Leer dato 1
Instrucción registro 2 Zero Leer
0 ALU dirección Lect.
[31-0] Lect. dato 1
Escribir 0
dato 2 result
Memoria de Instrucción M registro M Escribir
M
U U dirección
Instrucciones [15-11] X Escribir X
U
dato Registros X
1 Escribir Memoria
1 dato de 0
Datos

Instrucción [15-0] 16 32
Ext
Signo
Varias instrucciones en pipeline
1
M MEM/WB
EX/MEM
U IF/ID ID/EX
X
0

Add

4 Add
Desp.
Izq.
Instrucción [25-21]
P Leer
C Leer registro 1
dirección Instrucción [20-16] Lect.
Leer dato 1
Instrucción registro 2 Zero Leer
ALU dirección Lect.
[31-0] Lect. dato 1
Escribir 0
dato 2 result
registro M Escribir
Memoria de U dirección
M
Instrucciones Escribir X
U
dato Registros X
1 Escribir Memoria
dato de 0
Datos

Instrucción [15-0] 16 32
Ext
Instrucción Signo
[20-16] 0

M
U
X
Instrucción
[15-11] 1
Varias instrucciones en pipeline
Ciclo 1
lw $1, 4($3) #IF
1
M MEM/WB
U EX/MEM
X
IF/ID ID/EX
0

Add

4 Add
Desp.
Izq.
Instrucción [25-21]
P Leer
C Leer registro 1
dirección Instrucción [20-16] Lect.
Leer dato 1
Instrucción registro 2 Zero Leer
ALU dirección Lect.
[31-0] Lect. dato 1
Escribir 0
registro dato 2 result
M Escribir
Memoria de U dirección
M
Instrucciones Escribir X
U
dato Registros X
1 Escribir Memoria
dato de 0
Datos

Instrucción [15-0] 16 32
Ext
Signo
Instrucción
0
[20-16]
M
U
X
Instrucción 1
[15-11]

Reloj:
1
Varias instrucciones en pipeline
Ciclo 2
add $3, $4, $5 #IF lw $1, 4($3) #ID
1
M MEM/WB
EX/MEM
U
X
IF/ID ID/EX
0

Add

4 Add
Desp.
Izq.
Instrucción [25-21]RS
P Leer
C Leer registro 1
dirección Instrucción [20-16]RT Lect.
Leer dato 1
Instrucción registro 2 Zero Leer
ALU dirección Lect.
[31-0] Lect. dato 1
Escribir 0
registro dato 2 M result Escribir
Memoria de U dirección
M
Instrucciones Escribir X
U
dato Registros X
1 Escribir Memoria
dato de 0
Datos

Instrucción [15-0] 16 32
Ext
Signo
Instrucción
[20-16]RT 0

M
U
X
Instrucción 1
[15-11]RD

Reloj:
1 2
Varias instrucciones en pipeline
Ciclo 3
sw $4, 8($5) #IF add $3, $4, $5 #ID lw $1, 4($3) #EX
1
M MEM/WB
U EX/MEM
X
IF/ID ID/EX
0

Add
4 Add
Desp.
Izq.
Instrucción [25-21]RS
P Leer
C Leer registro 1
dirección Instrucción [20-16]RT Lect.
Leer dato 1
Instrucción registro 2 Zero Leer
ALU dirección Lect.
[31-0] Lect. dato 1
Escribir 0
registro dato 2 M result Escribir
Memoria de U dirección
M
Instrucciones Escribir X
U
dato Registros X
1 Escribir Memoria
dato de 0
Datos
Instrucción [15-0] 16 32
Ext
Instrucción Signo
0
[20-16]RT
M RT
U
X
Instrucción 1
[15-11]RD

Reloj:
1 2 3
Varias instrucciones en pipeline
Ciclo 4
and $1, $2, $3 #IF sw $4, 8($5) #ID add $3, $4, $5 #EX lw $1, 4($3) #MEM
1
M MEM/WB
U EX/MEM
X
IF/ID ID/EX
0

Add

4 Add
Desp.
Izq.
Instrucción [25-21]RS
P Leer
C Leer registro 1
dirección Instrucción [20-16]RT Lect.
Leer dato 1
Instrucción registro 2 Zero Leer
ALU dirección Lect.
[31-0] Lect. dato 1
Escribir 0
registro dato 2 M result Escribir
Memoria de U dirección
M
Instrucciones Escribir X
U
dato Registros X
1 Escribir Memoria
dato de 0
Datos

Instrucción [15-0] 16 32
Ext
Signo
Instrucción
0
[20-16]RT RD RT
M
U
X
Instrucción 1
[15-11]RD

Reloj:
1 2 3 4
Varias instrucciones en pipeline
Ciclo 5 add $3, $4, $5
lw $1, 4($3)
# MEM #WB
beq $2, $3, L1 #IF and $1, $2, $3 #ID sw $4, 8($5) #EX
1
M
EX/MEM MEM/WB
U
X
IF/ID ID/EX
0

Add
4 Add
Desp.
Izq.
Instrucción [25-21]RS
P Leer
C Leer registro 1
dirección Instrucción [20-16]RT Lect.
Leer dato 1
Instrucción registro 2 Zero Leer
ALU dirección Lect.
[31-0] Lect. dato 1
Escribir 0
registro dato 2 M result Escribir
Memoria de U dirección M
Instrucciones Escribir X U
dato Registros 1 Escribir X
Memoria
dato de 0
Datos
Instrucción [15-0] 16 Ext 32
Instrucción Signo 0
[20-16]RT RT
M RT RD
U
X

Instrucción 1

[15-11]RD

Reloj:
1 2 3 4 5
Tipos de conflictos de datos
 Conflicto de Datos ocurre cuando una instrucción en el
pipeline es dependiente de otra instrucción todavía en el
pipeline

I1: add r1, r2, r3

I2: sub r4, r1, r5

I3: or r2, r6, r7

I4: and r1, r8, r9


Tipos de conflictos de datos
 RAW (read after write)
 Instrucción I1 genera un dato que instrucción I2 usa
 I1 debe ejecutarse antes que I2

I1: add r1, r2, r3

I2: sub r4, r1, r5

I3: or r2, r6, r7

I4: and r1, r8, r9


Tipos de conflictos de datos
 WAW (write after write)
 Instrucciones I1 e I4 escriben en el mismo registro
 I1 debe ejecutarse antes que I4
 ¿Por qué no puede producirse en MIPS segmentado?

I1: add r1, r2, r3

I2: sub r4, r1, r5

I3: or r2, r6, r7

I4: and r1, r8, r9


Tipos de conflictos de datos
 WAR (write after read)
 Instrucción I1 lee un registro que instrucción I3 escribe
 I1 debe ejecutarse antes que I3
 ¿Por qué no puede producirse en MIPS segmentado?

I1: add r1, r2, r3

I2: sub r4, r1, r5

I3: or r2, r6, r7

I4: and r1, r8, r9


Conflicto de datos (RAW)
Tiempo (ciclos reloj)

ALU
Sec. add r1,r2,r3 Im Reg Dm Reg
Instr

ALU
Im Reg Dm Reg
sub r4,r1,r3

ALU
Im Reg Dm Reg
and r6,r1,r7

ALU
Im Reg Dm Reg
or r8,r1,r9

ALU
Im Reg Dm Reg
xor r10,r1,r11

 Flechas hacia atrás representan conflictos: no se puede usar un


dato hasta que se haya generado
Solución: forwarding (redireccionamiento)
Tiempo (ciclos reloj)

ALU
Sec add r1,r2,r3 Im Reg Dm Reg
Instr

ALU
Im Reg Dm Reg
sub r4,r1,r3

ALU
Im Reg Dm Reg
and r6,r1,r7

ALU
Im Reg Dm Reg
or r8,r1,r9

ALU
Im Reg Dm Reg
xor r10,r1,r11

Pasar dato directamente de la etapa en que se genera a la etapa en que se usa


Instrucción “or r9, r1, r9” no necesita forwarding si se define orden lectura-escritura en
el banco de registros
Límites de forwarding
 Forwarding elimina conflicto de datos cuando dato se genera en la
misma etapa en que se utiliza, o antes
 ALU – ALU (EX - EX)
 ALU – SW (EX – MEM)
 LW – SW (MEM – MEM)
 ¿Qué pasa cuando dato se genera en etapa posterior a etapa de
uso?
Tiempo (ciclos de reloj)
IF ID/RF EX MEM WB

ALU
lw $1, 0($2) Im Reg Dm Reg

ALU
Im Reg Dm Reg
sub $4, $1, $3

ALU
Im Reg Dm Reg
or $10, $11, $12
Soluciones a conflicto de datos LW – ALU
 Load retrasado
 Similar a salto retrasado, intrucción en el “delay slot” no puede utilizar
resultado del load
 Visible en ISA
 Stall
 Hardware detecta si instrucción siguiente a load utiliza resultado, y
retrasa su ejecución hasta que el dato esté disponible
 Introduce burbuja en el pipeline
 Mismo impacto en desempeño que load retrasado, pero compilador no
necesita insertar NOP
 Técnica conocida como “pipeline interlock”
Tiempo (ciclos de reloj)
IF ID/RF EX MEM WB
ALU
lw $1, 0($2) Im Reg Dm Reg

ALU
Im Reg Dm Reg
sub $4, $1, $3
burbuja

ALU
Im Reg Dm Reg
or $10, $11, $12
Optimización por software
 Compilador puede insertar instrucción independiente después del
load para reducir CPI
 Funciona para load retrasados e interlocks

Original (lw retrasado) Original (interlock) Optimizado


I1: lw $1, 0($2) burbuja I1: lw $1, 0($2) I1: lw $1, 0($2)
I2: nop I2: sub $4, $1, $3 I3: or $10, $11, $12
I3: sub $4, $1, $3 I3: or $10, $11, $12 I2: sub $4, $1, $3
I4: or $10, $11, $12

Tiempo (ciclos de reloj)


IF ID/RF EX MEM WB

lw $1, 0($2) ALU


Im Reg Dm Reg

ALU
Im Reg Dm Reg
or $10, $11, $12

sub $4, $1, $3 Im Reg ALU


Dm Reg
Conflicto de datos en load-add
lw $1, 4($3)
beq $2, $3, L1 #IF and $2, $1, $3 #ID #WB
1
M
EX/MEM MEM/WB
U
X
IF/ID ID/EX
0

Add
4 Add
Desp.
Izq.
Instrucción [25-21]
P Leer
C Leer registro 1
dirección Instrucción [20-16] Lect.
Leer dato 1
Instrucción registro 2 Zero Leer
ALU dirección Lect.
[31-0] Lect. dato 1
Escribir 0
registro dato 2 M result Escribir
Memoria de U dirección M
Instrucciones Escribir X U
dato Registros 1 Escribir X
Memoria
dato de 0
Datos
Instrucción [15-0] 16 Ext 32
Instrucción Signo 0
[20-16]RT M RT
X

Instrucción 1

[15-11]RD

Conflicto
Reloj: Load debe escribir en $1 y add debe leer
1 2 3 $1. Lectura debe ocurrir despues de
escritura
Ejecución en pipeline con forwarding y
detección de conflicto
Conflicto de datos en load-and
Conflicto de datos en load-and
Conflicto de datos en load-add
(agregando burbuja)
Conflicto de datos con load-and
Conflicto de datos en load-and
Conflicto de datos en load-and
Conflictos de control

 Producidos por instrucciones branch


 No se puede leer próxima instrucción hasta
saber cuál es el siguiente PC
 Qué hacer
 Esperar
 Saltos retrasados
 Predecir
Solución #1: Esperar: bloquear el
pipeline
Tiempo (ciclos reloj)

ALU
Mem Reg Mem Reg
Sec. Add
Instr

ALU
Mem Reg Mem Reg
Beq
Load potencial

ALU
Mem Reg Mem Reg
perdido

 Instrucción branch se ejecuta en tres ciclos


 Dos ciclos perdidos esperando por siguiente PC
 Solución parcial: Mover cálculo de siguiente PC al final
de la etapa de decodificación
 Aún se pierde un ciclo
Solución #2: saltos retrasados
Tiempo (ciclos reloj)

ALU
Mem Reg Mem Reg
Add
Sec.

ALU
Mem Reg Mem Reg
Inst Beq

ALU
Misc Mem Reg Mem Reg

ALU
Load Mem Reg Mem Reg

 Salto retrasado: instrucción que sigue al salto se ejecuta de todas formas


 Afecta ISA
 Costo
 0 ciclos si compilador encuentra instrucción que se ejecute de todas formas, 1
ciclo si hay que llenar el delay slot con un NOP
 Mayor paralelismo a nivel de instrucciones  más delay slots por salto  salto
retrasado es menos útil
Compilador puede llenar el slot
 Programa original Programa optimizado
I1: xor $23, $7, $1
I2: and $3, $12, $10 I2: and $3, $12, $10
I3: or $5, $2, $8 I3: or $5, $2, $8
I4: add $3, $5, $7 I4 add $3, $5, $7
I5: add $2, $6, $7 I5: add $2, $6, $7
I6: beq $3, $2, ROTULO I6: beq $3, $2, ROTULO
I7: nop I1: xor $23, $7, $1
I8: lw $5, $6, $17 I8: lw $5, $6, $17

 Eficiencia
 Ej. 15% de saltos, y compilador puede llenar el slot en un 80% de los
casos
 CPI = 1 + 0.15*0.2*1 = 1.03 (3% degradación)
 Mayor paralelismo a nivel de instrucciones (ej. pipeline más profundo)
 más slots por salto  más difícil llenar slots  menor eficiencia
 Ej. 2 slots por salto, 15% de saltos, compilador puede llenar primer
slot en el 80% de los casos, pero segundo slot en sólo el 25% de los
casos
 CPI = 1 + 0.15*(0.2*1 + 0.75*1) = 1.14 (14% degradación)
¿Por qué no podemos mover instrucciones I2 – I5 al slot?
Solución #3: predecir el salto
Tiempo (ciclos reloj)
Sec
Inst

ALU
Mem Reg Mem Reg
Add

ALU
Mem Reg Mem Reg
Beq
Load

ALU
Mem Reg Mem Reg

 Predicción de saltos
 Adivinar resultado y continuar con siguiente instrucción
 Verificar resultado y corregir si predicción fue incorrecta
 Implica eliminar instrucción incorrecta del pipeline
 Costo
 0 ciclos predicción correcta, 1 ciclo predicción incorrecta
 Ej. Correcta 50%: CPIbranch = (1*0.5 + 2*0.5) = 1.5
 30% branch: CPItotal = (1*0.7 + 1.5*0.3) = 1.15
 Mejorar predicción: utilizar historia del salto (~90% correcto)
Organización de CPU segmentada

 Examinar sección de datos y control


 Asociar recursos con estados
 Detectar y resolver conflictos entre
instrucciones
 Activar señales de control en las etapas
apropiadas del pipeline
Control en pipeline
 Control se genera en etapa Reg/Dec
 Control para Exec (ExtOp, AluSrc,…) se utilizan 1 ciclo después
 Control para Mem (MemWr) se utiliza 2 ciclos después
 Control para WB (MemToReg, RegWr,…) se utiliza 3 ciclos después)
 Control estacionario: señales de control viajan junto con los datos

Reg/Dec Exec Mem Wr

ExtOp ExtOp
ALUSrc ALUSrc

Ex/Mem Register

Mem/Wr Register
ALUOp ALUOp
ID/Ex Register
IF/ID Register

Main
Control
MemWr MemWr MemWr
RegDst RegDst RegDst RegDst
MemtoReg MemtoReg MemtoReg MemtoReg
RegWr RegWr RegWr RegWr
Resumen
 Pipelining es forma natural de paralelismo
 Maximizar uso de recursos ejecutando múltiples instrucciones
en diferentes etapas
 Conflictos
 Estructurales: competencia por uso de hardware
 Control: dirección de siguiente instrucción depende de
resultado de instrucción en ejecución
 Datos: secuencia de ejecución limitada por dependencias de
datos
 Pipeline simple (MIPS)
 Conflictos eliminados por diseño (estructurales, WAW, WAR)
 Conflictos de control manejados como saltos retrasados
 Conflictos RAW manejados por forwarding (ALU), stalling
(loads)
 Excepciones aumentan complejidad del control
 Aún peor con formas más agresivas de paralelismo
(superscalar, VLIW)
Material adicional
 Existen simuladores que permiten
clarificar el funcionamiento del pipeline
 MIPSim32, accesible en website del
curso
 WinMIPS64, Simulador de MIPS de 64
bits, también accesible en website del
curso
 Otro sitio web con simulador de pipeline :
http://bellerofonte.dii.unisi.it/WEBMIPS/

También podría gustarte