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 instrucción VLIW), todas las operaciones pueden predicarse. Para establecer los valores de los predicados se utilizan instrucciones de comparación (cmp) con el formato (p) p1[, p2] cmp.cnd x,y donde cnd es la condición que se comprueba entre x e y (lt, ge, eq, ne, …). Si la condición es verdadera p1=1 [y p2=0], y si es falsa, p1=0 [y p2=1]. La operación sólo se ejecuta si el predicado p=1 (habrá sido establecido por otra instrucción de comparación). Indique cómo se escribiría 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 operación de salto y con el mínimo número de instrucciones VLIW, teniendo en cuenta que las instrucciones de comparación sólo pueden aparecer en el primer campo o slot de la instrucción VLIW (el resto de las instrucciones pueden aparecer en cualquier campo). Considere que dispone del número 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 máximo, y se retiran hasta tres instrucciones por ciclo. La emisión y la ejecución son desordenadas, y las instrucciones, una vez decodificadas, se introducen en un buffer de reordenamiento (ROB) que permite la finalización ordenada del procesamiento de las instrucciones. Indique las dependencias entre instrucciones y cómo evolucionaría el buffer de reordenamiento hasta que se hayan retirado todas las instrucciones de la secuencia: addd f1, f1 ,f4 ; f1 = f1 + f4 multd f3, f1, f2 ; f3 = f1 * f2 addd f6, f1, f4 ; f6 = f1 + f4 subd f4, f1, f6 ; f4 = f1 – f6 Suponiendo una frecuencia de 2 GHz, ¿cuánto tarda en procesarse la secuencia de instrucciones? ¿Cuál es la velocidad pico del procesador? NOTA: La suma y la resta consumen un ciclo de reloj y la multiplicación cuatro ciclos. Considere que no hay limitaciones en la capacidad de los buffers, y en el número de unidades funcionales. Se supone que f1, f2, y f4 tienen valores válidos previos. 4. (1.5 punto) Una función F se va a implementar en un cauce con 5 etapas S1, S2, S3, S4, S5 de forma que visita las etapas según la secuencia: S1 S5 S1 S4 S3 S2 S1 S4. Obtenga la ganancia en velocidad con respecto a la ejecución sin cauce para 200 operaciones, teniendo en cuenta que sin cauce la función requiere un tiempo de 16 ns y que las etapas del cauce suponen unos tiempos de ejecución 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). ¿Cuál es la productividad en función del número de operaciones? Determine los valores de la productividad máxima y la ganancia máxima. 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 ejecución 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? ¿Cuál es la máxima ganancia de velocidad que se puede obtener por mejoras en la unidad de enteros? ¿Y por mejoras en la de coma flotante?

Solución al Problema 1: Dado que el tamaño de los registros vectoriales del procesador propuesto en el problema es MVL = 32 y que el vector que deseamos procesar tiene un tamaño n = 350 mayor, tendremos que aplicar la técnica de strip-mining para trocear el vector y procesarlo iterativamente. El compilador realizará un cambio al código similar a este:

Al traducir este código a ensamblador, el bucle que se encuentra sombreado se cambiará por instrucciones vectoriales y el resto de instrucciones permanecerán tal y como están. Dado que R∞ se define como

kkkk T

RR frecuenciaes vectorialsoperacioneklimlim ××==

∞→∞→∞

el primer paso consistirá en estimar el tiempo Tk. Para ello, debemos determinar las instrucciones vectoriales que se ejecutarán dentro del bucle interno y la forma en que se solaparán y encadenarán. Dichas instrucciones serán tres cargas vectoriales de X, Y, y Z, una multiplicación, una suma y un almacenamiento del resultado en Z. El diagrama de tiempos de estas instrucciones es el siguiente:

Como sólo tenemos tres unidades de carga/almacenamiento, la instrucción 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 multiplicación 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:

( ) ( ) ciclos ·2101632

8TPCTLIMLV BUCLEBASE kkkTkTTk ++⎥⎥

⎤⎢⎢⎡+=⋅++⎥⎥

⎤⎢⎢⎡+=

Una vez obtenido Tk, obtenemos R∞:

( ) ( )MFLOPS 11,711

·22632

8

2000lim·21016

328

00102limfrecuencia vecopslimlim =+⎥⎥

⎤⎢⎢⎡+

=++⎥⎥

⎤⎢⎢⎡+

××=

××==

∞→∞→∞→∞→∞

kkk

kkk

TkRR

kkk

kkk

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; }

TLI=8

TLI=8

TLI=8

TLI=16

TLI=8

TLI=8

LV VY, RY

LV VZ, RZ

LV VX, RX

MULT V1, VX, VY

ADD VZ, VZ, V1

SV RZ, VZ

8 32 8 32

Solución al Problema 2: Como en el enunciado nos indican que la secuencia de instrucciones debe quedar sin ningún salto, debemos desenrollar el bucle y predicar las instrucciones que contiene en su interior. A continuación se muestran el organigrama del programa una vez que se ha desenrollado el bucle y se han predicado las instrucciones y su código en ensamblador derivado.

Tras desenrollar e introducir las operaciones con predicados, sólo nos queda reorganizar el código respetando las dependencias de datos para construir las instrucciones VLIW:

Slot 1 Slot 2 Slot 3 p3 cmp.ne r0, r0 lw r1, X(r0) p4 cmp.ne r0, r0 lw r2, Y(r0) p1, p2 cmp.gt r1, r2 (p1) p3, p2 cmp.ge r2, r0 (p2) p4 cmp.lt r2, r0 (p3) sub r1, r0, r1 p7 cmp.ne r0, r0 (p4) add r1, r0, r2 lw r3, X+4(r0) p8 cmp.ne r0, r0 sw r1, X(r0) lw r4, Y+4(r0) p5, p6 cmp.gt r3, r4 (p5) p7, p6 cmp.ge r4, r0 (p6) p8 cmp.lt r4, r0 (p7) sub r3, r0, r3 (p8) add r3, r0, r4 sw r3, X+4(r0)

Inicio

X[1] > Y[1]

Fin

Si No

Si

No

(p1) (p2)

(p3)

Y[1] ≥ 0

X[1] ← –X[1] X[1] ← Y[1]

No (p2) Y[1] < 0

Si(p4)

X[2] > Y[2] Si No

Si

No

(p5) (p6)

(p7)

Y[2] ≥ 0

X[2] ← –X[2] X[2] ← Y[2]

No (p6) Y[2] < 0

Si(p8)

p3 cmp.ne r0, r0 ; p3 ← 0 p4 cmp.ne r0, r0 ; p4 ← 0 lw r1, X(r0) ; r1 ← X[1] lw r2, Y(r0) ; r2 ← Y[1] p1, p2 cmp.gt r1, r2 ; p1 ← 1 si X[1] > Y[1](p1) p3, p2 cmp.ge r2, r0 ; p3 ← 1 si Y[1] ≥ 0 (p3) sub r1, r0, r1 ; r1 ← –X[1] (p2) p4 cmp.lt r2, r0 ; p4 ← 1 si Y[1] < 0 (p4) add r1, r0, r2 ; r1 ← Y[1] sw r1, X(r0) ; X[1] ← r1 p7 cmp.ne r0, r0 ; p7 ← 0 p8 cmp.ne r0, r0 ; p8 ← 0 lw r3, X+4(r0) ; r3 ← X[2] lw r4, Y+4(r0) ; r4 ← Y[2] p5, p6 cmp.gt r3, r4 ; p5 ← 1 si X[2] > Y[2](p5) p7, p6 cmp.ge r4, r0 ; p7 ← 1 si Y[2] ≥ 0 (p7) sub r3, r0, r3 ; r3 ← –X[2] (p6) p8 cmp.lt r4, r0 ; p8 ← 1 si Y[2] < 0 (p8) add r3, r0, r4 ; r3 ← Y[2] sw r3, X+4(r0) ; X[2] ← r3

Solución al Problema 3: Ya que el procesador no dispone de estaciones de reserva, la lógica de emisión tiene que esperar a que los operandos le sean facilitados por la lógica de bypass, por tanto, las dependencias RAW afectarán al orden de emisión de las instrucciones. En concreto, las instrucciones (2), (3) y (4) dependen del valor de f1 producido por la instrucción (1) y la instrucción (4) depende del valor de f6 producido por la instrucción (3) Teniendo en cuenta estas dependencias, las instrucciones se ejecutarían como se muestra en la siguiente figura:

Instrucción / Ciclo 1 2 3 4 5 6 7 8 9 (1) addd f1, f1, f4 IF ID/ISS EX ROB WB (2) multd f3, f1, f2 IF ID/ISS EX EX EX EX ROB WB (3) addd f6, f1, f4 IF ID/ISS EX ROB WB (4) subd f4, f1, f6 IF ID/ISS EX ROB WB

A continuación pasamos a describir la evolución del buffer de reorden:

Ciclo 2: • Se decodifican las instrucciones (1), (3) y

(3) y se introducen en el ROB

# Cod. Op. Dest. Result. Ok 1 addd f1 ? 0 2 multd f3 ? 0 3 addd f6 ? 0

Ciclo 3: • Se decodifica la instrucción (4) y se

introducen en el ROB

# Cod. Op. Dest. Result. Ok 1 addd f1 ? 0 2 multd f3 ? 0 3 addd f6 ? 0 4 subd f4 ? 0

Ciclo 4: • Finaliza la instrucción (1) y se escribe el

resultado en el ROB

# Cod. Op. Dest. Result. Ok 1 addd f1 f1 + f4 1 2 multd f3 ? 0 3 addd f6 ? 0 4 subd f4 ? 0

Ciclo 5: • Se retira la instrucción (1) del ROB • Finaliza la instrucción (3) y se escribe el

resultado en el ROB

# Cod. Op. Dest. Result. Ok 2 multd f3 ? 0 3 addd f6 f1 + f4 1 4 subd f4 ? 0

Ciclo 6: • Finaliza la instrucción (4) y se escribe el

resultado en el ROB

# Cod. Op. Dest. Result. Ok 2 multd f3 ? 0 3 addd f6 f1 + f4 1 4 subd f4 f1 – f6 1

Ciclo 8: • Finaliza la instrucción (3) y se escribe el

resultado en el ROB

# Cod. Op. Dest. Result. Ok 2 multd f3 f1 * f2 1 3 addd f6 f1 + f4 1 4 subd f4 f1 – f6 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 sería

9 ciclos * 5×10–10 s/ciclo = 4,5×10–9 s = 4,5 ns Para la calcular la velocidad pico, como sólo se pueden retirar dos instrucciones por ciclo, suponiendo que no hubiera atascos en el cauce se podrían ejecutar 3 instrucciones por ciclo

3 instr./ciclo * 2×109 ciclos/s = 6 GIPS

Solución 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:

MLMnTLInT

nTnT

nS Orig

Seg

OrigSeg )1(

)()()(

)(−+

==

Viendo el tiempo de ejecución de las diferentes etapas, fijaremos el tiempo de reloj del cauce a:

{ } ns5ns5,ns4,ns3maxReloj ==T

Por lo que el tiempo de latencia inicial es:

ns40ns58etapas8 Reloj =×=×= TTLI

Una vez obtenido el TLI, sólo nos queda obtener la Mínima Latencia Media (MLM) del cauce propuesto en el enunciado. La tabla de reservas del cauce es la siguiente:

1 2 3 4 5 6 7 8 S1 X X X S2 X S3 X S4 X X S5 X

Mediante esta tabla de reservas, es fácil 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:

La mínima latencia mínima del cauce es:

MLM = (5 + 3) / 2 = 4 ciclos = 4 · 5 ns = 20 ns

Por tanto, el tiempo tardará la ejecución de n operaciones en el cauce segmentado será

)1(2020)1(40)1()( +⋅=⋅−+=⋅−+= nnMLMnTLInTSeg

Utilizando esta expresión, ya podemos calcular la ganancia en velocidad para 200 operaciones mediante:

796.039803200

)1200(2016200

)200()200(

)200( ==+⋅

×==

Seg

OrigSeg T

TS

La productividad en función del número de operaciones se define como:

)1(20)()(

+⋅==

nn

nTnnW

SegSeg

Los valores para la productividad y la ganancia máximas son:

MOPS50ns20

11max ===

MLMW 8.0

201616

max ===MLM

S

7+

1 3

101111 101011

101010

5

111111

1

7+

7+

7+

5

3 5

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

( )11 −+≤

pfpS

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 ejecución de operaciones con enteros:

fent = 1 – 0.2 = 0.8 pent = 2 / (2 – 1) = 2 mientras que si se mejora la unidad de ejecución de operaciones en coma flotante:

fFP = 1 – 0.1 = 0.9 pFP = 6 / (6 – 4) = 3 Para ver qué mejora es más conveniente, simplemente debemos aplicar la ecuación anterior:

( ) 1.1128.01

2ent =

−+≤S

( ) 07.1139.01

3FP =

−+≤S

Con lo que teniendo en cuenta las cargas de trabajo habituales ejecutadas, conviene más realizar la mejora a la unidad de enteros. Si la mejora que se realiza en las unidades de ejecución fuese máxima, es decir, p → ∞, la ganancia máxima que se podría obtener sería:

25.18.0

11liment

ententmax ====∞→ f

SSp

11.19.0

11limFP

FPFPmax ====∞→ f

SSp