ARQUITECTURA DE COMPUTADORES

Examen Final. Febrero de 2005

1. (1.5 puntos) En un procesador vectorial a 1 GHz, con registros vectoriales de 32 componentes, tres unidades de
carga/almacenamiento de memoria (LV/SV), un sumador y un multiplicador segmentados, se ejecuta el bucle:
for i:=1 to 350 do Z(i):=Z(i)+X[i]*Y[i]
Determine el valor de R teniendo en cuenta que el procesador puede encadenar y solapar los cauces y que cada uno de
esos cauces, por separado, puede terminar un componente por ciclo.
(Nota: TLI(Mult) =16 ciclos; TLI(Suma)=8 ciclos; TLI(LV/SV)=8; TBASE=8 ciclos; TBUCLE=10 ciclos).
2. (2 puntos) En un procesador VLIW cuyas instrucciones pueden codificar tres operaciones (tres campos o slots en
cada instruccin VLIW), todas las operaciones pueden predicarse. Para establecer los valores de los predicados se
utilizan instrucciones de comparacin (cmp) con el formato (p) p1[, p2] cmp.cnd x,y donde cnd es la condicin que se
comprueba entre x e y (lt, ge, eq, ne, ). Si la condicin es verdadera p1=1 [y p2=0], y si es falsa, p1=0 [y p2=1]. La
operacin slo se ejecuta si el predicado p=1 (habr sido establecido por otra instruccin de comparacin).
Indique cmo se escribira la sentencia
for i=1 to 2 do if ((X[i]>Y[i]) and (Y[i]0)) then X[i]=-X[i] else if (Y[i]<0) then X[i]=Y[i]
sin ninguna operacin de salto y con el mnimo nmero de instrucciones VLIW, teniendo en cuenta que las
instrucciones de comparacin slo pueden aparecer en el primer campo o slot de la instruccin VLIW (el resto de las
instrucciones pueden aparecer en cualquier campo). Considere que dispone del nmero de unidades funcionales que
necesite en cada momento.
3. (2 puntos) 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 mximo, y se retiran hasta tres instrucciones por
ciclo. La emisin y la ejecucin son desordenadas, y las instrucciones, una vez decodificadas, se introducen en un
buffer de reordenamiento (ROB) que permite la finalizacin ordenada del procesamiento de las instrucciones.
Indique las dependencias entre instrucciones y cmo evolucionara el buffer de reordenamiento hasta que se hayan
retirado todas las instrucciones de la secuencia:
addd
multd
addd
subd

f1, f1 ,f4
f3, f1, f2
f6, f1, f4
f4, f1, f6

; f1 = f1 + f4
; f3 = f1 * f2
; f6 = f1 + f4
; f4 = f1 f6

Suponiendo una frecuencia de 2 GHz, cunto tarda en procesarse la secuencia de instrucciones? Cul es la velocidad
pico del procesador?
NOTA: La suma y la resta consumen un ciclo de reloj y la multiplicacin cuatro ciclos. Considere que no hay
limitaciones en la capacidad de los buffers, y en el nmero de unidades funcionales. Se supone que f1, f2, y f4 tienen
valores vlidos previos.
4. (1.5 punto) Una funcin F se va a implementar en un cauce con 5 etapas S1, S2, S3, S4, S5 de forma que visita las
etapas segn la secuencia: S1 S5 S1 S4 S3 S2 S1 S4. Obtenga la ganancia en velocidad con respecto a la ejecucin sin
cauce para 200 operaciones, teniendo en cuenta que sin cauce la funcin requiere un tiempo de 16 ns y que las etapas
del cauce suponen unos tiempos de ejecucin de 4 ns para S1, S4 y S5, 5 ns para S2, y 3 ns para S3 (incluyendo los
retardos de los registros de acoplo). Cul es la productividad en funcin del nmero de operaciones? Determine los
valores de la productividad mxima y la ganancia mxima.
5. (1 punto) Suponga que en los programas que constituyen la carga de trabajo habitual de un procesador las
operaciones de coma flotante consumen un promedio del 10% del tiempo de ejecucin de los programas y las de enteros
un 20%. Las operaciones de coma flotante se hacen en una unidad funcional con un retardo de 6 ciclos y las de enteros
en otra unidad con un retardo de 2 ciclos. Qu es mejor reducir un ciclo el retardo de la unidad de enteros o 4 ciclos el
de la de coma flotante? Cul es la mxima ganancia de velocidad que se puede obtener por mejoras en la unidad de
enteros? Y por mejoras en la de coma flotante?

Solucin al Problema 1:
Dado que el tamao de los registros vectoriales del procesador propuesto en el problema es MVL = 32 y que el vector que deseamos
procesar tiene un tamao n = 350 mayor, tendremos que aplicar la tcnica de strip-mining para trocear el vector y procesarlo
iterativamente. El compilador realizar un cambio al cdigo similar a este:
low = 1;
VL = (n mod MVL); /* resto de la division */
for ( j = 0 ; j <= (n / MVL) ; j++)
{
for ( i = low ; i < low + VL ; i++)
Z(i):= Z(i)+X(i)*Y(i);
low += VL;
VL = MVL;
}

Al traducir este cdigo a ensamblador, el bucle que se encuentra sombreado se cambiar por instrucciones vectoriales y el resto de
instrucciones permanecern tal y como estn.
Dado que R se define como

R = lim Rk = lim
k

k operaciones vectoriales frecuencia

Tk

el primer paso consistir en estimar el tiempo Tk. Para ello, debemos determinar las instrucciones vectoriales que se ejecutarn dentro
del bucle interno y la forma en que se solaparn y encadenarn. Dichas instrucciones sern tres cargas vectoriales de X, Y, y Z, una
multiplicacin, una suma y un almacenamiento del resultado en Z. El diagrama de tiempos de estas instrucciones es el siguiente:
TLI=8

LV VX, RX

TLI=8

LV VY, RY

TLI=8

LV VZ, RZ
MULT V1, VX, VY

TLI=16

ADD VZ, VZ, V1

TLI=8

TLI=8
8

32

32

SV RZ, VZ

Como slo tenemos tres unidades de carga/almacenamiento, la instruccin SV debe esperar a que terminen las instrucciones LV, por
tanto, tenemos que el tiempo por componente es TPC = 2 y que el tiempo de latencia inicial TLI = 8 + 8 = 16, ya que la
multiplicacin y la suma han quedado solapadas con las instrucciones de carga y de almacenamiento. Con estos valores de TLI y
TPC y con los valores de TBASE y TBUCLE que nos dan en el enunciado del problema, podemos calcular Tk como:
k
k
Tk = TBASE +
(TLI + TBUCLE ) + k TPC = 8 + 32 (16 + 10) + 2k ciclos
MLV

Una vez obtenido Tk, obtenemos R:

R = lim Rk = lim
k

k ops vec frecuencia

= lim
k
Tk

k 2 1000
2000k
= lim
= 711,11 MFLOPS
k
k
k
8 + (16 + 10 ) + 2k
8 + (26) + 2k
32
32

Solucin al Problema 2:
Como en el enunciado nos indican que la secuencia de instrucciones debe quedar sin ningn salto, debemos desenrollar el bucle y
predicar las instrucciones que contiene en su interior. A continuacin se muestran el organigrama del programa una vez que se ha
desenrollado el bucle y se han predicado las instrucciones y su cdigo en ensamblador derivado.
Inicio
(p1)

Si

Y[1] 0
(p3)

X[1] > Y[1]

(p4)

Si

Y[2] 0

No
(p1)
(p3)
(p2)
(p4)

Si

X[1] Y[1]

X[1] X[1]

(p7)

(p2)
Y[1] < 0

No (p2)

Si

(p5)

No

X[2] > Y[2]

No

(p6)
Y[2] < 0

No (p6)

(p8)

Si

No
(p5)
(p7)
(p6)
(p8)

Si

X[2] Y[2]

X[2] X[2]

Fin

p3
p4

cmp.ne
cmp.ne
lw
lw
p1, p2 cmp.gt
p3, p2 cmp.ge
sub
p4
cmp.lt
add
sw

r0, r0
r0, r0
r1, X(r0)
r2, Y(r0)
r1, r2
r2, r0
r1, r0, r1
r2, r0
r1, r0, r2
r1, X(r0)

; p3 0
; p4 0
; r1 X[1]
; r2 Y[1]
; p1 1 si X[1] > Y[1]
; p3 1 si Y[1] 0
; r1 X[1]
; p4 1 si Y[1] < 0
; r1 Y[1]
; X[1] r1

p7
p8

r0, r0
r0, r0
r3, X+4(r0)
r4, Y+4(r0)
r3, r4
r4, r0
r3, r0, r3
r4, r0
r3, r0, r4
r3, X+4(r0)

; p7 0
; p8 0
; r3 X[2]
; r4 Y[2]
; p5 1 si X[2] > Y[2]
; p7 1 si Y[2] 0
; r3 X[2]
; p8 1 si Y[2] < 0
; r3 Y[2]
; X[2] r3

cmp.ne
cmp.ne
lw
lw
p5, p6 cmp.gt
p7, p6 cmp.ge
sub
p8
cmp.lt
add
sw

Tras desenrollar e introducir las operaciones con predicados, slo nos queda reorganizar el cdigo respetando las dependencias de
datos para construir las instrucciones VLIW:

(p1)
(p2)

(p5)
(p6)

p3
p4
p1, p2
p3, p2
p4
p7
p8
p5, p6
p7, p6
p8

Slot 1
cmp.ne
cmp.ne
cmp.gt
cmp.ge
cmp.lt
cmp.ne
cmp.ne
cmp.gt
cmp.ge
cmp.lt

r0, r0
r0, r0
r1, r2
r2, r0
r2, r0
r0, r0
r0, r0
r3, r4
r4, r0
r4, r0

(p3)
(p4)

Slot 2
lw
lw

r1, X(r0)
r2, Y(r0)

Slot 3

sub
add
sw

r1, r0, r1
r1, r0, r2
r1, X(r0)

(p7)
(p8)

lw
lw

r3, X+4(r0)
r4, Y+4(r0)

sub
add
sw

r3, r0, r3
r3, r0, r4
r3, X+4(r0)

Solucin al Problema 3:
Ya que el procesador no dispone de estaciones de reserva, la lgica de emisin tiene que esperar a que los operandos le sean
facilitados por la lgica de bypass, por tanto, las dependencias RAW afectarn al orden de emisin de las instrucciones. En concreto,
las instrucciones (2), (3) y (4) dependen del valor de f1 producido por la instruccin (1) y la instruccin (4) depende del valor de f6
producido por la instruccin (3)
Teniendo en cuenta estas dependencias, las instrucciones se ejecutaran como se muestra en la siguiente figura:
Instruccin
(1) addd
(2) multd
(3) addd
(4) subd

/ Ciclo
f1, f1, f4
f3, f1, f2
f6, f1, f4
f4, f1, f6

1
IF
IF
IF
IF

2
ID/ISS
ID/ISS
ID/ISS

3
EX

4
ROB
EX
EX

ID/ISS

5
WB
EX
ROB
EX

EX

EX

ROB

WB
WB
WB

ROB

A continuacin pasamos a describir la evolucin del buffer de reorden:

Ciclo 2:
Se decodifican las instrucciones (1), (3) y
(3) y se introducen en el ROB

#
1
2
3

Cod. Op.
addd
multd
addd

Dest.
f1
f3
f6

Result.
?
?
?

Ok
0
0
0

Ciclo 3:
Se decodifica la instruccin (4) y se
introducen en el ROB

#
1
2
3
4

Cod. Op.
addd
multd
addd
subd

Dest.
f1
f3
f6
f4

Result.
?
?
?
?

Ok
0
0
0
0

Ciclo 4:
Finaliza la instruccin (1) y se escribe el
resultado en el ROB

#
1
2
3
4

Cod. Op.
addd
multd
addd
subd

Dest.
f1
f3
f6
f4

Result.
f1 + f4
?
?
?

Ok
1
0
0
0

Ciclo 5:
Se retira la instruccin (1) del ROB
Finaliza la instruccin (3) y se escribe el
resultado en el ROB

#
2
3
4

Cod. Op.
multd
addd
subd

Dest.
f3
f6
f4

Result.
?
f1 + f4
?

Ok
0
1
0

Ciclo 6:
Finaliza la instruccin (4) y se escribe el
resultado en el ROB

#
2
3
4

Cod. Op.
multd
addd
subd

Dest.
f3
f6
f4

Result.
?
f1 + f4
f1 f6

Ok
0
1
1

Ciclo 8:
Finaliza la instruccin (3) y se escribe el
resultado en el ROB

#
2
3
4

Cod. Op.
multd
addd
subd

Dest.
f3
f6
f4

Result.
f1 * f2
f1 + f4
f1 f6

Ok
1
1
1

Ciclo 9:
Se retiran las instrucciones (2), (3) y (4)

Cod. Op.

Dest.

Result.

Ok

Si el procesador funciona a 2 GHz, el tiempo de procesamiento sera

9 ciclos * 51010 s/ciclo = 4,5109 s = 4,5 ns
Para la calcular la velocidad pico, como slo se pueden retirar dos instrucciones por ciclo, suponiendo que no hubiera atascos en el
cauce se podran ejecutar 3 instrucciones por ciclo
3 instr./ciclo * 2109 ciclos/s = 6 GIPS

Solucin al Problema 4:
La ganancia en velocidad S(n) se define como el cociente entre los tiempos sin segmentar y segmentado para ejecutar n operaciones:
S Seg ( n ) =

T Orig ( n )
T Seg ( n )

T Orig ( n )
TLI + ( n 1) MLM

Viendo el tiempo de ejecucin de las diferentes etapas, fijaremos el tiempo de reloj del cauce a:
TReloj = max {3 ns , 4 ns , 5 ns } = 5 ns

Por lo que el tiempo de latencia inicial es:

TLI = 8 etapas T Reloj = 8 5 ns = 40 ns

Una vez obtenido el TLI, slo nos queda obtener la Mnima Latencia Media (MLM) del cauce propuesto en el enunciado. La tabla de
reservas del cauce es la siguiente:
1
X

S1
S2
S3
S4
S5

3
X

7
X

X
X
X

Mediante esta tabla de reservas, es fcil obtener las latencias prohibidas y los vectores de colisiones:
F = {2,4,6}

C = (101010)

Por ltimo, para determinar la MLM, realizamos un diagrama de estados a partir del vector de colisiones:
7+
7+

101111

3
5

7+
101010
1
7+

101011

111111
5

3
La mnima latencia mnima del cauce es:

MLM = (5 + 3) / 2 = 4 ciclos = 4 5 ns = 20 ns
Por tanto, el tiempo tardar la ejecucin de n operaciones en el cauce segmentado ser
T Seg ( n ) = TLI + ( n 1) MLM = 40 + ( n 1) 20 = 20 ( n + 1)

Utilizando esta expresin, ya podemos calcular la ganancia en velocidad para 200 operaciones mediante:
S Seg ( 200 ) =

T Orig ( 200 )
T Seg ( 200 )

200 16
3200
=
= 0 .796
20 ( 200 + 1) 3980

La productividad en funcin del nmero de operaciones se define como:

W Seg ( n ) =

n
n
=
TSeg ( n ) 20 ( n + 1)

Los valores para la productividad y la ganancia mximas son:

Wmax =

1
1
=
= 50 MOPS
MLM 20 ns

S max =

16
16
=
= 0.8
MLM 20

Solucin al Problema 5:
Este problema se puede resolver simplemente aplicando la ley de Amdahl, definida como:

p
1 + f ( p 1)

donde f es el porcentaje de tiempo que no se usa la unidad mejorada y p es el factor de mejora aplicado a dicha unidad.
En el caso de que se mejore la unidad de ejecucin de operaciones con enteros:
fent = 1 0.2 = 0.8

pent = 2 / (2 1) = 2

mientras que si se mejora la unidad de ejecucin de operaciones en coma flotante:

fFP = 1 0.1 = 0.9

pFP = 6 / (6 4) = 3

Para ver qu mejora es ms conveniente, simplemente debemos aplicar la ecuacin anterior:

Sent

2
= 1.1
1 + 0.8(2 1)

S FP

3
= 1.07
1 + 0.9(3 1)

Con lo que teniendo en cuenta las cargas de trabajo habituales ejecutadas, conviene ms realizar la mejora a la unidad de enteros.
Si la mejora que se realiza en las unidades de ejecucin fuese mxima, es decir, p , la ganancia mxima que se podra obtener
sera:
S max ent = lim S ent =
p

1
f ent

1
= 1.25
0.8

S max FP = lim S FP =
p

1
1
=
= 1.11
f FP 0.9