ARQUITECTURA DE COMPUTADORES I Ingeniera Informtica.

Septiembre de 2007
1. (2.5) Suponga un procesador superescalar en que se captan, decodifican, emiten y retiran hasta dos instrucciones por ciclo. La etapa de decodificacin se realiza de forma ordenada, ya que es en esta etapa donde se introducen las instrucciones en un buffer de reordenamiento (ROB) que permite su finalizacin ordenada. Por el contrario, la emisin es desordenada y se implementa mediante estaciones de reserva individuales para cada unidad funcional. El procesador utiliza prediccin dinmica de saltos con dos bits de historia. Para la primera ejecucin de una instruccin de salto dada, el procesador predice saltar si la direccin de salto es hacia direcciones inferiores, y no saltar si la direccin es mayor. Las instrucciones de salto se procesan en la etapa de ejecucin y consumen un ciclo en esa etapa (en el siguiente ciclo ya se tendra la direccin de salto correcta y se podra captar la instruccin correcta si la prediccin de salto no hubiera sido correcta). Suponiendo una frecuencia de 2 GHz, que el cauce se encuentra inicialmente vaco, y que inicialmente r2=100000, para la siguiente secuencia de instrucciones: bucle: addd multd subd loop addd f1, f1, f6 f6, f2, f5 f5, f1, f3 r2, bucle f7, f1, f5 ; f1 = f1 + f6 ; f6 = f2 * f5 ; f5 = f1 f3 ; f7 = f1 + f5

(a) Cunto tarda en procesarse la secuencia de instrucciones? (b) Cul es la velocidad pico del procesador? NOTA: La suma y la resta en coma flotante consumen dos ciclos de reloj y la multiplicacin en coma flotante cuatro ciclos. Considere que no hay limitaciones en la capacidad de los buffers y en el nmero de unidades funcionales. Se supone que todos los registros tienen valores vlidos previos. La instruccin loop decrementa el registro y salta si el valor del registro es distinto de cero. 2. (1.5) Suponga un procesador en el que todas las instrucciones pueden predicarse. Para establecer los valores de los predicados se utilizan instrucciones de comparacin con el formato (p) p1, p2 cmp.cnd rx, ry

donde cnd es la condicin que se comprueba entre 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 valor del predicado p es 1 (habr sido establecido por otra instruccin de comparacin). (a) En estas condiciones, escriba la secuencia de instrucciones mquina que implementaran el siguiente cdigo sin utilizar ninguna instruccin de salto: X = 0; if ((AB) and (B0)) then X = 1; else if ((B<0) and (A<B)) then X = 2; (b) Optimice el cdigo anterior para un procesador VLIW con dos slots de emisin, en el que las instrucciones de comparacin slo pueden colocarse en el primero de ellos y las latencias de las operaciones son de 1 ciclo para las sumas, restas y comparaciones, de dos ciclos para las multiplicaciones y de tres ciclos para las cargas de memoria.

3. (2.5) Suponga que en el siguiente programa N=108, a y c son dos vectores de nmeros en coma flotante, y b es un escalar en coma flotante. for (i=0 ; i<N ; i++) a[i+2] = (a[i+1] + a[i]) * b; c[0] = a[N+1]; (a) Si se han tardado 200 milisegundos en ejecutar el programa, cuntos GFLOPS se han alcanzado? (Suponga que el producto y la suma en coma flotante tienen un coste similar). Las instrucciones mquina que implementan este bucle en el procesador donde se ha ejecutado son: ld add ld loop: ld ld addf mulf sf add sub bnez add sf f1, b r1, r0, a r2, N f2, 0(r1) f3, 4(r1) f4, f3, f2 f4, f4, f1 8(r1), f4 r1, r1, #4 r2, r2, #1 r2, loop r5, r0, c 0(r5), f4 ; cargar en f1 el valor de b ; apuntar r1 donde empieza a[] ; cargar en r2 el nmero de iteraciones ; cargar f2 con a[i] ; cargar f3 con a[i+1] ; f4=a[i+1]+a[i] ; f4=f4*b ; almacenar f4 en a[i+2] ; apuntar a a[i+1] ; queda una iteracin menos ; apuntar r5 donde empieza c[] ; almacenar f4 (a[N+1]) en c[0]

(b) Si sabe que el procesador que se est utilizando es de 2 GHz, qu podra decir respecto al tipo de procesador utilizado teniendo en cuenta el valor de CPI? (c) Si el programa anterior se implementa en un procesador segmentado con salto retardado y un hueco para instrucciones tras la instruccin de salto, indique si hay algn problema en la ejecucin del cdigo anterior si el salto: (1) se anula siempre; (2) no se anula nunca; (3) se anula si se salta; (4) se anula si no se salta. (d) Qu cambios hara en el cdigo en el caso en que hay problemas y para que, si es posible, se mejoren las prestaciones? 4. (1.5) En un procesador vectorial, con una frecuencia de reloj de 500 MHz y con registros vectoriales de 16 componentes, se ejecuta el siguiente bucle utilizando la tcnica de troceado del vector (strip mining). for i := 1 to n do Z(i) := a*Z(i) + b*X(i) + c*Y(i) Teniendo en cuenta que el tiempo de ejecucin es TCV=63 ciclos para la secuencia de instrucciones vectoriales que implementan Z := a*Z + b*X + c*Y con 16 componentes, que el valor del tiempo de latencia de inicio es TLI=15 ciclos, que el tiempo correspondiente a las operaciones escalares necesarias para preparar el ciclo es TBASE =10 ciclos, y que el tiempo correspondiente al control del bucle en el troceado del vector es TBUCLE=20 ciclos, calcule para el bucle: (a) El tiempo de ejecucin para n=317 elementos, T317. (b) El nmero de operaciones ejecutadas por unidad de tiempo para un vector de longitud infinita, Rinf.

Solucin al problema 1:
Para responder al primer apartado es necesario tener en cuenta que el programa se ejecutar en un procesador superescalar en el que se solaparn las iteraciones del bucle. Por tanto, una vez terminada la primera iteracin tras un tiempo TLI, el resto de iteraciones irn terminando cada MLM ciclos. Para determinar estos dos parmetros es necesario desarrollar una traza de la ejecucin del programa en la que se tengan en cuenta las caractersticas del procesador. A la hora de realizar esta traza tenemos que tener cuidado con los riesgos que ocurrirn en la ejecucin del programa: Riesgos RAW entre datos dentro de una iteracin y tambin entre iteraciones consecutivas (marcados con flechas rojas), Riesgos estructurales (marcados con flechas azules), Riesgos de control al procesar el salto del bucle (marcados con flechas verdes).

A continuacin se simula la ejecucin del bucle haciendo tres iteraciones. Instruccin addd f1, f1, f6 multd f6, f2, f5 subd f5, f1, f3 loop r2, bucle addd f7, f1, f5 Sig. instruccin addd f1, f1, f6 multd f6, f2, f5 subd f5, f1, f3 loop r2, bucle addd f1, f1, f6 multd f6, f2, f5 subd f5, f1, f3 loop r2, bucle addd f1, f1, f6 multd f6, f2, f5 subd f5, f1, f3 loop r2, bucle addd f1, f1, f6 multd f6, f2, f5 addd f7, f1, f5 1
IF IF

6
ROB EX EX ROB X X

10 11 12 13 14 15 16 17 18 19 20 21

ID ISS EX EX ID ISS EX EX IF ID IF ID ISS EX IF X X IF X X IF ID IF ID IF IF

WB EX ROB WB EX ROB WB WB WB X ROB EX EX ROB

X X X X X X ISS EX EX ISS EX EX ID ISS ID ISS EX IF ID IF ID IF ID IF ID ISS IF ID IF ID IF IF

WB WB EX ROB WB EX ROB WB WB ISS EX EX ROB WB ISS EX EX EX EX ROB WB ISS EX EX ROB WB ROB WB X X X X X X X WB X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X IF ID ISS EX EX ROB

EX ISS ID ID IF IF

WB WB X WB X WB X X WB WB

10

La primera vez que se capta el salto no se puede usar el predictor dinmico porque no existe ninguna entrada en el BTB del procesador para l. Por tanto, en la etapa de decodificacin, una vez que se identifique el salto, se incluir una entrada en el BTB para que la siguiente vez que se capte se pueda usar el predictor dinmico, se usar un predictor esttico que predecir saltar (el salto es hacia atrs), y se anularn las dos instrucciones que se captaron errneamente tras el salto. Teniendo en cuenta las etapas del cauce, el predictor esttico tendr una penalizacin de 1 ciclo para los saltos acertados. A partir de la segunda iteracin, cada vez que se capta el salto se usa el predictor dinmico, por lo que no hay penalizacin en caso de acertar. Esto ocurrir en el resto de iteraciones menos en la ltima, en la que el predictor fallar y tendremos una penalizacin de 3 ciclos hasta captar la siguiente instruccin al salto, ya que es en la etapa de ejecucin en la que se comprueba la correccin de la prediccin. Una vez que se comprueba que fall la prediccin, se anulan todas las instrucciones captadas especulativamente y se comienza a captar desde la direccin correcta para terminar la ejecucin del programa. Si nos fijamos en el instante de tiempo en el que se retira la ltima instruccin del bucle en cada iteracin, podemos comprobar que la primera iteracin tarda en concluir un tiempo TLI = 10 ciclos, que el resto de iteraciones terminan cada MLM = 4 ciclos, y que la ltima instruccin termina 3 ciclos despus de la ltima iteracin del bucle, por tanto para un bucle de n iteraciones tenemos: T(n) = TLI + MLM(n 1) + Tfinal = 10 + 4(n 1) + 3 = 4n + 9 ciclos Teniendo en cuenta que el registro r2 = 100000 y que la frecuencia de reloj es de 2 GHz, el tiempo de ejecucin es de:

T (100000 ) =

4 10 5 + 9 ciclos 200 microsegundos 2 10 9 ciclos s

Y como el procesador puede completar hasta 2 instrucciones por ciclo, su velocidad pico es de:
R pico = 2 instrucciones ciclo 2 10 9 ciclos s = 4 10 9
instruccio nes s

Solucin al problema 2:
El organigrama y el cdigo secuencial que implementa la secuencia de cdigo del enunciado es el siguiente:
Inicio

X0 Si p1 Si p1 X1 Si p2 X2 p2 A<B No B0 No p2 Si B<0 No No

AB

lw lw add (p1) (p2) (p2) (p1) (p2) p1, p2 p1, p2 p2 p2 cmp.ge cmp.ge cmp.lt cmp.lt addi addi sw

r1, A ; r1 = A r2, B ; r2 = B r3, r0, r0 ; r3 = 0 r1, r2 r2, r0 r2, r0 r1, r2 ; A >= B? ; B >= 0? ; B < 0? ; A < B?

r3, r0, #1 ; r3 = 1 r3, r0, #2 ; r3 = 2 r3, X ; X = r3

Fin

Una vez escrito el cdigo, slo nos queda optimizarlo para la arquitectura VLIW propuesta en el enunciado: Slot 1 lw add p1, p2 p1, p2 p2 p2 cmp.ge cmp.ge cmp.lt cmp.lt r1, A r3, r0, r0 r1, r2 r2, r0 r2, r0 r1, r2 Slot 2 lw r2, B

(p1) (p2) (p2)

(p1) (p2)

addi addi sw

r3, r0, #1 r3, r0, #2 r3, X

Solucin al problema 3:
Para responder al primer apartado hay que calcular el nmero de operaciones en coma flotante que se pueden realizar por segundo. En cada iteracin del bucle se realiza una suma y una multiplicacin, y como se realizan 108 iteraciones, el programa realiza un total de 2108 operaciones en coma flotante en 20010-3 segundos, por tanto, se alcanzan

R10 =
8

2 108 operaciones = 1GFLOP 200 10 3 segundos

Teniendo en cuenta el cdigo ensamblador del enunciado, el programa ejecuta un nmero de instrucciones de NI = 3 + 8108 + 2 Y como sabemos que el tiempo de ejecucin es T = NI CPI TClk, podemos obtener el nmero medio de ciclos que tarda

en ejecutarse una instruccin:

CPI =

T 200 10 -3 2 109 = 0.5 NI TClk 5 + 8 108

) (

Por tanto, el procesador puede terminar 2 instrucciones por ciclo, con lo que se puede concluir que el procesador es superescalar o VLIW, segn explote el paralelismo dinmica o estticamente. Dependiendo de la implementacin del salto retardado, puede que sea necesario cambiar el cdigo del programa para asegurar su correcto funcionamiento: (1) En el caso en el que la instruccin que entra en el cauce tras el salto se anule siempre, sera necesario insertar una instruccin NOP entre el salto y la suma, ya que en la ltima iteracin, en la que no se debe saltar, se anulara la siguiente instruccin al salto y la operacin de almacenamiento final no accedera a la direccin correcta. (2) Si la instruccin siguiente al salto no se anula nunca, el programa podra fallar si dicha instruccin afecta a los registros que se usan en el bucle. En este ejemplo concreto, como dicha instruccin afecta a r5, que no se usa en el bucle, el programa funcionara correctamente, aunque ejecutara la instruccin siguiente al salto en todas las iteraciones, desperdiciando un tiempo de computacin que podra usarse en algn clculo til. (3) Si la siguiente instruccin al salto se anula slo si se toma el salto, el programa se puede dejar tal y como est, ya que slo se ejecutar cuando se termine el bucle. (4) Por ltimo, si la siguiente instruccin al salto se anula slo si no se salta, ocurre igual que en el caso (2), el programa podra fallar si dicha instruccin afecta a los registros que se usan en el bucle. Pero en este ejemplo concreto el programa funcionara correctamente si el bucle itera ms de una vez, ya que se fijara en r5 el valor del puntero donde empieza la matriz c en todas las iteraciones menos en la ltima, por lo que en el almacenamiento se accedera a la direccin correcta. En este caso, tambin sera conveniente modificar el programa para ejecutar la instruccin siguiente al salta una sola vez tras la ltima iteracin y aprovechar el spot del salto para realizar algn clculo til. A continuacin se muestran las modificaciones que seran necesarias para optimizar el programa en cada caso: Se anula siempre ld f1, b add r1, r0, a ld r2, N loop: ld f2, 0(r1) ld f3, 4(r1) addf f4, f3, f2 mulf f4, f4, f1 sf 8(r1), f4 add r1, r1, #4 sub r2, r2, #1 bnez r2, loop nop add r5, r0, c sf 0(r5), f4 No se anula nunca ld f1, b add r1, r0, a ld r2, N loop: ld f2, 0(r1) ld f3, 4(r1) addf f4, f3, f2 mulf f4, f4, f1 sf 8(r1), f4 sub r2, r2, #1 bnez r2, loop add r1, r1, #4 add r5, r0, c sf 0(r5), f4 Se anula si se salta ld f1, b add r1, r0, a ld r2, N loop: ld f2, 0(r1) ld f3, 4(r1) addf f4, f3, f2 mulf f4, f4, f1 sf 8(r1), f4 add r1, r1, #4 sub r2, r2, #1 bnez r2, loop add r5, r0, c sf 0(r5), f4 Se anula si no se salta ld f1, b add r1, r0, a ld r2, N ld f2, 0(r1) loop: ld f3, 4(r1) addf f4, f3, f2 mulf f4, f4, f1 sf 8(r1), f4 add r1, r1, #4 sub r2, r2, #1 bnez r2, loop ld f2, 0(r1) add r5, r0, c sf 0(r5), f4

Cualquiera de las soluciones (2) y (4) son intercambiables para ambos casos.

Solucin al problema 4:
Sabemos que en un procesador vectorial, el tiempo para procesar una operacin completa vectorial (para los 16 elementos que caben en un registro vectorial) es: TCV = TLI + MVL TPC Por lo tanto, podemos obtener el tiempo por componente de la secuencia de instrucciones vectoriales como:

TPC =

TCV TLI 63 15 = =3 MVL 16

Una vez obtenido el tiempo por componente, el tiempo de ejecucin del programa se obtiene mediante la siguiente expresin:

k Tk = TBASE + (TLI + TBUCLE ) + k TPC MVL Por tanto, el tiempo para procesar 317 elementos sera de: 317 (15 + 20) + 317 3 = 1661 ciclos = 1661 6 segundos T317 = 10 + 500 10 16 El rendimiento de un cauce vectorial se obtiene mediante la siguiente expresin:
Rk = k operacione s vectorial es = Tk 5k 500 10 6 25k 10 8 = k k 10 + (15 + 20 ) + 3k 10 + 35 + 3k 16 16

Por tanto, el mximo rendimiento se obtendr cuando el tamao del vector tienda a infinito, es decir,
R = lim Rk =
k

25 108 = 481.93 MFLOPS 35 +3 16