Capítulo 3: Superescalares

1 (Ejercicios de clase)
Suponiendo que en cada ciclo sólo se puede hacer una lectura/escritura de/en los registros, indique
el número mínimo de puertos de lectura y escritura que harían falta en el banco de registros de un
procesador superescalar capaz de ejecutar hasta dos instrucciones por ciclo.

Solución.
Si se pueden emitir 2 instrucciones por ciclo, y como cada instrucción tiene dos operandos, se
necesitarían cuatro lecturas. Es decir, haría falta cuatro puertos de lectura en el banco de registros o
en el búfer de reordenamiento

Si se pueden retirar 2 instrucciones por ciclo, como cada instrucción podría tener que escribir un
resultado, se necesitarían dos puertos de escritura.

Por tanto haría falta que los bancos de registros tuvieran 6 puertos como mínimo (cuatro de lectura
y dos de escritura)

2 (Ejercicios de clase)
Indique el número de bits de las líneas de las estaciones de reserva en un procesador superescalar en
el que cada unidad funcional tiene una estación de reserva propia, y que implementa una
arquitectura con 64 instrucciones de dos operandos, tamaño de palabra de 32 bits, banco de 32
registros, y búfer de reordenamiento de 32 registros suponiendo:

a) Que los operandos se captan durante la emisión de la instrucción.

b) Que los operandos se captan en el envío a la unidad de ejecución.

¿Y si cada estación de reserva estuviese compartida por cuatro unidades funcionales que ejecutan
operaciónes de distinto código de operación?.

Solución.
En la tabla, se muestran las respuestas para la cuestión (a) y (b).

op1 ok1 op2 ok2 dest

(a) 32 1 32 1 5
(b) 5 1 5 1 5

La opción (a) precisa de 71 bits mientras que la opción (b) sólo

necesita 17.
Si cada estación de reserva está compartida por cuatro unidades
funcionales habría que añadir 2 bits más en cada caso (para codificar
la unidad a la que hay que enviar la operación). Se tendrían 73 y 19
bits respectivamente.
3 (Ejercicios de clase)
Para el fragmento de código siguiente:

1 lw r1,0x1ac
2 lw r2,0xc1f
3 add r3,r0,r0
4 mul r4,r2,r1
5 add r3,r3,r4
6 add r5,r0,0x1ac
7 add r6,r0,0xc1f
8 sub r5,r5,#4
9 sub r6,r6,#4
10 sw (r5),r3
11 sw (r6),r4

y suponiendo que se pueden captar cuatro instrucciones por ciclo y emitir cuatro instrucciones por
ciclo, indique el orden en que se emitirán las instrucciones para cada uno de los siguientes casos:

a) Una ventana de instrucciones centralizada con emisión ordenada y alineada

b) Una ventana de instrucciones centralizada con emisión desordenada y alineada
c) Una estación de reserva de tres líneas para cada unidad funcional, con envío ordenado y
ventana deslizante.

Nota: considere que hay una unidad funcional para la carga (2 ciclos), otra para el almacenamiento
(1 ciclo), tres para la suma/resta(1 ciclo), y una para la multiplicación (6 ciclos).

Solución.
En las tablas se muestra la evolución de las instrucciones en cada etapa y situación.

P1.a Ventana Centralizada. Emisión alineada y ordenada

Instrucción Inst # IF ID ISS/EX Comentarios

lw r1,0x1ac (1) 1 2 3-4
lw r2,0xc1f (2) 1 2 5-6 Colisión con (1) por uso de
Load

add r3,r0,r0 (3) 1 2 5

mul r4,r2,r1 (4) 1 2 7 - 12 Necesita r2, r1 proporcionadas
por (1) y (2)

add r3,r3,r4 (5) 2 7 13 Entran en la ventana cuando se

vacía (alineada), Necesita r4

add r5,r0,0x1ac (6) 2 7 13

add r6,r0,0xc1f (7) 2 7 13
sub r5,r5,#4 (8) 2 7 14 Necesita r5 para poder
ejecutarse

sub r6,r6,#4 (9) 3 14 15 Entran en la ventana cuando se

vacia (alineada)

sw (r5),r3 (10) 3 14 15 Necesita r5 (y r3)

sw (r6),r4 (11) 3 14 16 Necesita r6 (y r4)

Ordenada

En el caso de la emisión alineada, hasta que no se han emitido todas las instrucciones que entraron
en la ventana al decodificarse no se introducen nuevas instrucciones en la ventana que puedan ser
emitidas. Esta situación se puede observar en la columna ID, donde se indica el ciclo en el que las
instrucciones se terminarían de decodificar y pasarían a la ventana de instrucciones (cuando ésta se
ha quedado vacía).
 P1.b Ventana Centralizada. Emisión alineada y desordenada

Instrucción Inst # IF ID ISS/EX Comentarios

lw r1,0x1ac (1) 1 2 3-4
lw r2,0xc1f (2) 1 2 5-6 Colisión con (1) por uso de
Load

add r3,r0,r0 (3) 1 2 3 Se adelanta el envío

mul r4,r2,r1 (4) 1 2 7 - 12 Necesita r2, r1 proporcionadas

por (1) y (2)

add r3,r3,r4 (5) 2 7 13 Entran en la ventana cuando se

vacía (alineada), Necesita r4

add r5,r0,0x1ac (6) 2 7 8 Se adelanta el envío

add r6,r0,0xc1f (7) 2 7 8 Se adelanta el envío

sub r5,r5,#4 (8) 2 7 9 Necesita r5 para poder

ejecutarse

sub r6,r6,#4 (9) 3 13 14 Entran en la ventana cuando se

vacia (alineada)

sw (r5),r3 (10) 3 13 14 Necesita r5 (y r3)

sw (r6),r4 (11) 3 13 15 Necesita r6 (y r4)

Emisión Desordenada

P1.c Emisión a Estaciones de Reserva (RS) y envío ordenado

Instrucción Inst # IF ID/ISS DISP/EX Comentarios
lw r1,0x1ac (1) 1 2 3-4 RS(LD)

lw r2,0xc1f (2) 1 2 5-6 Colisión con (1) por uso de

Load RS(LD)

add r3,r0,r0 (3) 1 2 3 Se adelanta el envío RS1(ADD)

mul r4,r2,r1 (4) 1 2 7 - 12 Necesita r2, r1 proporcionadas

por (1) y (2) RS(MUL)

add r3,r3,r4 (5) 2 3 13 Entran en la ventana cuando se

vacía (alineada), Necesita r4
RS2(ADD)

add r5,r0,0x1ac (6) 2 3 4 Se adelanta el envío RS3(ADD)

add r6,r0,0xc1f (7) 2 3 4 Se adelanta el envío RS1(ADD)

sub r5,r5,#4 (8) 2 3 5 Necesita r5 para poder

ejecutarse RS3(ADD)

sub r6,r6,#4 (9) 3 4 5 Entran en la ventana cuando se

vacia (alineada) RS1(ADD)

sw (r5),r3 (10) 3 4 14 Necesita r5 (y r3) RS(ST)

sw (r6),r4 (11) 3 4 15 Necesita r6 (y r4) RS(ST)

En negrita la estación de reserva donde se emite la instrucción (ISS)

En el caso se utilizar estaciones de reserva, las instrucciones se emiten desde el decodificador

(columna ID/ISS) a cada estación de reserva. Desde ahí se envían a las correspondientes unidades
funcionales. Se ha supuesto que la emisión a las estaciones de reserva se hace de forma que se
distribuyen las instrucciones entre todas las unidades del mismo tipo, para minimizar las colisiones
y los tiempos de espera en la correspondiente estación.

4 (Ejercicios de clase)
En un procesador superescalar con renombrado de registros en el que se utilizan registros
específicos para implementar el renombrado, y acceso indexado a esos registros a través de una
tabla de mapeo. Indique como evolucionarían los registros de renombrado al ejecutar las
instrucciones:

1 mul r2,r0,r1
2 add r3,r1,r2
3 sub r2,r0,r1

Solución.
En las figuras siguientes se muestra como evolucionarían los búferes de renombrado.
 Reg Entrada Índice Valor Válido
Válida Buffer
0 1 2
1 1 4 10 1
2 1 6
3 15 1

mul r2,r0,r1
Se pueden leer r0 y r1 que se han asignado a los bufferes 2 y 4.
El valor de r2 se asigna al registro 6 y se indica como no válido
(hasta que no esté el resultado)

Reg Entrada Índice Valor Válido

Válida Buffer
0 1 2
1 1 4 10 1
2 1 6
3 1 5 15 1
0
0

add r3,r1,r2
Como r2 no está disponible, se indica que el operando de add
correspondiente a r2 se toma del registro 6.
A r3 se le asigna el registro 5, que se indica como no válido
hasta que no se genere el resultado

Reg Entrada Índice Valor Válido

Válida Buffer
0 1 2
1 1 4 10 1
2 1 7
3 1 5 15 1
0
0

sub r2,r0,r1 0

Como r0 y r1 están disponibles puede iniciarse la operación,

pero r2 se asigna a otro registro.
Con las otras dos instrucciones anteriores no hay problema: la
multiplicación pondrá el resultado en el registro 6 que será de
donde lo tome la suma.
Queda como último valor para r2, el contenido del registro de
renombrado número 7.

5 (Ejercicios de clase)
Suponga que las cuatro instrucciones siguientes

multd f3,f1,f2 ; f3= f1*f2 (ciclo 3)

addd f2,f3,f1 ; f2=f3+f1 (ciclo 4)
subd f3,f3,f1 ; f3=f3 - f1 (ciclo 5)
addd f5,f1,f2 ; f5=f1+f2 (ciclo 5)

se introducen una tras otra (en los ciclos indicados entre paréntesis) en un búfer de renombrado con
acceso asociativo. Indique (a) cómo evoluciona el búfer de renombrado (registros del búfer de
renombrado que se van asignando, los registros de donde tomarían los datos y donde escribirían los
resultados las instrucciones, etc.) para esas instrucciones; (b) en qué momento empieza y termina la
ejecución de las instrucciones; y (c) cuáles son los valores que quedan en los registros de la
arquitectura al terminar, si inicialmente f1=2.0 y f2=3.0.
(NOTA: la multiplicación tarda 6 ciclos, y la suma y la resta 2 ciclos, y hay suficientes unidades
funcionales como para que no afecten los riesgos estructurales)

Solución.
(a) A continuación se muestra la evolución del búfer de renombrado con acceso asociativo

(Ciclo 3)
# Entrada Registro Valor Valor Válido Bit de
Valida Último
0 1 f1 2.0 1 1
1 1 f2 3.0 1 1
2 1 f3 0 1

Se inicia la multiplicación en el ciclo 4, puesto que tiene los valores disponibles. Terminará en el
ciclo 9 (dura 6 ciclos).

En el búfer de renombrado se observa que el registro 2 asignado a f3 no tiene un valor válido y que
los tres bits de último de los registros asignados están a 1 porque son las últimas asignaciones
realizadas para f1, f2, y f3.

(Ciclo 4)
# Entrada Registro Valor Valor Válido Bit de
Valida Último
0 1 f1 2.0 1 1
1 1 f2 3.0 1 0
2 1 f3 0 1
3 1 f2 0 1

Como se hace una asignación nueva a f2, el bit de último del registro r1 se hace 0, indicando que si
una instrucción posterior necesitase tomar el valor de f2 lo debe tomar del registro 3. El bit de Valor
Válido del nuevo registro asignado debe estar a 0. La operación de suma de addd f2,f3,f1 no puede
ejecutarse antes del ciclo 10 (cuando termina la multiplicación), y tomará el valor de f3 del registro
2 del búfer de renombrado. Termina en el ciclo 11, y el resultado se escribirá en el registro 3 del
búfer.

(Ciclo 5)
# Entrada Registro Valor Valor Válido Bit de
Valida Último
0 1 f1 2.0 1 1
1 1 f2 3.0 1 0
2 1 f3 0 0
3 1 f2 0 1
4 1 f3 0 1
5 1 f5 0 1

Se asigna el registro 4 a f3, por lo que el bit de último del registro 2 del búfer se pone a 0. También
se asigna el registro 5 del búfer a f5.

La instrucción subd f3,f3,f1 tomará el valor de f1 del registro1 del búfer (su valor es 2.0) y tomará
el valor de f3 que necesita del registro 2 del búfer. Esta operación empezará a ejecutarse en el ciclo
10 y terminará en el ciclo 11 escribiendo el resultado en el registro 4.

La instrucción addd f5,f1,f2 tomará el valor de f1 del registro1 del búfer (su valor es 2.0) y tomará
el valor de f2 que necesita del registro 3 del búfer. Esta operación empezará a ejecutarse en el ciclo
12 y terminará en el ciclo 13.

(b) Las instrucciones empiezan a ejecutarse según se indica en la siguiente tabla, donde se indican
también los resultados que obtienen.

Instrucción Empieza Termina Resultado

multd f3,f1,f2 4 9 2.0*3.0=6.0
addd f2,f3,f1 10 11 6.0+2.0=8.0
subd f3,f3,f1 10 11 6.0-2.0=4.0
addd f5,f1,f2 12 13 2.0+8.0=10.0

(c) A partir de los resultados que se muestran en la última columna de la tabla anterior se tiene que
al final, los valores de los registros son:

f1=2.0, f2=8.0, f3=4.0, f5=10.0.

6 (Examen diciembre 2005)

Suponga que las cinco instrucciones siguientes

(1) multd f3, f1 ,f2 ; f3 = f1 * f2 (ciclo 3)

(2) addd f2, f3, f1 ; f2 = f3 + f1 (ciclo 4)
(3) subd f3, f3, f1 ; f3 = f3 – f1 (ciclo 4)
(4) multd f5, f1, f4 ; f5 = f1 + f4 (ciclo 5)
(5) addd f6, f2, f3 ; f6 = f2 * f3 (ciclo 6)

se introducen una tras otra (en los ciclos indicados entre paréntesis) en un búfer de renombrado con
acceso asociativo. Indique (a) cómo evoluciona el búfer de renombrado para esas instrucciones
(registros del búfer de renombrado que se van asignando, los registros de donde tomarían los datos
y donde escribirían los resultados las instrucciones, etc.); (b) en qué momento empieza y termina la
ejecución de las instrucciones suponiendo que en el procesador hay una unidad de multiplicación y
otra de suma/resta, y se utiliza emisión desordenada; y (c) indique el número más pequeño de
unidades de multiplicación y de suma/resta que habría que añadir para minimizar el tiempo de
ejecución de las instrucciones.

(NOTA: la unidad de multiplicación tarda 5 ciclos, y la de suma/resta 2 ciclos, y cada unidad

dispone de una estación de reserva con espacio suficiente para tres instrucciones)

Solución.
Suponemos que inicialmente el búfer de renombrado está vacío y que el primer renombrado se
produce en el ciclo 3, tal y como dice el enunciado. También suponemos que todos los valores con
los que se va a operar están preparados en el banco de registros del computador, de forma que sólo
tendremos en cuanta las dependencias entre las 5 instrucciones del problema.

En el ciclo 3 se introduciría en el búfer de renombrado la instrucción (1), que tomaría sus operandos
del banco de registros y podría pasar a ejecutarse. El búfer de renombrado quedaría así:

# Ent. Válida Reg. Destino Valor Ok Ultimo

 1 1 f3 0 1

En el ciclo 4 se introducirían en el búfer de renombrado las instrucciones (2) y (3). Como ambas
operan con los mismos operandos, las dos tomarían el operando f1 del banco de registros y
marcarían al segundo operando en la estación de reserva como pendiente y esperando a que se
calcule y se almacene en la entrada 1 del búfer de renombrado. Como la instrucción (3) vuelve a
escribir en f3, se marca como último el renombrado de la entrada 3 del búfer de renombrado. El
búfer de renombrado quedaría así:

# Ent. Válida Reg. Destino Valor Ok Ultimo

1 1 f3 0 0
2 1 f2 0 1
3 1 f3 0 1

En el ciclo 5 se introduciría en el búfer de renombrado la instrucción (4), que tiene sus dos
operandos disponibles en el banco de registros, con lo que se renombraría al registro f5 en la
siguiente entrada del búfer de renombrado y podría pasar a ejecutarse. El búfer de renombrado
quedaría así:

# Ent. Válida Reg. Destino Valor Ok Ultimo

1 1 f3 0 0
2 1 f2 0 1
3 1 f3 0 1
4 1 f5 0 1

En el ciclo 6, se introduciría en el búfer de renombrado la última instrucción, que depende de los

operandos f2 y f3 que están pendientes y que se tomarán de las entradas del búfer de renombrado 2
y 3 respectivamente cuando estén disponibles. Esta instrucción provoca el renombrado del registro
f6, quedando el búfer de renombrado así:

# Ent. Válida Reg. Destino Valor Ok Ultimo

1 1 f3 0 0
2 1 f2 0 1
3 1 f3 0 1
4 1 f5 0 1
5 1 f6 0 1

Las instrucciones escribirían sus resultados en los campos Valor de sus entradas del búfer de
renombrado. En el momento de escribir el valor, se cambiaría el campo ok de 0 a 1 y cualquier
instrucción que estuviera esperando el dato escrito podría pasar a ejecutarse. Teniendo en cuanta las
dependencias de datos, las latencias de las unidades de ejecución, y que solamente hay un sumador
y un multiplicador, las escrituras se realizarían en la etapa FIN del cauce, en el siguiente orden:

3 4 5 6 7 8 9 10 11 12 13 14 15
(1) ID/ISS EX FIN
(2) ID/ISS EX FIN
(3) ID/ISS EX FIN
(4) ID/ISS EX FIN
(5) ID/ISS EX FIN

Aumentando el número de sumadores y de multiplicadores a 2, eliminamos todos los riesgos

estructurales y conseguimos que los únicos atascos en el cauce se deban a dependencias entre datos,
lo que nos ahorra dos ciclos en la ejecución del programa.
 3 4 5 6 7 8 9 10 11 12 13
(1) ID/ISS EX FIN
(2) ID/ISS EX FIN
(3) ID/ISS EX FIN
(4) ID/ISS EX FIN
(5) ID/ISS EX FIN

7 (Ejercicios de clase)
Suponga que las cuatro instrucciones siguientes

multd f3,f1,f2 ; f3= f1*f2 (ciclo 2)

addd f2,f3,f1 ; f2=f3+f1 (ciclo 2)
subd f3,f3,f1 ; f3=f3-f1 (ciclo 3)
addd f4,f1,f2 ; f4=f1+f2 (ciclo 3)

se han decodificado en los ciclos indicados entre paréntesis, introduciéndose en una estación de
reserva común para todas las unidades funcionales de coma flotante. Teniendo en cuenta que el
procesador superescalar dispone de un ROB para implementar la finalización ordenada, y que la
emisión es desordenada y no alineada. Indique (a) cómo evolucionaría el ROB para esas
instrucciones; (b) en qué momento empieza y termina la ejecución de las instrucciones; y (c) cuáles
son los valores que quedan en los registros de la arquitectura al terminar, si inicialmente f1=3.0 y
f2=2.0.

(NOTA: la multiplicación tarda 4 ciclos, y la suma y la resta 2 ciclos; hay tantas unidades
funcionales como sea necesario para que no haya riesgos estructurales; y se pueden enviar, retirar,
etc. dos instrucciones por ciclo como máximo)

Solución.

Para resolver el problema se parte de la tabla siguiente, donde se indican los ciclos en los que (1) las
instrucciones se terminan de decodificar (ID) y han pasado a la estación de reserva, (2) comienza y
termina la ejecución de la operación correspondiente a la instrucción (EX), (3) el resultado de
operación se ha almacenado en el ROB, y (4) el momento en que después de retirar la instrucción
del ROB, los resultados se han almacenado en el banco de registros de la arquitectura:

Instrucción ID EX ROB WB
1 multd f3,f1,f2 2 3-6 7 8
2 addd f2,f3,f1 2 7-8 9 10
3 subd f3,f3,f1 3 7-8 9 10
4 addd f4,f1,f2 3 9 - 10 11 12

La tabla anterior constituye la respuesta al apartado (b) del problema. Las instrucciones segunda y
tercera deben esperar que termine la ejecución de la primera, y la cuarta instrucción espera que
termine la segunda. A partir de esta tabla también se puede determinar la evolución del ROB.

(b) El ROB empieza a llenarse al final del ciclo 2, después de haberse decodificado las dos primeras
instrucciones.

(Final de 2)
# Instrucción Reg.Dest. Valor OK Unidad Flush
0 1 f3 - 0 - 0
 1 2 f2 - 0 - 0

Al finalizar el tercer ciclo se introducen en el ROB las dos instrucciones restantes, y también habrá
empezado la multiplicación.

(Final de 3)
# Instrucción Reg.Dest. Valor OK Unidad Flush
0 1 f3 - 0 mult 0
1 2 f2 - 0 - 0
2 3 f3 - 0 - 0
3 4 f4 - 0 - 0

Hasta el final del ciclo 7 no ocurre nada en el ROB (en relación con las instrucciones que indica el
problema). Como se muestra a continuación, se habrá terminado la multiplcación, y el resultado
estará almacenado en el campo de valor del registro 0 del búfer, el bit de OK estará a 1, y también
se ha iniciado la ejecución de las instrucciones 2, y 3. En el siguiente ciclo (ciclo 8) se retirará la
instrucción 1 del ROB.

(Final de 7)
# Instrucción Reg.Dest. Valor OK Unidad Flush
0 1 f3 6.0 1 Mult 0
1 2 f2 - 0 Add 0
2 3 f3 - 0 Sub 0
3 4 f4 - 0 - 0

Al final del ciclo 9 la instrucción 1 ya no está en el ROB, habrá terminado la ejecución de las
instrucciones 2 y 3 y sus resultados estarán almacenador en los registros 2 y 3 el ROB, y habrá
empezado la ejecución de la instrucción 4.

(Final de 9)
# Instrucción Reg.Dest. Valor OK Unidad Flush
1 2 f2 9.0 1 Add 0
2 3 f3 3.0 1 Sub 0
3 4 f4 - 0 Add 0

Al final del ciclo siguiente se habrán retirado las instrucciones 2 y 3 y se escribirán sus resultados
en los registros f2 y f3.

(Final de 10)
# Instrucción Reg.Dest. Valor OK Unidad Flush
3 4 f4 - 0 Add 0

Al finalizar el siguiente ciclo, el resultado de la instrucción 4 se habrá almacenado en el registro 3

del ROB.

(Final de 11)
# Instrucción Reg.Dest. Valor OK Unidad Flush
3 4 f4 12.0 1 Add 0

En el siguiente ciclo (ciclo 12) se retirará la instrucción y se escribirá el resultado en f1.

(c) Teniendo en cuenta la evolución del ROB (el orden en que se han retirado las instrucciones y se
almacenan los resultados en el banco de registros) y las operaciones realizadas, los registros quedan
al final con los valores:

f1=3.0, f2= 9.0, f3=3.0, f4=12.0

8 (Benchmark diciembre 2003)

Suponga que las cinco instrucciones siguientes se introducen una tras otra (en los ciclos indicados
entre paréntesis) en un búfer de reordenamiento (ROB) y en una ventana de instrucciones (estación
de reserva centralizada): (a) ¿En qué momento empieza y termina la ejecución de cada instrucción?
(b) ¿En qué instantes se van retirando las instrucciones? (c) ¿Qué valores quedan en los registros si
f1=3.0 y f2=2.0?

addd f3,f1,f2 ; f3=f1+f2 (ciclo 3)

addd f2,f3,f2 ; f2=f3+f2 (ciclo 3)
multd f4,f3,f2 ; f4=f3*f2 (ciclo 3)
subd f5,f2,f1 ; f5=f2-f1 (ciclo 4)
addd f2,f3,f1 ; f2=f3+f1 (ciclo 4)

(NOTA: La multiplicación tarda 6 ciclos; la suma y la resta 2 ciclos; se retiran dos instrucciones por
ciclo como máximo; y el envío es desordenado y no alineado pudiéndose enviar dos instrucciones
por ciclo como máximo)

9 (Benchmark diciembre 2003)

Se dispone de un procesador superescalar con la siguiente configuración:

 una estación de reserva RS1 para las sumas y restas,

 una estación de reserva RS2 para las multiplicaciones y divisiones,
 un búfer de reordenamiento ROB,
 dos unidades de ejecución de sumas/restas con una latencia de 2 ciclos,
 una unidad de ejecución de multiplicaciones con una latencia de 5 ciclos,
 una unidad de ejecución de divisiones con una latencia de 40 ciclos

El procesador es capaz de emitir dos instrucciones por ciclo, las estaciones de reserva pueden
realizar envíos no alineados y desordenados a las unidades de ejecución, y se pueden retirar hasta
dos instrucciones por ciclo.

Si en la cola de instrucciones se encuentran las siguientes instrucciones:

addd f3, f1, f2 ; f3 = f1 + f2

addd f2, f3, f2 ; f2 = f3 + f2
multd f4, f3, f2 ; f4 = f3 * f2
divd f5, f2, f1 ; f5 = f2 / f1
subd f2, f3, f1 ; f2 = f3 - f1

y los registros f1 y f2 tienen inicialmente los valores 10 y 5, ¿qué valores y en qué ciclos se
escribirá en los registros de la arquitectura?

Solución.
El esquema del cauce del procesador propuesto en el problema es el siguiente:
 ADD/
DISP SUB 1
RS1

ADD/
ISS DISP SUB 2

COLA F
CACHE I INSTR. I
F N
ISS DISP MUL

ISS RS2

DISP DIV

ROB

RET

REGS

En el enunciado se nos dice que las instrucciones ya están en la cola de instrucciones y que e
procesador es capaz de emitir y retirar dos instrucciones por ciclo, así que asumiendo que nos
encontramos en el ciclo 1 vamos a ir emitiendo las instrucciones tal y como se muestra en la
siguiente tabla.

Instrucción ID/ISS DISP/EX FIN RET Comentario

addd f3, f1, f2 (1) 1 2–3 4 5 f3 ← 15 en el ciclo 5
addd f2, f3, f2 (2) 1 4–5 6 7 f2 ← 20 en el ciclo 7, RAW con (1)
multd f4, f3, f2 (3) 2 6 – 10 11 12 f4 ← 300 en el ciclo 12, RAWs con (1) y (2)
divd f5, f2, f1 (4) 2 6 – 45 46 47 f5 ← 2 en el ciclo 47, RAW con (2)
subd f2, f3, f1 (5) 3 4–5 6 47 f2 ← 5 en el ciclo 47, RAW con (1)

 La instrucción (1) se emite a la estación de reserva RS1 en el ciclo 1 y puede enviarse al

sumador 1 al siguiente ciclo (ciclo 2) de su emisión, ya que sus operandos f1 y f2 están
disponibles en la estación de reserva RS1 en el momento de su emisión. Tras los dos ciclos
que tarda una suma, la instrucción finaliza en el ciclo 4 y se almacena el resultado en el
ROB y en las estaciones de reserva que necesiten el nuevo valor de f3. Al ciclo siguiente
(ciclo 5) se retirará del ROB almacenando en el registro f3 el valor 15.

 La instrucción (2) también se emite en el ciclo 1 a RS1, pero como tiene una dependencia
RAW con la instrucción (1) en f3, debe esperar a que f3 se haya calculado en el ciclo 4 para
poder ejecutarse. En cuanto tiene disponible f3 (ciclo 4) pasa a ejecutarse al sumador 1 y
 finaliza en el ciclo 6 (los sumadores tienen una latencia de 2 ciclos). En el siguiente ciclo
(ciclo 7) se retirará del ROB y almacenará en el registro f2 el valor 20.

 La instrucción (3) se emite en el ciclo 2 a la estación de reserva RS2, ya que las dos
primeras se emitieron en el ciclo 1 y solo se pueden emitir dos instrucciones por ciclo. Esta
instrucción no podrá ejecutarse hasta el ciclo 6, ya que tiene dependencias RAW con las
instrucciones (1) y (2) en los registros f3 y f2 respectivamente, y finalizará en el ciclo 11
porque el multiplicador tiene una latencia de 5 ciclos. En el ciclo 12 se retirará del ROB
escribiendo en el registro f4 el valor 300.

 La instrucción (4) se emite también a RS2 en el ciclo 2 pero no podrá ejecutarse hasta el
ciclo 6 debido a la dependencia RAW con las instrucción (2) en f2. Como las divisiones
tienen una latencia de 40 ciclos, esta instrucción estará ejecutándose desde el ciclo 6 hasta el
45. En el ciclo 46 escribirá el resultado en el ROB y en el ciclo 47 se retirará escribiendo
en el registro f5 el valor 2.

 La instrucción (5) se emitirá en el ciclo 3 a RS1, ya que las dos anteriores se emitieron en
el ciclo anterior, y en el ciclo 4, como ya tiene disponible el valor de f3 que produce la
instrucción (1), podrá pasar a ejecutarse a uno de los sumadores. En el ciclo 6 finalizará y
almacenará el resultado en el ROB, pero no podrá retirarse hasta el ciclo 47, que es cuando
se retira la instrucción (4), ya que la retirada debe ser ordenada, así que como pueden
retirarse dos instrucciones por ciclo, en el ciclo 47 se retirará y escribirá en el registro f2
el valor 5.

10 (Ejercicios de clase)
Considere que el fragmento de código siguiente:

1 lw r3,0x10a
2 addi r2,r0,#128
3 add r1,r0,0x0a
4 lw r4,0(r1)
5 lw r5,-8(r1)
6 mult r6,r5,r3
7 add r5,r6,r3
8 add r6,r4,r3
9 sw 0(r1),r6
10 sw -8(r1),r5
11 sub r2,r2,#16

se ejecuta en un procesador superescalar que es capaz de captar 4 instrucciones/ciclo, de

decodificar 2 instrucciones/ciclo, de emitir (utilizando una ventana de instrucciones con emisión no
alineada) 2 instrucciones/ciclo, escribir hasta 2 resultados/ciclo en los registros correspondientes
(registros de reordenamiento, o registros de la arquitectura según el caso), y completar (o retirar)
hasta 2 instrucciones/ciclo.

Indique el número de ciclos que tardaría en ejecutarse el programa suponiendo:

a) Emisión ordenada y ejecución desordenada

b) Emisión desordenada y ejecución desordenada

(Nota: Considere que tiene una unidad funcional de carga (2), una de almacenamiento(1), tres
unidades de suma/resta(1), y una de multiplicación (6)- y que no hay limitaciones para el número de
líneas de la cola de instrucciones, ventana de instrucciones, búfer de reordenamiento, puertos de
lectura/escritura etc.).

Solución.
La forma en que las instrucciones van pasando por las distintas etapas del cauce se muestra en las
tablas que se proporcionan a continuación. En las tablas también se marcan las dependencias RAW
que existen entre las instrucciones.

En la emisión ordenada (Tabla P2.a) los instantes en los que las instrucciones empiezan a ejecutarse
(columna EX) deben estar ordenados de menor a mayor, a diferencia de lo que ocurre en la emisión
desordenada (Tabla P2.b)

Dado que el procesador utiliza un búfer de reordenamiento (ROB), la finalización del

procesamiento de las instrucciones es ordenada y por ello, en la columna WB los tiempos (momento
en que se retiran las instrucciones del ROB y se escriben en los registros de la arquitectura) deben
estar ordenados (en ambas tablas).

Otro aspecto que debe tenerse en cuenta es que en las columnas ID, EX, ROB, y WB no deben
existir más de dos instantes de tiempo iguales ya que se decodifican, emiten, escriben en el ROB, o
retiran, dos instrucciones por ciclo como máximo. Por ello, por ejemplo, la instrucción (11) en la
tabla P2.b se termina (escribe el resultado en el ROB) en el ciclo 10, y no en el 9.

P2.a Emisión Ordenada / Finalización Ordenada (Ejecución Desordenada)

Intrucción Inst# IF ID EX ROB WB Comentarios

lw r3,0x10a (1) 1 2 3 5 6 Sólo se pueden retirar dos
instrucciones por ciclo
addi r2,r0,#128 (2) 1 2 3 4 6 Termina antes que la (1) pero
se retira al mismo tiempo
add r1,r0,0x0a (3) 1 3 4 5 7
lw r4,0(r1) (4) 1 3 5 7 8
lw r5,-8(r1) (5) 2 4 7 9 10 Se inicia cuando termine (4)
por colisión en el load
mult r6,r5,r3 (6) 2 4 9 15 16
add r5,r6,r3 (7) 2 5 15 16 17
add r6,r4,r3 (8) 2 5 15 16 17
sw 0(r1),r6 (9) 3 6 16 18
sw –8(r1),r5 (10) 3 6 17 19 Hay colisión en la unidad
Store (se podría lanzar antes)
sub r2,r2,#16 (11) 3 7 17 18 19

Ordenado
 P2.b Emisión Desordenada / Finalización Ordenada

Intrucción Inst# IF ID EX ROB WB Comentarios

lw r3,0x10a (1) 1 2 3 5 6 Sólo se pueden retirar dos
instrucciones por ciclo
addi r2,r0,#128 (2) 1 2 3 4 6 Termina antes que la (1) pero
se retira al mismo tiempo
add r1,r0,0x0a (3) 1 3 4 5 7
lw r4,0(r1) (4) 1 3 5 7 8
lw r5,-8(r1) (5) 2 4 7 9 10 Se inicia cuando termine (4)
por colisión en el load
mult r6,r5,r3 (6) 2 4 9 15 16
add r5,r6,r3 (7) 2 5 15 16 17
add r6,r4,r3 (8) 2 5 7 8 17
sw 0(r1),r6 (9) 3 6 8 18
sw –8(r1),r5 (10) 3 6 16 18 No hay colisión en el Store

sub r2,r2,#16 (11) 3 7 8 10 19 Sólo se retiran del ROB 2

intrucciones por ciclo

Desordenado Ordenado

A partir de las tablas correspondientes a cada situación se comprueba que el tiempo que tarda la
secuencia de instrucciones es el mismo tanto para la emisión ordenada como para la desordenada.
Esto se debe, fundamentalmente, a las dependencias existentes entre las instrucciones,
concretamente entre la multiplicación (6) y el almacenamiento (10) y al tiempo de la multiplicación,
que hace que se tenga que retrasar la instrucción de almacenamiento (6). De hecho, si se
considerase que las instrucciones finalizan cuando terminan (no deben esperar en el ROB a que les
toque el turno para ser retiradas), para el caso (a) se tendrían 19 ciclos, y para el (b) 18 ciclos (se
supone que la instrucción (11) ha escrito sus resultados en el ciclo 11).

11 (Ejercicios de clase)
En el problema anterior, (a) indique qué mejoras realizaría en el procesador para reducir el tiempo
de ejecución en la mejor de las opciones sin cambiar el diseño de las unidades funcionales
(multiplicador, sumador, etc.) y sin cambiar el tipo de memorias ni la interfaz entre procesador y
memoria (no varía el número de instrucciones captadas por ciclo. (b) ¿Qué pasaría si se reduce el
tiempo de multiplicación a la mitad?

Solución.
 P3.a Instrucciones decodificadas por ciclo (4) y retiradas por ciclo (3);
Unidades de acceso a memoria (2); no hay límite en la emisión
Intrucción Inst# IF ID EX ROB WB Comentarios
lw r3,0x10a (1) 1 2 3 5 6 Se pueden retirar tres
instrucciones por ciclo
addi r2,r0,#128 (2) 1 2 3 4 6 Termina antes que la (1) pero
se retira al mismo tiempo
add r1,r0,0x0a (3) 1 2 3 4 6 Se pueden emitir más de 2
instrucciones/ciclo
lw r4,0(r1) (4) 1 2 4 6 7
lw r5,-8(r1) (5) 2 3 4 6 7 No hay colisión en el load

mult r6,r5,r3 (6) 2 3 6 12 13

add r5,r6,r3 (7) 2 3 12 13 14
add r6,r4,r3 (8) 2 3 6 7 14
sw 0(r1),r6 (9) 3 4 7 14
sw –8(r1),r5 (10) 3 4 13 15 No hay colisión en el Store

sub r2,r2,#16 (11) 3 4 5 6 15 Comienza una vez

decodificada

Desordenado Ordenado

P3.b Instrucciones decodificadas por ciclo (4) y retiradas por ciclo (3);
Unidades de acceso a memoria (2); no hay límite en la emisión
Intrucción Inst# IF ID EX ROB WB Comentarios
lw r3,0x10a (1) 1 2 3 5 6 Se pueden retirar tres
instrucciones por ciclo
addi r2,r0,#128 (2) 1 2 3 4 6 Termina antes que la (1) pero
se retira al mismo tiempo
add r1,r0,0x0a (3) 1 2 3 4 6 Se pueden emitir más de 2
instrucciones/ciclo
lw r4,0(r1) (4) 1 2 4 6 7
lw r5,-8(r1) (5) 2 3 4 6 7 No hay colisión en el load

mult r6,r5,r3 (6) 2 3 6 9 10 Se reduce a la mitad mult

add r5,r6,r3 (7) 2 3 9 10 11

add r6,r4,r3 (8) 2 3 6 7 11
sw 0(r1),r6 (9) 3 4 7 11
sw –8(r1),r5 (10) 3 4 10 12 No hay colisión en el Store

sub r2,r2,#16 (11) 3 4 5 6 12 Comienza una vez

decodificada

Desordenado Ordenado

En las Tablas P3.a y P3.b se muestra la forma en que las instrucciones pasan por el cauce
superescalar para las cuestiones (a) y (b) planteadas en el problema.

Para resolver la cuestión (a), inicialmente se considera que se decodifica el mismo número de
instrucciones que se capta, ya que no existen limitaciones impuestas por las instrucciones al ritmo
de decodificación (éste viene determinado por las posibilidades de los circuitos de descodificación y
la capacidad para almacenar las instrucciones decodificadas hasta que se emitan). También se
considera que no existen limitaciones para el número de instrucciones por ciclo que se emiten,
escriben el ROB, y se retiran. Por último, se consideran que están disponibles todas las unidades
funcionales que se necesiten para que no haya colisiones (riesgos estructurales).

Una vez encontrada la distribución temporal de las instrucciones en las distintas etapas, tal y como
se muestra en la Tabla P3.a, se observa que, las mejoras necesarias (sin modificar los tiempos de
procesamiento de las unidades funcionales) para reducir el tiempo al mínimo que permiten las
dependencias RAW entre las instrucciones han sido: decodificar 4 instrucciones por ciclo, emitir,
escribir en el ROB, y retirar hasta tres instrucciones por ciclo, y añadir una unidad de carga de
memoria más.

En la Tabla 3.b se muestra la distribución temporal de instrucciones en etapas cuando, además de

las mejoras anteriores, se reduce el tiempo de la multiplicación a tres ciclos (la mitad de lo que
duraba antes). Como se puede comprobar, esa reducción de tres ciclos también se observa en el
tiempo final de la secuencia de instrucciones. Se pone así de manifiesto, que el tiempo de la
multiplicación es uno de los determinantes fundamentales de las prestaciones.

Si se tiene en cuenta que la secuencia consta de 11 instrucciones, que el tiempo mínimo que tarda la
primera instrucción en salir son 6 ciclos (lo tomamos como tiempo de latencia de inicio del cauce),
y que el tiempo total de ejecución en este caso es de 12 ciclos, se puede escribir:

12 = 6 + (11 – 1) * (Ciclos por Instrucción)

con lo que, si se despeja, se tiene que el procesador superescalar presenta una media de 0.6 ciclos
por instrucción, o lo que es lo mismo, ejecuta 1.67 (1/0.6) instrucciones por ciclo.

12 (Ejercicios de clase)
En el caso descrito en el problema 2, suponga que se utiliza un búfer de reordenamiento para
permitir la ejecución desordenada y la finalización ordenada. Indique cómo evolucionaría dicho
búfer de reordenamiento en el mejor de los casos.

Solución.
A continuación se muestra la evolución del búfer de reordenamiento (ROB) del procesador
superescalar descrito en el problema 2. Entre los dos casos que se plantean en el problema indicado
se considerado el caso de emisión desordenada.

Se muestra el estado del ROB al final del ciclo indicado. En el ROB que se ha utilizado se considera
que existe espacio para almacenar los resultados de las instrucciones correspondientes y, por tanto,
implementa también el renombrado de registros.

Al final del ciclo 2 se han introducido las instrucciones (1) y (2) que escribirán sus resultados en r3
y r2, respectivamente (no tienen valores válidos en el ROB, y por ello sus bits de ok están a 0). Al
final del ciclo 3, se han introducido las instrucciones (3) y (4) y se han emitido las instrucciones (1)
y (2). Por eso se escribe la unidad en la que se están ejecutando en la columna Unidad (última
columna) del ROB).
 Ciclo 2

# Inst. Codop Reg.Dst Dato OK Unidad

1 1 lw r3 - 0

2 2 addi r2 - 0

Ciclo 3

# Inst. Codop Reg.Dst Dato OK Unidad

1 1 lw r3 - 0 load

2 2 addi r2 - 0 add

3 3 add r1 - 0

4 4 lw r4 - 0

Al final del ciclo 4 han entrado en el ROB las instrucciones (5) y (6), se ha terminado la instrucción
(2), y por eso su bit OK está a 1, y se ha emitido la instrucción 3.

Ciclo 4

# Inst. Codop Reg.Dst Dato OK Unidad

1 1 lw r3 - 0 load

2 2 addi r2 128 1 add

3 3 add r1 - 0 add

4 4 lw r4 - 0

5 5 lw r5 - 0

6 6 mult r6 - 0

Al final del ciclo 5 se han introducido las instrucciones 7 y 8, y se han terminado de ejecutar las
instrucciones (1) y (3). También se ha emitido la instrucción 4.
Ciclo 5

# Inst. Codop Reg.Dst Dato OK Unidad

1 1 lw r3 [0x10a] 1 load

2 2 addi r2 128 1 add

3 3 add r1 0x0a 1 add

4 4 lw r4 - 0 load

5 5 lw r5 - 0

6 6 mult r6 - 0

7 7 add r5 - 0

8 8 add r6 - 0
Al terminar el ciclo 6 se habrán retirado las instrucciones (1) y (2). La instrucción (3) no se puede
retirar ya que como máximo se pueden retirar dos instrucciones por ciclo (condiciones del problema
2). También se han introducido las instrucciones (9) y (10) en el ROB.

Ciclo 6

# Inst. Codop Reg.Dst Dato OK Unidad

3 3 add r1 0x0a 1 add
4 4 lw r4 - 0 load
5 5 lw r5 - 0
6 6 mult r6 - 0
7 7 add r5 - 0
8 8 add r6 - 0
9 9 sw - - 0
10 10 sw - - 0

Al final del ciclo 7 se habrá introducido la instrucción (11) en el ROB y se habrá retirado la
instrucción (3). La instrucción (4) ha terminado su ejecución, y se han emitido las instrucciones (5)
y (8).

Ciclo 7

# Inst. Codop Reg.Dst Dato OK Unidad

4 4 lw r4 [0(r1)] 1 load
5 5 lw r5 - 0 load
6 6 mult r6 - 0
7 7 add r5 - 0
8 8 add r6 - 0 add
9 9 sw - - 0
10 10 sw - - 0
11 11 sub r2 - 0

Al final del ciclo 8 se ha retirado la instrucción (4), se ha terminado la ejecución de la (8) y se ha

emitido la instrucción (11).
 Ciclo 8

# Inst. Codop Reg.Dst Dato OK Unidad

5 5 lw r5 - 0 load
6 6 mult r6 - 0
7 7 add r5 - 0
8 8 add r6 r4 + r3 1 add
9 9 sw - - 0
10 10 sw - - 0
11 11 sub r2 - 0 add

Al final del ciclo 9 se ha terminado la ejecución de la instrucción (5), y de la (9). También se ha

emitido la intrucción de multiplicación (6).

Ciclo 9

# Inst. Codop Reg.Dst Dato OK Unidad

5 5 lw r5 [-8(r1)] 1 load
6 6 mult r6 - 0 mult
7 7 add r5 - 0
8 8 add r6 r4 + r3 1 add
9 9 sw - - 1 st
10 10 sw - - 0
11 11 sub r2 - 0 add

Al final del ciclo 10 se habrá terminado la ejecución de la instrucción (11) y se ha retirado la

instrucción (5).
Ciclo 10

# Inst. Codop Reg.Dst Dato OK Unidad

6 6 mult r6 - 0 mult
7 7 add r5 - 0
8 8 add r6 r4 + r3 1 add
9 9 sw - - 1 st
10 10 sw - - 0
11 11 sub r2 112 1 add

Desde el ciclo 10 al ciclo 15, el ROB no sufre ningún cambio (se supone que no hay más
instrucciones que se van introduciendo en el mismo). Al final del ciclo 15 ha terminado la
multiplicación, y se ha emitido la instrucción (7), que dependía de ella.
 Ciclo 15

# Inst. Codop Reg.Dst Dato OK Unidad

6 6 mult r6 r5 * r3 1 mult
7 7 add r5 - 0 add
8 8 add r6 r4 + r3 1 add
9 9 sw - - 1 st
10 10 sw - - 0
11 11 sub r2 112 1 add

Al final del ciclo 16 se habrá retirado la instrucción (6) de multiplicación, termina la ejecución de la
(7), y se emite la instrucción (10), que termina en el ciclo siguiente. Así, finalmente, al finalizar el
ciclo 17 se habrán retirado las instrucciones (7) y (8), al final del 18, la (9) y la (10), y al finalizar el
ciclo 19 se habrá retirado la instrucción (11) y habrá concluido el procesamiento de la secuencia de
instrucciones.

Ciclo 16

# Inst. Codop Reg.Dst Dato OK Unidad

7 7 add r5 r6+r3 1 add
17
8 8 add r6 r4 + r3 1 add
9 9 sw - - 1 st
18
10 10 sw - - 0 st
11 11 sub r2 112 1 add 19

Termina en 17
Ciclos en los
que salen

13 (Ejercicios de clase)
Considere que el fragmento de código siguiente:

subd f2,f2,f1 ; f2 = f2-f1

addd f4,f2,f3 ; f4 = f2+f3
subd f5,f2,f3 ; f5 = f2-f3
multd f6,f2,f3 ; f6 = f2*f3
subd f2, f2,f5 ; f2 = f2-f5
subd f7,f4,f6 ; f7 = f4-f6

se ejecuta en un procesador superescalar capaz de captar, decodificar y emitir (mediante una

ventana de instrucciones centralizada) 3 instrucciones/ciclo, y completar (o retirar) hasta 2
instrucciones/ciclo.

 Si el procesador dispone de un búfer de reordenamiento para permitir la ejecución

desordenada y la finalización ordenada, indique el tiempo de ejecución en el caso de
emisión ordenada (no alineada). ¿Se gana tiempo si la emisión es desordenada (y no
alineada)?
 Para la situación más favorable, ¿qué es mejor aumentar en uno el número unidades de
suma/resta o reducir el tiempo de ejecución de las existentes en una unidad?
  Considerando que f1=2.0, f2=4.0, y f3=5.0 indique cuales serán los valores finales que
tendrán los registros de la arquitectura al final de la ejecución de la secuencia.

Nota: El procesador dispone de 2 unidades de suma/resta (de 2 ciclos), una de multiplicación (de 4
ciclos), y que no hay limitaciones en el número de líneas de la cola de instrucciones, búfer de
reordenamiento, puertos de lectura/escritura, etc.

Solución.
La distribución de etapas del procesador superescalar descrito se muestra en la figura siguiente,
donde no se han representado las estructuras de almacenamiento entre etapas (colas, búferes, etc.).

EX

Suma/Resta

IF ID ROB WB
Suma/Resta
3 ins/ciclo 3 ins/ciclo 2 ins/ciclo

3 ins/ciclo
Multiplicación

(a) En la Tabla siguiente se muestra la evolución temporal del conjunto de instrucciones indicado
para emisión ordenada (no alineada).

Instrucción IF ID EX ROB WB
(1) subd f2,f2,f1 1 2 3-4 5 6
(2) addd f4,f2,f3 1 2 5-6 7 8
(3) subd f5,f2,f3 1 2 5-6 7 8
(4) multd f6,f2,f3 2 3 5-8 9 10
(5) subd f2,f2,f5 2 3 7-8 9 10
(6) subd f7,f4,f6 2 3 9 - 10 11 12

Las instrucciones 2, 3, y 4 han de esperar a que termine de ejecutarse la instrucción 1 para disponer
de su operando f2. La instrucción 5 también tiene que esperar al operando f2, pero como también
necesita f5 que es producida por la instrucción 3 no puede esperar hasta que hasta que ha terminado
ésta. Por otra parte, tampoco podría enviarse dado que no se puede enviar más de tres instrucciones
por ciclo, y se envían las instrucciones 2, 3, y 4 en el ciclo 5. Por otra parte, la instrucción 6 debe
esperar que termine la 4, dado que necesita f6 (también necesita f4, pero la instrucción 2 que lo
produce termina su ejecución antes que la instrucción 4).

Si la emisión es desordenada no se ganaría nada para las instrucciones indicadas ya que lo que
limita su emisión son las dependencias RAW entre ellas. Ninguna instrucción posterior a la
instrucción 1 se puede lanzarse antes del ciclo 5 (la instrucción 1 produce f2 que necesitan las
instrucciones 2, 3, 4, y 5). La instrucción 5 no se puede lanzar antes del ciclo 7 ya que necesita el
valor de f5 que produce la instrucción 3. La instrucción 6 no puede lanzarse antes del ciclo 9 dado
que necesita el valor de f6, que se tiene en el ciclo 8, obtenido por la instrucción 4.

(b) En la figura siguiente se muestra un esquema del uso de los recursos del procesador.

Ciclo 1 2 3 4 5 6 7 8 9 10 11 12
Suma/Resta 1 1 2 2 5 5
1
Suma/Resta 3 3 6 6
1
Producto 4 4 4 4

En ningún momento se retrasa la emisión de una instrucción porque estén ocupadas todas las
unidades funcionales (suma/resta y multiplicación), son las dependencias RAW las que determinan
los tiempos de espera de las instrucciones. Por lo tanto, añadir más unidades funcionales al cauce no
va a afectar al tiempo de ejecución.

Si se reduce el tiempo de las unidades funcionales en un ciclo, la distribución temporal de

instrucciones en las etapas del cauce sería (da igual que la emisión sea emisión ordenada o
desordenada porque lo que sigue determinando los tiempos de espera son las dependencias RAW):

Instrucción IF ID EX ROB WB
(1) subd f2,f2,f1 1 2 3 4 5
(2) addd f4,f2,f3 1 2 4 5 6
(3) subd f5,f2,f3 1 2 4 5 6
(4) multd f6,f2,f3 2 3 4–6 7 8
(5) subd f2,f2,f5 2 3 5 6 8
(6) subd f7,f4,f6 2 3 7 8 9

Por lo tanto, el diseño de unidades funcionales más rápidas es la mejor opción para este trozo de
código.

14 (Examen septiembre 2004)

Suponga un procesador superescalar en el que se decodifican dos instrucciones por ciclo, se emiten
tres instrucciones por ciclo como máximo, y se retiran hasta dos instrucciones por ciclo. La emisión
es desordenada y no alineada y se realiza directamente a las unidades de ejecución, es decir, que el
procesador no dispone de estaciones de reserva. La ejecución también es desordenada, y para
permitir la finalización ordenada, se dispone de un búfer de reordenamiento (ROB) en el que se
introducen las instrucciones una vez decodificadas y del que se retiran en orden una vez que ha
finalizado.

Indique las dependencias entre las instrucciones, los ciclos en los que se emiten para su ejecución y
cómo evolucionaría en búfer de reordenamiento hasta que se hayan retirado todas las instrucciones
de la siguiente secuencia almacenada en la cola de instrucciones captadas:

multd f1, f1, f5 ; f1 = f1 * f5

addd f2, f2, f5 ; f2 = f2 + f5
addd f4, f1, f2 ; f4 = f1 + f2
addd f6, f1, f5 ; f6 = f1 + f5
multd f5, f2, f2 ; f5 = f2 * f2
subd f6, f2, f1 ; f6 = f2 – f1
Suponiendo una frecuencia de 2 GHz, ¿cuánto tarda en procesarse la secuencia de instrucciones?
¿Cuál es la velocidad pico del procesador?

Nota: La suma y la resta consumen 1 ciclo de reloj y la multiplicación tres ciclos. Considere que no
hay limitaciones en la capacidad de los búferes ni en el número de unidades funcionales. Se supone
que f1, f2 y f5 tienen valores previos.

Solución.
Ya que el procesador no dispone de estaciones de reserva, la lógica de emisión tiene que esperar a
que los operandos le sean facilitados por la lógica de bypass, por tanto, las dependencias RAW
afectarán al orden de emisión de las instrucciones. Existen las siguientes dependencias RAW:

 La instrucción 3 depende de f1 producido por la instrucción 1 y f2 producido por la

instrucción 2.
 La instrucción 4 depende de f1 producido por la instrucción 1.
 La instrucción 5 depende de f2 producido por la instrucción 2.
 La instrucción 6 depende de f1 producido por la instrucción 1 y f2 producido por la
instrucción 2.

Teniendo en cuenta estas dependencias, las instrucciones se ejecutarían como se muestra en la

siguiente figura:

Instrucción / Ciclo 1 2 3 4 5 6 7 8
(1) multd f1, f1, f5 ID ISS EX EX EX WB
(2) addd f2, f2, f5 ID ISS EX WB
(3) addd f4, f1, f2 ID ISS EX WB
(4) addd f6, f1, f5 ID ISS EX WB
(5) multd f5, f2, f2 ID ISS EX EX EX WB
(6) subd f6, f1, f2 ID ISS EX WB

A continuación pasamos a describir la evolución del búfer de reordenamiento:

Ciclo 1: # Cod. Op. Dest. Result. Ok

 Se decodifican las instrucciones 1 y 2 1 multd f1 ? 0
y se introducen en el ROB 2 addd f2 ? 0

# Cod. Op. Dest. Result. Ok

Ciclo 2: 1 multd f1 ? 0
 Se decodifican las instrucciones 3 y 4 2 addd f2 ? 0
y se introducen en el ROB 3 addd f4 ? 0
4 addd f6 ? 0

# Cod. Op. Dest. Result. Ok

1 multd f1 ? 0
Ciclo 3:
2 addd f2 f2+f5 1
 Finaliza la instrucción 2
3 addd f4 ? 0
 Se decodifican las instrucciones 5 y 6
4 addd f6 ? 0
y se introducen en el ROB
5 multd f5 ? 0
6 subd f6 ? 0

# Cod. Op. Dest. Result. Ok

1 multd f1 f1*f5 1
2 addd f2 f2+f5 1
Ciclo 5:
3 addd f4 ? 0
 Finaliza la instrucción 1
4 addd f6 ? 0
5 multd f5 ? 0
6 subd f6 ? 0
 # Cod. Op. Dest. Result. Ok
Ciclo 6: 3 addd f4 f1+f2 1
 Se retiran las instrucciones 1 y 2 4 addd f6 f1+f5 1
 Finalizan las instrucciones 3, 4 y 6 5 multd f5 ? 0
6 subd f6 f1–f2 1

Ciclo 7: # Cod. Op. Dest. Result. Ok

 Se retiran las instrucciones 3 y 4 5 multd f5 f2*f2 1
 Finaliza la instrucción 5 6 subd f6 f1–f2 1
Ciclo 8:
# Cod. Op. Dest. Result. Ok
 Se retiran las instrucciones 5 y 6

Si el procesador funciona a 2 GHz, el tiempo de procesamiento sería

8 ciclos * 5×10–10 s/ciclo = 4×10–9 s = 4 ns

Para la calcular la velocidad pico, como sólo se pueden retirar dos instrucciones por ciclo,
suponiendo que no hubiera atascos en el cauce se podrían ejecutar 2 instrucciones por ciclo

2 instr./ciclo * 2×109 ciclos/s = 4 GIPS

15 (Examen febrero 2005)

Suponga un procesador superescalar en que se captan cuatro instrucciones por ciclo, se decodifican
tres instrucciones por ciclo, se emiten tres instrucciones por ciclo como máximo, y se retiran hasta
tres instrucciones por ciclo. La emisión y la ejecución son desordenadas, y las instrucciones, una
vez decodificadas, se introducen en un búfer de reordenamiento (ROB) que permite la finalización
ordenada del procesamiento de las instrucciones.
Indique las dependencias entre instrucciones y cómo evolucionaría el búfer de reordenamiento hasta
que se hayan retirado todas las instrucciones de la secuencia:

addd f1, f1 ,f4 ; f1 = f1 + f4

multd f3, f1, f2 ; f3 = f1 * f2
addd f6, f1, f4 ; f6 = f1 + f4
subd f4, f1, f6 ; f4 = f1 – f6

Suponiendo una frecuencia de 2 GHz, ¿cuánto tarda en procesarse la secuencia de instrucciones?

¿Cuál es la velocidad pico del procesador?

NOTA: La suma y la resta consumen un ciclo de reloj y la multiplicación cuatro ciclos. Considere
que no hay limitaciones en la capacidad de los búferes, y en el número de unidades funcionales. Se
supone que f1, f2, y f4 tienen valores válidos previos.

Solución.
Ya que el procesador no dispone de estaciones de reserva, la lógica de emisión tiene que esperar a
que los operandos le sean facilitados por la lógica de bypass, por tanto, las dependencias RAW
afectarán al orden de emisión de las instrucciones. En concreto, las instrucciones (2), (3) y (4)
dependen del valor de f1 producido por la instrucción (1) y la instrucción (4) depende del valor de
f6 producido por la instrucción (3)

Teniendo en cuenta estas dependencias, las instrucciones se ejecutarían como se muestra en la

siguiente figura:
 Instrucción / Ciclo 1 2 3 4 5 6 7 8 9
(1) addd f1, f1, f4 IF ID/ISS EX ROB WB
(2) multd f3, f1, f2 IF ID/ISS EX EX EX EX ROB WB
(3) addd f6, f1, f4 IF ID/ISS EX ROB WB
(4) subd f4, f1, f6 IF ID/ISS EX ROB WB

A continuación pasamos a describir la evolución del búfer de reordenamiento:

# Cod. Op. Dest. Result. Ok
Ciclo 2:
1 addd f1 ? 0
 Se decodifican las instrucciones (1),
2 multd f3 ? 0
(3) y (3) y se introducen en el ROB
3 addd f6 ? 0
# Cod. Op. Dest. Result. Ok
Ciclo 3: 1 addd f1 ? 0
 Se decodifica la instrucción (4) y se 2 multd f3 ? 0
introducen en el ROB 3 addd f6 ? 0
4 subd f4 ? 0

# Cod. Op. Dest. Result. Ok

Ciclo 4: 1 addd f1 f1 + f4 1
 Finaliza la instrucción (1) y se escribe 2 multd f3 ? 0
el resultado en el ROB 3 addd f6 ? 0
4 subd f4 ? 0

Ciclo 5: # Cod. Op. Dest. Result. Ok

 Se retira la instrucción (1) del ROB 2 multd f3 ? 0
 Finaliza la instrucción (3) y se escribe 3 addd f6 f1 + f4 1
el resultado en el ROB 4 subd f4 ? 0

# Cod. Op. Dest. Result. Ok

Ciclo 6:
2 multd f3 ? 0
 Finaliza la instrucción (4) y se escribe
3 addd f6 f1 + f4 1
el resultado en el ROB
4 subd f4 f1 – f6 1

# Cod. Op. Dest. Result. Ok

Ciclo 8:
2 multd f3 f1 * f2 1
 Finaliza la instrucción (3) y se
3 addd f6 f1 + f4 1
escribe el resultado en el ROB
4 subd f4 f1 – f6 1
Ciclo 9:
 Se retiran las instrucciones (2), (3) # Cod. Op. Dest. Result. Ok
y (4)

Si el procesador funciona a 2 GHz, el tiempo de procesamiento sería

9 ciclos * 5×10–10 s/ciclo = 4,5×10–9 s = 4,5 ns

Para la calcular la velocidad pico, como sólo se pueden retirar dos instrucciones por ciclo,
suponiendo que no hubiera atascos en el cauce se podrían ejecutar 3 instrucciones por ciclo

3 instr./ciclo * 2×109 ciclos/s = 6 GIPS

16 (Examen diciembre 2007)

Suponga un procesador superescalar en el que se decodifican dos instrucciones por ciclo, se emiten
tres instrucciones por ciclo como máximo, y se retiran hasta dos instrucciones por ciclo. La emisión
es desordenada y no alineada y se realiza directamente a las unidades de ejecución, es decir, que el
procesador no dispone de estaciones de reserva. La ejecución también es desordenada, y para
permitir la finalización ordenada, se dispone de un búfer de reordenamiento (ROB) en el que se
introducen las instrucciones una vez decodificadas y del que se retiran en orden una vez que ha
finalizado.
 Indique las dependencias entre las instrucciones, los ciclos en los que se emiten para su ejecución y
cómo evolucionaría en búfer de reordenamiento hasta que se hayan retirado todas las instrucciones
de la siguiente secuencia almacenada en la cola de instrucciones captadas:

multd f1, f1, f5 ; f1 = f1 * f5

addd f2, f2, f5 ; f2 = f2 + f5
divd f4, f1, f2 ; f4 = f1 / f2
addd f6, f1, f5 ; f6 = f1 + f5
multd f5, f2, f2 ; f5 = f2 * f2
subd f6, f2, f1 ; f6 = f2 – f1

Suponiendo una frecuencia de 2 GHz, ¿cuánto tarda en procesarse la secuencia de instrucciones?

¿Cuál es la velocidad pico del procesador?

Nota: La suma y la resta consumen 1 ciclo de reloj, la multiplicación tres ciclos y la división cuatro
ciclos. Considere que sólo hay un multiplicador, un divisor, y dos unidades para sumar/restar, y que
no hay limitaciones en la capacidad de los búferes. Se supone que f1, f2 y f5 tienen valores previos.

Solución.
Para estimar el tiempo de ejecución del programa, hacemos el siguiente diagrama:

Instrucción 1 2 3 4 5 6 7 8 9 10 11 12
multd f1, f1, f5 IF ID EX EX EX ROB WB
addd f2, f2, f5 IF ID EX ROB WB
divd f4, f1, f2 IF ID EX EX EX EX ROB WB
addd f6, f1, f5 IF ID EX ROB WB
multd f5, f2, f2 IF ID EX EX EX ROB WB
subd f6, f2, f1 IF ID EX ROB WB

Como muestra el diagrama anterior, la emisión de las instrucciones (2) y (3) se debe retrasar hasta que se ejecute la
instrucción (1) porque ambas instrucciones dependen del valor de f1, la emisión de la instrucción (5) se debe retrasar un
ciclo porque sólo hay un multiplicador, y la emisión de la instrucción (6) se debe retrasar un ciclo porque sólo se pueden
emitir tres instrucciones por ciclo.
A continuación se describe cómo evolucionaría el búfer de reordenamiento:

Ciclo 1: # Cod. Op. Dest. Result. Ok

 Inicialmente el ROB está vacío
Ciclo 2: # Cod. Op. Dest. Result. Ok
 Se decodifican las instrucciones (1) y (2) y se introducen 1 multd f1 ? 0
en el ROB 2 addd f2 ? 0
Ciclo 3: # Cod. Op. Dest. Result. Ok
 Se decodifican las instrucciones (3) y (4) y se introducen 1 multd f1 ? 0
en el ROB 2 addd f2 ? 0
3 divd f4 ? 0
4 addd f6 ? 0
Ciclo 4: # Cod. Op. Dest. Result. Ok
 Se decodifican las instrucciones (5) y (6) y se introducen 1 multd f1 ? 0
en el ROB 2 addd f2 f2 + f5 1
 La instrucción (2) escribe su resultado 3 divd f4 ? 0
4 addd f6 ? 0
5 multd f5 ? 0
6 subd f6 ? 0
Ciclo 6: # Cod. Op. Dest. Result. Ok
 La instrucción (1) escribe su resultado 1 multd f1 f1 * f5 1
2 addd f2 f2 + f5 1
3 divd f4 ? 0
4 addd f6 ? 0
5 multd f5 ? 0
6 subd f6 ? 0
Ciclo 7: # Cod. Op. Dest. Result. Ok
 Se retiran las instrucciones (1) y (2) 3 divd f4 ? 0
 La instrucción (4) escribe su resultado 4 addd f6 f1 + f5 1
5 multd f5 ? 0
6 subd f6 ? 0
Ciclo 8: # Cod. Op. Dest. Result. Ok
 La instrucción (6) escribe su resultado 3 divd f4 ? 0
4 addd f6 f1 + f5 1
5 multd f5 ? 0
6 subd f6 f2 – f1 1
Ciclo 9: # Cod. Op. Dest. Result. Ok
 La instrucción (5) escribe su resultado 3 divd f4 ? 0
4 addd f6 f1 + f5 1
5 multd f5 f2 * f2 1
6 subd f6 f2 – f1 1
Ciclo 10: # Cod. Op. Dest. Result. Ok
 La instrucción (3) escribe su resultado 3 divd f4 f1 / f2 1
4 addd f6 f1 + f5 1
5 multd f5 f2 * f2 1
6 subd f6 f2 – f1 1
Ciclo 11: # Cod. Op. Dest. Result. Ok
 Se retiran las instrucciones (3) y (4) 5 multd f5 f2 * f2 1
6 subd f6 f2 – f1 1
Ciclo 12: # Cod. Op. Dest. Result. Ok
 Se retiran las instrucciones (5) y (6)

Suponiendo una frecuencia del procesador de 2GHz, el tiempo de ejecución de este fragmento de
código sería:

12 ciclos
T  6  10 9 s  6 ns
2  109 ciclos/s

Teniendo en cuenta que el procesador sólo puede retirar dos instrucciones por ciclo, la velocidad
pico del procesador es:

Rpico = 2 instrucciones/ciclo × 2×109 ciclos/s = 4×109 instrucciones/s = 4 GIPS

17 (Examen septiembre 2006)

Suponga un procesador superescalar en que se captan y decodifican dos instrucciones por ciclo, se
emiten tres instrucciones por ciclo como máximo (con emisión desordenada y no alineada, sin
estaciones de reserva), y se retiran hasta dos instrucciones por ciclo como máximo. La emisión y la
ejecución son desordenadas, y las instrucciones, una vez decodificadas, se introducen en un búfer
de reordenamiento (ROB) que permite la finalización ordenada del procesamiento de las
instrucciones.

Indique las dependencias entre instrucciones, los ciclos en los que se emiten las instrucciones para
su ejecución y cómo evolucionaría el búfer de reordenamiento hasta que se hayan retirado todas las
instrucciones de la siguiente secuencia de instrucciones almacenadas en la cola de instrucciones
captadas:

multd f1, f1, f2; f1 = f1 * f2

addd f3, f3, f2; f3 = f3 + f2
multd f4, f1, f3; f4 = f1 * f3
addd f5, f4, f2; f5 = f4 + f2
addd f3, f1, f3; f3 = f1 + f3
subd f5, f2, f1; f5 = f2 – f1

Suponiendo una frecuencia de 3.0 GHz, ¿cuánto tarda en procesarse la secuencia de instrucciones?
 ¿Cuál es la velocidad pico del procesador?

Nota: La suma y la resta consumen dos ciclos de reloj y la multiplicación cuatro ciclos. Considere
que no hay limitaciones en la capacidad de los búferes, pero sólo tiene un multiplicador y dos
sumadores/restadores. Se supone que f1, f2, y f3 tienen valores válidos previos.

Solución.
Ya que el procesador no dispone de estaciones de reserva, la lógica de emisión tiene que esperar a
que los operandos le sean facilitados por la lógica de bypass, por tanto, las dependencias RAW
afectarán al orden de emisión de las instrucciones. Por otro lado, como se pueden decodificar hasta
dos instrucciones por ciclo y emitir hasta tres, suponemos que cada una de estas tareas se realizarán
en etapas diferentes del cauce. Es decir, que la etapas serán IF para captar instrucciones, ID para
decodificarlas, ISS para emitirlas, EX para ejecutarlas, ROB para escribir los resultados en el ROB
y WB para retirar las instrucciones del cauce. Las dependencias entre instrucciones y los momentos
de emisión de las mismas se muestran en la siguiente figura:

Instrucción / Ciclo 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
multd f1, f1, f2 IF ID ISS EX EX EX EX ROB WB
addd f3, f3, f2 IF ID ISS EX EX ROB WB
multd f4, f1, f3 IF ID ISS EX EX EX EX ROB WB
addd f5, f4, f2 IF ID ISS EX EX ROB WB
addd f3, f1, f3 IF ID ISS EX EX ROB WB
subd f5, f2, f1 IF ID ISS EX EX ROB WB

A continuación pasamos a describir la evolución del búfer de reordenamiento:

Ciclo 2: # Cod. Op. Dest. Result. Ok

 Se decodifican las instrucciones (1) y 1 multd f1 ? 0
(2) y se introducen en el ROB 2 addd f3 ? 0
# Cod. Op. Dest. Result. Ok
Ciclo 3: 1 multd f1 ? 0
 Se decodifican las instrucciones (3) y 2 addd f3 ? 0
(4) y se introducen en el ROB 3 multd f4 ? 0
4 addd f5 ? 0

# Cod. Op. Dest. Result. Ok

1 multd f1 ? 0
Ciclo 4: 2 addd f3 ? 0
 Se decodifican las instrucciones (5) y 3 multd f4 ? 0
(6) y se introducen en el ROB 4 addd f5 ? 0
5 addd f1 ? 0
6 subd f5 ? 0
# Cod. Op. Dest. Result. Ok
1 multd f1 ? 0
Ciclo 6: 2 addd f3 f3 + f2 1
 Finaliza la instrucción (2) y se escribe 3 multd f4 ? 0
el resultado en el ROB 4 addd f5 ? 0
5 addd f1 ? 0
6 subd f5 ? 0
# Cod. Op. Dest. Result. Ok
1 multd f1 f1 * f2 1
Ciclo 8: 2 addd f3 f3 + f2 1
 Finaliza la instrucción (1) y se escribe 3 multd f4 ? 0
el resultado en el ROB 4 addd f5 ? 0
5 addd f1 ? 0
6 subd f5 ? 0
# Cod. Op. Dest. Result. Ok
3 multd f4 ? 0
Ciclo 9:
4 addd f5 ? 0
 Se retiran las instrucciones (1) y (2)
5 addd f1 ? 0
6 subd f5 ? 0
 # Cod. Op. Dest. Result. Ok
Ciclo 10:
3 multd f4 ? 0
 Finalizan las instrucciones (5) y (6)
4 addd f5 ? 0
y se escriben los resultados en el
5 addd f1 f1 + f3 1
ROB
6 subd f5 f2 – f1 1
# Cod. Op. Dest. Result. Ok
Ciclo 12: 3 multd f4 f1 * f3 1
 Finaliza la instrucción (3) y se 4 addd f5 ? 0
escribe el resultado en el ROB 5 addd f1 f1 + f3 1
6 subd f5 f2 – f1 1
# Cod. Op. Dest. Result. Ok
Ciclo 13: 4 addd f5 ? 0
 Se retira la instrucción (3) 5 addd f1 f1 + f3 1
6 subd f5 f2 – f1 1
# Cod. Op. Dest. Result. Ok
Ciclo 14:
4 addd f5 f4 + f2 1
 Finaliza la instrucción (4) y se
5 addd f1 f1 + f3 1
escribe el resultado en el ROB
6 subd f5 f2 – f1 1
Ciclo 15: # Cod. Op. Dest. Result. Ok
 Se retiran las instrucciones (4) y (5) 6 subd f5 f2 – f1 1
Ciclo 16:
# Cod. Op. Dest. Result. Ok
 Se retira la instrucción (6)

Si el procesador funciona a 3 GHz, el tiempo de procesamiento sería

16 ciclos * 3,3×10–10 s/ciclo = 5,3×10–9 s = 5,3 ns

Para la calcular la velocidad pico, como sólo se pueden retirar dos instrucciones por ciclo,
suponiendo que no hubiera atascos en el cauce se podrían ejecutar 3 instrucciones por ciclo

2 instr./ciclo * 3×109 ciclos/s = 6 GIPS

18 (Examen septiembre 2005)

Suponga un procesador superescalar en que se decodifican dos instrucciones por ciclo, se emiten
tres instrucciones por ciclo como máximo (con emisión desordenada y no alineada, sin estaciones
de reserva), y se retiran hasta dos instrucciones por ciclo como máximo. La emisión y la ejecución
son desordenadas, y las instrucciones, una vez decodificadas, se introducen en un búfer de
reordenamiento (ROB) que permite la finalización ordenada del procesamiento de las instrucciones.

Indique las dependencias entre instrucciones, los ciclos en los que se emiten las instrucciones para
su ejecución y cómo evolucionaría el búfer de reordenamiento hasta que se hayan retirado todas las
instrucciones de la siguiente secuencia de instrucciones almacenadas en la cola de instrucciones
captadas:

multd f1,f1,f2; f1=f1*f2

addd f3,f3,f2; f3=f3+f2
multd f4,f1,f3; f4=f1*f3
addd f6,f4,f2; f6=f4+f2
addd f3,f1,f3; f3=f1+f3
subd f6,f2,f1; f6=f2-f1

Suponiendo una frecuencia de 3.0 GHz, ¿cuánto tarda en procesarse la secuencia de instrucciones?
¿Cuál es la velocidad pico del procesador?
Nota: La suma y la resta consumen dos ciclos de reloj y la multiplicación cuatro ciclos. Considere
que no hay limitaciones en la capacidad de los búferes, pero sólo tiene un multiplicador y dos
sumadores/restadores. Se supone que f1, f2, y f3 tienen valores válidos previos.

Solución.
Ya que el procesador no dispone de estaciones de reserva, la lógica de emisión tiene que esperar a
que los operandos le sean facilitados por la lógica de bypass, por tanto, las dependencias RAW
afectarán al orden de emisión de las instrucciones. Existen las siguientes dependencias RAW:

 La instrucción 3 depende de f1 producido por la instrucción 1 y f3 producido por la

instrucción 2.
 La instrucción 4 depende de f4 producido por la instrucción 3.
 La instrucción 5 depende de f1 producido por la instrucción 1 y f3 producido por la
instrucción 2.
 La instrucción 6 depende de f1 producido por la instrucción 1.

Teniendo en cuenta estas dependencias, las instrucciones se ejecutarían como se muestra en la

siguiente figura:

Instrucción / Ciclo 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
(1) multd f1, f1, f2 ID ISS EX EX EX EX ROB WB
(2) addd f3, f3, f2 ID ISS EX EX ROB WB
(3) addd f4, f1, f3 ID ISS EX EX EX EX ROB WB
(4) addd f6, f4, f2 ID ISS EX EX ROB WB
(5) multd f3, f1, f3 ID ISS EX EX ROB WB
(6) subd f6, f2, f1 ID ISS EX EX ROB WB

A continuación pasamos a describir la evolución del búfer de reordenamiento:

Ciclo 1: # Cod. Op. Dest. Result. Ok

 Se decodifican las instrucciones 1 y 2 1 multd f1 ? 0
y se introducen en el ROB 2 addd f3 ? 0

# Cod. Op. Dest. Result. Ok

Ciclo 2: 1 multd f1 ? 0
 Se decodifican las instrucciones 3 y 4 2 addd f3 ? 0
y se introducen en el ROB 3 addd f4 ? 0
4 addd f6 ? 0

# Cod. Op. Dest. Result. Ok

1 multd f1 ? 0
Ciclo 3: 2 addd f3 ? 0
 Se decodifican las instrucciones 5 y 6 3 addd f4 ? 0
y se introducen en el ROB 4 addd f6 ? 0
5 multd f3 ? 0
6 subd f6 ? 0

# Cod. Op. Dest. Result. Ok

1 multd f1 ? 0
2 addd f3 f3+f2 1
Ciclo 5:
3 addd f4 ? 0
 Finaliza la instrucción 2
4 addd f6 ? 0
5 multd f3 ? 0
6 subd f6 ? 0
 # Cod. Op. Dest. Result. Ok
1 multd f1 f1*f2 1
2 addd f3 f3+f2 1
Ciclo 7:
3 addd f4 ? 0
 Finaliza la instrucción 1
4 addd f6 ? 0
5 multd f3 ? 0
6 subd f6 ? 0

# Cod. Op. Dest. Result. Ok

3 addd f4 ? 0
Ciclo 8:
4 addd f6 ? 0
 Se retiran las instrucciones 1 y 2
5 multd f3 ? 0
6 subd f6 ? 0

# Cod. Op. Dest. Result. Ok

3 addd f4 ? 0
Ciclo 9:
4 addd f6 ? 0
 Finalizan las instrucciones 5 y 6
5 multd f3 f1+f3 1
6 subd f6 f2–f1 1

# Cod. Op. Dest. Result. Ok

3 addd f4 f1*f3 1
Ciclo 11:
4 addd f6 ? 0
 Finaliza la instrucción 3
5 multd f3 f1+f3 1
6 subd f6 f2–f1 1

# Cod. Op. Dest. Result. Ok

Ciclo 12: 4 addd f6 ? 0
 Se retira la instrucción 3 5 multd f3 f1+f3 1
6 subd f6 f2–f1 1
# Cod. Op. Dest. Result. Ok
Ciclo 13: 4 addd f6 f4+f2 1
 Finaliza la instrucción 4 5 multd f3 f1+f3 1
6 subd f6 f2–f1 1
Ciclo 14: # Cod. Op. Dest. Result. Ok
 Se retiran las instrucciones 4 y 5 6 subd f6 f2–f1 1
Ciclo 15:
# Cod. Op. Dest. Result. Ok
 Se retira la instrucción 6

Si el procesador funciona a 3 GHz, el tiempo de procesamiento sería

15 ciclos * 3,33×10–10 s/ciclo = 5×10–9 s = 5 ns

Para la calcular la velocidad pico, como sólo se pueden retirar dos instrucciones por ciclo,
suponiendo que no hubiera atascos en el cauce se podrían ejecutar 2 instrucciones por ciclo

2 instr./ciclo * 3×109 ciclos/s = 6 GIPS

19 (Examen febrero 2007)

Considere que el fragmento de código siguiente:

(1) lf f3, 0(r1) (7) multf f6, f6, f4

(2) lf f2, 8(r1) (8) sf 8(r2), f6
(3) addf f4, f2, f3 (9) addi r3, r2, #32
(4) sf 16(r1), f4 (10) lf f7, 0(r3)
(5) lf f5, 16(r2) (11) multf f8, f7, f3
(6) addf f6, f5, f2 (12) sf 0(r3), f8

se ejecuta en un procesador superescalar que es capaz de captar (IF), decodificar/emitir (ID/ISS) y

finalizar (WB) 4 instrucciones/ciclo. El procesador utiliza un ROB para realizar el renombramiento
y la finalización ordenada y dispone de tres estaciones de reserva de 3 líneas cada una (una para las
instrucciones de acceso a memoria, otra para las operaciones de coma flotante, y otra para las
operaciones con enteros). Las estaciones de reserva pueden enviar una instrucción por ciclo a cada
una de las unidades funcionales conectadas a ellas (la velocidad de envío depende, por tanto, del
número de unidades que estén conectadas a cada estación). El procesador permite los
adelantamientos de stores por loads no especulativos, pero no permite los especulativos.

a) Indique el número de ciclos que tardaría en ejecutarse el conjunto de instrucciones anterior

suponiendo envío desordenado desde las estaciones de reserva a las unidades funcionales.
b) ¿Y si el envío fuera ordenado desde las estaciones de reserva para operaciones con enteros y
operaciones con datos en coma flotante, pero desordenado para la estación de acceso a
memoria?

NOTA: Considere que, conectadas a la estación de reserva para el acceso a memoria, tiene una
unidad funcional de carga con un retardo de dos ciclos y una de almacenamiento con retardo de un
ciclo; conectadas a la estación de reserva para enteros tiene dos ALUs con retardo de un ciclo; y,
conectadas a la estación de reserva para coma flotante tiene una unidad de multiplicación con cinco
ciclos de retardo y dos unidades de suma con dos ciclos de retardo. No hay límite en el número de
líneas de la cola de instrucciones y del ROB).

Solución.
Suponiendo un envío desordenado para todas las estaciones de reserva, el código tardaría 28 ciclos
en ejecutarse, tal y como se muestra en el siguiente diagrama:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
(1) lf f3, 0(r1) IF ID EX EX ROB WB
(2) lf f2, 8(r1) IF ID X X EX EX ROB WB
(3) addf f4, f2, f3 IF ID EX EX ROB WB
(4) sf 16(r1), f4 IF ID EX WB
(5) lf f5, 16(r2) IF ID EX EX ROB WB
(6) addf f6, f5, f2 IF ID EX EX ROB WB
(7) multf f6, f6, f4 IF ID EX EX EX EX EX ROB WB
(8) sf 8(r2), f6 IF X X ID EX WB
(9) addi r3, r2, #32 IF X ID EX ROB WB
(10) lf f7, 0(r3) IF X X X X X ID EX EX ROB WB
(11) multf f8, f7, f3 IF X X X X X ID EX EX EX EX EX ROB WB
(12) sf 0(r3), f8 IF X X X X X X ID EX WB

En el enunciado se especifica que las cargas podrán adelantar a los almacenamientos siempre que
no sean especulativas, es decir cuando se sepa que va a acceder a direcciones de memoria
diferentes. Las instrucciones (5) y (4), acceden a memoria con el mismo desplazamiento y dos
registros índice diferentes (r2 y r1), con lo que si r2 tuviera un valor diferente al de r1, la
instrucción (5) podría adelantar a la (4). Como no sabemos los valores de estos registros, se ha
supuesto el peor caso, que es la coincidencia de r1 y r2, lo que obliga a que la instrucción (5)
tenga que esperar a la (4). Por otro lado, las instrucciones (10) y (8) acceden a posiciones de
memoria diferentes, ya que la instrucción (8) almacena en la posición 8+r2 y la instrucción (10) lee
de la posición 0+r3 = 32+r2. Como suponemos que las direcciones efectivas se calculan en el
primer ciclo de la etapa de ejecución de las instrucciones de acceso a memoria, aunque las
direcciones finales sean diferentes, este hecho no se puede comprobar por la lógica de envío de la
estación de reserva, lo que obliga a enviar primero el almacenamiento y luego la carga. Estas dos
dependencias están marcadas en el diagrama mediante flechas de color amarillo.

Las colisiones que se producen en el cauce están marcadas con el símbolo X. Estas colisiones
pueden ser bien en las estaciones de reserva o en las unidades de ejecución. Como las estaciones de
reserva tienen sólo tres entradas cada una, cuando alguna se llena no permite que se puedan emitir
más instrucciones hacia ella hasta que envíe alguna instrucción y deje algún hueco. Este fenómeno
se puede apreciar en la instrucción (8), que no puede entrar hasta que se envía la instrucción (2) y se
quedan en la estación de reserva las instrucciones (4) y (5). También se crea un cuello de botella en
la estación de reserva de acceso a memoria con la instrucción (10), que no puede emitirse hasta que
se envía la instrucción (4), y que retrasa la emisión de la instrucción (11), ya que la emisión es
ordenada. Por último, la instrucción (12) se bloqueará en la cola de instrucciones hasta que se envíe
a ejecutar la instrucción (5).

En cuanto a las colisiones en las unidades de ejecución, la instrucción (2) debe esperar a que la (1)
libere la unidad de carga, y lo mismo ocurre entre las instrucciones (11) y (7) por el multiplicador y
entre las instrucciones (10) y (5) al acceder a memoria.

Por último, los riesgos de datos adelantados por los caminos de bypass están marcados mediante
flechas negras en el diagrama.

En el caso de que el envío fuese desordenado sólo para la estación de reserva de acceso a memoria,
el resultado sería exactamente el mismo, ya que debido a los riesgos del programa, todas las
instrucciones se han enviado ordenadamente.

20 (Examen septiembre 2005)

En la ejecución de una programa una instrucción se salto condicional (salta a una dirección anterior)
genera la secuencia de saltos (S) y no saltos (N) siguiente:

SSSSN SSSSN SSNSS NSSSN NNNN

Indique la penalización que se introduce si se utiliza:

a) Predicción fija (siempre se considera que se va a producir el salto)
b) Predicción estática (si el desplazamiento es negativo se toma y si es positivo no)
c) Predicción dinámica con dos bits, inicialmente en el estado (11).

Nota: La penalización por saltos incorrectamente predichos es de 5 ciclos y para los saltos
correctamente predichos es 0 ciclos.

Solución.
En el primer caso, con predicción fija, se predecirá siempre que se va a producir el salto, por lo que
se sufrirá una penalización en aquellas ocasiones que las que no se produzca el salto. Para la
secuencia de saltos del enunciado tenemos:

Predicción S S S S S S S S S S S S S S S S S S S S S S S S
Secuencia S S S S N S S S S N S S N S S N S S S N N N N N
Penalización P P P P P P P P P

Si la penalización es P = 5 ciclos, al final se pierden 9 · P = 9 · 5 = 45 ciclos.

En el caso de usar un predictor estático, como el salto es hacia atrás, el predictor estimará que
siempre se va a producir el salto, con lo que el resultado es exactamente igual al anterior,
produciéndose una penalización de 45 ciclos.

En el último caso se utiliza un predictor dinámico de 2 bits inicializado al valor 11 (saltar). Para la
secuencia anterior tenemos las siguientes predicciones:
Estado 11 11 11 11 11 10 11 11 11 11 10 11 11 10 11 11 10 11 11 11 10 01 00 00
Predicción S S S S S S S S S S S S S S S S S S S S S N N N
Secuencia S S S S N S S S S N S S N S S N S S S N N N N N
Penalización P P P P P P

En este caso la penalización es 6 · P = 6 · 5 = 30 ciclos.

21 (Ejercicios de clase)
En un programa, una instrucción de salto condicional (a una dirección de salto anterior) dada tiene
el siguiente comportamiento en una ejecución de dicho programa:

SSNNNSSNSNSNSSSSSN

donde S indica que se produce el salto y N que no

Indique la penalización efectiva que se introduce si se utiliza:

a) Predicción fija (siempre se considera que se no se va a producir el salto)

b) Predicción estática (si el desplazamiento es negativo se toma y si es positivo no)
c) Predicción dinámica con dos bits, inicialmente en el estado (11).
d) Predicción dinámica con tres bits, inicialmente en el estado (111).

Nota: La penalización por saltos incorrectamente predichos es de 5 ciclos y para los saltos
correctamente predichos es 0 ciclos.

Solución.
A continuación se van a ir considerando cada uno de los esquemas de predicción indicados:

(a) Predicción Fija. En el esquema de predicción fija considerado hay penalización cuando se
produce el salto. Es decir en el caso de S (marcadas en negrita):

SSNNNSSNSNSNSSSSSN

como hay 11 casos, la penalización es igual a 11 * 5 = 55 ciclos.

(b) Predicción Estática. Teniendo en cuenta que se predice salto si éste es hacia direcciones
menores, como es el caso que aquí se considera, habrá penalización cuando no se produzca el salto:
N en la secuencia considerada (marcadas en negrita).

SSNNNSSNSNSNSSSSSN

como hay 7 casos, la penalización es igual a 7 *5 = 35 ciclos

(c) Predicción Dinámica (con dos bits de historia).

En la Tabla se muestran las penalizaciones para cada una de las 18 veces que se ejecuta la
instrucción de salto. La última fila muestra las predicciones que se hacen cada vez que se ejecuta la
instrucción de salto.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
S S N N N S S N S N S N S S S S S N
P P P P P P P P P P P
S S S S N N N S N S N S N S S S S S
 3 4,8,10,12 5
NS NS NS
S 11 (S) 10 (S) 01 (NS) 00 (NS)

S S S
1,2,15 14 7,9,11,13 6

Situación
Inicial

La justificación de esas penalizaciones (tercera fila) se obtiene a partir del diagrama de estados del
esquema de predicción dinámica con dos bits, en el que se han marcado las transiciones ocasionadas
por cada ejecución de la instrucción de salto (1, 2,...., 18).

Como hay error de predicción en 11 casos, se tiene que la penalización es igual a 11* 5 =55 ciclos.

(d) Predicción Dinámica (con tres bits de historia)

En la Tabla que se muestra a continuación se indican los bits de historia que existen antes de que se
ejecute la instrucción, la predicción que determinan esos bits, y lo que finalmente ocurre (según se
indica en la secuencia objeto del problema). La última columna indica si ha habido penalización (no
coinciden la predicción y lo que ocurre al final).

Bits de Predicción Ocurre Penalización Número de

Historia Ejecución
111 S S 1
111 S S 2
111 S N P 3
011 S N P 4
001 N N 5
000 N S P 6
100 N S P 7
110 S N P 8
011 S S 9
101 S N P 10
010 N S P 11
101 S N P 12
010 N S P 13
101 S S 14
110 S S 15
111 S S 16
111 S S 17
111 S N P 18

Hay error de predicción en 10 casos, por lo tanto la penalización es de 10 * 5 = 50 ciclos

Como se puede ver, en la secuencia de ejecuciones de la instrucción de salto considerada en este

problema, el mejor esquema de predicción es la predicción estática que aquí se utiliza. El esquema
de predicción de salto dinámico con dos bits es igual de bueno (o malo) que la predicción fija.

Así, se puede indicar que la eficacia de un esquema de salto depende del perfil de saltos a que de
lugar la correspondiente instrucción de salto condicional. En la práctica, los esquemas de predicción
dinámica suelen funcionar mejor que los de predicción estática porque las instrucciones de salto
suelen repetir el comportamiento de su ejecución previa. En ese sentido, la secuencia utilizada en
este problema es bastante atípica.

22 (Benchmark diciembre 2005)

Un procesador utiliza un esquema de predicción dinámica de saltos de dos niveles similar al del
Pentium III: tres bits de historia se utilizan para indicar si en las tres últimas ejecuciones de la
instrucción hubo o no hubo salto, y esos tres bits de historia sirven de puntero a 8 contadores de dos
bits, cada uno de los cuales se utiliza para realizar la predicción correspondiente según su estado
como en un esquema de predicción de dos bits. En la primera ejecución, los tres bits que apuntan a
los contadores de dos bits están a 000 y los bits de los contadores de dos bits se inicializan a 00
(predice no saltar) si la instrucción de salto es hacia adelante y a 11(predice saltar) si el salto es
hacia atrás. Si la predicción es correcta no hay ciclos de penalización y si es correcta hay cuatro
ciclos.
¿Cual es la penalización para la secuencia de instrucciones de salto que se indica a continuación

N1S2N3N1N2S3 N1S2N3 S1S2N3

teniendo en cuenta que S significa que la instrucción dará lugar a un salto, N que no dará lugar a un
salto y cada subíndice, 1, 2, 3 hace referencia a una instrucción de salto distinta?

(Nota: La instrucción 1 es de salto hacia atrás y las 2 y 3 de salto hacia adelante).

Solución.
Se deben considerar cada una de las instrucciones de salto por separado.

Así, para la instrucción de salto 1 se tiene

N1S2N3N1N2S3 N1S2N3 S1S2N3

y por lo tanto se produce NNNS

En la siguiente tabla se muestran los resultados para esta instrucción de salto (hacia atrás):

Puntero de 3 Contador de Se predice Se produce Penalización

bits 2 bits (al que
apunta el
puntero de 3
bits)
000 11 S N P
000 10 S N P
000 01 N N -
000 00 N S P

Para la instrucción de salto 2 se tiene

N1S2N3N1N2S3 N1S2N3 S1S2N3

con lo que la secuencia de saltos y no saltos para esta instrucción es SNSS, y en la tabla siguiente se
muestran los resultados para esta instrucción de salto hacia delante.
 Puntero de 3 Contador de Se predice Se produce Penalización
bits 2 bits (al que
apunta el
puntero de 3
bits)
000 00 N S P
100 00 N N -
010 00 N S P
100 00 N S P

Finalmente, para la instrucción de salto 3 se tiene

N1S2N3N1N2S3 N1S2N3 S1S2N3

con lo que la secuencia de saltos y no saltos para esta instrucción es NSNN, y en la tabla siguiente
se muestran los resultados para esta instrucción de salto hacia delante.

Puntero de 3 Contador de Se predice Se produce Penalización

bits 2 bits (al que
apunta el
puntero de 3
bits)
000 00 N N -
000 00 N S P
100 00 N N -
010 00 N N -

De esta forma el número de fallos de predicción es 7. Teniendo en cuenata que cada uno de ellos
supone una penalización de cuatro ciclos, el número de ciclos de penalización total es 7*4=28
ciclos.

23 (Benchmark diciembre 2006)

Un procesador utiliza un esquema de predicción dinámica de saltos de dos niveles similar al del
Pentium III: tres bits de historia se utilizan para indicar si en las tres últimas ejecuciones de la
instrucción hubo o no hubo salto, y esos tres bits de historia sirven de puntero a 8 contadores de dos
bits, cada uno de los cuales se utiliza para realizar la predicción correspondiente, según su estado,
como en un esquema de predicción dinámica de dos bits. En la primera ejecución, los tres bits que
apuntan a los contadores de dos bits están a 000 y los bits de los contadores de dos bits se
inicializan a 00 (predice no saltar) si la instrucción de salto es hacia adelante, y a 11(predice saltar)
si el salto es hacia atrás. Si la predicción es correcta no hay ciclos de penalización y si es incorrecta
hay cuatro ciclos.
¿Cual es la penalización para el bucle que se indica a continuación, para 1<d<8?

for (i=1 ; i<=10 ; i++)

{
b[i]=a[i]+d;
d=d+1;
if (d>8) then goto etiqueta;
}
etiqueta: ......
Compárelo con un esquema de predicción estática que predice saltar si el salto es hacia atrás y no
saltar si el salto es hacia adelante.

Solución.
Una vez traducido el código a ensamblador tendría un aspecto similar a este:

bucle: …
…
saltar a etiqueta ;S
…
…
saltar a bucle ; SB
etiqueta: …
…

En este código hay dos saltos, que a partir de ahora notaremos como S y S B (si saltan) o N y N B (si
no saltan). Para valores de d tales que 1 < d < 8 el patrón de saltos del código es:

(NSB)8 – d S

es decir, que el salto del bucle siempre se va a tomar y el salto hacia delante no se tomará nunca
excepto la última vez, en la que se saldrá del bucle y continuará hacia delante. Como tenemos un
predictor dinámico de dos niveles, para cada salto habrá un conjunto de 8 contadores de dos bits,
que se inicializarán a 00 para el salto hacia delante y a 11 para el salto hacia atrás, y se seleccionará
uno de estos 8 contadores para hacer la predicción en función del los 3 bits de historia (según el
comportamiento del salto en las últimas tres iteraciones).

Salto hacia atrás Salto hacia delante

Iter. Hist. Cont. Estado Pred. Ejec. Hist. Cont. Estado Pred. Ejec.
1 000 0 11 SB SB 000 0 00 N N
2 001 1 11 SB SB 000 0 00 N N
3 011 3 11 SB SB 000 0 00 N N
4 111 7 11 SB SB 000 0 00 N N
… … … … … … … … … … …
Última 111 7 11 — — 000 0 00 N S

Según estas tablas, en la última iteración el salto del bucle no se llega a ejecutar, ya que se sale del
bucle por el salto hacia delante. Los predictores aciertan en el comportamiento del salto hacia atrás,
que se toma todas las veces, en todas las ejecuciones del salto hacia delante menos en la última, por
lo que sólo se equivocan una vez. Por tanto, la penalización total es de:

P = 1 fallo × 4 ciclos = 4 ciclos

En el caso de que el mecanismo de predicción fuera estático, se usaría el mismo predictor para
todos los saltos. Este predictor, según el enunciado del problema, realizaría la siguiente predicción:

(NSB)8 – d N

Como el comportamiento del fragmento de código es

(NSB)8 – d S
se equivocaría en el último salto, con lo que volvemos a obtener una penalización de

P = 1 fallo × 4 ciclos = 4 ciclos

24 (Ejercicios de clase)
Considere el bucle:

for (i=1;i<=10;i++)
{
b[i]=a[i]*c;
c=c+1;
if (c>10) then goto etiqueta;
}
etiqueta:......

Indique cuál es la penalización efectiva debida a los saltos, en función del valor inicial de c (número
entero), considerando que el procesador utiliza:

a) Predicción fija (siempre se considera que se va a producir el salto)

b) Predicción estática (si el desplazamiento es negativo se toma y si es positivo no)
c) Predicción dinámica con un bit (1= Saltar; 0 = No Saltar; Inicialmente está a 1)

Nota: La penalización por saltos incorrectamente predichos es de 4 ciclos y para los saltos
correctamente predichos es 0 ciclos.

Solución.
El perfil de saltos que se produce en el bucle depende del valor inicial de la variable c. Se pueden
distinguir tres casos:

(1) c ≤ 0 : La secuencia de saltos es (N significa que no se salta, y S que se salta)

N Sb N Sb N Sb ...... N Sb N Nb = (N Sb)9 N Nb

donde el índice b se utiliza para designar a la instrucción que controla las iteraciones del bucle (una
instrucción de salto condicional hacia atrás) y distinguirla de la instrucción de salto condicional que
hay dentro del bucle (salto hacia delante, para la que no se utiliza índice). En este caso, se ejecutan
todas las iteraciones del bucle.

(2) 1 ≤ c < 10 :
Si c = 9 N Sb S
Si c = 8 N Sb N Sb S
............................................
Es decir, que se tiene
(N Sb) (10-c) S

(3) 10 ≤ c : La secuencia de saltos es

S

Ya que no se realizaría ninguna iteración completa, al verificarse la condición de salto de la

instrucción condicional que hay dentro del bucle.
Una vez obtenidas las posibles secuencias de saltos / no saltos correspondientes a los distintos
valores posibles de c, se pasa a considerar cada uno de los esquemas de predicción indicados:

a) Predicción Fija (considerando que siempre se salta):

1. (N Sb) ocasiona penalización debido a N, es decir 4 ciclos; N y Nb ocasionan otros 4

ciclos cada una, por lo que
(N Sb)9 N Nb da lugar a 9 x 4 + 4 + 4 = 44 ciclos de penalización
(10-c)
2. Como (N Sb) da lugar a 4 ciclos de penalización y S a ninguno, se tiene que (N Sb)
S da lugar a 4*(10-c) ciclos de penalización.

3. S no da lugar a ninguna penalización en este esquema.

b) Predicción Estática (Se predice salto en los saltos a direcciones menores y no saltar a las
mayores.

En este tipo de predicción, N y Sb no dan lugar a penalización, y S y Nb dan lugar a una

penalización igual a 4 ciclos

1. (N Sb) 9 N Nb da lugar a una penalización de 9*0 + 0 + 4 = 4 ciclos

2. (N Sb) (10-c) S da lugar a una penalización de (10-c) * 0 + 4 = 4 ciclos
3. S da lugar a una penalización de 4 ciclos

Por consiguiente, para cualquier valor de c, este esquema de predicción siempre da lugar a 4
ciclos de penalización.

c) Predicción dinámica con 1 bit de historia

Se considera que inicialmente el bit es igual a 1, prediciendo que se produce el salto. El

diagrama de estados correspondiente a este esquema de predicción es el siguiente (se
predice lo último que ocurrió):
Salta

1 0
Salta (Saltar) (NoSaltar)

No Salta

1. (N Sb) 9 N Nb ocasiona una penalización debida al primer N y al último Nb, por lo que
hay 4 + 4 = 8 ciclos de penalización (un fallo por cada instrucción).
2. (N Sb) (10-c) S ocasiona una penalización debida al primer N y al último S, por lo que hay
4 +4 = 8 ciclos de penalización (las dos asociadas a la instrucción que hay dentro del
bucle).
3. Este último caso no da lugar a penalización porque la predicción inicial para toda
instrucción de salto es, precisamente, que se produce el salto.

25 (Ejercicios de clase)
En la situación descrita en el problema anterior. ¿Cuál de los tres esquemas es más eficaz por
término medio si hay un 25% de probabilidades de que c sea menor o igual a 0, un 30% de que sea
mayor o igual a 10; y un 45% de que sea cualquier número entre 1 y 9, siendo todos equiprobables?
Solución.
Para resolver el problema se tendrán en cuenta los valores de las penalizaciones para cada valor de
la variable c, y las probabilidades de cada uno de esos valores.

(a) Predicción fija (se tiene en cuenta que todos los valores de c entre 1 y 9 son equiprobables):

0 .4 5
P  4 4 * 0 .2 5  
c  1 ,., 9
4 * (1 0  c ) * (
9
)  11 9  20

(Para valores mayores o iguales a 10 la penalización es 0)

(b) Predicción estática: La penalización es igual a 4 ciclos dado que toma este valor para todo c.

(c) Predicción dinámica (con 1 bit de historia):

P = 8*0.25 + 8*0.45 = 8 * 0.7 = 5.6 ciclos

Como se puede ver, para este bucle, y para la distribución de probabilidad de los valores de c, el
esquema de predicción más eficiente corresponde a la predicción estática. No obstante, como se ha
visto, esta situación depende de las probabilidades de los distintos valores de c. Si, por ejemplo, la
probabilidad de que c esté entre 1 y 9 es de 0.15, la penalización para la predicción dinámica con 1
bit de historia sería de 8*0.4=3.2 ciclos, mientras que la predicción estática seguiría presentando
una penalización de 4 ciclos.

26 (Benchmark diciembre 2004)

En la secuencia de instrucciones DLX siguientes:

addi r1,r0,#6 ; r1 = 6
add r4,r0,r1 ; r4 = r1
lw r2,dato ; r2 = dato
inicio: subi r3,r1,r2 ; r3 = r1 – r2
beqz r3, final ; si r3=0 saltar a final
addf f3,f2,f1 ; f3 = f2 + f1
addi r2,r2,#1 ; r2 = r2 + 1
subi r4,r4,#1 ; r4 = r4 – 1
bnez r4,inicio ; saltar a inicio si r4 es distinto de 0
final:

Indique cuál es la penalización efectiva debida a los saltos, en función del valor inicial de dato
(número entero mayor o igual que cero), considerando:

a) Que el procesador utiliza predicción estática (si el salto es hacia atrás predice saltar y si es
hacia delante no saltar).

b) Que el procesador utiliza predicción dinámica con un bit, suponiendo que el estado inicial es
1 (es decir, predice saltar) si el salto es hacia atrás, y 0 (es decir, predice no saltar) si el salto
es hacia adelante.

c) Que el procesador utiliza predicción dinámica con dos bits, suponiendo que el estado inicial
es 11 (es decir, predice saltar) si el salto es hacia atrás, y 00 (es decir, predice no saltar) si el
salto es hacia adelante.
 d) ¿Cuál es la penalización media en cada uno de los casos anteriores si la probabilidad de que
dato sea menor que 5 es un 70%?

Nota: La penalización por saltos incorrectamente predichos es de 4 ciclos y para los saltos
correctamente predichos es 0 ciclos.

Solución.
En el trozo de código del enunciado aparecen dos saltos, el primero hacia delante, que notaremos
como S o N, dependiendo de si salta o no, y el segundo, que es el salto de control del bucle, que
notaremos como SB o NB. Lo primero que hay que hacer es encontrar los patrones que describen el
comportamiento de los saltos en función del valor que tenga la variable dato:

 Si dato = 0 o dato ≥ 7, la ejecución de los saltos será: (NSB)5 NNB.

 Si 0 < dato < 7, la ejecución de los saltos será: (NSB)6 – dato S.

Una vez que tenemos el comportamiento que tendrán los saltos, solo nos queda ver cómo le afectan
los distintos predictores:

(a) El predictor estático predice los saltos hacia delante como no tomados y los saltos hacia atrás
como tomados, así las predicciones serían:

 Si dato = 0 o dato ≥ 7, la ejecución será: (NSB)5 NNB.

la predicción será: (NSB)5 NSB.

El predictor se equivoca sólo en el último salto, por tanto, la penalización será de:

P = 1 fallo × 4 ciclos/fallo = 4 ciclos

 Si 0 < dato < 7, la ejecución será: (NSB) 6 – dato S.

la predicción será: (NSB) 6 – dato N.

El predictor se equivoca sólo en el último salto, por tanto, la penalización será de:

P = 1 fallo × 4 ciclos/fallo = 4 ciclos

(b) Los predictores dinámicos de un bit están inicializados a 0 (no saltar hacia delante) para el
primer salto y 1 (saltar hacia atrás), por tanto las predicciones serían:

 Si dato = 0 o dato ≥ 7, la ejecución será: (NSB)5 NNB.

la predicción será: (NSB)5 NSB.

El predictor se equivoca sólo en el último salto, por tanto, la penalización será de:

P = 1 fallo × 4 ciclos/fallo = 4 ciclos

 Si 0 < dato < 7, la ejecución será: (NSB) 6 – dato S.

la predicción será: (NSB) 6 – dato N.

El predictor se equivoca sólo en el último salto, por tanto, la penalización será de:

P = 1 fallo × 4 ciclos/fallo = 4 ciclos

(c) Los predictores dinámicos de dos bits están inicializados a 00 (no saltar fuerte hacia delante)
para el primer salto y 11 (saltar fuerte hacia atrás), por tanto las predicciones serían:

 Si dato = 0 o dato ≥ 7, la ejecución será: (NSB)5 NNB.

la predicción será: (NSB)5 NSB.

El predictor se equivoca sólo en el último salto, por tanto, la penalización será de:

P = 1 fallo × 4 ciclos/fallo = 4 ciclos

 Si 0 < dato < 7, la ejecución será: (NSB) 6 – dato S.

la predicción será: (NSB) 6 – dato N.

El predictor se equivoca sólo en el último salto, por tanto, la penalización será de:

P = 1 fallo × 4 ciclos/fallo = 4 ciclos

(d) Según los resultados obtenidos, la penalizazión media será de 4 ciclos, independientemente del
valor de la variable dato y del predictor usado.

27 (Examen febrero 2004)

En la secuencia de instrucciones DLX siguientes:

addi r1,r0,#4 ; r1 = 4
add r4,r0,r1 ; r4 = r1
lw r2,dato ; r2 = dato
add r5,r2,r0 ; r5 = dato
inicio: subi r3,r1,r2 ; r3 = r1 – r2
beqz r3, final ; si r3=0 saltar a final
addf f3,f2,f1 ; f3 = f2 + f1
beqz r5,final ; si r5=0 saltar a final
addf f3,f2,f1 ; f3 = f2 + f1
addi r2,r2,#1 ; r2 = r2 + 1
subi r5,r5,#1 ; r5 = r5 - 1
subi r4,r4,#1 ; r4 = r4 – 1
bnez r4,inicio ; saltar a inicio si r4 es distinto de 0
final:

Indique cuál es la penalización efectiva debida a los saltos, en función del valor inicial de dato
(número entero mayor o igual que cero), considerando que el procesador utiliza predicción
dinámica con dos bits. ¿Cuál es la penalización media si la probabilidad de que dato sea menor que
5 es un 80%?

Nota: La penalización por saltos incorrectamente predichos es de 4 ciclos y para los saltos
correctamente predichos es 0 ciclos. Para hacer la predicción en la primera ejecución de la
instrucción de salto se utiliza un esquema de predicción estática (salta si el salto es hacia atrás y no
salta si el salto es hacia adelante) y el estado inicial es 00 si se ha predicho no saltar y 11 si se ha
predicho saltar.
Solución.
En la secuencia de instrucciones del problema aparecen tres saltos, que a partir de ahora notaremos
coma S1, S2 y S3 como se muestra a continuación:

addi r1,r0,#4 ; r1 = 4
add r4,r0,r1 ; r4 = r1
lw r2,dato ; r2 = dato
add r5,r2,r0 ; r5 = dato
inicio: subi r3,r1,r2 ; r3 = r1 – r2
beqz r3, final ; si r3=0 saltar a final S1
addf f3,f2,f1 ; f3 = f2 + f1
beqz r5,final ; si r5=0 saltar a final S2
addf f3,f2,f1 ; f3 = f2 + f1
addi r2,r2,#1 ; r2 = r2 + 1
subi r5,r5,#1 ; r5 = r5 - 1
subi r4,r4,#1 ; r4 = r4 – 1
bnez r4,inicio ; saltar a inicio si r4 es distinto de 0 S3
final:

Tras analizar el código podemos descubrir que:

 el salto S1 controla el contador ascendente r2, que se inicializa con el valor dato y que
provoca la salida del bucle cuando r2 alcanza el valor 4 (siempre que dato haya sido
inicializado a un valor menor o igual que 4)

 el salto S2 controla el contador descendente r5, que se inicializa con el valor dato y que
provoca la salida del bucle cuando r5 alcanza el valor 0

 el salto S3 controla el contador descendente r4, que se inicializa con el valor inmediato 4 y
que permite la iteración del bucle un máximo de 4 veces, ya que deja de saltar hacia incio
cuando r4 vale 0

Dependiendo del valor de dato tendremos los siguientes comportamientos:

dato 0 1 2 3 4 >4
S1 N N N N N S N S S N N N N
S2 S N S N N – N – – N N N N
S3 – S – S S – S – – S S S N

Por lo tanto, podemos deducir que el comportamiento de los saltos es el siguiente:

Si dato < 2 Si 2 ≤ dato ≤ 4 Si dato > 4

S1: N(dato + 1) S1: N(4 – dato)S S1: N4
S2: N(dato)S S2: N(4 – dato) S2: N4
S3: S(dato) S3: S(4 – dato) S3: S3N

 Si dato < 2, el predictor estático acertará la primera vez para cada uno de los tres saltos,
inicializando los predictores dinámicos de S1 a 00, de S2 a 00 y de S3 a 11. Como después
de esta inicialización todos los saltos repiten su comportamiento hasta el final excepto S2,
que es el que provoca la salida del bucle, todos los saltos serán bien predichos a excepción
del último salto de S2, con lo que la penalización total de de 1 fallo, es decir, 4 ciclos.
  Si 2 ≤ dato ≤ 4, el predictor estático acertará la primera vez para cada uno de los tres saltos,
como pasaba en el caso anterior. Como después de esta inicialización todos los saltos repiten
su comportamiento hasta el final excepto S1, que es el que provoca la salida del bucle, todos
los saltos serán bien predichos a excepción del último salto de S1, con lo que la penalización
total de de 1 fallo, es decir, 4 ciclos.

 Si dato > 4, el predictor estático también acertará la primera vez para cada uno de los tres
saltos. Como después de esta inicialización todos los saltos repiten su comportamiento hasta
el final excepto S3, que es el que provoca la salida del bucle, todos los saltos serán bien
predichos a excepción del último salto de S3, con lo que la penalización total de de 1 fallo,
es decir, 4 ciclos.

Como conclusión podemos decir que independientemente del valor de la variable dato, la secuencia
de instrucciones tiene una penalización de 4 ciclos debida a los saltos.

28 (Examen febrero 2004)

Disponemos del siguiente código DLX:

lw r9, n ; r9 <– tamaño del vector a

add r10, r0, r0 ; r10 <– 0
inicio: lw r1, a(r10) ; r1 <– cargo un elemento del vector a
sgt r2, r1, r0 ; r2 <– true si r1 > 0
bnez r2, mayor ; salto a mayor si r2 es true
sub r1, r0, r1 ; r1 <– –r1;
beqz r2, fin ; salto al final del bucle
mayor: add r1, r1, r1 ; r1 <– 2*r1
fin: sw r1, a(r10) ; almaceno el nuevo elemento de a
addi r10, r10, #1 ; r10 <– r10 + 1
seq r3, r9, r10 ; r3 <– true si r9 = r10
bnez r3, inicio ; siguiente iteración
trap #0

Suponiendo que el procesador que ejecutará este código tiene un predictor estático que predice
como tomados los saltos hacia atrás y como no tomados los saltos hacia delante, y que la
penalización en caso de errar la predicción es de 5 ciclos, ¿qué penalización media se obtendrá si
solo el 10% de los elementos del vector a son positivos?

Se han añadido a este procesador nuevas instrucciones de salto condicional para invertir el
comportamiento del predictor de saltos. Estas nuevas instrucciones añaden el sufijo “n” a las ya
existentes y predicen como tomados los saltos hacia delante y como no tomados los saltos hacia
atrás. Conociendo que solo el 10% de los elementos del vector a son positivos, modifique el
programa con estas nuevas instrucciones para minimizar la penalización media debida a los saltos
mal predichos. ¿Qué penalización media debida a los saltos tiene esta nueva versión del programa?

Solución.
En la secuencia de instrucciones del problema aparecen tres saltos, que a partir de ahora notaremos
coma S1, S2 y S3 como se muestra a continuación:

lw r9, n ; r9 <– tamaño del vector a

add r10, r0, r0 ; r10 <– 0
inicio: lw r1, a(r10) ; r1 <– cargo un elemento del vector a
sgt r2, r1, r0 ; r2 <– true si r1 > 0
bnez r2, mayor ; salto a mayor si r2 es true S1
sub r1, r0, r1 ; r1 <– –r1;
beqz r2, fin ; salto al final del bucle S2
mayor: add r1, r1, r1 ; r1 <– 2*r1
fin: sw r1, a(r10) ; almaceno el nuevo elemento de a
addi r10, r10, #1 ; r10 <– r10 + 1
seq r3, r9, r10 ; r3 <– true si r9 = r10
bnez r3, inicio ; siguiente iteración S3
trap #0

Teniendo en cuenta el comportamiento del predictor estático descrito en el enunciado y que solo el
10% de los valores del vector a son positivos, podemos descubrir que:

 el salto S1 saltará hacia adelante el 10% de las iteraciones (dependiendo de si el elemento es

positivo), y cuando salte incurrirá en una penalización de 5 ciclos

 el salto S2 saltará hacia delante el 90% de las iteraciones (siempre que se ejecute y no se
haya saltado en S1), y cuando salte incurrirá en una penalización de 5 ciclos

 el salto S3 controla el bucle, con lo que saltará hacia atrás en todas las iteraciones excepto en
la última, provocando una penalización de 5 ciclos

Por tanto, para un vector a de tamaño n, la penalización debida a los saltos mal predichos será:

P = 5 · 0,1 · n + 5 · 0,9 · n + 5 = 5(n + 1) ciclos

Tras esto podemos darnos cuenta de que el salto S2 está mal predicho todas las veces que se ejecuta
(90% de las iteraciones), así que haciendo uso de las nuevas instrucciones de salto para cambiar la
predicción, deberíamos sustituirlo por la siguiente instrucción:

beqzn r2, fin ; salto al final del bucle

Esta instrucción cambia el comportamiento del predictor estático y hace que no se equivoque nunca,
con lo que con esta mejora la penalización se reduce a:

P = 5 · 0,1 · n + 5 = 0,5n + 5 ciclos

Con este resultado podemos concluir que este cambio nos reduce la penalización debida saltos mal
predichos en casi un 90%.

29 (Examen septiembre 2006)

Se desea ejecutar el siguiente programa en un procesador superescalar:

(1) lw r1, N
(2) add r2, r0, r0
(3) bucle: lw r3, X(r2)
(4) sgt r4, r3, r0
(5) bnz r4, mayor
(6) sub r3, r0, r3
(7) mayor: sw X(r2), r3
(8) add r2, r2, #4
(9) sub r1, r1, #1
(10) bnz r1, bucle

Si el procesador usa predictores dinámicos de dos bits que se inicializan con un predictor estático
que predice como tomados los saltos hacia atrás y como no tomados los saltos hacia delante, y que
la penalización en caso de errar la predicción es de 5 ciclos, ¿qué penalización se obtendrá si X (0)
= 1 y X (i+1) = 1 – X (i)? ¿Qué penalización se obtendría si se optimizara el código usando
sentencias de ejecución condicional?
Solución.
El programa del enunciado calcula el valor absoluto de los elementos del vector X. Va
procesándolos de uno en uno y les cambia el signo si no son positivos. Consta de dos saltos, el
primero de ellos, notado como S1 en el código de más abajo, sirve para detectar si los números son
positivos y el segundo, notado como S2, se emplea para volver a ejecutar el código mientras queden
elementos por procesar en el vector X.

(1) lw r1, N
(2) add r2, r0, r0
(3) bucle: lw r3, X(r2)
(4) sgt r4, r3, r0
(5) bnz r4, mayor S1
(6) sub r3, r0, r3
(7) mayor: sw X(r2), r3
(8) add r2, r2, #4
(9) sub r1, r1, #1
(10) bnz r1, bucle S2

Para mejorar las prestaciones en la ejecución de los saltos, el computador que se describe en el
enunciado usa un predictor dinámico de dos bits para cada uno de los saltos que se encuentre en el
programa. El esquema de este tipo de predictores es el siguiente:

N N N

S 1 1 0 0 N
1 0 1 0

S S S
Saltar Saltar No saltar No saltar
fuerte débil débil fuerte

Para cada salto, su predictor dinámico se inicializará según el predictor estático del computador, que
predice como tomados los saltos hacia atrás. Por tanto, el predictor dinámico para S1 se iniciará al
valor 00 (no saltar fuerte), ya que es un salto hacia delante, y el predictor dinámico para S2 se
iniciará al valor 11 (saltar fuerte) porque salta hacia atrás.

Una vez inicializados los predoctores dinámicos, la penalización que introduzca cada uno de ellos
dependerá del comportamiento de cada salto. En el caso de S1, su comportamiento está determinado
por el valor de cada elemento del vector X. S1 Saltará siempre que X(i) sea mayor que cero, y según
el enunciado, el vector X es de la forma X = {1, 0, 1, 0, 1, 0,…}, por lo que S1 saltará una vez sí y
otra no hasta que se termine de procesar el vector X. Por tanto, el comportamiento del predictor
dinámico para S1 viene explicado según la siguiente tabla:

Iteración 1 2 3 4 6 7 8 …
Valor de X 1 0 1 0 1 0 1 …
Estado actual 00 01 00 01 00 01 00 …
Predicción N N N N N N N …
Ejecución S N S N S N S …
Penalización P P P P …
Estado siguiente 01 00 01 00 01 00 01 …

Por lo que la penalización que introduce S1 es de:

N
PS1  5    ciclos
2
El salto S2 saltará tantas veces como elementos tenga el vector X, es decir N veces, ya que el
programa se dedica a procesar dicho vector. Teniendo esto en cuenta, el comportamiento del
predictor dinámico para S2 viene explicado según la siguiente tabla:

Iteración 1 2 3 4 … N–2 N–1 N

Estado actual 11 11 11 11 … 11 11
Predicción S S S S … S S S
Ejecución S S S S … S S N
Penalización P
Estado siguiente 11 11 11 11 … 11 11 10

El comportamiento de este salto es muy fácil de predecir, ya que salta siempre excepto en la última
iteración del bucle, por lo que introduce una penalización de:

PS2  5 ciclos

Por tanto, teniendo en cuenta los dos predictores, la penalización total es de:

 N 
Ptotal  5  1     ciclos
  2 

Está claro que el comportamiento S1 no puede ser aprendido por el predictor dinámico, por lo que
nos va a ocasionar muchas faltas, así que sería interesante cambiarlo por una sentencia de ejecución
condicional, tal y como muestra el siguiente código:

(1) lw r1, N
(2) add r2, r0, r0
(3) bucle: lw r3, X(r2)
(4) sub r4, r0, r3
(5) cmov.gt r4, r3, r3
(7) sw X(r2), r4
(8) add r2, r2, #4
(9) sub r1, r1, #1
(10) bnz r1, bucle S2

En esta versión mantenemos el mismo número de instrucciones para ejecutar el algoritmo, y además
evitamos el salto S1, que depende del valor de cada componente de X, por lo que la penalización
total del programa es de:

Ptotal  PS2  5 ciclos

30 (Examen febrero 2006)

Se dispone de un procesador superescalar capaz de captar, decodificar y retirar hasta dos
instrucciones por ciclo, con una única ventana de instrucciones con emisión desordenada y no
alineada, búfer de reordenamiento para el renombrado y la finalización ordenada, y una latencia de
dos ciclos para las instrucciones de carga de memoria y de un ciclo para las instrucciones
aritméticas con enteros y los almacenamientos. Se desea ejecutar el siguiente programa en el
procesador:

.data 0 .text 256

.global n1 lw r1, n1
n1: .word 2 lw r2, n2
.global n2 add r3, r0, r0
n2: .word 3 bucle: add r3, r3, r2
.global n3 subi r1, r1, #1
 n3: .space 4 bnez r1, bucle
sw r3, n3
trap #0

El procesador utiliza un predictor de saltos dinámico de dos bits que se consulta en el momento de
captar las instrucciones, de forma que si la dirección de memoria de la que se está captando una
instrucción se encuentra en el BTB, y la predicción es saltar, guarda el contenido actual de PC y se
cambia por la dirección de destino del salto para que se empiece a captar desde ahí en el siguiente
ciclo. Cuando la instrucción de salto entra en el búfer de reordenamiento tras la decodificación, se
marca con un bit PRED=1 si el predictor decidió tomar el salto o PRED=0 en caso contrario.
Posteriormente, cuando se resuelve la condición del salto en la etapa de ejecución, se comprueba si
la predicción se realizó con éxito, y en caso contrario, se marcan con FLUSH=1 todas aquellas
instrucciones que se han introducido en el cauce de forma especulativa para que no actualicen los
registros al ser retiradas, y se fija PC al valor guardado en el momento de la predicción para
continuar con la siguiente instrucción en el siguiente ciclo. La primera vez que se capta un salto,
obviamente no se encuentra en el BTB, por lo que no se podrá predecir su comportamiento hasta la
etapa de decodificación, en la que se emplea un predictor estático que predice como tomados todos
los saltos hacia atrás y crea una entrada en el BTB para los saltos encontrados.

(a) Realice una traza de la ejecución del programa en el procesador. ¿Cuántos ciclos tarda en
ejecutarse el programa? (b) Estime la penalización (en ciclos) que se produce en el procesamiento
del salto tanto si acierta como si falla cada uno de los predictores (estático y dinámico) del
procesador. (c) ¿Cuántos ciclos de penalización en total se sufrirían si n1 fuera igual a 100 y n2
igual a 200?
(NOTA: Suponga que hay tantas unidades de ejecución y de acceso a memoria como sea necesario)

Solución.
A continuación se muestra una traza de ejecución del programa:

Instrucción 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
lw r1, n1 IF ID ISS EX EX ROB WB
lw r2, n2 IF ID ISS EX EX ROB WB
add r3, r0, r0 IF ID ISS EX ROB WB
add r3, r3, r2 IF ID ISS EX ROB WB
subi r1, r1, #1 IF ID ISS EX ROB WB
bnez r1, bucle IF ID ISS EX ROB WB
sw r3, n3 IF Flush Flush Flush Flush Flush WB*
trap #0 IF Flush Flush Flush Flush Flush WB*
add r3, r3, r2 IF ID ISS EX ROB WB
subi r1, r1, #1 IF ID ISS EX ROB WB
bnez r1, bucle IF ID ISS EX ROB WB
sw r3, n3 IF Flush Flush Flush Flush Flush WB*
add r3, r3, r2 IF ID ISS Flush Flush Flush WB*
subi r1, r1, #1 IF ID ISS Flush Flush Flush WB
bnez r1, bucle IF ID Flush Flush Flush Flush WB*
sw r3, n3 IF Flush Flush Flush Flush Flush WB*
add r3, r3, r2 IF Flush Flush Flush Flush Flush WB*
subi r1, r1, #1 IF Flush Flush Flush Flush Flush WB*
sw r3, n3 IF ID ISS EX ROB WB
trap #0 IF ID ISS EX ROB WB
Penalizaciones P P P P

En esta traza se muestran con flechas de color negro las dependencias de datos RAW que son
adelantadas por la lógica de bypass de procesador, con flechas verdes las predicciones hechas por
los predictores estático o dinámico, y con flechas rojas las correcciones de las predicciones falladas.

La primera vez que se capta el salto se usa el predictor estático, que no puede realizar la predicción
hasta que se decodifica la instrucción. Por tanto, se introduce una penalización de un ciclo, ya que
mientras que se decodifica el salto entran en el cauce las instrucciones sw y trap que se deben anular
en el momento en el que se predice que el salto se va a realizar (cuando se retiren en la etapa WB no
se modificarán los registros de la arquitectura, por eso se ha marcado esta etapa con un asterisco).
En la etapa de ejecución del salto se comprueba que la predicción ha sido correcta y se procede a la
inicialización del predictor dinámico creando una entrada en el BTB para estas instrucción de salto
con el estado 11 (saltar).

A partir de ahora, todas las veces que se capte el salto, se captará junto con la instrucción siguiente
(sw), ya que las instrucciones se captan de dos en dos. En la etapa de captación se consultará el
BTB y se descubrirá que la instrucción captada es un salto con una predicción de saltar, así que se
anulará la instrucción sw y se comenzará a captar en el ciclo siguiente por la instrucción de destino
del salto. En la mayoría de los casos, esta predicción acertaría, ya que se supone que un bucle va a
iterar bastantes veces. Sin embargo, en este problema el bucle sólo tiene que iterar n1=2 veces, así
que el predictor dinámico fallará. El procesador no se da cuenta del fallo de la predicción hasta que
el salto termina la etapa EX, en la que se calcula la condición del salto. En este momento se anulan
todas las instrucciones captadas especulativamente y se fija el contenido de PC a la instrucción del
camino secuencial. En total se pierden 3 ciclos.

Tras introducir las instrucciones sw y trap en el cauce, se sigue su ejecución hasta que se retiran en
el ciclo 16, momento en el que finaliza la ejecución del programa.

Como el salto es hacia atrás, la penalización del predictor estático es de:

 Pest_acierto = 1 ciclo (la predicción se realiza en la etapa de decodificación) y

 Pest_fallo = 3 ciclos (no se corrige hasta después de la etapa de ejecución),

mientras que la del predictor dinámico es de:

 Pdin_acierto = 0 ciclos (se realiza predicción anticipada en la captación) y

 Pest_fallo = 3 ciclos (al igual que el predictor estático, no se corrige hasta después de la
etapa de ejecución).

Por tanto, como el bucle itera n1 veces, la expresión general para calcular su penalización sería:

P(n1) = Pest_acierto + (n1 – 2) × Pdin_acierto + Pdin_fallo

ya que la primera iteración se predice con el predictor estático y el resto con el dinámico, y los
predoctores acertarán en todas sus predicciones excepto en la última iteración, en la que el
productor dinámico predecirá saltar y fallará. En el caso que nos ocupa, como n1 = 2, obtenemos
una penalización de:

P(2) = Pest_acierto + (2 – 2) × Pdin_acierto + Pdin_fallo = 1 + 0 + 3 = 4 ciclos

que coincide con la que se ha obtenido en la traza, y para el caso en el que n1 = 100, obtendríamos
exactamente la misma penalización, ya que en las iteraciones intermedias el predictor dinámico va a
acertar y no nos va a costar ningún ciclo:

P(100) = Pest_acierto + (100 – 2) × Pdin_acierto + Pdin_fallo = 1 + 98 × 0 + 3 = 4 ciclos.

31 (Examen septiembre 2007)

Suponga un procesador superescalar en que se captan, decodifican, emiten y retiran hasta dos instrucciones
por ciclo. La etapa de decodificación se realiza de forma ordenada, ya que es en esta etapa donde se
introducen las instrucciones en un búfer de reordenamiento (ROB) que permite su finalización ordenada. Por
 el contrario, la emisión es desordenada y se implementa mediante estaciones de reserva individuales para
cada unidad funcional. El procesador utiliza predicción dinámica de saltos con dos bits de historia. Para la
primera ejecución de una instrucción de salto dada, el procesador predice saltar si la dirección de salto es
hacia direcciones inferiores, y no saltar si la dirección es mayor. Las instrucciones de salto se procesan en la
etapa de ejecución y consumen un ciclo en esa etapa (en el siguiente ciclo ya se tendría la dirección de salto
correcta y se podría captar la instrucción correcta si la predicción de salto no hubiera sido correcta).

Suponiendo una frecuencia de 2 GHz, que el cauce se encuentra inicialmente vacío, y que inicialmente
r2=100000, para la siguiente secuencia de instrucciones:

bucle: addd f1, f1, f6 ; f1 = f1 + f6

multd f6, f2, f5 ; f6 = f2 * f5
subd f5, f1, f3 ; f5 = f1 – f3
loop r2, bucle
addd f7, f1, f5 ; f7 = f1 + f5

a) ¿Cuánto tarda en procesarse la secuencia de instrucciones?

b) ¿Cuál es la velocidad pico del procesador?

NOTAS:
 La suma y la resta en coma flotante consumen dos ciclos de reloj y la multiplicación en coma
flotante cuatro ciclos. Considere que no hay limitaciones en la capacidad de los búferes y en el
número de unidades funcionales. Se supone que todos los registros tienen valores válidos previos.
 La instrucción loop decrementa el registro y salta si el valor del registro es distinto de cero.

Solución.
 Para responder al primer apartado es necesario tener en cuenta que el programa se ejecutará en un
procesador superescalar en el que se solaparán las iteraciones del bucle. Por tanto, una vez terminada
la primera iteración tras un tiempo TLI, el resto de iteraciones irán terminando cada MLM ciclos.
Para determinar estos dos parámetros es necesario desarrollar una traza de la ejecución del programa
en la que se tengan en cuenta las características del procesador. A continuación se simula la
ejecución del bucle haciendo tres iteraciones.

Instrucción 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
R
IS E E W
addd f1, f1, f6 IF ID O
S X X B
B
R
IS E E E E W
multd f6, f2, f5 IF ID O
S X X X X B
B
R
E E W
subd f5, f1, f3 IF ID O
X X B
B
R
IS E W
loop r2, bucle IF ID O
S X B
B
W
addd f7, f1, f5 IF X X X X X X
B
W
Sig. instrucción IF X X X X X X X
B
R
IS E E W
addd f1, f1, f6 IF ID O
S X X B
B
R
IS E E E E W
multd f6, f2, f5 IF ID O
S X X X X B
B
R
IS E E W
subd f5, f1, f3 IF ID O
S X X B
B
 R
IS E W
loop r2, bucle IF ID O
S X B
B
R
IS E E W
addd f1, f1, f6 IF ID O
S X X B
B
R
IS E E E E W
multd f6, f2, f5 IF ID O
S X X X X B
B
R
IS E E W
subd f5, f1, f3 IF ID O
S X X B
B
R
IS E W
loop r2, bucle IF ID O
S X B
B
IS W
addd f1, f1, f6 IF ID X X X X X X X
S B
W
multd f6, f2, f5 IF ID X X X X X X X X
B
W
subd f5, f1, f3 IF ID X X X X X X X X
B
W
loop r2, bucle IF ID X X X X X X X X X
B
W
addd f1, f1, f6 IF X X X X X X X X X
B
W
multd f6, f2, f5 IF X X X X X X X X X X
B
R
IS E E W
addd f7, f1, f5 IF ID O
S X X B
B

10 4 4 3
A la hora de realizar esta traza tenemos que tener cuidado con los riesgos que ocurrirán en la ejecución del
programa:

 Riesgos RAW entre datos dentro de una iteración y también entre iteraciones consecutivas (marcados
con flechas rojas),
 Riesgos estructurales (marcados con flechas azules),
 Riesgos de control al procesar el salto del bucle (marcados con flechas verdes).

La primera vez que se capta el salto no se puede usar el predictor dinámico porque no existe
ninguna entrada en el BTB del procesador para él. Por tanto, en la etapa de decodificación, una vez
que se identifique el salto, se incluirá una entrada en el BTB para que la siguiente vez que se capte
se pueda usar el predictor dinámico, se usará un predictor estático que predecirá saltar (el salto es
hacia atrás), y se anularán las dos instrucciones que se captaron erróneamente tras el salto. Teniendo
en cuenta las etapas del cauce, el predictor estático tendrá una penalización de 1 ciclo para los saltos
acertados.

A partir de la segunda iteración, cada vez que se capta el salto se usa el predictor dinámico, por lo
que no hay penalización en caso de acertar. Esto ocurrirá en el resto de iteraciones menos en la
última, en la que el predictor fallará y tendremos una penalización de 3 ciclos hasta captar la
siguiente instrucción al salto, ya que es en la etapa de ejecución en la que se comprueba la
corrección de la predicción. Una vez que se comprueba que falló la predicción, se anulan todas las
instrucciones captadas especulativamente y se comienza a captar desde la dirección correcta para
terminar la ejecución del programa.
Si nos fijamos en el instante de tiempo en el que se retira la última instrucción del bucle en cada
iteración, podemos comprobar que la primera iteración tarda en concluir un tiempo TLI = 10 ciclos,
que el resto de iteraciones terminan cada MLM = 4 ciclos, y que la última instrucción termina 3
ciclos después de la última iteración del bucle, por tanto para un bucle de n iteraciones tenemos:

T(n) = TLI + MLM(n – 1) + Tfinal = 10 + 4(n – 1) + 3 = 4n + 9 ciclos

Teniendo en cuenta que el registro r2 = 100000 y que la frecuencia de reloj es de 2 GHz, el tiempo
de ejecución es de:

4 105  9ciclos
)
T(100000  200microsegun
dos
2 109 cicloss

Y como el procesador puede completar hasta 2 instrucciones por ciclo, su velocidad pico es de:
9 ciclos 9
Rpico  2 instruccio
nes
ciclo 2 10 s  4  10
instruccio
nes
s

32 (Examen febrero 2008)

Se dispone de un procesador superescalar capaz de captar, decodificar y retirar hasta cuatro
instrucciones por ciclo, con una única ventana de instrucciones con emisión centralizada,
desordenada y no alineada, y con un búfer de reordenamiento para el renombrado y la finalización
ordenada. El procesador utiliza un predictor de saltos dinámico de dos bits que se consulta en el
momento de captar las instrucciones, de forma que si la dirección de memoria de la que se está
captando una instrucción se encuentra en el BTB, y la predicción es saltar, guarda el contenido
actual de PC y se cambia por la dirección de destino del salto para que se empiece a captar desde
ahí en el siguiente ciclo. Cuando la instrucción de salto entra en el búfer de reordenamiento tras la
decodificación, se marca con un bit PRED=1 si el predictor decidió tomar el salto o PRED=0 en
caso contrario. Posteriormente, cuando se resuelve la condición del salto en la etapa de ejecución, se
comprueba si la predicción se realizó con éxito, y en caso contrario, se marcan con FLUSH=1 todas
aquellas instrucciones que se han introducido en el cauce de forma especulativa para que no
actualicen los registros al ser retiradas, y se fija PC al valor guardado en el momento de la
predicción para continuar con la siguiente instrucción en el siguiente ciclo. La primera vez que se
capta un salto, obviamente no se encuentra en el BTB, por lo que no se podrá predecir su
comportamiento hasta la etapa de decodificación, en la que se emplea un predictor estático que
predice como tomados todos los saltos hacia atrás y crea una entrada en el BTB para los saltos
encontrados. Si en el procesador descrito se ejecuta el siguiente programa:
.data 0 .text 256
.global N lw r1, N
a) ¿Qué N: .word 3 lw r2, X valor tiene R al
add r3, r0, r0
final del .global X bucle: add r3, r3, r2
programa?
b) ¿Cuántos X: .word 3 add r4, r3, r3 ciclos tarda en
subi r1, r1, #1 ejecutarse el
.global R bnez r1, bucle programa?
c) ¿Cuál es R: .space 4 sw R, r4 la penalización
trap #0
que se obtiene cuando
se predice mal un salto en este procesador?
d) ¿Cuántos ciclos tardaría en ejecutarse el programa si N tuviera el valor 500?

NOTAS: Suponga un número de unidades de ejecución y un tamaño de búferes suficiente como

para que no se provoquen riesgos estructurales en el cauce.
Las unidades funcionales de acceso a memoria tienen una latencia de 2 ciclos y el resto de unidades
funcionales utilizadas 1 ciclo de latencia.

Solución.
Para responder a la primera pregunta es necesario entender el funcionamiento del programa, que
básicamente consiste en lo siguiente:

r3(i) = r3(i – 1) + X
r4(i) = 2 × r3(i)

siendo i el número de iteraciones que se ejecutan y r3(0) = 0. Reescribiendo las expresiones

anteriores de forma que no se calculen de forma recursiva tenemos que:

r3(i) = i × X
r4(i) = 2 × i × X

Como el número de iteraciones del programa está controlado por el registro r1, que inicialmente se
fija al valor de la variable N, el valor final para R es de:

R = r4(N) = 2 × N × X

Teniendo en cuenta que las variables N y X están inicializadas al valor 3, podemos concluir que:

R = 2 × 3 × 3 = 18

Para responder a la siguiente cuestión es necesario realizar una traza de la ejecución del programa:

Instrucción 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
lw r1,N IF ID ISS EX EX ROB WB
lw r2,X IF ID ISS EX EX ROB WB
add r3,r0,r0 IF ID ISS EX ROB WB
add r3,r3,r2 IF ID ISS EX ROB WB
add r4,r3,r3 IF ID ISS EX ROB WB
subi r1,r1,#1 IF ID ISS EX ROB WB
bnez r1,bucle IF ID ISS EX ROB WB
sw R,r4 IF ID X X X X X X
trap #0 IF X X X X X X

Sig. instrucción IF X X X X X X

Sig. instrucción IF X X X X X X

Sig. instrucción IF X X X X X X
add r3,r3,r2 IF ID ISS EX ROB WB
add r4,r3,r3 IF ID ISS EX ROB WB
subi r1,r1,#1 IF ID ISS EX ROB WB
bnez r1,bucle IF ID ISS EX ROB WB
add r3,r3,r2 IF ID ISS EX ROB WB
add r4,r3,r3 IF ID ISS EX ROB WB
subi r1,r1,#1 IF ID ISS EX ROB WB
bnez r1,bucle IF ID ISS EX ROB WB
add r3,r3,r2 IF ID ISS EX X X
add r4,r3,r3 IF ID ISS X X
subi r1,r1,#1 IF ID ISS EX X X
bnez r1,bucle IF ID ISS X X
add r3,r3,r2 IF ID ISS X X
add r4,r3,r3 IF ID X X
subi r1,r1,#1 IF ID ISS X X
bnez r1,bucle IF ID X X
add r3,r3,r2 IF ID X X
add r4,r3,r3 IF ID X X
subi r1,r1,#1 IF ID X X
bnez r1,bucle IF ID X X
add r3,r3,r2 IF X X
add r4,r3,r3 IF X X
subi r1,r1,#1 IF X X
bnez r1,bucle IF X X
sw R,r4 IF ID ISS EX EX ROB WB
trap #0 IF ID ISS EX ROB WB
Penalización P P P P P

En cuanto a la penalización debida a saltos, analizando el diagrama anterior se puede comprobar

que el predictor estático (que se aplica en la etapa de decodificación la primera vez que se capta un
salto) introduce un ciclo de penalización para los saltos tomados. El resto de las iteraciones que se
ejecute el salto se usa el predictor dinámico, que no introduce penalización en caso de acertar. Sin
embargo, en la última iteración el predictor dinámico falla. El fallo se detecta en la etapa de
ejecución del salto, por lo que se introduce una penalización de cuatro ciclos.

Por último, para calcular el tiempo de ejecución para N iteraciones hay que tener en cuenta que
transcurren 9 ciclos hasta que se termina la primera iteración, que cada iteración termina un ciclo
después de la anterior, y que tras la última iteración hay que añadir 5 ciclos para almacenar el
resultado final, es decir, que el tiempo para ejecutar N iteraciones se puede calcular mediante las
expresión:

T(N) = 9 + (N – 1) + 5 = 13 + N

Por tanto, para ejecutar N = 500 iteraciones serían necesarios 513 ciclos.

33 (Benchmark diciembre 2005)

Se dispone de un procesador superescalar en el que se pueden captar y decodificar hasta dos
instrucciones por ciclo. Este ordenador cuenta con dos sumadores de latencia 2 ciclos, un
multiplicador de latencia 4 ciclos, y una unidad de carga con una latencia de 1 ciclo si se produce un
acierto en la cache o 3 ciclos si el dato solicitado no se encuentra en la cache. Cada unidad de
ejecución cuenta con su propia estación de reserva de 3 entradas. Para mantener la consistencia
secuencial y garantizar un tratamiento preciso de las interrupciones, las instrucciones se introducen
en un búfer de reordenamiento en la etapa de decodificación, del que se retiran de dos en dos de
manera ordenada una vez han terminado su ejecución. En dicho procesador se pretende ejecutar el
siguiente fragmento de código (que ya está alojado en la cache de instrucciones):

multd f4, f1, f2 ; f4 = f1 * f2

ld f5, X(r3) ; f5 = Mem(X + r3)
addd f2, f3, f1 ; f2 = f3 + f1
addd f3, f4, f2 ; f3 = f4 + f2
subd f2, f3, f5 ; f2 = f3 – f5

Al intentar cargar la variable X, se produce un fallo de página porque dicha variable no se encuentra
ni en la cache ni en memoria principal. Dicho fallo se detecta en el ciclo 2 de la ejecución de la
instrucción ld, cuando se consulta la tabla de páginas de SO. En ese momento, se genera una
excepción para indicar el problema.

a) ¿Qué contenido tiene el búfer de reordenamiento en ese ciclo?

b) ¿En qué ciclo se comenzará a ejecutar la rutina de servicio de la interrupción?
c) Si la rutina de servicio de interrupción tarda 237 ciclos en traer la página a la memoria
principal y retornar el control al programa, ¿Qué instrucción del programa se ejecutará y en
qué ciclo comenzará a ejecutarse?
 d) ¿Cuántos ciclos tardará en terminar la ejecución completa del fragmento de código?

Solución.
Hasta que se produce la excepción, el cauce va evolucionando normalmente, de forma que en el
momento en el que no se encuentra la página está en el siguiente estado:

Instrucción / ciclo 1 2 3 4
multd f4, f1, f2 IF ID/ISS EX EX
ld f5, X(r3) IF ID/ISS EX EX
addd f2, f3, f1 IF ID/ISS EX
Excepción
addd f3, f4, f2 IF ID/ISS
subd f2, f3, f5 IF ID/ISS

En el ciclo 4 se han emitido todas las instrucciones, pero no ha finalizado ninguna, por tanto, el
búfer de reordenamiento tendrá el siguiente contenido:

# codop Nº Inst. Reg. Dest. Unidad Resultado ok marca ‘ready’ excep flush
1 MULT 1 4 float_mult - 0 x 7 0 0
2 LD 2 5 load - 0 x 6 1 1
3 ADD 3 2 float_add - 0 x 5 0 1
4 ADD 4 3 float_add - 0 i 0 1
5 SUB 5 2 float_add - 0 i 0 1

Al producirse la excepción, se marca la instrucción load y se anula junto con todas las posteriores,
ya que en un cauce secuencial no deberían haberse introducido en el procesador hasta que se
hubiera ejecutado la rutina de servicio de interrupción que debe traer a memoria la página que
contiene el dato que la instrucción load necesita. En este momento se dejan de captar instrucciones
y se continúa la ejecución de las instrucciones que hay en el cauce hasta que la instrucción que ha
provocado la excepción alcance el tope del búfer de reordenamiento. En el ciclo 9, tras retirar esta
instrucción, se salvará la dirección de la instrucción load para poder reiniciar la ejecución del
programa una vez se haya traído la página a memoria, y se comenzará a captar instrucciones de la
Rutina de Servicio de Interrupción (RSI), suponiendo que no hay ningún retardo para obtener la su
dirección:

Instrucción / ciclo 1 2 3 4 5 6 7 8 9 10
multd f4, f1, f2 IF ID/ISS EX EX EX EX ROB WB
ld f5, X(r3) IF ID/ISS EX EX WB
addd f2, f3, f1 IF ID/ISS EX WB
addd f3, f4, f2 IF ID/ISS WB
subd f2, f3, f5 IF ID/ISS WB
1ª instr. RSI IF ID/ISS
2ª instr. RSI IF ID/ISS
3ª instr. RSI IF
4ª instr. RSI IF

Las instrucciones descartadas dejan de ejecutarse y se retiran en cuanto alcanzan el tope del búfer
de reordenamiento sin modificar los registros de la máquina. Como la RSI tarda 237 ciclos, habrá
terminado en el ciclo 245. Su última instrucción será un retorno de interrupción, que modifica el
registro PC con la dirección previamente guardada, así que en el ciclo 246 se volverá a captar a
partir de la instrucción load, que ahora no cometerá la excepción porque el dato que quiere leer ya
está en memoria.

Instrucción / ciclo 246 247 248 249 250 251 252 253
ld f5, X(r3) IF ID/ISS EX EX EX ROB WB
addd f2, f3, f1 IF ID/ISS EX ROB WB
addd f3, f4, f2 IF ID/ISS EX ROB WB
subd f2, f3, f5 IF ID/ISS EX ROB WB
 Al final, el programa tarda en ejecutarse 253 ciclos.

34 (Examen diciembre 2004)

La siguiente secuencia de instrucciones DLX calcula la división de dos vectores x e y componente a
componente:
addi r2, r0, r0 ; r2 = 0 (índice)
lw r3, n ; r3 = n
slli r4, r3, #2 ; r4 = n * 4 (final del vector)
inicio: lf f0, x(r2) ; f0 = x(i)
lf f1, y(r2) ; f1 = y(i)
divf f2, f0, f1 ; f2 = x(i) / y(i)
sf f2, z(r2) ; z(i) = x(i) / y(i)
addui r2, r2, #4 ; r2 = r2 + 4 (incremento el desplazamiento)
sub r5, r4, r2 ; compruebo si he llegado al final
bnez r5, inicio ; saltar a inicio si r5 es distinto de 0
trap #0 ; fin del programa

El procesador superescalar en el que se ejecutará es capaz de captar 2 instrucciones por ciclo,

decodificar y enviar a las RS 2 instrucciones por ciclo, y retirar 2 instrucciones por ciclo. Para
mantener la consistencia secuencial, así como para renombrar los registros y gestionar las
interrupciones se utiliza un ROB. Existe una RS para cada unidad de ejecución y el predictor de
saltos es fijo y predice que nunca se va saltar. Se dispone de las siguientes unidades de ejecución:
dos unidades load de latencia 2 (calcula las direcciones en el primer ciclo y accede a la cache en el
segundo, se supone que la cache nunca falla), dos unidades store con latencia 1 (en la unidad de
store sólo se calcula la dirección, el dato se manda a memoria cuando la instrucción se retira del
ROB) dos ALUs enteras de latencia 1, un sumador flotante de latencia 2, un divisor flotante de
latencia 4, una unidad de saltos que resuelve los saltos en un ciclo. Tras este ciclo se comprueba si
el predictor ha acertado, y en caso contrario se anulan las instrucciones captadas erróneamente y se
comienza a captar a partir de la dirección de destino. La instrucción trap no causa la terminación del
programa hasta que se retira del ROB. Si la unidad de división provoca una excepción de división
por cero en el primer ciclo de ejecución para el segundo elemento de y, ¿en qué ciclo se produce la
excepción? ¿Qué contenido tendrá el ROB en ese ciclo? Suponga un tamaño ilimitado para el ROB
y las RS.

Solución.
Para obtener el contenido del ROB en el instante de la excepción, tendremos que simular la
ejecución del programa hasta dicho momento, sabiendo que las instrucciones se introducen en el
ROB en su emisión, que se actualizan sus resultados cuando la unidad de ejecución finaliza, y que
se retiran del ROB ordenadamente. La traza de ejecución del programa es la siguiente:

Instrucción 1 2 3 4 5 6 7 8 9 10 11 12 13
addi r2, r0, r0 IF ID/ISS EX ROB WB
lw r3, n IF ID/ISS EX EX ROB WB
slli r4, r3, #2 IF ID/ISS EX ROB WB
lf f0, x(r2) IF ID/ISS EX EX ROB WB
lf f1, y(r2) IF ID/ISS EX EX ROB WB
divf f2, f0, f1 IF ID/ISS EX EX EX EX ROB WB
sf f2, z(r2) IF ID/ISS EX ROB WB
addui r2, r2, #4 IF ID/ISS EX ROB WB
sub r5, r4, r2 IF ID/ISS EX ROB
bnez r5, inicio IF ID/ISS EX ROB
trap #0 IF ID/ISS XXX
Sig. instrucción IF ID/ISS XXX
Sig. instrucción IF ID/ISS XXX
Sig. instrucción IF ID/ISS XXX
Sig. instrucción IF XXX
Sig. instrucción IF XXX
lf f0, x(r2) IF ID/ISS EX EX ROB
lf f1, y(r2) IF ID/ISS EX EX ROB
divf f2, f0, f1 IF ID/ISS EX
sf f2, z(r2) IF ID/ISS
addui r2, r2, #4 IF ID/ISS
sub r5, r4, r2 IF ID/ISS
bnez r5, inicio IF ID/ISS
trap #0 IF ID/ISS
Sig. instrucción IF
Sig. instrucción IF

Esta gráfica muestra que la excepción de división por cero se produciría en el ciclo 13. También se
puede apreciar cómo tras el salto se introducen en el cauce seis instrucciones de forma errónea (el
predictor se equivoca). Como no sabemos qué instrucciones puede haber tras la instrucción trap, ni
sus operandos, lo único que podemos asegurar es que se van a captar y a decodificar/emitir, pero no
sabemos si llegarán a ejecutarse o se quedarán en las estaciones de reserva, ya que no conocemos
sus operandos. Hemos supuesto que no se llegan a enviar a las unidades de ejecución, en cualquier
caso, una vez resuelto el salto en el ciclo 9, se abortan y se comienza a captar a partir de la dirección
de inicio del bucle.

En el ciclo 13 ya se han retirado las primeras 8 instrucciones del programa, así que el contenido del
ROB es el siguiente:

# codop #Inst. Reg.Dst. Unidad Result ok marca ‘ready’ excep flush

1 SUB 9 R5 ALU 1 36 1 f 8
2 BNEZ 10 -- BRANCH -- 0 f 9
3 TRAP 11 -- -- -- 0 i -- 1
4 ???? 12 ?? ?? -- 0 i ?? 1
5 ???? 13 ?? ?? -- 0 i ?? 1
6 ???? 14 ?? ?? -- 0 i ?? 1
7 ???? 15 ?? ?? -- 0 i ?? 1
8 ???? 16 ?? ?? -- 0 i ?? 1
9 LF 4 F0 LOAD 1 18.5 1 f 13
10 LF 5 F1 LOAD 2 0 1 f 13
11 DIVF 6 F2 DIV -- 0 x 17 1 1
12 SF 7 -- STORE 1 -- 0 i -- 1
13 ADDUI 8 R2 ALU 1 -- 0 i 1
14 SUB 9 R5 ALU 2 -- 0 i 1
15 BNEZ 10 -- BRANCH -- 0 i 1
16 TRAP 11 -- -- -- 0 i 1

Se puede comprobar cómo las instrucciones que fueron captadas erróneamente tras el salto se han
marcado con flush = 1 para ser descartadas, al igual que la instrucción DIV y las siguientes, que se
deben descartar porque se ha producido una excepción. A partir del ciclo 14 se comenzarán a captar
instrucciones de la rutina de servicio de la interrupción mientras se van retirando las instrucciones
que quedan en el ROB. Las únicas instrucciones que modificarán el estado de la máquina (de
manera ordenada) serán la resta y el salto (instrucciones 9 y 10), y los dos loads (instrucciones 4 y
5).