2022

Arquitectura de las Universidad Nacional de la

Patagonia Austral

Computadoras
Unidad Académica Caleta
Olivia
2022

UNIDAD II – Parte G

CPU Segmentada (Pipelining)

Arquitectura de las computadoras 2

 Estructura del curso
2022

1. Evolución y caracterización de los computadores.

2. Arquitectura del MIPS: Introducción.
3. Tipo de datos.
4. El repertorio de instrucciones.
5. Aritmética del computador.
6. El camino de datos.
7. Sección de control.
8. CPU Segmentada (Pipelining)

Arquitectura de las computadoras 3

 Esquema de contenidos
2022

1. Conceptos básicos
2. Peligros (hazards)

Arquitectura de las computadoras 4

 Definición
2022

 Técnica de implementación.
 Consiste en ejecutar traslapadas varias instrucciones
al mismo tiempo.

Arquitectura de las computadoras 5

 Ejemplo
2022  Pasos para lavar y secar ropa:

1. Poner una carga de ropa sucia en la lavadora.

2. Al terminar, poner la ropa húmeda en la secadora.
3. Al terminar, poner la ropa seca en una mesa y
doblarla.
4. Guardar la ropa doblada.

 Al terminar, poner la siguiente carga en la

lavadora.

Arquitectura de las computadoras 6

 Ejemplo
2022  Hay dos formas de lavar ropa:

1. Hacer un paso a la vez (versión secuencial).

2. Hacer varios pasos a la vez (versión con pipeline).

 Suponiendo que hay cuatro cargas de ropa y que

cada paso tarda media hora (30 minutos).

Arquitectura de las computadoras 7

 Versión secuencial
2022

Arquitectura de las computadoras 8

 Versión con pipeline
2022

Arquitectura de las computadoras 9

 Conclusión
2022
 Para 1 carga de ropa:
 Versión secuencial: 2 horas.
 Versión con pipeline: 2 horas.
 Speedup: 2 / 2 = 1.0.

 Para 4 cargas de ropa:

 Versión secuencial: 8 horas.
 Versión con pipeline: 3.5 horas.
 Speed-up: 8 / 3.5 = 2.29.

Arquitectura de las computadoras 10

 Conclusión
2022
 Para 20 cargas de ropa:
 Versión secuencial: 40 horas.
 Versión con pipeline: 11.5 horas.
 Speed-up: 40 / 11.5 = 3.48.

 El speed-up está limitado por el número de etapas

del pipeline.
 El speed-up depende del factor de utilización del
pipeline.

Arquitectura de las computadoras 11

 Conclusión
2022

Para tener un pipeline se necesitan recursos para

cada etapa.

Arquitectura de las computadoras 12

 Pipelining en MIPS
2022
Las instrucciones de MIPS tienen 5 etapas:

1. IF (instruction fetch): obtiene la instrucción de la

memoria.
2. ID (instruction decoding): decodifica la
instrucción y lee los operandos.
3. EX (execute): ejecuta la instrucción, o si es
lw/sw calcula la dirección de la memoria.
4. MEM (memory access): lee/escribe la memoria.
Es una no-op para instrucciones tipo-R.
5. WB (write back): escribe el resultado en el
registro.

Arquitectura de las computadoras 13

 Pipelining en MIPS
2022

MEM

WB

Arquitectura de las computadoras 14

 Pipelining en MIPS
2022
 Características de MIPS que ayudan a
implementar cada etapa del pipeline en un ciclo:

1. Las instrucciones tienen la misma longitud.

Etapas IF e ID.
2. Solo 3 formatos de instrucción. Etapa ID.
3. Las instrucciones lw y sw son las únicas que
accesan la memoria. Etapas EX y MEM.
4. Los operandos están alineados en la memoria.
Etapa MEM.

Arquitectura de las computadoras 15

 Ejemplo
Sombreado derecha lectura de datos Sombreado izquierda escritura de datos
2022

 El cuadro completo representa la memoria de instrucciones.

 El cuadro punteado representa el banco de registros.
 EX tiene el símbolo de la ALU.
 MEM está en blanco porque add no accede a la memoria de
datos.

Arquitectura de las computadoras 16

 Comparación
 Comparar la implementación MIPS de un ciclo
2022
contra la implementación de un pipeline.
 Versión de 8 instrucciones:
 carga palabra (lw),
 guarda palabra (sw),
 suma (add),
 resta (sub),
 and,
 or,
 set-on-less-than (slt) y
 branch-on-equal (beq).
 Versión de un ciclo: todas las instrucciones tardan
un ciclo de reloj.
Arquitectura de las computadoras 17
 Comparación
 Versión con pipeline: ps = pico segundos
2022 1 ps = 1 × 10–12 s
• 200 ps por acceso a memoria.
• 200 ps por operación de la ALU.
• 100 ps por leer o escribir en el banco de registros.

Arquitectura de las computadoras 18

 Comparación
2022

 En la versión de un ciclo, la duración del ciclo de

reloj se acopla a la instrucción mas lenta.

 El periodo de reloj es de 800 ps, aunque haya

instrucciones que ocupen 500 ps.

 Se van a comparar una secuencia de 3

instrucciones lw.

Arquitectura de las computadoras 19

 Versión de un ciclo
2022
 Las 3 instrucciones tardan 800 x 3 = 2,400 ps.

Arquitectura de las computadoras 20

 Versión pipeline
2022
 Las 3 instrucciones tardan 1,400 ps.

Arquitectura de las computadoras 21

 Conclusiones
2022

 En la versión pipeline, la longitud del ciclo en cada

etapa es la misma y se acopla a la etapa mas lenta.
 Cada etapa dura 200 ps.
 Speedup = 2400 / 1400 = 1.71.

Arquitectura de las computadoras 22

 Speedup
2022
 Si las etapas del pipeline están perfectamente
balanceadas, el speedup máximo es:

 Speedupmax =Num. de etapas

 En teoría, el speedup máximo de un pipeline es

aproximadamente igual al número de etapas.
 Un pipeline de 5 etapas es hasta 5 veces más
rápido que la versión sin pipeline (secuencial).

Arquitectura de las computadoras 23

 Speedup
2022

 En teoría, si el periodo de reloj en la versión de un

ciclo es de 800 ps, en una versión balanceada del
pipeline el periodo debería ser de 800 / 5 = 160 ps.
 Pero, como las etapas no están balanceadas, el
periodo de reloj es de 200 ps.
 En el ejemplo, el speedup está limitado a 4.

Arquitectura de las computadoras 24

 Speedup
2022
 En general, para pipelines balanceados o no
balanceados, el speedup máximo es:

Ciclosecuencial
Speedup max =
Ciclo pipeline

 En el ejemplo:
800
 Speedup max = =4
200

Arquitectura de las computadoras 25

 Speedup
2022
 En el ejemplo, con 3 instrucciones el speedup es de
1.71.
 La razón es que son solo 3 instrucciones.
 Si se ejecutan un millón de lw:

800,002,400
Speedup = = 3.99998
200,001, 400

 El speedup depende de la utilización del pipeline.

Arquitectura de las computadoras 26

 Conclusión
2022

 El uso de un pipeline mejora el rendimiento

incrementando el throughput sin decrementar el
tiempo de ejecución de una instrucción individual.

Arquitectura de las computadoras 27

 Peligros (hazards)
Eventos que evitan que la siguiente instrucción se
2022 ejecute en el siguiente ciclo de reloj.

• Estructurales: Conflictos de recursos

• Datos: Dependencias de instrcciones

• Control: Predicción de Saltos

Arquitectura de las computadoras 28

 Peligros estructurales
2022
• Motivo: conflicto de recursos.
• Solución: duplicar recursos.

• Ejemplo: IF y MEM necesitan acceso a la memoria.

• Solución: separar la memoria de instrucciones y la
memoria de datos.
• Ejemplo: IF e ID necesitan acceso al PC.
• Solución: tener 2 copias del PC. Un PC apunta a la
siguiente instrucción y otro a la instrucción que está
siendo ejecutada.

Arquitectura de las computadoras 29

 Peligros estructurales
2022

MEM

WB

Arquitectura de las computadoras 30

 Peligros de datos
2022  Motivo: Dependencia de datos, una instrucción en
el pipeline : debe esperar a que otra instrucción
termine. Soluciones

1. Detener el pipeline (stall) .

2. Anticipar datos (fowarding / bypassing).
3. Reordenar las instrucciones
 Ejemplo:
A: add $s0, $t0, $t1 ; s0 = t0 + t1
B: sub $t2, $s0, $t3 ; t2 = s0 - t3

Arquitectura de las computadoras 31

 Peligros de datos: Stall
2022 1. Detener el pipeline

add $s0, $t0, $t1

sub $t2, $s0, $t3

Arquitectura de las computadoras 32

 Peligros de datos: Forwarding / Bypassing

2022
2. Anticipación de resultados mediante conexiones por
hardware las etapas del pipeline.

Arquitectura de las computadoras 33

 Peligros de datos: RAW (Read after write)

2022
 El Fowarding / bypassing no soluciona todos los
peligros. Leer un dato antes de que este escrito.
 Ejemplo:

A: lw $s0, 20($t1) ; s0 = Mem[t1 + 20]

B: sub $t2, $s0, $t3 ; t2 = s0 - t3
 s0 se calcula en la etapa MEM de A.
 Ya es tarde para hacer un bypass a la etapa EX de B.

Arquitectura de las computadoras 34

 Peligros de datos: RAW (Read after write)

2022

 Riesgo del dato una carga,

 Solución: el pipeline se detiene (stall) un ciclo.

Arquitectura de las computadoras 35

 Peligros de datos : Reordenar Instrucciones

2022 3. Reordenar instrucciones.

 El sentido del programa no debe cambiar.
 Ejemplo:

A: lw $s0, 20($t1) ; s0 = Mem[t1 + 20]

B: sub $t2, $s0, $t3 ; t2 = s0 - t3
 Solución:
A: lw $s0, 20($t1) ; s0 = Mem[t1 + 20]
C: lw $t3, 8($a0) ; t3 = Mem[a0 + 8]
B: sub $t2, $s0, $t3 ; t2 = s0 - t3

Arquitectura de las computadoras 36

 Peligros de datos : Reordenar Instrucciones

2022

Encontrar las dependencias en el siguiente código y

reordenar las instrucciones para evitarlas.

 Código en C/Java

A=B+E
C=B+F

Arquitectura de las computadoras 37

 Peligros de datos : Reordenar Instrucciones
 Soluciones: Reordenamiento de instrucciones (compilador).
2022

A = B + E; C = B + F;

lw $t1, 0($t0) lw $t1, 0($t0)

lw $t2, 4($t0) lw $t2, 4($t0)
stall add $t3, $t1, $t2 lw $t4, 8($t0)
sw $t3, 12($t0) add $t3, $t1, $t2
lw $t4, 8($t0) sw $t3, 12($t0)
stall add $t5, $t1, $t4 add $t5, $t1, $t4
sw $t5, 16($t0) sw $t5, 16($t0)
13 cycles 11 cycles

Arquitectura
Chapter 4 — The Processor de las computadoras
— 38
 Peligros de datos : Reordenar Instrucciones

2022  Ejemplo Código MIPS

 Asumiendo que B está apuntada por t0, E por t0+4, F por
t0+8, A por t0+12 y C por t0+16.

1. lw $t1, 0($t0) ; t1 = Mem[t0]

2. lw $t2, 4($t0) ; t2 = Mem[t0+4]
3. add $t3, $t1, $t2 ; t3 = t1 + t2
4. sw $t3, 12($t0) ; Mem[t0+12] = t3
5. lw $t4, 8($t0) ; t4 = Mem[t0+8]
6. add $t5, $t1, $t4 ; t5 = t1 + t4
7. sw $t5, 16($t0) ; Mem[t0+16] = t5

Arquitectura de las computadoras 39

 Peligros de datos : Reordenar Instrucciones

2022  Ejemplo Código MIPS

 Análisis de la dependencias de datos

a) 1 y 3.
b) 2 y 3.
c) 3 y 4.
d) 5y6
e) 6y7

 Forwarding (bypassing) elimina todas las dependencias

excepto b) y d).
Arquitectura de las computadoras 40
 Peligros de datos : Reordenar Instrucciones

2022  Ejemplo Código MIPS

 Las dependencias b) y d) se resuelven moviendo la

instrucción 5 hacia arriba:
1. lw $t1, 0($t0) ; t1 = Mem[t0
2. lw $t2, 4($t0) ; t2 = Mem[t0+4]
5. lw $t4, 8($t0) ; t4 = Mem[t0+8]
3. add $t3, $t1, $t2 ; t3 = t1 + t2
4. sw $t3, 12($t0) ; Mem[t0+12] = t3
6. add $t5, $t1, $t4 ; t5 = t1 + t4
7. sw $t5, 16($t0) ; Mem[t0+16] = t5

Arquitectura de las computadoras 41

 Peligros de control
2022  También llamados peligros de saltos.
 No se sabe que instrucción sigue a un salto.
 Ejemplo:
beq $t0, $t1, etiqueta
instrucción_1
…
etiqueta:
instrucción_2

Arquitectura de las computadoras 42

 Peligros de control
2022
 Por ahora se mencionarán tres soluciones:
1. Detener (stall) el pipeline. La siguiente instrucción
entra cuando se sepa el resultado del salto.
2. Predecir (adivinar) si se va a saltar o no.
3. Decisión retrasada.

Arquitectura de las computadoras 43

 Peligro de control: Detener el pipeline
2022
Esperar hasta que la condición de salto se haya resuelto antes de
buscar la próxima instrucción

Arquitectura de las computadoras 44

 Peligro de control:Predicción de saltos
2022
 Algunas estrategias básicas:
1. Predecir que los saltos nunca se toman.
2. Usar alguna heurística. Por ejemplo, predecir que
los saltos hacia arriba son parte de un ciclo y
predecir que se toman.
3. Predecir cada salto en base a la historia del
salto.

Arquitectura de las computadoras 45

 Peligro de control:Predicción de saltos
2022

 Intentar adivinar el resultado de un salto.

 Si se acierta, el pipeline continúa a toda velocidad.
 Si no se acierta, hay que deshacer la instrucciones del
camino equivocado y empezar a sacar instrucciones del
camino correcto.

Arquitectura de las computadoras 46

 Peligro de control: Predicción de saltos
2022

Arquitectura de las computadoras 47

 Peligro de control: Decisión Retrasada
2022
 Se usa en MIPS.
 Poner una instrucción que no sea afectada por el
salto, después del salto.
 Por ejemplo:
add $t0, $t1, $t2
beq $s0, $s1, Etiqueta
 Se convierte en:
beq $s0, $s1, Etiqueta
add $t0, $t1, $t2
La inclusión del add da tiempo a que la CPU sepa el resultado
del beq.
Arquitectura de las computadoras 48