Pipelining

Sistemas Computacionales
 Ejecucin Secuencial de Instrucciones
Instrucciones se ejecutan en varias etapas
Lectura de instruccin

Decodificacin

Ejecucin de operacin

Escritura de resultados

Termina una instruccin

antes de comenzar la siguiente.
Bajo flujo de instrucciones

Recursos ociosos
 Ejecucin Secuencial de
Instrucciones
Lavanderia secuencial: mal negocio!!!
6 PM 7 8 9 10 11 12
Tiempo

O 30 40 20 30 40 20 30 40 20 30 40 20
r
d
A
e
n
B
L
a
v C
a
d
o D
 Principios de pipelining

Segmentacin o pipelining: dividir el

procesamiento de una instruccin en etapas
Ejecutar etapas de instrucciones diferentes en
paralelo
Aumenta el desempeo (throughput) del sistema
en instrucciones procesadas por unidad de tiempo
(segundo)
Puede aumentar un poco la latencia
Latencia: tiempo total requerido para ejecutar una
sola instruccin desde el principio al final.
 Sistema sin pipeline

Sistema computacional con hardware sin pipeline

Lgica combinacional
Registro almacena resultado
Una seal de reloj controla la carga del registro cada cierto intervalo de
tiempo (regular)

Los retardos del circuito se miden en picosegundos (10-12

segundos)
Las operaciones en la lgica combinacional requieren 300 ps
La carga del registro requiere 20ps
 Sistema sin pipeline

La figura muestra lo que llamamos un diagrama de pipeline. En

este diagrama el tiempo va de izquierda a derecha.
I1, I2, I3 son instrucciones.
Los rectngulos indican el lapso de tiempo que demora en
ejecutarse cada una de las instrucciones.
Implementacin serial ejecucin completa de una instruccin
antes de comenzar la siguiente.
 Sistema sin pipeline
1 nanosegund o 1000 picosegundos

1 instruccin 1000 ps 1 instruccin

Throughput * 9
3.12 GIPS
(20 300) ps 1 ns (20 300) *10 seg

El throughput se expresa en giga instrucciones por

segundo (GIPS) o un billon de instrucciones por
segundo.
La latencia del sistema sera de 320 ps.
1 1
Latencia 320 ps
Throughput 3.12 GIPS
 Sistema con pipeline

Dividir operacin en 3 etapas A, B y C

Cada etapa requiere de 100 ps.
Utilizar pipeline-registers entre los estados.
Cada instruccin se mueva en tres pasos.
Cada instruccin requiere de tres ciclos de reloj
completos desde principio a fin.
Tres instrucciones diferentes pueden compartir el
hardware.
 Sistema con pipeline
(continuacin)

I2 puede comenzar a ejecutar el estado A tan pronto I1 pasa

a ejecutar el estado B y as sucesivamente.
En estado estacionario, todos los tres estados podran estar
activos, con una instruccin dejando un estado mientrs la
otra entra en ese estado en cada ciclo de reloj.
Podemos ver lo anterior en el tercer ciclo de reloj, cuando I1
est en el estado C, I2 est en estado B y I3 est en el estado
A.
 Sistema con pipeline
(continuacin)

Este sistema divide operacin en 3 etapas A, B

yC
Agrega 2 registros de pipeline entre etapas
Almacenar resultados intermedios
Cada 120 ps termina una operacin
Podemos situar el fin de un ciclo de reloj en
100+20=120 ps.
Latencia de una etapa: 120 ps
Throughput sera de alrededor de 8.33 GIPS
1 instruccin 1000 ps 1 instruccin
Throughput * 9
8.33 GIPS
120 ps 1 ns 120*10 seg
 Sistema con pipeline
(continuacin)

Procesar una sola instruccin toma ahora 3 ciclos

de reloj
Latencia de la operacin (pipeline): 3x120= 360 ps

Leve incremento en la latencia (360/320=1.12)

Aumento del desempeo: 3 ops en 360 ps.

Luego, se ha incrementado el desempeo
(throughput) del sistema por un factor de 2.67
(8.33/3.12=2.67)
 Sistema con pipeline

Sistema con pipeline de 3 etapas

100 ps 20 ps 100 ps 20 ps 100 ps 20 ps

Lgica R Lgica R Lgica R

comb. e comb. e comb. e
A g B g C g

Diagrama de tiempo Reloj

I1 A B C
Latencia = 360 ps
I2 A B C
I3 A B C
Throughput = 8.33 GOPS
Tiempo
 Pipelining en detalle (1)

Diagrama de tiempo muestra ejecucin de etapas de

diferentes instrucciones al mismo tiempo
Cada 120ps la seal del reloj va en flanco de subida de 0 a 1
Las tres etapas estn en uso entre t = 240 y t = 360 ps
Mostraremos qu pasa para t = 239 (punto1), 241
(punto2), 300 (punto3) y 359(punto4) ps

I1 A B C
I2 A B C
I3 A B C

Tiempo
0 120 240 360 480 600
j k
l
m
 Pipelining en detalle (2)

Qu pasa entre t=240 y t = 360?

Datos circulan por lgica combinacional de las tres
etapas
Cada etapa progresa a su propia velocidad
Resultados se traspasan a registros en el flanco de
subida de reloj
Estn disponibles para la siguiente etapa despus
del flanco de subida del reloj
 Pipelining en detalle (3)

j Tiempo = 239 (justo antes del flanco de subida del reloj en el tiempo 240ps)
100 ps 20 ps 100 ps 20 ps 100 ps 20 ps

Lgica R Lgica R Lgica R

comb. e comb. e comb. e
A g B g C g

Reloj

Instruccin I1 ha completado la etapa B

Instruccin I2 ha completado la etapa A
Resultados de cada instruccin estn ya
disponibles a la entrada de la etapa siguiente
 Pipelining en detalle (4)

k Tiempo = 241 (justo despus del flanco de subida del reloj en el tiempo 240ps)
100 ps 20 ps 100 ps 20 ps 100 ps 20 ps

Lgica R Lgica R Lgica R

comb. e comb. e comb. e
A g B g C g

Reloj

t=240: se activan los registros intermedios

Resultados de etapa anterior estn disponibles a la
entrada de la etapa siguiente
Comienza la ejecucin de la lgica combinacional
de cada etapa
 Pipelining en detalle (5)

l Tiempo = 300
100 ps 20 ps 100 ps 20 ps 100 ps 20 ps

Lgica R Lgica R Lgica R

Comb. e Comb e Comb e
A g B g C g

Reloj

t=300: se ejecuta la lgica combinacional de

cada etapa
Cada etapa progresa a su propia velocidad
siguiendo su evolucin natural
 Pipelining en detalle (6)
m Tiempo = 359 (justo antes del trmino de ejecucin de las instrucciones)
100 ps 20 ps 100 ps 20 ps 100 ps 20 ps

Lgica R Lgica R Lgica R

Comb. e Comb. e Comb. e
A g B g C g

Reloj

t=359: La lgica combinacional para cada etapa ya

gener los resultados intermedios
stos deben estar listos para ser almacenados en los
registros en el siguiente flanco de reloj
Cuando el reloj va en flanco de subida a 360ps cada una
de las instr. Habran progresado al menos un estado del
pipeline
 Pipelining no uniforme

Figura anterior muestra pipeline ideal

3 etapas independientes, del mismo largo
Qu pasa si son de largos distintos?
Desempeo limitado por etapa ms larga
Otras etapas tienen tiempo ocioso
Etapas que generalmente no pueden
subdividirse
Acceso a memoria
Algunas operaciones de ALU
 Pipeline no uniforme

A). Hardware: Pipeline de 3 etapas, retardos no uniformes El reloj se ve

limitado por el
50 ps 20 ps 150 ps 20 ps 100 ps 20 ps
retraso del
estado ms
Lgica R Lgica R Lgica R lento.
Comb.
e Comb. e Comb. e
A g B g C g

B). Diagrama de tiempos Clock

I1 A B C
I2 A B C
Latencia = 510 ps
I3 A B C
Throughput = 5.88 GIPS
Time
 Pipelining no uniforme

En el pipeline anterior el reloj se ve limitado por el

retraso del estado ms lento.
El estado A estar inactivo por 100 ps en cada ciclo
de reloj.
El estado C estar inactivo por 50 ps cada ciclo de
reloj
Solo el estado B estar continuamente activo.
El ciclo de reloj lo seteamos a 150+20=170 ps
Troughput ser de 5.88 GIPS.
La Latencia se incrementara a 510 ps
 Pipeline de 6 etapas
La siguiente figura muestra otra limitacin del pipeline:
Supongamos que aumentamos al doble los estados de pipeline. (6
estados)
Periodo de reloj mnimo 50+20=70ps,
Troughput de 14.29GIPS.
Al aumentar al doble los estados de pipeline mejoramos el performance en
un factor de 14.29/8.33=1.71
Los retardos introducidos por los registros agregados afectan al sistema.

50 ps 20 ps 50 ps 20 ps 50 ps 20 ps 50 ps 20 ps 50 ps 20 ps 50 ps 20 ps

R R R R R R
Logica Logica Logica Logica Logica Logica
Comb. e Comb. e Comb. e Comb. e Comb. e Comb. e
g g g g g g

Reloj Latencia = 420 ps

Throughput = 14.29 GOPS

Throughput aumenta, y tambin la latencia

 Profundidad del pipeline

Profundidad del pipeline determina aumento

de desempeo
A ms niveles, mayor latencia
Retardos de registros limitan aumento
Dividir hardware en pipeline de 6 etapas
Latencia es 420 ps (70ps*6=420ps)
Throughput es 14.29 GIPS
Retardo registros representa un 29% del total del
periodo del reloj
 Desempeo de un pipeline

En pipelines de profundidad m, ejecutar N

operaciones independientes requiere de N + m
1 ciclos
La aceleracin obtenida es
Ts mN

Tpipe N m 1
El desempeo (Throughput) puede verse usando

N 1

Tpipe 1 m 1
N
 Pipeline con realimentacin

Muchos sistemas tienen dependencias entre

instrucciones debido a uso de resultados
intermedios
Operacin correcta de instruccin requiere que
operacin anterior en curso termine
Dependencias de datos
Instruccin depende de un dato an no generado
por instruccin anterior
Dependencias de control
Instruccin depende de una decisin an no
tomada por instruccin anterior
 Ejemplo de dependencias

Dependencia de datos

Resultado de la 1ra. instruccin es un argumento

para la 2da. instruccin
2da instruccin debe esperar que la 1ra. termine
Resultado de 2da. instruccin es argumento para
la 3ra. instruccin
3ra. instruccin debe esperar que la 2da. termine
 Ejemplos de dependencias

Dependencia de control
La instruccin jne crea una
dependencia de control

Ejecucin de subq y luego jne determina

prxima instruccin a ejecutarse
 Feedback en HW sin pipeline

Hardware sin pipeline, con realimentacin

R
Lgica combinacional e
g

Diagrama de tiempo Reloj

OP1
OP2
OP3
Tiempo
 Pipeline con realimentacin
Utilizando el ejemplo anterior con hardware con pipeline
de 3 etapas y realimentacin

Lgica R Lgica R Lgica R

Comb. e Comb. e Comb. e
A g B g C g

Diagrama de tiempo Reloj

I1 A B C Error! Resultado de I1
I2 A B C debe ser entrada a I2
I3 A B C
I4 A B C No se puede ir contra
Tiempo el tiempo!
 Pipeline con realimentacin
Utilizando el ejemplo anterior con hardware con pipeline
de 3 etapas y realimentacin

Lgica R Lgica R Lgica R

Comb. e Comb. e Comb. e
A g B g C g

Diagrama de tiempo
Para convertirlo
correctamente a un
sistema pipeline
tenemos que hacer que
el resultado de I1 sea la
entrada de I4
 Procesador simple con pipeline

Supondremos un procesador segmentado

simple
5 etapas:
Instruction Fetch (F)
Instruction Decode (D)
Execute (E)
Memory (M)
Writeback (W)
 Procesador simple con pipeline

Instruction fetch (F)

Se lee la instruccin a ejecutar desde memoria
Se incrementa el registro PC
En el caso de instrucciones jmp call
absolutas, se carga la direccin de la siguiente
instruccin en el registro PC
Instruction decode (D)
Se leen los registros para
Operaciones aritmticas
Clculo de direcciones efectivas
 Procesador simple con pipeline

Execute (E)
Se usa la ALU para
Operaciones aritmticas entre registros
Clculo de direcciones efectivas
Memory (M)
Se accede a la memoria para lectura y/o escritura
de datos
Write-Back (W)
Se escribe en registros los resultados de
operaciones aritmticos datos ledos de memoria
 Procesador simple con pipeline

Instruccin movl (%ebx, %ecx), %eax

Fetch: lectura de instruccin
Decode: lectura de registros %ebx y %ecx
Execute: clculo de direccin efectiva
Memory: Lectura desde memoria
Writeback: Escribe registro %eax
Supondremos que
no hay modos de direccionamiento escalados
no hay modos de 3 argumentos
Slo instruccin movl accede a memoria
 Procesador simple con pipeline

Instruccin addl %ecx, %eax

Fetch: lectura de instruccin
Decode: lectura de registros %ecx y %eax
Execute: suma de registros %ecx y %eax
Memory: nada
Writeback: Escribe registro %eax
Supondremos que las operaciones aritmtico-
lgicas operan slo entre registros
 Procesador simple con pipeline

Instruccin movl %ecx, 10(%eax)

Fetch: lectura de instruccin
Decode: lectura de registros %ecx y %eax
Execute: suma de registro %eax y constante 10
Memory: Escribe registro %ecx a memoria
Writeback: nada
Instruccin utiliza la ALU durante el ciclo
Execute para calcular la direccin efectiva
 Flujo de instrucciones

Flujo de instrucciones
1 2 3 4 5 6 7 8 9

I1 F D E M W
I2 F D E M W
I3 F D E M W
I4 F D E M W
I5 F D E M W

Ciclo 5
W
I1
M
En un ciclo dado, hay 5 I2
instrucciones en ejecucin E
I3
Cada una en una etapa D
diferente I4
F
I5
 Ejecucin sin control de pipeline
(pipeline hazards)
1 2 3 4 5 6 7 8 9 10 11

Cdigo prog 1 I1 F D E M W
I1: movl $10, %edx I2 F D E M W
I3 F D E M W
I2: movl $3, %eax
I4 F D E M W
I3: nop I5 F D E M W
I4: nop I6 F D E M W
I5: nop
Dependencia de
I6: addl %edx, %eax datos sin peligros
Ciclo 6
de datos debido a
Instruccin nop: no operation W los retrasos
Nuevo valor de %eax R[%eax] f 3 producidos por la
instruccin nop
disponible al final del ciclo 6
Ciclo 7
Etapa Writeback de I2
D
I3 lo necesita en el ciclo 7 R[%edx] = 10
Etapa Decode de I6 R[%eax] = 3
 Ejecucin sin control de pipeline
(pipeline hazards)
1 2 3 4 5 6 7 8 9 10

Cdigo prog 2 I1 F D E M W
I1: movl $10, %edx I2 F D E M W
I3 F D E M W
I2: movl $3, %eax
I4 F D E M W
I3: nop I5 F D E M W
I4: nop
I5: addl %edx, %eax
Ciclo 6
Se elimina una instruccin nop W
Error! , peligro de datos R[%eax] f 3

Nuevo valor de %eax disponible

al final del ciclo 6

Etapa Writeback de I2 D
Necesario en etapa Decode de I5 R[%edx] = 10 Error
R[%eax] = 0
 Ejecucin sin control de pipeline
(pipeline hazards)
1 2 3 4 5 6 7 8 9

Cdigo prog 3 I1 F D E M W
I2 F D E M W
I1: movl $10, %edx
I3 F D E M W
I2: movl $3, %eax I4 F D E M W
I3: nop
I4: addl %edx, %eax Ciclo 5
Error! Peligro de Datos W

Nuevo valor de %edx disponible R[%edx] f 10

al final del ciclo 5

M
Nuevo valor de %eax disponible
al final del ciclo 6
Valores necesarios en ciclo 7 D
Etapa Decode de I4 R[%edx] = 0 Error
R[%eax] = 0
 Ejecucin sin control de pipeline
(pipeline hazards)
1 2 3 4 5 6 7 8

Cdigo prog 4 I1 F D E M W
I1: movl $10, %edx I2 F D E M W
I3 F D E M W
I2: movl $3, %eax
I3: addl %edx, %eax
Error! Peligro de Datos Ciclo 4
Nuevo valor de %edx M
disponible al final del ciclo 5
Nuevo valor de %eax
E
disponible al final del ciclo 6
Valores necesarios en ciclo 4
Etapa Decode de I4 D
Error
R[%edx] = 0
R[%eax] = 0
 Peligros en pipelines
(pipeline hazards)
Errores en pipelines son causados por peligros
de datos (data hazards) y peligros de control
(control hazards)
Peligros de datos
Instruccin modifica el estado del procesador
Estado es ledo por una instruccin siguiente
Estado del procesador
Registros
Flags de condicin
Memoria
 Peligros en pipelines
(pipeline hazards)
Etapas en conflicto potencial
Registros
Ledos en etapa Decode
Escritos en etapa WriteBack
Flags de condicin
Escritos y ledos en etapa Execute por mov condicionales.
Ledos por jump condicional en el estado de Memoria.
Cuando un mov o jump condicional alcanza la etapa
Execute cualquier operacin anterior se habra ejecutado.
No generan peligros.
 Peligros en pipelines
(pipeline hazards)
Etapas en conflicto potencial
Memoria
Memoria de datos es escrita y leda en etapa Memory
Memoria de instrucciones es leda en etapa Fetch
 Evitando peligros en pipelines

Burbujas (stalling)

Redireccin (Forwarding)
 Burbujas (Stalling)

Procesador demora una o ms instrucciones

para evitar el peligro de datos
Instruccin que requiere datos an no generados
se queda en la etapa Decode hasta que el dato est
disponible.
Se introduce una burbuja en el pipeline
Una burbuja equivale a generar dinamicamente una
instruccin nop
No modifica registros, memoria o flags de condicin
Fcil de implementar
Degrada el desempeo del pipeline
 Prog 2 con burbujas

1 2 3 4 5 6 7 8 9 10 11

Cdigo prog 2 I1 F D E M W
I1: movl $10, %edx I2 F D E M W
I2: movl $3, %eax I3 F D E M W
I3: nop I4 F D E M W
E M W
I4: nop
I5 F D D E M W
burbuja
I6 F F D E M W
I5: addl %edx, %eax
No hay problemas!
Se pierde un ciclo
En el ciclo decode se detecta el peligro de
datos
I5 repite etapa Decode 2 veces
I6 repite etapa Fetch 2 veces
 Prog 3 con burbujas

1 2 3 4 5 6 7 8 9 10 11

Cdigo prog 3 I1 F D E M W
I2 F D E M W
I1: movl $10, %edx
I3 F D E M W
I2: movl $3, %eax E M W
I3: nop E M W
burbuja I4 F D D D E M W

burbuja I5 F F F D E M W

I4: addl %edx, %eax

No hay problemas!
Se pierden dos ciclos
I4 repite etapa Decode 3 veces
I5 repite etapa Fetch 3 veces
 Prog 4 con burbujas

1 2 3 4 5 6 7 8 9 10 11

Cdigo prog 4 I1 F D E M W
I1: movl $10, %edx I2 F D E M W
I2: movl $3, %eax E M W
burbuja E M W
E M W
burbuja
I3 F D D D D E M W
burbuja
I4 F F F F D E M W
I3: addl %edx, %eax
No hay problemas!
Se pierden tres ciclos
I3 repite etapa Decode 4 veces
I4 repite etapa Fetch 4 veces
 Redireccin (Forwarding)

Procesador puede redirigir datos desde una

instruccin en proceso a otra
Prog 2: instruccin addl necesita leer nuevo
valor de %eax desde el registro, que ya est
disponible en la etapa Writeback de instruccin
movl
Porqu no redirigir salida de Writeback a etapa
Decode?
 Redireccin (Forwarding)

Procesador puede redirigir datos desde una

instruccin en proceso a otra.
La redireccin requiere hacer modificaciones
de hw y lgica de control en el pipeline.
Evita burbuja adicional
No degrada desempeo del pipeline
 Ejecucin con redireccin
1 2 3 4 5 6 7 8 9 10

I1 F D E M W
Cdigo prog 2 I2 F D E M W
I1: movl $10, %edx I3 F D E M W
I2: movl $3, %eax I4 F D E M W
I5 F D E M W
I3: nop
I6 F D E M W
I4: nop
I5: addl %edx, %eax Ciclo 6
W
En ciclo 6, detectar la escritura
Escribe $3 a registro %eax
pendiente al registro %eax, y
usar ese valor en vez de leer
%eax desde el banco de
registros D
Lee %edx del banco de registros
Lee valor pendiente de %eax
 Forwarding y peligros de datos

En este pipeline, uso de forwarding permite

eliminar mayor parte de las burbujas
Excepto el caso de peligro de lectura y uso
Ocurre cuando se lee un dato desde memoria y se
necesita ese dato en la instruccin siguiente
Instruccin movl lee dato desde memoria en
etapa Memory
Instruccin addl siguiente necesita ese dato en
etapa Decode
 Peligros de lectura y uso

Es un tipo de peligro de datos

No es posible hacer redireccin desde etapa
Memory a etapa Decode de instruccin
siguiente
Dato no est disponible porque an no ha sido
ledo desde memoria
Qu hacer? Combinacin de burbuja y
redireccin
Intercerrojo de lectura (load interlock)
 Ejecucin con redireccin
1 2 3 4 5 6 7 8 9 10 11

Cdigo prog 5 I1 F D E M W
I1: movl $128, %edx I2 F D E M W
I3 F D E M W
I2: movl $3, %ecx
I4 F D E M W
I3: movl %ecx, 0(%edx) I5 F D E M W
I4: movl $10, %ebx I6 F D E M W
I5: movl 0(%edx), %eax
I6: addl %ebx, %eax Ciclo 7 Ciclo 8
En ciclo 7, se leen %ebx y %eax M

desde el banco de registros Valor de %eax se lee

Pero, el nuevo valor de %eax se
lee de memoria en el ciclo 8
Error!
desde memoria
D Error
Lee %ebx desde registro
Lee %eax desde registro
 Ejecucin con redireccin
1 2 3 4 5 6 7 8 9 10 11 12

Cdigo prog 5 I1 F D E M W
I2 F D E M W
I1: movl $128, %edx
I3 F D E M W
I2: movl $3, %ecx I4 F D E M W
I3: movl %ecx, 0(%edx) I5 F D E M W
I4: movl $10, %ebx E M W

I5: movl 0(%edx), %eax I6 F D D E M W

I6: addl %ebx, %eax Ciclo 8

Combinacin de burbuja y W
Escribe $10 en %ebx
redireccin asegura la
ejecucin correcta
M
Lee desde memoria al
registro %eax

D
Lee valor pendiente de %eax
Lee valor pendiente de %edx
 Prioridades de forwarding

Qu pasa si hay varias instrucciones seguidas

que modifican el mismo registro?
Pipeline debe dar prioridad a la fuente de la
etapa ms temprana
Contiene el valor ms nuevo del dato a usar
Verifica primero etapa Execute, luego etapa
Memory, y luego etapa Writeback
 Prioridad de redireccin
1 2 3 4 5 6 7 8

I1: movl $10, %edx I1 F D E M W

I2 F D E M W
I2: movl $3, %edx I3 F D E M W
I3: movl %edx, %eax I4 F D E M W

Las primeras dos instrucciones

Ciclo 4
modifican el registro %edx M
La tercera instruccin Escribe $10 en %edx
requiere el ltimo valor de
E
%edx
Escribe $3 en %edx
Redireccin de etapa Execute
a etapa Decode D

Lee valor pendiente de %edx

 Peligros de control (I)

Control de flujo de instrucciones puede causar

problemas con el pipeline
Ejemplo: Instruccin ret
Ejecucin de programa debe continuar con la
instruccin en la direccin de retorno
Direccin de retorno se lee en la etapa Memory
Procesador no puede leer la prxima instruccin hasta
despus de esa etapa
3 ciclos de instruccin perdidos
 Pipeline instruccin ret

Ejemplo: cdigo a ejecutar

I1: movl pila, %esp
llama a funcin fun1 en
I2: call fun1
instruccin I2
I3: movl $10, %edx
Fun1 retorna
I4: halt
inmediatamente
. . .
Procesador no puede leer fun1:
siguiente instruccin hasta I5: ret
fin de etapa Memory de I6: movl %edx, %ebx
ret
I7: incl %esi
Final del ciclo 6 del ejemplo
I8: decl %eax
 Pipeline instruccin ret

1 2 3 4 5 6 7 8 9 10 11
I1 F D E M W
I2 F D E M W
I5 F D E M W
I6 F D E M W
I1: movl pila, %esp I7 F D E M W
I8 F D E M W
I2: call proc I3 F D E M W
I5: ret
burbuja
burbuja
burbuja
I3: movl $10, %edx
 Pipeline instruccin ret

Pipeline debe demorar la ejecucin de la

prxima instruccin hasta que su direccin
haya sido leda
Pero no puede insertar burbujas en etapa Fetch
Pipeline repite etapa Fetch de instruccin
siguiente a instruccin ret hasta haber
definido la direccin de retorno
Instruccin siguiente a ret es leda 3 veces
 Pipeline instruccin ret

1 2 3 4 5 6 7 8 9 10 11

I1 F D E M W
I2 F D E M W
I1: movl pila, %esp I5 F D E M W
I2: call proc I6 F
D E M W
I5: ret I6 F
I6: movl %edx, %ebx D E M W
burbuja I6 F
D E M W
I6: movl %edx, %ebx I3 F D E M W
burbuja
I6: movl %edx, %ebx
burbuja
I3: movl $10, %edx
 Peligros de control (II)

La ejecucin de saltos condicionales tambin

degrada el desempeo del pipeline
Saltos incondicionales no tienen este problema!
Procesador no sabe si debe saltar hasta despus
de etapa Execute de instruccin aritmtica
Para entonces, ya ha ledo otras 2 instrucciones
Penalidad de 2 ciclos para todas las instrucciones de
salto condicional
Prediccin de saltos puede reducir esta penalidad
 Prediccin de saltos

Estrategia esttica de prediccin de saltos:

predecir que el salto siempre se toma
Ejecutar siempre la instruccin indicada en la
instruccin
Si salto se toma, penalidad es cero
Si salto no se toma, penalidad es 2 ciclos
Estadsticas muestran que esta estrategia tiene
una tasa de aciertos de 65%
 Pipeline prediccin errada

Cdigo de ejemplo resta I1: subl %ebx, %eax

dos registros en I1 I2: jne salto
Salto condicional en I2 I3: movl $1, %edx
Si condicin se cumple, I4: halt
se ejecuta instruccin I5
salto:
Si condicin no se
I5: movl $2, %edx
cumple, se ejecuta
instruccin I3 I6: movl $3, %ebx
I7: halt
 Pipeline prediccin errada

1 2 3 4 5 6 7 8 9 10

I1: subl %ebx, %eax I1 F D E M W

I2: jne salto I2 F D E M W

I5: movl $2, %edx I5 F D

E M W
burbuja I6 F
I6: movl $3, %ebx D E M W

burbuja I3 F D E M W
I4 F D E M W
I3: movl $1, %edx
I4: halt
 Anlisis de desempeo

Insercin de burbujas en el pipeline afecta el

desempeo
Ciclos de reloj perdidos
Instruccin ret pierde 3 ciclos
Peligro de lectura y uso pierde 1 ciclo
Saltos condicionales pierden 2 ciclos
Esto afecta el objetivo de ejecutar una onstruccin
por cada ciclo de reloj.
 Anlisis de desempeo

Podemos estimar el efecto que tiene en el

performance una estimacin del promedio de
ciclos de reloj.
Estimar promedio de ciclos por instruccin
para este procesador
CPI: Cycles per instruction
Esta medida es el recproco del promedio del
throughput del pipeline, pero con el tiempo
medido en CPI en vez de ps.
 Anlisis de desempeo

Ci instrucciones y Cb burbujas
CPI=(Ci+Cb)/Ci
CPI = 1.0 + Cb/Ci

Luego, CPI es igual a una instruccin por ciclo de

reloj ms un trmino de penalidad Cb/Ci indicando el
promedio de burbujas inyectadas por instruccin
ejecutada.
 Anlisis de desempeo

Podemos descomponer el trmino de

penalidad en tres componentes:
CPI = 1.0 + lp + mp + rp
lp: penalidad por peligros de lectura y uso
mp: penalidad por prediccin errada
rp: penalidad por instrucciones de retorno
Penalidad depende del nmero de burbujas
insertadas para cada caso
 Ejemplo de anlisis

Instrucciones de lectura de memoria (movl y popl) es 25%

del total
20% de stas tienen peligros de lectura y uso
Saltos condicionales son 20% del total
60% de stos se toman
Instrucciones de retorno son 2% del total
CPI es 1.0 + 0.27 = 1.27
Penalidad Frecuencia Frecuencia Burbujas Producto
instrucciones condicion
lp 0.25 0.2 1 0.05
mp 0.2 0.4 2 0.16
rp 0.02 1.0 3 0.06
0.27