Escolar Documentos
Profissional Documentos
Cultura Documentos
Procesamiento superescalar
Captación Cola de
instruccione
(IF) s
2 1 sub r6 r5 0 [r2] 1 –
0 mult r5 [r1] 1 [r5] 1 –
3 3 add r2 [r3] 1 [r1] 1 –
2 sub r5 [r4] 1 [r3] 1 –
1 sub r6 r5 0 [r2] 1 –
4 3 add r2 [r3] 1 [r1] 1 –
1 sub r6 r5 0 [r2] 1 –
6 1 sub r6 r5 0 [r2] 1 –
9
La operación a realizar.
En el caso de acceso indexado, hay un búfer con una línea para cada
uno de los registros del banco de registros del procesador. En cada
una de esas líneas hay un campo entrada válida que indica (cuando
está a 1) si se ha hecho un renombrado al registro correspondiente a
esa línea y otro campo que apunta a una línea del búfer de
renombrado propiamente dicha. En esa línea está el espacio reservado
para el renombrado del registro (campo valor) y hay además otro
campo que indica si el valor es válido o no (campo valor válido). Aquí
no hay necesidad de un campo de último dado que en el campo de
índice se mantiene el puntero al último renombrado realizado para el
registro de la línea correspondiente.
# ENTRADA REGISTRO VALOR VALOR ÚLTIMO
VÁLIDA DE DESTINO VÁLIDO
0 1 r2 50 1 0
1 1 r3 1200 1 1
2 1 r2 20 1 1
3 1 r1 – 0 1
… … … … … …
3 mult r1 – 0
4 st – – 0
5 add r1 17 1
6 xor r1 – 0
NT NT NT
T 11 10 01 00 NT
T T T
Tomado Tomado No No
fuerte débil tomado tomado
débil fuerte
Predecir tomado Predecir no tomado
3 mult r1 – 0 0 0
4 st – – 0 1 1
5 add r1 17 1 0 1
6 xor r1 0xa1 1 0 1
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
La Figura 5 muestra la evolución de las instrucciones en un cauce con una
ventana de instrucciones centralizada con emisión ordenada y alineada. En
este caso, hasta que no se han emitido todas las instrucciones que entraron
en la ventana al decodificarse, no se introducen nuevas instrucciones que
puedan ser emitidas. Esta situación se muestra en la figura mediante una
línea gruesa. A continuación se comentan los atascos que se producen en el
cauce:
Ciclo 5:
Ciclo 7:
La instrucción (4) debe retrasarse hasta que la instrucción
(2) haya cargado el valor de r2.
Ciclo 13:
Ciclo 14:
Ciclo 16:
sw (r6), r4 IF ID EX
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
lw r1, 0x1ac IF ID EX
lw r2, 0xc1f IF ID EX
sw (r6), r4 IF ID EX
Figura 6. Traza de la ejecución del código del problema 1 usando una ventana de
instrucciones centralizada con emisión desordenada y alineada.
Ciclo 3:
Ciclo 8:
Ciclo 13:
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
lw r1, 0x1ac IF ID EX
lw r2, 0xc1f IF ID EX
sw (r5), r3 IF ID EX
sw (r6), r4 IF ID EX
Figura 7. Traza de la ejecución del código del problema 1 usando una estación de
reserva de tres líneas para cada unidad funcional, con envío ordenado y ventana
deslizante.
Solución
La Figura 8 muestra el resultado de insertar la primera instrucción de la
secuencia en el búfer de renombrado. Se ha supuesto que los registros r0 y
r1 estaban previamente renombrados y con valores válidos en las entradas 2
y 4 del búfer, y se ha reservado la entrada 6 para almacenar el resultado de
la instrucción, por tanto, dicha entrada permanecerá marcada como no válida
hasta que el resultado esté disponible.
Solución
La Tabla 4 muestra la evolución del búfer de renombrado a lo largo de la
ejecución de las instrucciones del fragmento de código del enunciado,
marcando en negrita los cambios que ocurren en cada ciclo. Se ha supuesto
que los registros f1 y f2 están previamente renombrados y con los valores
válidos 2.0 y 3.0 respectivamente. A continuación se describe brevemente el
contenido de la tabla:
3 0 1 f1 2.0 1 1
1 1 f2 3.0 1 1
2 1 f3 – 0 1
4 0 1 f1 2.0 1 1
1 1 f2 3.0 1 0
2 1 f3 – 0 1
3 1 f2 – 0 1
5 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
INSTRUCCIÓN 3 4 5 6 7 8 9 10 11 12 13
multd f3, f1,
ID EX
f2
addd f2, f3, f1 ID EX
Solución
La Tabla 6 muestra la evolución del búfer desde el ciclo 3 al ciclo 6,
marcando en negrita los cambios que ocurren en cada ciclo. A continuación
se describe brevemente su contenido:
3 0 1 f3 – 0 1
4 0 1 f3 – 0 0
1 1 f2 – 0 1
2 1 f3 – 0 1
5 0 1 f3 – 0 0
1 1 f2 – 0 1
2 1 f3 – 0 1
3 1 f5 – 0 1
6 0 1 f3 – 0 0
1 1 f2 – 0 1
2 1 f3 – 0 1
3 1 f5 – 0 1
4 1 f6 – 0 1
INSTRUCCIÓN 3 4 5 6 7 8 9 10 11 12 13 14
multd f3, f1, EX
ID
f2
addd f2, f3, f1 ID EX
INSTRUCCIÓN 3 4 5 6 7 8 9 10 11 12
multd f3, f1, EX
ID
f2
addd f2, f3, f1 ID EX
Figura 13. Traza de la ejecución del código del problema 4 aumentando el número de
unidades de ejecución.
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9 10 11 12
multd f3, f1, IF ID EX ROB WB
f2
addd f2, f3, f1 IF ID EX ROB WB
2 0 multd f3 – 0
1 addd f2 – 0
3 0 multd f3 – 0
1 addd f2 – 0
2 subd f3 – 0
3 addd f4 – 0
7 0 multd f3 6.0 1
1 addd f2 – 0
2 subd f3 – 0
3 addd f4 – 0
8 1 addd f2 – 0
2 subd f3 – 0
3 addd f4 – 0
9 1 addd f2 9.0 1
2 subd f3 3.0 1
3 addd f4 – 0
10 3 addd f4 – 0
11 3 addd f4 12.0 1
f1 = 3.0
f2 = 9.0
f3 = 3.0
f4 = 12.0
Solución
La Figura 15 muestra una traza de la ejecución del programa en el
procesador que se detalla en el enunciado. A continuación se describe lo que
ocurre en el procesador para cada instrucción:
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9 10 11 12 13 14 … 46 47 48
addd f3, f1, f2 IF ID EX ROB WB
addd f2, f3, f2 IF ID EX ROB WB
multd f4, IF
ID EX ROB WB
f3, f2
divd f5, f2, f1 IF ID EX … ROB WB
NOTA: Considere que el procesador tiene una unidad funcional de carga con
una latencia de 2 ciclos, una unidad de almacenamiento con una
latencia de 1 ciclo, tres unidades de suma/resta con una latencia de 1
ciclo, una unidad de multiplicación con una latencia de 6 ciclos, 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
En la emisión ordenada (Figura 16) los instantes en los que las instrucciones
empiezan a ejecutarse (etapa EX) deben estar ordenados de menor a mayor, a
diferencia de lo que ocurre en la emisión desordenada (Figura 17). Dado que
el procesador utiliza un búfer de reordenamiento (ROB), la finalización del
procesamiento de las instrucciones es ordenada y por ello, las etapas WB de
las instrucciones (momento en que se retiran las instrucciones del ROB y se
escriben en los registros de la arquitectura) deben estar ordenadas en ambas
tablas.
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
lw r3, 0x10a IF ID EX ROB WB
addi r2, r0,
IF ID EX ROB WB
#128
add r1, r0,
IF ID EX ROB WB
0x0a
lw r4, 0(r1) IF ID EX ROB WB
sw 0(r1), r6 IF ID EX ROB WB
sw –8(r1), r5 IF ID EX ROB WB
sub r2, r2,
IF ID EX ROB WB
#16
Figura 16. Traza de la ejecución del código del problema 7 usando una
emisión ordenada.
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
lw r3, 0x10a IF ID EX ROB WB
addi r2, r0,
IF ID EX ROB WB
#128
add r1, r0,
IF ID EX ROB WB
0x0a
lw r4, 0(r1) IF ID EX ROB WB
sw 0(r1), r6 IF ID EX ROB WB
sw –8(r1), r5 IF ID EX ROB WB
sub r2, r2,
IF ID EX ROB WB
#16
Figura 17. Traza de la ejecución del código del problema 7 usando una emisión
desordenada.
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
lw r3, 0x10a IF ID EX ROB WB
addi r2, r0,
IF ID EX ROB WB
#128
add r1, r0,
IF ID EX ROB WB
0x0a
lw r4, 0(r1) IF ID EX ROB WB
lw r5, –8(r1) IF ID EX ROB WB
sw –8(r1), r5 IF ID EX ROB WB
sub r2, r2,
IF ID EX ROB WB
#16
Figura 18. Traza de la ejecución del código del problema 7 usando una emisión
desordenada y sin restricciones en el número de unidades de ejecución, instrucciones
procesadas por etapa, tamaño de los búferes, etc.
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9 10 11 12
lw r3, 0x10a IF ID EX ROB WB
addi r2, r0,
IF ID EX ROB WB
#128
add r1, r0,
IF ID EX ROB WB
0x0a
lw r4, 0(r1) IF ID EX ROB WB
lw r5, –8(r1) IF ID EX ROB WB
sw –8(r1), r5 IF ID EX ROB WB
sub r2, r2,
IF ID EX ROB WB
#16
Figura 19. Traza de la ejecución del código del problema 7 usando una emisión
desordenada, procesando hasta res instrucciones por ciclo, con dos unidades de carga y
con un multiplicador de tres ciclos de latencia.
Solución
La Tabla 8 muestra la evolución del búfer de reordenamiento marcando en
negrita los cambios que se producen en cada ciclo:
2 0 lw r3 – 0
1 addi r2 – 0
2 add r1 – 0
3 lw r4 – 0
3 0 lw r3 – 0
1 addi r2 – 0
2 add r1 – 0
3 lw r4 – 0
4 lw r5 – 0
5 mult r6 – 0
6 add r5 – 0
7 add r6 – 0
4 0 lw r3 – 0
1 addi r2 128 1
2 add r1 0x0a 1
3 lw r4 – 0
4 lw r5 – 0
5 mult r6 – 0
6 add r5 – 0
7 add r6 – 0
8 sw – – 0
9 sw – – 0
10 sub r2 – 0
5 0 lw r3 [0x1a] 1
1 addi r2 128 1
2 add r1 0x0a 1
3 lw r4 – 0
4 lw r5 – 0
5 mult r6 – 0
6 add r5 – 0
7 add r6 – 0
8 sw – – 0
9 sw – – 0
10 sub r2 – 0
6 3 lw r4 [0x0a] 1
4 r5 [0x0a – 1
lw
8]
5 mult r6 – 0
6 add r5 – 0
7 add r6 – 0
8 sw – – 0
9 sw – – 0
10 sub r2 112 1
7 5 mult r6 – 0
6 add r5 – 0
7 add r6 r4 + r3 1
8 sw – – 0
9 sw – – 0
10 sub r2 112 1
8 5 mult r6 – 0
6 add r5 – 0
7 add r6 r4 + r3 1
8 sw – – 1
9 sw – – 0
10 sub r2 112 1
9 5 mult r6 r5 × r3 1
6 add r5 – 0
7 add r6 r4 + r3 1
8 sw – – 1
9 sw – – 0
10 sub r2 112 1
10 6 add r5 r6 + r3 1
7 add r6 r4 + r3 1
8 sw – – 1
9 sw – – 0
10 sub r2 112 1
11 9 sw – – 1
10 sub r2 112 1
Solución
En la Figura 20 se muestra la evolución temporal del conjunto de
instrucciones indicado usando una emisión ordenada (no alineada).
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9 10 11 12
subd f2, f2, f1 IF ID EX ROB WB
addd f4, f2, f3 IF ID EX ROB WB
Figura 20. Traza de la ejecución del código del problema 9 usando emisión ordenada.
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), debe esperar hasta que haya terminado
ésta. Por otra parte, tampoco podría enviarse, dado que no se pueden enviar
más de tres instrucciones por ciclo, y se envían las instrucciones (2), (3), y (4)
en el ciclo 5. Por último, la instrucción (6) debe esperar que termine la (4)
porque depende de f6.
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9
subd f2, f2, f1 IF ID EX ROB WB
Figura 21. Traza de la ejecución del código del problema 9 usando unidades de
ejecución un ciclo más rápidas.
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, los riesgos RAW entre las instrucciones (3), (4) y
(6) y la instrucción (1), a causa de f1, afectarán al orden de emisión de las
instrucciones.
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9
multd f1, f1,
IF ID EX ROB WB
f5
addd f2, f2, f5 IF ID EX ROB WB
addd f4, f1, f2 IF ID EX ROB WB
addd f6, f1, f5 IF ID EX ROB WB
multd f5, f2,
IF ID EX ROB WB
f2
subd f6, f2, f1 IF ID EX ROB WB
2 0 multd f1 – 0
1 addd f2 – 0
3 0 multd f1 – 0
1 addd f2 – 0
3 addd f4 – 0
4 addd f6 – 0
4 0 multd f1 – 0
1 addd f2 f2 + f5 1
3 addd f4 – 0
4 addd f6 – 0
5 multd f5 – 0
6 subd f6 – 0
6 0 multd f1 f1 × f5 1
1 addd f2 f2 + f5 1
3 addd f4 – 0
4 addd f6 – 0
5 multd f5 – 0
6 subd f6 – 0
7 3 addd f4 f1 + f2 1
4 addd f6 f1 + f5 1
5 multd f5 – 0
6 subd f6 f2 – f1 1
8 5 multd f5 f2 × f2 1
6 subd f6 f2 – f1 1
número
deciclos 9
T 4.5ns
F 2 109
Solución
Analizando el código del enunciado se detecta fácilmente que las
instrucciones (2) y (3) dependen del valor de f1 producido por la instrucción
(1) y que 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 Figura 23.
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9
addd f1, f1 ,f4 IF ID EX ROB WB
multd f3, f1,
IF ID EX ROB WB
f2
addd f6, f1, f4 IF ID EX ROB WB
2 0 addd f1 – 0
1 multd f3 – 0
2 addd f6 – 0
3 0 addd f1 – 0
1 multd f3 – 0
2 addd f6 – 0
3 subd f4 – 0
4 0 addd f1 f1 + f4 1
1 multd f3 – 0
2 addd f6 – 0
3 subd f4 – 0
5 1 multd f3 – 0
2 addd f6 f1 + f4 1
3 subd f4 – 0
6 1 multd f3 – 0
2 addd f6 f1 + f4 1
3 subd f4 f1 – f6 1
8 1 multd f3 f1 × f2 1
2 addd f6 f1 + f4 1
3 subd f4 f1 – f6 1
número
deciclos 9
T 4.5ns
F 2 109
Solución
La Figura 24 muestra una traza de la ejecución del programa de la que puede
obtener su tiempo de ejecución, los ciclos en los que se emite cada
instrucción. También ilustra los riesgos RAW ocasionados entre las
instrucciones (3), (4) y (6) y la instrucción (1) ocasionados por el uso del
registro f1.
INSTRUCCIÓ
1 2 3 4 5 6 7 8 9 10 11 12
N
multd f1, f1,
IF ID EX ROB WB
f5
addd f2, f2,
IF ID EX ROB WB
f5
divd f4, f1,
IF ID EX ROB WB
f2
addd f6, f1,
IF ID EX ROB WB
f5
multd f5, f2,
IF ID EX ROB WB
f2
subd f6, f2,
IF ID EX ROB WB
f1
2 0 multd f1 – 0
1 addd f2 – 0
3 0 multd f1 – 0
1 addd f2 – 0
2 divd f4 – 0
3 addd f6 – 0
4 0 multd f1 – 0
1 addd f2 f2 + f5 1
2 divd f4 – 0
3 addd f6 – 0
4 multd f5 – 0
5 subd f6 – 0
6 0 multd f1 f1 × f5 1
1 addd f2 f2 + f5 1
2 divd f4 – 0
3 addd f6 – 0
4 multd f5 – 0
5 subd f6 – 0
7 2 divd f4 – 0
3 addd f6 f1 + f1 1
4 multd f5 – 0
5 subd f6 f2 – f1 1
8 2 divd f4 – 0
3 addd f6 f1 + f1 1
4 multd f5 f2 × f2 1
5 subd f6 f2 – f1 1
10 2 divd f4 f1 / f2 1
3 addd f6 f1 + f1 1
4 multd f5 f2 × f2 1
5 subd f6 f2 – f1 1
11 4 multd f5 f2 × f2 1
5 subd f6 f2 – f1 1
número
deciclos 12
T 6ns
F 2 109
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, EX para
ejecutarlas, ROB para escribir los resultados en el ROB y WB para retirar las
instrucciones del cauce. La Figura 25 muestra una traza de la ejecución del
fragmento de código del enunciado en la que se muestra el número de ciclos
que tarda en ejecutarse, el momento en que se emite cada instrucción y los
siguientes riesgos RAW entre instrucciones:
2 0 multd f1 – 0
1 addd f3 – 0
3 0 multd f1 – 0
1 addd f3 – 0
2 multd f4 – 0
3 addd f5 – 0
4 0 multd f1 – 0
1 addd f3 – 0
2 multd f4 – 0
3 addd f5 – 0
4 addd f3 – 0
5 subd f5 – 0
5 0 multd f1 – 0
1 addd f3 f3 + f2 1
2 multd f4 – 0
3 addd f5 – 0
4 addd f3 – 0
5 subd f5 – 0
7 0 multd f1 f1 × f2 1
1 addd f3 f3 + f2 1
2 multd f4 – 0
3 addd f5 – 0
4 addd f3 – 0
5 subd f5 – 0
8 2 multd f4 – 0
3 addd f5 – 0
4 addd f3 – 0
5 subd f5 – 0
9 2 multd f4 – 0
3 addd f5 – 0
4 addd f3 f1 + f3 1
5 subd f5 f2 – f1 1
11 2 multd f4 f1 × f3 1
3 addd f5 – 0
4 addd f3 f1 + f3 1
5 subd f5 f2 – f1 1
12 3 addd f5 – 0
4 addd f3 f1 + f3 1
5 subd f5 f2 – f1 1
13 3 addd f5 f4 + f2 1
4 addd f3 f1 + f3 1
5 subd f5 f2 – f1 1
14 5 subd f5 f2 – f1 1
número
deciclos 15
T 5ns
F 3 109
Para la calcular la velocidad pico, como sólo se pueden retirar hasta dos
instrucciones por ciclo, tenemos:
INSTRUCCIÓN 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
lf f3, 0(r1) IF ID EX ROB WB
SSNNNSSNSNSNSSSSSN
Solución
En el caso de usar predicción fija, se produciría un fallo del predictor cada
vez que se tome el salto, tal y como muestra la Tabla 13. Por tanto, la
penalización total sería de:
PREDICCIÓN N N N N N N N N N N N N N N N N N N
EJECUCIÓN S S N N N S S N S N S N S S S S S N
PENALIZACIÓN P P P P P P P P P P P
Pestático Nestático
P 7 5 35ciclos
PREDICCIÓN S S S S S S S S S S S S S S S S S S
EJECUCIÓN S S N N N S S N S N S N S S S S S N
PENALIZACIÓN P P P P P P P
1 1 1 1 0 0 0 1 0 1 0 1 0 1 1 1 1 1
ESTADO
1 1 1 0 1 0 1 0 1 0 1 0 1 0 1 1 1 1
PREDICCIÓN S S S S N N N S N S N S N S S S S S
EJECUCIÓN S S N N N S S N S N S N S S S S S N
PENALIZACIÓN P P P P P P P P P P P
Tabla 15. Comportamiento del predictor dinámico con dos bits de historia en
el problema 15.
Por último, en la Tabla 16 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 fila indica si ha habido penalización (no coinciden la predicción y lo
que ocurre al final). Teniendo en canta esta información, tenemos que la
penalización total es de:
1 1 1 0 0 0 1 1 0 1 0 1 0 1 1 1 1 1
ESTADO 1 1 1 1 0 0 0 1 1 0 1 0 1 0 1 1 1 1
1 1 1 1 1 0 0 0 1 1 0 1 0 1 0 1 1 1
PREDICCIÓN S S S S N N N S S S N S N S S S S S
EJECUCIÓN S S N N N S S N S N S N S S S S S N
PENALIZACIÓN P P P P P P P P P P
Tabla 16. Comportamiento del predictor dinámico con tres bits de historia en
el problema 15.
Solución
Como para cada instrucción de salto se utiliza un contador y unos bits de
estado independientes del resto de los saltos, consideraremos cada una de
las instrucciones de salto por separado. Así, para la primera instrucción
tenemos el comportamiento N1 N1 N1 S1, para la segunda S2 N2 S2 S2, y para
la tercera N3 S3 N3 N3.
SALTO 1 ÚLTIMAS ITERACIONES 000 000 000 000
ESTADO DEL CONTADOR 11 10 01 00
PREDICCIÓN S S N N
EJECUCIÓN N N N S
PENALIZACIÓN P P P
SALTO 2 ÚLTIMAS ITERACIONES 000 100 010 101
ESTADO DEL CONTADOR 00 00 00 00
PREDICCIÓN N N N N
EJECUCIÓN S N S S
PENALIZACIÓN P P P
SALTO 3 ÚLTIMAS ITERACIONES 000 000 100 010
ESTADO DEL CONTADOR 00 00 00 00
PREDICCIÓN N N N N
EJECUCIÓN N S N N
PENALIZACIÓN P
Ptotal F1 F2 F3 P 3 3 1 4 28ciclos
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 ; S1
saltar a bucle ; S2
etiqueta: …
En este código hay dos saltos, que a partir de ahora notaremos como S1 y S2
(si saltan) o N1 y N2 (si no saltan). Para valores de d tales que 1 < d < 8 el
patrón de saltos del código es:
N1S2 8d S1
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).
Pdinámico F1 F2 P 1 0 4 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:
N1S2 8d N1
Teniendo en cuenta el comportamiento del fragmento de código, el predictor
estático sólo se equivocaría en el último salto, con lo que volvemos a obtener
una penalización de
Pestático F P 1 4 4 ciclos
etiqueta:
Solución
Al igual que en el ejercicio anterior, al traducir el fragmento de código a
ensamblador se codificarán dos saltos: S1, que estará dentro del bucle y
saltará hacia etiqueta, y S2, que será el salto al final del bucle para iniciar
otra iteración. Dependiendo del valor inicial de c se pueden distinguir tres
comportamientos diferentes de los saltos:
1. c ≤ 0: El salto S1 no salta nunca y el salto S2 salta 9 veces (el bucle
realiza 10 iteraciones, el máximo de iteraciones del bucle):
N1S2 9 N1N2
2. 1 ≤ c < 10:
Si c = 9: N1S2S1
Si c = 8: N1S2 2S1
…
Si c = 1: N1S2 9S1
Es decir:
N1S2 10cS1
3. c ≥ 10:
S1
Pestático
1
Festático
1
P 1 4 4 ciclos
Pestático
2
Festático
2
P 1 4 4 ciclos
Pestático
3
Festático
3
P 1 4 4 ciclos
Pdinámico
1
F1 F2 P 1 1 4 8ciclos
2. 1 ≤ c < 10:
Pdinámico
2
F1 F2 P 2 0 4 8ciclos
Pdinámico
3
0 0 P 0ciclos
9
10 c 4
c1
Pfijo 0.25 Pfijo1 0.45 Pfijo2 0.30 Pfijo3 0.25 44 0.45 0.30 0 20ciclo
9
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:
DATO 0 1 2 3 4 >4
SALTO 1 N N N N N S N S S N N N N
SALTO 2 S N S N N – N – – N N N N
SALTO 3 – S – S S – S – – S S S N
1. Si dato < 2:
S1: N dato + 1.
S2: N dato S.
S3: S dato.
2. Si 2 ≤ dato ≤ 4:
S1: N 4 – dato S.
S2: N 4 – dato.
S3: S 4 – dato.
3. Si dato > 4:
S1: N 4.
S2: N 4.
S3:. S 3 N
lw r9, n ; (1)
add r10, r0, r0 ; (2)
inicio: lw r1, a(r10) ; (3)
sgt r2, r1, r0 ; (4)
bnez r2, mayor ; (5)
sub r1, r0, r1 ; (6)
beqz r2, fin ; (7)
mayor: add r1, r1, r1 ; (8)
fin: sw r1, a(r10) ; (9)
addi r10, r10, #1 ; (10)
seq r3, r9, r10 ; (11)
bnez r3, inicio ; (12)
trap #0 ; (13)
Solución
En la secuencia de instrucciones del problema aparecen tres saltos, que a
partir de ahora notaremos como S1, S2 y S3 como se muestra a continuación:
lw r9, n
add r10, r0, r0
inicio: lw r1, a(r10)
sgt r2, r1, r0
bnez r2, mayor ; (S1)
sub r1, r0, r1
beqz r2, fin ; (S2)
mayor:add r1, r1, r1
fin: sw r1, a(r10)
addi r10, r10, #1
seq r3, r9, r10
bnez r3, inicio ; (S3)
trap #0
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:
n 10
P F1 F2 F3 P 0.1n 1 5 ciclos
2
Con este resultado podemos concluir que este cambio nos reduce la
penalización debida saltos mal predichos en casi un 90%.
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, al que notaremos 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.
lw r1, N
add r2, r0, r0
bucle: lw r3, X(r2)
sgt r4, r3, r0
bnz r4, mayor ; (S1)
sub r3, r0, r3
mayor:sw X(r2), r3
add r2, r2, #4
sub r1, r1, #1
bnz r1, bucle ; (S2)
Para cada uno de los dos saltos, sus bits de historia se inicializarán según el
predictor estático del computador, que predice como tomados los saltos hacia
atrás. Por tanto, los bits de historia de S1 se iniciarán al valor 00, ya que es
un salto hacia delante, y los de S2 al valor 11 porque salta hacia atrás. Una
vez inicializados los bits de historia, 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. El salto S2 saltará
tantas veces como elementos tenga el vector X menos una, es decir N – 1
veces, ya que el programa se dedica a procesar dicho vector. Teniendo esto
en cuenta, el comportamiento del predictor será el que indica la Tabla 20.
ITERACIÓN 0 1 2 3 … N– N
1
VALOR DE X 1 0 1 0 … 0 1
SALTO 1 BITS DE HISTORIA 00 01 00 01 … 01 00
PREDICCIÓN N N N N … N N
EJECUCIÓN S N S N … N S
PENALIZACIÓN P P … P
SALTO 2 BITS DE HISTORIA 11 11 11 11 … 11 11
PREDICCIÓN S S S S … S S
EJECUCIÓN S S S S … S N
PENALIZACIÓN … P
N
Poriginal F1 F2 P 1 5ciclos
2
lw r1, N
add r2, r0, r0
bucle: lw r3, X(r2)
sub r4, r0, r3
cmov.gt r4, r3, r3
sw X(r2), r4
add r2, r2, #4
sub r1, r1, #1
bnz r1, bucle
ón F2 P 1 5 5ciclos
Poptimizaci
lw r1, n
lw r2, a
add r3, r0, r0
bucle: add r3, r3, r2
subi r1, r1, #1
bnez r1, bucle
sw r3, b
trap #0
Solución
La Figura 27 muestra una traza de ejecución del programa. 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 no se
modificarán los registros de la arquitectura).
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 a
partir de la instrucción de destino del salto.
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9 10 11 12 13
lw r1, n IF ID EX ROB WB
lw r2, a IF ID EX ROB WB
sw r3, b IF Flush
trap #0 IF Flush
add r3, r3, r2 IF ID EX ROB WB
subi r1, r1, #1 IF ID EX ROB WB
sw r3, b IF Flush
Flus
add r3, r3, r2 IF
h
Flus
subi r1, r1, #1 IF
h
bnez r1, bucle IF Flush
sw r3, b IF Flush
sw r3, b IF ID EX ROB WB
trap #0 IF ID EX ROB WB
PENALIZACIÓN P P P
Por tanto, como el bucle itera n veces, la primera iteración se predice con el
predictor estático, y el resto con el dinámico, la expresión general para
calcular su penalización es:
P n Pest_aciert
o n 2 Pdin_aciert
o Pdin_fallo 1 n 2 0 2 3ciclos
Solución
Para responder al primer apartado es necesario realizar una traza de su
ejecución. En la Figura 28 se muestra una traza en la que se supone que
r2 = 3 iteraciones. En esta traza se observan los riesgos de control:
Estos ciclos de penalización se solapan con los introducidos por los riesgos
RAW entre las sucesivas iteraciones del bucle a causa de f6 y f5, por lo que al
final no influyen en el tiempo de ejecución, que está determinado por los
riesgos RAW existentes en el código.
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
addd f1, f1, f6 IF ID EX ROB WB
multd f6,
IF ID EX ROB WB
f2, f5
subd f5, f1, f3 IF ID EX ROB WB
T 100000
2 100000
3 109 200s
F
Rpico IPC F 2 2 109 4 109 instrucci
ones/s
CPI
lw r1, N ; (1)
lw r2, X ; (2)
add r3, r0, r0 ; (3)
bucle: add r3, r3, r2 ; (4)
add r4, r3, r3 ; (5)
subi r1, r1, #1 ; (6)
bnez r1, bucle ; (7)
sw R, r4 ; (8)
trap #0 ; (9)
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
r3 i i X
r4 i 2 i X
R r4 N 2 N X 2 3 3 18
Para responder a la siguiente cuestión usaremos la traza de la ejecución del
programa, mostrada en la Figura 29. En este diagrama 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 usará 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 tres ciclos.
INSTRUCCIÓN 1 2 3 4 5 6 7 8 9 10 11 12 13 14
lw r1, N IF ID EX EX ROB WB
lw r2, X IF ID EX EX ROB WB
add r3, r0,
IF ID EX ROB WB
r0
add r3, r3,
IF ID EX ROB WB
r2
add r4, r3,
IF ID EX ROB WB
r3
subi r1, r1,
IF ID EX ROB WB
#1
bnez r1,
IF ID EX ROB WB
bucle
sw R, r4 IF ID Flush
trap #0 IF Flush
Sig.
IF Flush
instrucción
Sig.
IF Flush
instrucción
Sig.
IF Flush
instrucción
add r3, r3,
IF ID EX ROB WB
r2
add r4, r3,
IF ID EX ROB WB
r3
subi r1, r1,
IF ID EX ROB WB
#1
bnez r1,
IF ID EX ROB WB
bucle
add r3, r3,
IF ID EX ROB WB
r2
add r4, r3,
IF ID EX ROB WB
r3
subi r1, r1,
IF ID EX ROB WB
#1
bnez r1,
IF ID EX ROB WB
bucle
add r3, r3,
IF ID EX Flush
r2
add r4, r3,
IF ID Flush
r3
subi r1, r1,
IF ID EX Flush
#1
bnez r1,
IF ID Flush
bucle
add r3, r3,
IF ID Flush
r2
add r4, r3,
IF ID Flush
r3
subi r1, r1,
IF ID Flush
#1
bnez r1,
IF ID Flush
bucle
add r3, r3,
IF Flush
r2
add r4, r3,
IF Flush
r3
subi r1, r1,
IF Flush
#1
bnez r1,
IF Flush
bucle
sw R, r4 IF ID EX EX ROB WB
trap #0 IF ID EX ROB WB
PENALIZACIÓ
P P P P
N
Por último, para calcular el tiempo de ejecución para N iteraciones hay que
tener en cuenta que transcurren 8 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 4 ciclos para almacenar el resultado
final, es decir, que el tiempo para ejecutar N iteraciones se puede calcular
mediante las expresión:
Por tanto, para ejecutar N = 500 iteraciones serían necesarios 511 ciclos.
Solución
La Figura 30 muestra una traza de la ejecución del programa. Hasta el ciclo
4, la ejecución del programa es normal, las instrucciones se van captando,
decodificando, etc., pero justo en este ciclo (el segundo ciclo de la ejecución
de la carga) se produce una excepción, por lo que se marca la instrucción (2)
con el campo excep = 1 y las instrucciones (2) – (5) con el campo flush = 1
como muestra la Tabla 21. A partir de 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.
4 0 mult f4 – 0 0 0
1 ld f5 – 0 1 1
2 add f2 – 0 0 1
3 add f3 – 0 0 1
4 sub f2 – 0 0 1