Arquitectura de Computadores. Ejercicios resueltos.

1. [Ejercicio de predicción dinámica de bifurcaciones]. En una determinada

arquitectura se ha implementado la predicción hardware de bifurcaciones mediante una tabla
BHT con un campo de predicción de bifurcaciones de 2 bits. Partiendo de un estado con
predicción efectiva, completa la siguiente tabla: [6]

Predicción de salto de 2 bits

Condición de salto
Vista en clase de teoría Contador saturado
Se cumple Predicción efectiva Predicción efectiva
No se cumple Predicción efectiva Predicción efectiva
No se cumple Predicción no efectiva Predicción no efectiva
Se cumple Predicción no efectiva Predicción efectiva
No se cumple Predicción no efectiva Predicción no efectiva
No se cumple Predicción no efectiva Predicción no efectiva
Se cumple Predicción no efectiva Predicción no efectiva
[Cada acierto/error suma/resta ½]

2. [Ejr. de planificación Warren para un procesador VLIW]. Sea un procesador

VLIW con capacidad de codificar en una sola instrucción dos operaciones de acceso a memoria,
una aritmética de punto flotante y una entera o de bifurcación.
Las latencias del procesador son: retardo de carga, 1 ciclo; dependencia verdadera entre dos
operaciones aritmético-lógicas de punto flotante, 4 ciclos; dependencia entre una aritmético-
lógica FP y un almacenamiento, 3 ciclos; dependencia entre entera y bifurcación, 1 ciclo. Las
falsas dependencias no impiden colocar dos operaciones en una misma instrucción.
loop: L.D F0,0(R1) ; i1
MUL.D F2,F0,F10 ; i2
L.D F4, 0(R2) ; i3
MUL.D F6,F4,F12 ; i4
ADD.D F0,F6,F2 ; i5
S.D F0,0(R1) ; i6
DADDI R1,R1,#8 ; i7
DADDI R2,R2,#8 ; i8
DADDI R3,R3,#8 ; i9
SGEI R6,R3,et1 ; i10
BEQZ R6, loop ; i11
NOP
Planifica el código anterior aplicando el algoritmo de Warren, para ello:
A) Completa el grafo de dependencias con cada una de las dependencias del bloque básico y su
correspondiente separación mínima en ciclos. Asume que el compilador sabe que R1≠R2. Sigue
el formato de las dependencias que tienes resueltas, con d, ad o ds para el tipo de dependencia.
[4]
{(i1,i2,2,d), (i1,i5,0,ds), (i1,i6,1,d), (i1,i6,0,ad), (i1,i7,0,ad), (i2,i5,5,d), (i2,i5,1,ad), (i3,i4,2,d), ...
(i3,i8,0,ad), (i4,i5,5,d), (i5,i6,4,d), (i6,i7,0,ad), (i9,i10,1,d), (i10,i11,2,d) .......................................
........................................................................................................................................................ }
B) Prepara el grafo anterior para planificar el bloque básico. Indica qué arcos quitas y cuáles
añades al grafo. [1+1+2=5]
B1/ Suprime los arcos que unan instrucciones que el compilador pueda cambiar de orden
retocando una de ellas (indica a continuación cada uno de los arcos que suprimes):
(i1,i7,0,ad), (i3,i8,0,ad), (i6,i7,0,ad)................................................................................................

B2/ Aunque no haya dependencia de datos, todos los nodos deben preceder a la bifurcación.
Indica a continuación qué arcos debes añadir para que se cumpla esta propiedad (la instrucción
NOP se ignora)
(i8,i11,0), (i7,i11,0), (i6,i11,0) .........................................................................................................

B3/ Suprime todo arco que una dos nodos unidos por un camino de mayor o igual longitud que
la del arco (indica a continuación que arcos del grafo suprimes):
(i1,i5,0,ds), (i1,i6,1,d), (i1,i6,0,ad), (i2,i5,1,ad) ..............................................................................

C) Escribe en la primera celda libre de la columna “Grafo” de la tabla siguiente cómo ha quedado
el grafo tras las operaciones realizadas en el apartado anterior y suprimiendo el tipo de
dependencia. Aplica a ese grafo el algoritmo de Warren teniendo en cuenta las características
del procesador VLIW. [6]
 Nodos Nodo
CT Grafo TTE
elegibles planificado

{(i1,i2,2), (i2,i5,5), (i3,i4,2), (i4,i5,5), (i5,i6,4),

i1,i3,i7,
0 i1 (i6,i11,0), (i7,i11,0), (i2,2)
i8, i9
(i8,i11,0), (i9,i10,1), (i10,i11,2)}

{(i2,i5,5), (i3,i4,2), (i4,i5,5), (i5,i6,4),

i3,i7, i8,
0 i3 (i6,i11,0), (i7,i11,0), (i2,2), (i4,2)
i9
(i8,i11,0), (i9,i10,1), (i10,i11,2)}

{(i2,i5,5), (i4,i5,5), (i5,i6,4),

(i2,2), (i4,2),
0 i7, i8, i9 i9 (i6,i11,0), (i7,i11,0),
(i10,1)
(i8,i11,0), (i9,i10,1), (i10,i11,2)}

{(i2,i5,5), (i4,i5,5), (i5,i6,4),

(i2,2), (i4,2),
1 i7, i8, i10 i10 (i6,i11,0), (i7,i11,0),
(i11,3)
(i8,i11,0), (i10,i11,2)}

i7, i8, i2, {(i2,i5,5), (i4,i5,5), (i5,i6,4), (i4,2), (i5,7),

2 i2
i4 (i6,i11,0), (i7,i11,0), (i8,i11,0)} (i11,3)

{(i4,i5,5), (i5,i6,4), (i4,2), (i5,7),

2 i7, i8 i7
(i6,i11,0), (i7,i11,0), (i8,i11,0)} (i11,3)

{(i4,i5,5), (i5,i6,4),
3 i4, i8 i4 (i5,8), (i11,3)
(i6,i11,0), (i8,i11,0)}

3 i8 i8 {(i5,i6,4), (i6,i11,0), (i8,i11,0)} (i5,8), (i11,3)

8 i5 i5 {(i5,i6,4), (i6,i11,0)} (i6,12), (i11,3)

12 i6 i6 {(i6,i11,0)} (i11,12)

12 i11 i11
 D) Escribe a continuación cómo ha quedado el código tras la planificación del apartado C (deben
aparecer las instrucciones completas):

Eti-
quet Acceso a memoria Acceso a memoria FP Entera/bifurcación
a
loop L.D F0,0(R1) L.D F4, 0(R2) DADDI R3,R3,#8
SGEI R6,R3,et1
MUL.D F2,F0,F10 DADDI R1,R1,#8
MUL.D F6,F4,F12 DADDI R2,R2,#8

ADD.D F0,F6,F2

S.D F0,-8(R1) BEQZ R6, loop

Ejercicios aparecidos en diversos exámenes de la asignatura.

3. Indica qué dependencias inter-iteraciones (loop-carried) hay en el código de la pregunta

siguiente con ADD.D F2,F0,F2 como primera instrucción. Escribe tu respuesta completando la tabla: [5]

Instrucción dependiente de
Tipo de dependencia Operando
ADD.D F2,F0,F2
L.D F0, 0(R1) WAR F0
MUL.D F0, F0, F4 WAR F0
ADD.D F2,F0,F2 RAW F2
ADD.D F2,F0,F2 WAW F2
ADD.D F2,F0,F2 WAR F2
4. Considera el siguiente fragmento de código MIPS:
i1: L.D F0, 0(R1) ; i1
L.D F4, 0(R2) ; i2
MUL.D F0, F0, F4 ; i3
ADD.D F2, F0, F2 ; i4
DADDUI R1, R1, #-8 ; i5
DADDUI R2, R2, #-8 ; i6
BNEZ R1, i1 ; i7
Asume que el valor inicial de R1 es 800 y que hay anticipación y bifurcaciones retardadas un
ciclo. Se sabe que la suma de punto flotante requiere 4 ciclos en la fase de ejecución y la
multiplicación, 5 ciclos.

A) Muestra el diagrama instrucciones-tiempo correspondiente a la ejecución del código

considerado, hasta que la primera instrucción del bucle es emitida por segunda vez. [4]
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
i1: L.D F0, 0(R1) F D X M W F D X
L.D F4, 0(R2) F D X M W F D
MUL.D F0, F0, F4 F D D X X X X X M W F
ADD.D F2, F0, F2 F s D s s s s X X X X M W
DADDUI R1, R1, #-8 F s s s s D X M W
DADDUI R2, R2, #-8 F D X M W
BNEZ R1, loop F D
NOP F

B) Calcula el número total de ciclos que conlleva la ejecución del bucle. [2]
El número de iteraciones es 800/8 = 100.
Cada iteración empieza y termina 13 ciclos después que la anterior y la primera iteración termina
en el ciclo 16 (13+3). Por tanto, la iteración i termina en el ciclo i×13+3. La iteración 100
terminará en el ciclo 100×13+3 = 1303.

C) Completa el grafo de dependencias con cada una de las dependencias del bloque básico y su
correspondiente separación mínima en ciclos (sigue el formato de la dependencia que tienes
resuelta, con d, ad o ds para el tipo de dependencia). [3,5]

{(i1,i3,2,d), (i1,i3,1,ds), (i1,i4,2,d), (i1,i5,1,ad), (i2,i3,2,d), (i2,i6,1,ad), (i3,i4,5,d), (i5,i7,2,d) .......

........................................................................................................................................................ }

D) Prepara el grafo para aplicar el algoritmo de Warren. Escribe en forma de texto y sin
especificar el tipo de dependencia como ha quedado el grafo preparado: [3]

{(i1,i3,2), (i2,i3,2), (i3,i4,5), (i5,i7,2), (i6,i7,1), (i4,i7,1)}

E) Planifica el bloque básico del bucle aplicando el algoritmo de Warren al grafo anterior. [4,5]

Tiempos más
Nodos Nodo
CT Grafo tempranos de
elegibles planificado
ejecución

{(i1,i3,2), (i2,i3,2), (i3,i4,5), (i5,i7,2),

1 i1, i2, i5, i6 i1 (i3, 3)
(i6,i7,1), (i4,i7,1)}

{(i2,i3,2), (i3,i4,5), (i5,i7,2),

2 i2, i5, i6 i2 (i3, 4)
(i6,i7,1), (i4,i7,1)}

3 i5, i6 i5 {(i3,i4,5), (i5,i7,2), (i6,i7,1), (i4,i7,1)} (i3,4), (i7,5)

4 i3, i6 i3 {(i3,i4,5), (i6,i7,1), (i4,i7,1)} (i4,9), (i7,5)

5 i6 i6 {(i6,i7,1), (i4,i7,1)} (i4,9), (i7,6)

9 i4 i4 {(i4,i7,1)} (i7,10)

10 i7 i7

F) Indica en la siguiente tabla cómo queda finalmente planificado el bucle, y en qué ciclo se emite
cada instrucción, tras colocar la instrucción adecuada en el hueco de retardo de la bifurcación.
[2]

Etiqueta Instrucción Ciclo

i1 L.D F0, 0(R1) 1
i2 L.D F4, 0(R2) 2
i5 DADDUI R1, R1, #-8 3
i3 MUL.D F0,F0,F4 4
i6 DADDUI R2, R2, #-8 5
i7 BNEZ R1, i1 6
i4 ADD.D F2, F0, F2 9
 5. Desenrolla una iteración del siguiente bucle y planifica el resultado sobre una arquitectura
VLIW que disponga de 2 unidades de acceso a memoria, 2 unidades de punto flotante y una
unidad entera. Ten en cuenta que la latencia entre una carga y una operación de punto flotante
dependiente es de 2 ciclos, mientras que en el caso de dos operaciones de punto flotante (o una
de punto flotante y un almacenamiento) dependientes es de 3 ciclos.
loop: L.D F0, 0(R1)
ADD.D F6, F0, F2
L.D F4, 0(R2)
ADD.D F8, F6, F4
S.D F8, 0 (R1)
ADDI R1, R1, #-8
ADDI R2, R2, #-8
BNEZ R1, Loop
Respuesta
Bucle desenrollado para un procesador escalar (sin planificar):

loop: L.D F0, 0(R1) ;i1

ADD.D F6, F0, F2 ;i2
L.D F4, 0(R2) ;i3
ADD.D F8, F6, F4 ;i4
S.D F8, 0 (R1) ;i5
L.D F10, -8(R1) ;i6
ADD.D F12, F10, F2 ;i7
L.D F14, -8(R2) ;i8
ADD.D F16, F12, F14 ;i9
S.D F16, -8 (R1) ;i10
ADDI R1, R1, #-16 ;i11
ADDI R2, R2, #-16 ;i12
BNEZ R1, Loop ;i13

Bucle desenrollado planificado sobre la arquitectura VLIW:

Ciclo Etiqueta Mem1 Mem2 FP1 FP2 Int
1 Loop L.D F0, 0(R1) L.D F10, -8(R1)
2 L.D F4, 0(R2) L.D F14, -8(R2) ADDI R1, R1, #-16
3 ADDI R2, R2, #-16
4 ADD.D F6, F0, F2 ADD.D F12, F10, F2
5
6
7
8 ADD.D F8, F6, F4 ADD.D F16, F12, F14
9
10
11
12 S.D F8, 16 (R1) S.D F16, 8 (R1) BNEZ R1, Loop