ARQUITECTURA DE COMPUTADORES I (4 de Febrero de 2010)

1. (2.5 puntos) Suponga que en el siguiente programa n = 10

8
, a y b son dos vectores de
nmeros en coma flotante, y z es un escalar en coma flotante.
z = 0;
for (i = 0 ; i < n ; i++)
z = z + a[i] * b[i];
a) El programa anterior se implementa en un procesador segmentado de 1 GHz,
que ejecuta instrucciones DLX, con salto retardado y un hueco para
instrucciones tras la instruccin de salto. Adems, la unidad de multiplicacin en
coma flotante tiene una latencia de 4 ciclos y la de suma en coma flotante de dos
ciclos. Indique si hay algn problema en la ejecucin del cdigo anterior si el
procesador no anula nunca la instruccin siguiente al salto. Qu cambios hara
en el cdigo en el caso en que haya problemas y/o para que, si es posible, se
mejoren las prestaciones?
b) Estime el tiempo mnimo de ejecucin si el computador dispone de caches de
datos y de instrucciones de 64 KBytes cada una, lneas de 32 bytes, mapeo
directo, poltica de actualizacin de post-escritura (write-back), y tiempo de
acceso de un ciclo de reloj. La memoria principal de 2 GBytes tiene un tiempo
de acceso de 50 ns y se conecta a travs de un bus de 64 bits a 100 MHz. que
utiliza ciclos burst 5-1-1-1 para transferir las lneas de cache.
c) Qu es mejor, sustituir el procesador segmentado por otro superescalar a
2 GHz que pueda terminar hasta tres instrucciones por ciclo, o utilizar caches
del doble de tamao?
Solucin
a) A continuacin se muestra una posible implementacin del fragmento de cdigo del enunciado:
add r1, r0, r0 ; r1 = i (inicialmente a 0)
subd f0, f0, f0 ; f0 = z (inicialmente a 0)
lw r2, n ; r2 = Nmero de elementos
bucle: ld f2, a(r1) ; f2 = a[i]
ld f4, b(r1) ; f4 = b[i]
multd f6, f4, f2 ; f6 = a[i] * b[i]
addd f0, f0, f6 ; f0 = f0 + a[i] * b[i]
addi r1, r1, #8 ; i = i + 1 (los datos son de doble precisin -> 8 bytes)
subi r2, r2, #1 ; Queda un elemento menos
bnez r2, bucle ; Saltamos si quedan elementos
sd f0, z ; Almacenamos el resultado
Como la instruccin siguiente al salto se ejecuta siempre (se salte o no), este programa tiene el
inconveniente de que en cada iteracin ir almacenando el valor de la suma parcial de z, que aunque
no cause un resultado errneo, supone un ciclo ms por iteracin y demasiados accesos innecesarios al
sistema de memoria. Por otro lado, dada la cadena de dependencias de datos entre la carga de b[i], la
multiplicacin y la suma, y teniendo en cuenta que el multiplicador tiene una latencia de 4 ciclos, que
el sumador tiene una latencia de 2, y que el cauce est compuesto por k etapas, el tiempo estimado de
ejecucin del cdigo sera de:

T(n) k +3 +12 n
Si se desenrolla el bucle una vez y se reorganizan las instrucciones adecuadamente, se pueden ocultar
las latencias de las multiplicaciones y aprovechar el slot del salto, tal y como se muestra a continuacin:
add r1, r0, r0 ; r1 = i (inicialmente a 0)
subd f0, f0, f0 ; f0 = z (inicialmente a 0)
lw r2, n ; r2 = Nmero de elementos
bucle: ld f2, a(r1) ; f2 = a[i]
ld f4, b(r1) ; f4 = b[i]
multd f6, f4, f2 ; f6 = a[i] * b[i]
ld f8, a+8(r1) ; f8 = a[i + 1]
ld f10, b+8(r1) ; f10 = b[i + 1]
subi r2, r2, #2 ; Quedan dos elementos menos
multd f12, f10, f8 ; f12 = a[i + 1] * b[i + 1]
addd f0, f0, f6 ; f0 = f0 + a[i] * b[i]
addi r1, r1, #16 ; i = i + 2 (los datos son de doble precisin -> 8 bytes)
bnez r2, bucle ; Saltamos si quedan elementos
addd f0, f0, f12 ; f0 = f0 + a[i + 1] * b[i + 1]
sd f0, z ; Almacenamos el resultado
Esta segunda versin del bucle tiene un tiempo de ejecucin estimado de:

T
2
(n) k +3+11
n
2
+2 = k +5+5.5n
Los dos ciclos que se suman al final salen de que como el sumador tiene una latencia de dos ciclos,
hay que esperar un ciclo para realizar el almacenamiento de z. Como se puede comprobar, esta
segunda versin tiene una ganancia mxima de:

S
max
= lim
n
T(n)
T
2
(n)
= lim
n
k +3 +12 n
k +5+5.5n
= 2.18
b) Asumiendo la versin optimizada del algoritmo, con un valor de n = 10
8
, k = 5, y con un sistema de
memoria ideal que fuera capaz de servir todas las operaciones en un ciclo de CPU, el tiempo de
ejecucin del programa sera de:

T
CPU
(n)
k +5+5.5n
f
=
5 +5 +5.510
8
10
9
=
10 +5.510
8
10
9
= 0.55 segundos
Como el sistema de memoria del enunciado no es ideal, a continuacin vamos a estimar el tiempo que
tardara en servir los datos. Para ello, supondremos que el tiempo que tarda en proporcionar las
instrucciones es despreciable, dado el tamao del programa. Tambin despreciaremos el tiempo
necesario para cargar la variable n y para almacenar el resultado z, ya que no es significativo con
respecto al tiempo necesario para cargar los vectores, dado su gran tamao. Como en el enunciado no
se dice nada acerca de la colocaccin de los datos en memoria, supondremos que tanto el primer
elemento de a como el primer elemento de b estn alineados a una lnea de cache. Asumiendo un
tamao de 8 bytes para los nmeros representados en coma flotante, y teniendo en cuenta que las
lneas de cache tienen un tamao de 32 Bytes, la tasa de fallos de la cache de datos ser de:

N
fallos_datos
=
210
8
8
32
= 5010
6

Por tanto, la tasa de fallos ser de:

f
D
=
N
fallos_datos
ND
=
5010
6
2 10
8
= 0.25
y la de aciertos de:

a
D
= 1 f
D
= 10.25 = 0.75
Como ninguno de los elementos de los vectores se modifica, no habr reemplazos. Por tanto, el
tiempo de acceso medio a un dato se puede calcular como:

T
acceso_datos
= a
D
t
D
+ 1a
D ( )
t
D
+t
M ( )
= 0.751 + 10.75
( )
1 +50
( )
= 13.5 ns
Como hay que leer dos vectores de n = 10
8
datos, el tiempo total ser de:

T
Mem
= NDT
acceso_datos
= 210
8
13.510
9
= 2.7 segundos
Por tanto, como T
CPU
< T
Mem
, el tiempo total del ejecucin ser T = T
Mem
= 2.7 segundos.
c) Por un lado, si se usara un procesador superescalar, probablemente se reducira el tiempo de CPU. Sin
embargo, como el cuello de botella est en la lectura de los vectores del sistema de memoria, la
sustitucin del procesador no mejorara el tiempo de ejecucin. Por otro lado, como el cuello de
botella del programa est en la lectura de los dos vectores, aunque se aumentara el tamao de las
caches se seguiran produciendo el mismo nmero de fallos de lectura, ya que el tamao de las lneas
de cache sigue siendo igual. Por tanto, como los tiempos de acceso a cache y a memoria principal
tampoco varan, el tiempo de acceso a los datos seguira siendo el mismo.
2. (2.5 puntos) Suponga un procesador superescalar en el que se pueden captar y decodificar
hasta dos instrucciones por ciclo, emitir hasta tres instrucciones por ciclo como mximo, y
retirar hasta dos instrucciones por ciclo. La emisin es desordenada y no alineada y se realiza
directamente a las unidades de ejecucin, es decir, que el procesador no dispone de
estaciones de reserva. La ejecucin tambin es desordenada, y para permitir la finalizacin
ordenada, se dispone de un bfer de reordenamiento (ROB) en el que se introducen las
instrucciones una vez decodificadas y del que se retiran en orden una vez que han finalizado.
El procesador utiliza un predictor de saltos dinmico de dos bits que se consulta en el
momento de captar las instrucciones, de forma que si la direccin de memoria de la que se
est captando una instruccin se encuentra en el BTB, y la prediccin es saltar, guarda el
contenido actual de PC y se cambia por la direccin de destino del salto para que se empiece
a captar desde ah en el siguiente ciclo. Cuando la instruccin de salto entra en el bfer de
reordenamiento tras la decodificacin, 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 condicin
del salto en la etapa de ejecucin, se comprueba si la prediccin 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 prediccin para continuar con la siguiente
instruccin 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
decodificacin, en la que se emplea un predictor esttico que predice como tomados todos
los saltos hacia atrs y crea una entrada en el BTB para los saltos encontrados.
Indique cuntos ciclos tarda en ejecutarse el siguiente fragmento de cdigo:
for (i = 0 ; i < n ; i++)
d[i] = a[i] + b[i] + c[i];
NOTA: Considere que el procesador dispone de recursos hardware suficientes como para que no se
produzcan riesgos estructurales en la ejecucin.
Solucin
A continuacin se muestra una posible implementacin del fragmento de cdigo del enunciado:
add r1, r0, r0 ; r1 = i (inicialmente a 0)
lw r2, n ; r2 = Nmero de elementos
bucle: lw r3, a(r1) ; r3 = a[i]
lw r4, b(r1) ; r4 = b[i]
lw r5, c(r1) ; r5 = c[i]
add r6, r3, r4 ; r6 = a[i] + b[i]
add r6, r6, r5 ; r6 = a[i] + b[i] + c[i]
sw r6, d(r1) ; d[i] = r6
addi r1, r1, #4 ; i = i + 1 (los enteros son de 4 bytes)
subi r2, r2, #1 ; Queda un elemento menos
bnez r2, bucle ; Saltamos si quedan elementos
La tabla siguiente muestra una traza de la primera iteracin de la ejecucin del programa:
INSTRUCCIN 1 2 3 4 5 6 7 8 9 10 11 12
add r1, r0, r0 IF ID EX ROB WB
lw r2, n IF ID EX ROB WB
lw r3, a(r1) IF ID EX ROB WB
lw r4, b(r1) IF ID EX ROB WB
lw r5, c(r1) IF ID EX ROB WB
add r6, r3, r4 IF ID EX ROB WB
add r6, r6, r5 IF ID EX ROB WB
sw r6, d(r1) IF ID EX ROB WB
addi r1, r1, #4 IF ID EX ROB WB
subi r2, r2, #1 IF ID EX ROB WB
bnez r2, bucle IF ID EX ROB WB
Siguiente instruccin IF ID EX Flush

Inicializacin 1
Cuerpo del bucle 11
Pred. esttico 6
Pred. dinmico 5

En las filas inferiores de la tabla se muestra que la primera iteracin del bucle tarda 1 ciclo en empezar,
ya que las instrucciones de inicializacin de r1 y r2 se capta en el primer ciclo. Tambin se muestra que
cada iteracin del bucle tarda 11 ciclos debido a las dependencias RAW existentes entre sus
instrucciones. En cuanto al resto de las iteraciones, la segunda se comenzar 6 ciclos despus de la
primera, ya que la primera vez se predice el salto mediante el predictor esttico, que se aplica en la
etapa de decodificacin del salto (ciclo 7). Para el resto de iteraciones se usar el predictor dinmico,
qu se aplica en la etapa de captacin del salto, por lo que empezarn 5 ciclos despus de la anterior.
Teniendo esto en cuenta, el tiempo de ejecucin del programa para n iteraciones es de:
T(1) = 1 + 11 = 12 ciclos
T(2) = 1 + 6 + 11 = 18 ciclos
T(3) = 1 + 6 + 5 + 11 = 23 ciclos
T(4) = 1 + 6 + 5 + 5 + 11 = 28 ciclos
T(n) = 1 + 6 + 5(n 2) + 11 = 18 + 5(n 2) = 8 + 5n ciclos (para n > 2)

3. (1.5 puntos) Suponga un procesador VLIW que puede codificar dos operaciones por
instruccin, de forma que las comparaciones slo pueden codificarse en el primer slot, las
transferencias con memoria y los saltos slo pueden colocarse en el segundo, y el resto de las
operaciones en cualquiera de los dos. El procesador puede utilizar predicados con cualquier
instruccin. Estos predicados se establecen a partir de los resultados de las instrucciones de
comparacin (cmp) con el formato (p) p1, p2 cmp.cnd rx, ry donde cnd es la condicin que se
comprueba entre los registros rx y ry (lt, ge, eq, ne,). Si la condicin es verdadera p1 = 1 y
p2 = 0, y si es falsa, p1 = 0 y p2 = 1. La instruccin slo se ejecuta si el predicado p = 1
(habr sido establecido por otra instruccin de comparacin). Tambin existen instrucciones
de comparacin con el formato (p) p1 cmp.cnd rx, ry donde p1 = 1 si la condicin es verdadera
y p1 = 0 si es falsa. Si una instruccin no tiene el predicado (p), se entiende que se ejecuta
siempre.
Si sabemos de antemano que el 75% de los elementos del vector a son negativos, muestre
cmo sacar provecho de la instruccin de carga especulativa lw.s (sin desenrollar el bucle).
for (i = 0 ; i < n ; i++)
if (a[i] < 0)
a[i] = b[i];
Qu ganancia en velocidad mxima se podra obtener con respecto a la ejecucin del cdigo
sin hacer uso de la instruccin de carga especulativa?
NOTA: La latencia de las cargas de memoria es de 4 ciclos, la de los saltos es de dos ciclos y la del
resto de operaciones es de 1 ciclo.
Solucin
A continuacin se muestra una posible implementacin del fragmento de cdigo del enunciado:
add r1, r0, r0 ; r1 = i (inicialmente a 0)
lw r2, n ; r2 = Nmero de elementos
bucle: lw r3, a(r1) ; r3 = a[i]
p1 cmp.lt r3, r0 ; p1 = 1 si a[i] < 0
(p1) lw r4, b(r1) ; r4 = b[i]
(p1) sw r4, a(r1) ; a[i] = b[i] (si a[i] < 0)
addi r1, r1, #4 ; i = i + 1 (los enteros son de 4 bytes)
subi r2, r2, #1 ; Queda un elemento menos
bnez r2, bucle ; Saltamos si quedan elementos
Teniendo en cuenta las restricciones del procesador, el cdigo se podra emitir as:
ETIQUETA SLOT 1 SLOT 2
add r1, r0, r0 lw r2, n
bucle: lw r3, a(r1)



p1 cmp.lt r3, r0
(p1) lw r4, b(r1)

subi r2, r2, #1
bnez r2, bucle
addi r1, r1, #4 (p1) sw r4, a(r1)
Por tanto, el tiempo de ejecucin se podra estimar como:

T(n) 10n +1
Como sabemos que el 75% de los valores del vector a son negativos, el cdigo predicado con p1 se
ejecutar el 75% de las veces, as que sera conveniente adelantar especulativamente la carga de b[i]
para ocultar parte de la latencia de la carga. El cdigo podra ser el siguiente:
add r1, r0, r0 ; r1 = i (inicialmente a 0)
lw r2, n ; r2 = Nmero de elementos
bucle: lw r3, a(r1) ; r3 = a[i]
lw.s r4, b(r1) ; r4 = b[i] (especulativa)
p1 cmp.lt r3, r0 ; p1 = 1 si a[i] < 0
(p1) specck b(r1) ; Comprueba la carga especulativa
(p1) sw r4, a(r1) ; a[i] = b[i] (si a[i] < 0)
addi r1, r1, #4 ; i = i + 1 (los enteros son de 4 bytes)
subi r2, r2, #1 ; Queda un elemento menos
bnez r2, bucle ; Saltamos si quedan elementos
Como se puede observar, la carga de b[i] se hace especulativamente antes de comprobar si a[i] es
negativo, y en el lugar original de la carga se ha colocado un centinela que comprueba si la
especulacin sali bien. Si la carga especulativa sale bien, tendremos el valor de b[i] antes, y en caso
contrario, se cargar el valor de b[i] (y se atender a la excepcin correspondiente) cuando se ejecute la
instruccin de chequeo. El cdigo VLIW sera el siguiente:
ETIQUETA SLOT 1 SLOT 2
add r1, r0, r0 lw r2, n
bucle: lw r3, a(r1)
lw.s r4, b(r1)


p1 cmp.lt r3, r0 subi r2, r2, #1
(p1) specck b(r1) bnez r2, bucle
addi r1, r1, #4 (p1) sw r4, a(r1)

En este caso, el tiempo de ejecucin es de:

T
2
(n) 7 n +1
Por tanto, la ganancia en velocidad mxima ser de:

S
max
= lim
n
S(n) = lim
n
T(n)
T
2
(n)
= lim
n
10n +1
7 n +1
= 1.43
4. (1.5 puntos) En un procesador vectorial a 500 MHz, con registros vectoriales de 32
componentes, una nica unidad de carga/almacenamiento vectorial de memoria, un nico
multiplicador, y dos sumadores, se ejecuta el siguiente bucle:
s = 1;
b = 1;
for (i = 0 ; i < n ; i++)
{
z[i] = a * x[i] + b * y[i];
b = b * s;
}
Determine el valor de R

teniendo en cuenta que el procesador puede encadenar los cauces.

NOTA: TLI
mem
= 6 ciclos; TLI
mult
= 10 ciclos; TLI
add
= 4 ciclos; T
base
= 8 ciclos; T
bucle
= 10 ciclos.
Puede suponer que en memoria existen dos variables de 32 bits, la variable masc_pares, que
almacena el contenido 0xaaaa, y la variable masc_impares, con el contenido 0x5555.
Solucin
Como el bucle est diseado para un tamao n desconocido, es necesario aplicar strip-mining para
trocear el vector. El cuerpo del bucle interno estara compuesto por las siguientes instrucciones:
lv v1, x(r1) ; cargamos un trozo del vector x
lv v2, y(r1) ; cargamos un trozo del vector y
multsv v3, f2, v1 ; v3 = a * x[i]
ld f0, masc_pares ; f0 = mscara para operar con los elementos en posiciones pares
movf2s vm, f0 ; fijamos la mscara
addv v4, v3, v2 ; sumamos los elementos de las posiciones pares
ld f0, masc_impares ; f0 = mscara para operar con los elementos en posiciones impares
movf2s vm, f0 ; fijamos la mscara
subv v4, v3, v2 ; restamos los elementos de las posiciones impares
cvm ; restauramos la mscara para que se afecte a todos los elementos
sv v4, z(r1) ; almacenamos un trozo del resultado en z
A continuacin se muestra un diagrama que muestra la temporizacin de la ejecucin de las
instrucciones vectoriales en funcin de las restricciones del procesador del enunciado:

Analizando la figura se puede comprobar que debido a que slo hay una unidad multiplicacin, y a
que se cambia el valor del vector de mscaras tres veces, tenemos un TCV:
n n
n n
n n 4 26 6
2
4
2
4 6 6 TCV + = + + + + + + + + + =
por lo que deducimos que TPC = 4 y TLI = 26. Por tanto, el tiempo de ejecucin ser el siguiente:
( ) ( ) 4 26 10
32
8 TPC TLI
MVL
) (
bucle base
+ +

+ = + +

+ = n
n
n T
n
T n T
Una vez calculado el tiempo de ejecucin, R

se calcula como:
( )
MFLOPS 68 . 292
10 500
1
4 26 10
32
8
3
) (
FP s operacione num.
lim ) ( lim
6
=

+ +

= = =

n
n
n
n T
n R R
n n

6 n n 4 n/2 n/2 6 n 4 6
lv v1, x(r1)
lv v2, y(r1)
multsv v3, f2, v1
addv v5, v3, v4
subv v5, v3, v4
sv v5, z(r1)