Índice de contenido:

1. Objetivo ................................................................................................................................. 2
2. Primera parte ........................................................................................................................ 2
Apartado a: ................................................................................................................................ 2
Apartado b: ............................................................................................................................... 2
Apartado c: ................................................................................................................................ 3
3. Segunda parte ....................................................................................................................... 3
Apartado a: ................................................................................................................................ 5
Apartado b: ............................................................................................................................... 5
Apartado c: ................................................................................................................................ 5
Apartado d: ............................................................................................................................... 7
 1. Objetivo
 Comprender el funcionamiento de las arquitecturas superescalares.
 Entender el funcionamiento de las técnicas especulativas.
 Familiarizarse con el simulador SIMDE.

2. Primera parte
Tras ejecutar el simulador y cargar el fichero ejemplo facilitado por el manual, llamado
bucle.pla, hemos fijado la arquitectura superescalar con los parámetros de configuración
predefinidos. A continuación, hemos inicializado los registros y la memoria con los siguientes
valores:

 Carga un 2.0 en la dirección 40 de memoria

 Carga el vector V a partir de la dirección 50:
V (1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0)
 Asegúrate que el contenido de todos los registros (GPR y FPR) es cero

Apartado a:
Completa la tabla con los valores pedidos:

Grado de emisión 4
Nº entradas ROB 47
Técnica de predicción de saltos Predicción dinámica con 2 bits de
desplazamiento.
BHT de 16 entradas.
% fallos de la caché de datos 0%

Apartado b:
Ejecuta el programa paso a paso e indica el contenido del componente decodificador para
los ciclos 4 y 5. Explica los resultados obtenidos:

En el ciclo 4 aparece en el decodificador las instrucciones 8, 9, 10, porque en la unidad

de pre búsqueda no hay más instrucciones, pues la predicción del salto de la instrucción
10 es no tomado.
En el ciclo 5 no aparece ninguna instrucción, porque el salto se predice como no tomado
y no hay más instrucciones en el programa.

Apartado c:
Calcula el CPI:

El número de ciclos es: 72

El número de instrucciones es: 5 + 16 iteraciones * 6 instrucciones = 101

𝑁º 𝑑𝑒 𝑐𝑖𝑐𝑙𝑜𝑠 72
CP I=
𝑁º 𝑑𝑒 𝑖𝑛𝑠𝑡𝑟𝑢𝑐𝑐𝑖𝑜𝑛𝑒𝑠
= = 0.7128
101

3. Segunda parte
En esta parte veremos en detalle el funcionamiento de las técnicas especulativas en las que se
conjuga la predicción dinámica de saltos para los saltos y la especulación con Tomasulo para
los datos.

 Carga el siguiente programa

Este programa calcula y(i)=x(i)*y(i)+k, siendo x e y dos vectores almacenados en memoria a
partir de las direcciones 10 y 30 respectivamente. El valor k es un escalar que se encuentra
almacenado en la dirección 5 de memoria. Al finalizar el programa nos indica en la direcciones
0 y 1 respectivamente, el número de elementos del vector y la dirección dónde está
almacenado el escalar.

 Carga el fichero memPract5.mem para inicializar la memoria y los registros del sistema
(Configurar --> Contenido memoria/registros Cargar Mem/Reg de Ficheros).

 Configura la máquina superescalar de 2 vías como indica la Figura1 (observa que

también hay que modificar el número de unidades funcionales de cada tipo):
Apartado a:
Explica el funcionamiento de la técnica de predicción de saltos empleada por el simulador
(ayúdate para ello del manual del simulador). Indica el estado del predictor en cada
ejecución de la instrucción de salto.

Es una BHT de 16 entradas. Se indexan con los 4 bits menos significativos de la DIR de
salto. Si una entrada tiene el valor F es que el salto que coincide con esa dirección, por
tanto, no se toma; si vale V el salto se toma. Además de esto se muestra el valor binario
de la entrada de la tabla entre paréntesis.

Apartado b:
Calcula la tasa de aciertos del predictor.

La instrucción de salto se ejecuta 10 veces a lo largo del código PRAC5.PLA, de las cuales falla
tres veces, la primera, la segunda y la última. Por tanto, vamos a tener un porcentaje de
aciertos del 70%:

7
% 𝑑𝑒 𝑎𝑐𝑖𝑒𝑟𝑡𝑜𝑠= * 100= 70%
10

Si el número de iteraciones fuera mayor, el porcentaje de aciertos también lo sería, ya que el

número de fallos de la predicción seguiría siendo tres.

Apartado c:
Indica el contenido del componente prefetch, decodificador y reorder buffer en los ciclos 26
y 27 de ejecución del programa. Razona los resultados.
Ciclo 26:

 Prefetch:

 Decodificador:

 Reorder Buffer:

Entrada Instrucción Destino Valor Dir Etapa

11 11 3 31 -1 Write
12 12 -1 1 -1 Write
13 13 -1 20 0 Write
14 14 -1 5 1 Write

Ciclo 27:

 Prefetch:

5
6
7
8

 Decodificador:

 Reorder Buffer:
Entrada Instrucción Destino Valor Dir Etapa

En el ciclo 26 nos encontramos con la siguiente situación:

Tras la primera iteración, llegamos a la instrucción de salto y, puesto que inicialmente el salto
lo hemos predicho como no tomado, se emiten las instrucciones siguientes a él, las dos
instrucciones SI. En este punto, el simulador ya ha hecho la pre-búsqueda de todas las
instrucciones, las cuales ya están todas decodificadas, por lo que prefetch y decodificador
están vacíos los dos.

En este ciclo se comprueba que el salto es realmente tomado, y por tanto, la

predicción ha sido errónea, por este motivo, en el siguiente ciclo, el 27, el Reorder Buffer se
vacía, se actualiza la predicción de salto y se realiza la pre-búsqueda de las instrucciones
correctas.

Apartado d:
Completa la tabla siguiente con los ciclos de inicio y fin de cada etapa para todo el fragmento
de programa, considerando sólo la primera iteración. ¿Se emiten las instrucciones en orden?
¿Se ejecutan en orden?

Instrucción Emisión Ejecución Escritura Terminación

Issue Execute resultado Commit
WriteResult
ADDI R2 R0 #10 3 4 5 6
ADDI R3 R0 #30 3 5 6 7
ADDI R4 R0 #5 5 6 7 8
LF F0 (R4) 5-6 7-12 13 14
ADDI R5 R2 #10 6 7 8-13 14
LF F1 (R2) 6 7-12 13-14 15
LF F2 (R3) 7 8-13 14 15
MULTF F1 F1 F2 7-13 14-19 20 21
ADDF F1 F1 F0 8-19 20-23 24 25
SF F1 (R3) 8 9-24 25 26
ADDI R2 R2 #1 9 10 11-25 26
ADDI R3 R3 #1 9 11 12-26 27
BNE R2 R5 10 11-12 13-26 27