ARQUITECTURA DE SISTEMAS PARALELOS.

3 INGENIERIA TECNICA EN INFORMATICA DE SISTEMAS.

BOLETN DE EJERCICIOS DE Introduccin al paralelismo. Curso 04/05
(SOLUCIONES)
1. Inicialmente R3 = R2 + 400. como R2 incrementa de 4 en 4 bytes (palabras de 32 bits) entonces se
efectuarn 100 iteraciones. La instruccin SUB R4, R3, R2 se puede sustituir por una del tipo SNE (set
if not equal).
ADDI R3,R2,#400
LOOP:
LW
R1,0(R2)
ADDI R1,R1,#1
SW
0(R2),R1
ADDI R2,R2,#4
SUB
R4,R3,R2
BNEZ R4,LOOP ; termina cuando R4 = 0 (100 iteraciones en total)
Si se examina el cdigo se puede ver como en cada iteracin se lee o carga un elemento E de un vector de
nmeros enteros apuntado por R2 y a continuacin se le suma un uno. Finalmente se vuelve a escribir el
elemento E en el vector en la misma posicin. Con estos datos un cdigo en alto nivel escrito en C, que
una vez compilado diese lugar al anterior cdigo en ensamblador, tendra el siguiente aspecto:

int vector[100]; // en principio vector tiene al menos

// cien elementos aunque pueda tener ms.
...
for (i=0; i<100; i++)
vector[i] = vector[i] + 1;
2. Se va a ir desglosando instruccin por instruccin los distintos resultados que se van produciendo:
XOR R1, R3, R3
; R1 = 0
ADDUI R1, R1, 0xE4F7 ; R1 = 0000 E4F7
SW 0(R4), R1
; [R4] = 0000 E4F7
LBU R2, 3(R4)
; R2 = 00 00 00 F7
SGT R1, R2, R1
; Si (R2 > R1) R1 = 1; Si (00 00 00 F7 > 0000 E4F7) R1 = 1;
Si no R1 = 0;
Si no R1 = 0;
En la representacin Big Endian se almacena en los primeros bytes de memoria la parte ms
significativa del nmero. Este tipo de representacin es seguida por ejemplo por la familia de
procesadores INTEL.
-1 +0 +1 +2 +3 +4
... 00 00 E4 F7 ...
... +4
F7 +3
E4 +2
00 +1
00 +0
... -1

3.

MOV AX, BX
CMP AX, BX

NEG [BX]
LOOP ETIQUETA
INC [BX+DI+100h]

ADD R1, R2, R0 (el registro R0 siempre contiene 0)

Varias opciones dependiendo de lo que se quiera comparar ya que
no hay registro de flags. Por ejemplo: SEL (set equal less)
SEL R3, R1, R2 ; Si (R1 <= R2) Entonces R3 = 1; Si no R3 = 0;)
Hay que hacerlo en tres pasos: LW R3, 0(R2) ; SUB R3, R0, R3
(complemento a 2) y SW 0(R2), R3
J ETIQUETA
Se precisan varias instrucciones RISC: ADD R1, R2, R4 ;
ADDI R1, R1, #256 ; LW R3, 0(R1) ; ADDI R3, R3, #1 ;
SW 0(R1), R3

4.

a) Se tienen los siguientes datos:

Tipo Instruccin Frecuencia Ciclos de reloj
ALU
40%
4
SALTOS
20%
4
MEMORIA
40%
5

Adems se dice que el periodo de reloj es de 10 ns y se pregunta cul es la duracin media de una
instruccin. Por lo tanto habr que hacer una media ponderada con las frecuencias y los ciclos de las
diferentes instrucciones:
Tinstr. = CPI * Tciclo = ( 0,4 * 4 + 0,2 * 4 + 0,4 * 5 ) * 10 = 44 ns
b) La mejora ser S = Tno segmentado / Tsegmentado
Se dice que debido a complicaciones de la arquitectura segmentada se necesita un nanosegundo ms en el
ciclo de reloj. Por lo tanto en este caso el ciclo de reloj es de 11 ns. As pues se tendr que:
S = 44 / 11 = 4 , es decir una mejora en el rendimiento de hasta un 300 % ms.

5. Se dispone de un procesador segmentado de 4 etapas: A B C D

Los saltos condicionales se toman al final de tercer ciclo y los incondicionales al final del segundo.
Adems los saltos condicionales suponen un 15% del total de instrucciones (de los que el 55% se toman)
y los incondicionales un 5%.
Hay que hacer un anlisis de lo que ocurre en los saltos:
1) Saltos condicionales:
I: A B C D
I +1
A - A B C D Se toma salto: 2 ciclos
I+2
A - B C D
No se toma salto: 1 ciclo
CPB = 1 2
2) Saltos incondicionales:
I: A B C D
I+1
A A B C D Se toma siempre el salto: 1 ciclo
CPB = 1
As pues el CPB (ciclos por bloqueo) global ser:
CPBglobal = % instrucciones de s.incondicional * CPBs.incondicionales + % instrucciones de s.condicional *
CPBs.condicionales = 0,05*1 + 0,15*(0,55*2 + 0,45*1) = 0,28 (28% ms lenta)
Comparando con la mquina secuencial la relacin entre la eficiencia de ambas es :
S = CPIno seg. / (CPIideal seg. + CPB) = 4 / 1,28 = 3,12
6. Lo que se quiere ver es el la relacin entre el tiempo que tarda un procesador en ejecutar un programa
respecto a otro.
El tiempo de ejecucin es:
T = N (n instrucciones programa) x CPI (ciclos reloj por instruccin) x t (ciclo de mquina o reloj)
La relacin que se quiere comprobar es S ,donde S = T*/T (siendo T* el tiempo del DLX modificado y T
el tiempo de un DLX normal)
N = N* ya que se suponen que los programas ejecutados por ambos procesadores son los mismos y por lo
tanto el n de instrucciones es igual.
t* = 1,5 x t (porque el DLX* tiene un reloj un 50% ms lento)

El CPI del DLX normal (CPIdlx) es 1,2 ya que ejecuta una instruccin por ciclo ms un 0,2 ciclos de
media por bloqueos (no se alcanza nunca el ideal de una instruccin por ciclo).
La pregunta clave es el CPI del DLX*. Para ello hay que examinar los posibles bloqueos que se producen
en un procesador pero no en otro. Se puede ver que todo es igual salvo un caso especial en las
dependencias de control (saltos). Esquemticamente:
DLX*
IF IDX M
WB
IF
IDX M
WB

DLX
Aritmtica IF ID EX M WB
Aritmtica
IF ID EX M WB
DATOS:
Load/carga IF ID EX M
Aritmtica
IF ID SALTOS:

WB
EX M

WB

IF IDX M
IF
-

WB
IDX M

WB

IF ID EX M WB
IF IF ID EX M

WB

IF IDX M
IF
IF

WB
IDX M

WB

En el DLX normal y corriente se pierde un ciclo en la instruccin de salto si la instruccin anterior crea
dependencia. Esto es debido a que en la fase ID del salto se evala la condicin de salto al final del ciclo.
Esto no es posible hacerlo si al final de la fase EX de la instruccin anterior, se calcula el valor de un
registro cuyo valor deba de tenerse listo justo al principio de la fase ID del salto.
Este caso sin embargo no ocurre en el DLX* ya que ID y EX se fusionan en un nico ciclo y se puede
hacer entonces un bypass normal y corriente. Esquemticamente se puede ver ms claramente esta
dependencia de control que se produce con algunas instrucciones de salto:

SEQ R2,R1,R6
BEQZ R2

DLX
IF ID EX M WB
IF ID EX M WB

DLX*
IF IDX M
WB
IF
IDX M WB

Por lo tanto el CPI* del DLX* ser el mismo CPI del DLX normal MENOS el CPI de los casos en los que
se produce la anterior dependencia que se acaba de describir. A esta ocurrencia de casos se la llama "f
(frecuencia de casos fdependencia_control). As pues la relacin entre ambos CPI-s es:
CPI* / CPI = ( CPIdlx - 1 ciclo_bloqueo x fdependencia_control) / CPIdlx = (1,2 - f) /1,2
Volviendo a nuestra frmula inicial de S = T*/ T se tiene:
S = T* / T = (N* x (1,2 - f) x 1,5) / (N x 1,2 x 1) = (1,2 - f) x 1,5 / 1,2
Haciendo S = 1 (es decir, ambos procesadores ejecutan el mismo programa en el mismo periodo de
tiempo) tendremos la "frontera" a partir de cual uno compensa ms que el otro. Resolviendo se tiene f =
0,4 y por lo tanto si hubiese ms de un 40% de las dependencias de control que se ha visto en nuestro
programa, entonces el DLX* sera mejor que el DLX normal. Eso es algo que en circunstancias normales
no va a ocurrir ya que para empezar el 40% de las instrucciones tendran que ser de saltos tendran que ser
saltos condicionales y para acabar adems todas ellas deberan dar dependencias.

7. a) El diagrama de ejecucin sin desvos en la primera iteracin es el siguiente:

1 2 3
4
ADDI R2,R0,#40
IF ID EX M
Suma: LW R1,0x100(R2)
IF ADD R5,R5,R1
SUBI R2,R2,#4
BNEZ R2,SUMA
Suma: LW R1,0x100(R2)

5
6
7 8
9
WB
ID EX M WB
IF - ID EX
IF ID
IF

10

11

12

13

14 15

M WB
EX M WB
ID EX M WB
IF IF ID EX

En la segunda y siguientes iteraciones el diagrama de ejecucin ser igual salvo la primera iteracin:

1 2 3
4
Suma: LW R1,0x100(R2) IF ID EX M
ADD R5,R5,R1
IF SUBI R2,R2,#4
BNEZ R2,SUMA
Suma: LW R1,0x100(R2)

5
6
WB
ID EX
IF ID
IF

10

11 12

13 14

M WB
EX M WB
ID EX M WB
IF IF ID EX M WB

El bucle se repite 10 veces y hay que hacer distincin entre la primera iteracin, la ltima y las otras 8.
T = Tprimera + Tsiguientes = 12 ciclos + 9 ciclos * 8 iteraciones + 12 ciclos = 96 ciclos
b) Con bypass/cortocircuitos:
1 2 3
ADDI R2,R0,#40
IF ID EX
Suma: LW R1,0x100(R2)
IF ID
ADD R5,R5,R1
IF
SUBI R2,R2,#4
BNEZ R2,SUMA
Suma: LW R1,0x100(R2)

4
M
EX
ID
IF

5
WB
M
-

10 11

12 13 14 15

WB
EX M WB
ID EX M WB
IF ID EX M WB
IF IF ID EX

T = Tprimera + Tsiguientes = 8 ciclos + 7 ciclos * 8 iteraciones + 10 ciclos = 74 ciclos

c) Reordenando sin bypass:
1 2 3
4
ADDI R2,R0,#40
IF ID EX M
Suma: LW R1,0x100(R2)
IF SUBI R2,R2,#4
ADD R5,R5,R1
BNEZ R2,SUMA
Suma: LW R1,0x100(R2)

5
6
WB
ID EX
IF ID
IF

10

11

12

13 14

M
EX
-

WB
M WB
ID EX M WB
IF ID EX M WB
IF IF ID EX M WB

15

T = Tprimera + Tsiguientes = 9 ciclos + 6 ciclos * 8 iteraciones + 9 = 66 ciclos

d) Reordenando y con bypass: no siempre la reordenacin es la misma y podra haberse
diferenciado de la anterior. En este caso si coinciden.
1 2 3
4
5
6
7
8
9
10 11 12 13 14 15
ADDI R2,R0,#40
IF ID EX M WB
Suma: LW R1,0x100(R2)
IF ID EX M WB
SUBI R2,R2,#4
IF ID EX M WB
ADD R5,R5,R1
IF ID EX M WB
BNEZ R2,SUMA
IF ID EX M WB
IF IF ID EX M WB
Suma: LW R1,0x100(R2)
T = Tprimera + Tsiguientes = 6 ciclos + 5 ciclos * 8 iteraciones + 6 = 54 ciclos

8.

a) El diagrama de ejecucin sin desvos en la primera iteracin es el siguiente:

1 2 3
ADDI R3,R2,#400
IF ID EX
LOOP:LW R1,0(R2)
IF ID
ADDI R1,R1,#1
IF
SW
0(R2),R1
ADDI R2,R2,#4
SUB
R4,R3,R2
BNEZ R4,LOOP
LOOP:LW R1,0(R2)

4
M
EX
-

5
6
7
8 9
10
WB
M WB
ID EX M WB
IF - ID EX
IF ID
IF

11

12

13

14

15 16

17

M WB
EX M WB
ID EX M WB
IF - ID EX
IF IF

En la segunda y siguientes iteraciones el diagrama de ejecucin ser igual salvo la primera iteracin:
1 2 3
4
LOOP: LW R1,0(R2) IF ID EX M
ADDI R1,R1,#1
IF SW
0(R2),R1
ADDI R2,R2,#4
SUB
R4,R3,R2
BNEZ R4,LOOP
LOOP:LW R1,0(R2)

5
6
7 8
9
WB
ID EX M WB
IF - ID EX
IF ID
IF

10

11

12

13

14 15

16

M WB
EX M WB
ID EX M WB
IF - ID EX
IF IF

El bucle se repite 100 veces y hay que hacer distincin entre la primera iteracin y las otras 99 siguientes.
T = Tprimera + Tsiguientes = 16 ciclos + 15 ciclos * 99 iteraciones = 1501 ciclos
b) Con bypass/cortocircuitos:
1 2 3
ADDI R3,R2,#400 IF ID EX
LOOP:LW R1,0(R2)
IF ID
ADDI R1,R1,#1
IF
SW
0(R2),R1
ADDI R2,R2,#4
SUB
R4,R3,R2
BNEZ R4,LOOP
LOOP:LW R1,0(R2)

4
M
EX
ID
IF

5
WB
M
-

WB
EX M
ID EX
IF ID
IF

WB
M
EX
ID
IF

10

11

12 13

14 15

WB
M
EX
-

WB
M WB
ID EX M WB
IF IF ID EX M WB

T = Tprimera + Tsiguientes = 10 ciclos + 9 ciclos * 99 iteraciones = 901 ciclos

Una forma alternativa de calcular el nmero total de ciclos es calculando el CPB. A continuacin se
calculara el nmero total de ciclos: T = N * CPI = N * (1 + CPB) , donde N es el nmero total de
instrucciones que se ejecutan. En este caso 601 instrucciones (6*100 ms la instruccin ADDI inicial).
CPB = CPBdatos + CPBcontrol = (2*100 iteraciones / 601 instrucciones) + (1*100 iteraciones / 601
instrucciones) = 300 / 601
T = N * CPI = N * (1 + CPB) = 601 * (1 + 300 /601) = 901 ciclos
c) Reordenando sin bypass:
1 2 3
ADDI R3,R2,#400 IF ID EX
LOOP:LW R1,0(R2)
IF ID
ADDI R2,R2,#4
IF
ADDI R1,R1,#1
SUB
R4,R3,R2
SW
-4(R2),R1
BNEZ R4,LOOP
LOOP:LW R1,0(R2)

4
M
EX
ID
IF

5
WB
M
EX
-

10

11

12

13

14 15

WB
M WB
ID EX M WB
IF ID EX M WB
IF ID EX M WB
IF ID EX M WB
IF IF ID EX M WB

T = Tprimera + Tsiguientes = 10 ciclos + 9 ciclos * 99 iteraciones = 901 ciclos

Hay que fijarse que aunque reordenando las instrucciones no se han conseguido eliminar todos los
bloqueos se ha conseguido un rendimiento igual al obtenido en el anterior caso con bypass.
d) Reordenando y con bypass: ahora con el bypass es posible eliminar los anteriores bloqueos .
1 2 3
4
5
6
7
8
9
10 11 12 13 14 15
ADDI R3,R2,#400 IF ID EX M WB
LOOP:LW R1,0(R2)
IF ID EX M WB
ADDI R2,R2,#4
IF ID EX M WB
ADDI R1,R1,#1
IF ID EX M WB
SUB
R4,R3,R2
IF ID EX M WB
SW
-4(R2),R1
IF ID EX M WB
BNEZ R4,LOOP
IF ID EX M WB
IF IF ID EX M WB
LOOP:LW R1,0(R2)
T = Tprimera + Tsiguientes = 8 ciclos + 7 ciclos * 99 iteraciones = 701 ciclos
El nmero de ciclos es menos de la mitad de ciclos empleados en el primer caso!

9. La nica instruccin que se puede reubicar en el hueco dejado por la instruccin de salto es la ADD
R5, R5, R1 ya que el resto alteran la lgica del programa. El cdigo del programa en ese caso quedara
entonces de la siguiente forma:
ADDI R2,R0,#40
SUMA: LW
R1,0x100(R2)
SUBI R2,R2,#4
RBNEZ R2,SUMA
ADD R5,R5,R1
Sin embargo del ejercicio 7 se sabe que existe una dependencia de datos entre SUBI y la instruccin de
salto debido a R2. Por ello se ha de poner la instruccin de SUBI antes de la instruccin LW.
1 2 3
ADDI R2,R0,#40
IF ID EX
Suma: SUBI R2,R2,#4
IF ID
LW
R1,0x104(R2)
IF
RBNEZ R2,SUMA
ADD R5,R5,R1
Suma: SUBI R2,R2,#4

4
M
EX
ID
IF

5
WB
M
EX
ID
IF

10

WB
M
EX
ID
IF

WB
M WB
EX M WB
ID EX M WB

11 12 13 14 15

T = Tprimera + Tsiguientes = 5 ciclos + 4 ciclos * 9 iteraciones = 41 ciclos.

Esto quiere decir que se tiene 4 ciclos por iteracin, lo cual es perfecto ya que en cada iteracin se
ejecutan 4 instrucciones.

10. En principio la alternativa de usar la tcnica de salto retrasado/retardado se puede aplicar con el salto
incondicional (J) y la instruccin ADDI ya que esa instruccin se habr necesariamente de ejecutar
junto con el salto. Por ello se podra pensar en una nueva instruccin RJMP que aplique salto
retardado.

LW
ADD
ETIQ: SUBI
BEQZ
ADDI
J
FIN:

R1, 0(R2)
R3,R0,R0
R1,R1,#4
R1,FIN
R3,R3,#1
ETIQ

LW R1, 0(R2)
ADD R3,R0,R0
ETIQ: SUBI R1,R1,#4
RBEQZ R1,FIN
_
RJ
ETIQ
ADDI R3,R3,#1
FIN:

No se podra aplicar el salto retardado con la otra instruccin de salto ya que no queda ninguna otra
instruccin libre puesto que el resto de instrucciones estn antes de la etiqueta de salto (ETQ) o despus
de etiqueta de FIN. La instruccin SUBI R1,R1,#4 aunque est dentro del bucle debido a la lgica del
programa se ha de ejecutar antes del salto condicional.

11. Se pide el CPBcontrol, o sea, el nmero medio de ciclos que se pierden por instruccin debido a las
instrucciones de saltos. Se dispone de una BTB que en caso de acierto (prediccin correcta) no se pierde
ningn ciclo. Hay que tener claro que el DLX por defecto no tiene BTB y aprovecha la fase IF de la
siguiente instruccin buscada en el caso de que finalmente el salto no se tome, es decir, despus de una
instruccin de salto se busca siempre la siguiente instruccin. Cuando en base a la evaluacin de la
condicin haya que anular la instruccin, entonces se anula la fase IF de la siguiente instruccin y se
busca la nueva instruccin. En todo este proceso se pierde un ciclo de reloj.
En el enunciado se proporcionan un montn de datos estadsticos respecto al porcentaje de aciertos en la
BTB y los saltos que se toman y los que no. En base a estos datos se va a calcular el CPBcontrol. Cuando se
produce un acierto en la BTB no producen bloqueos. Durante la fase IF de la instruccin de salto se
accede a la BTB y se obtiene la direccin de la siguiente instruccin:
i: SALTO
j:

IF ID EX M WB
IF ID EX M WB Instruccin salto correcta

Cuales seran los casos en los que se producen bloqueos? Dos casos:
1 - La bsqueda en la BTB es fructuosa (probabilidad 0,9) PERO luego resulta que se falla en la
prediccin (probabilidad 1-0,9=0,1). En este caso la probabilidad es 0,9*0,1. En este caso cuntos ciclos
se pierden? Dos ciclos. El primero porque el IF que ha entrado en pipeline es el de una instruccin
errnea (hay que anularlo) y el segundo porque hay que actualizar la BTB. Por lo tanto en este 2 ciclo de
bloqueo hay que actualizar la BTB antes de buscar el siguiente IF. Por lo tanto CPB = 0,9 x 0,1 x 2 ciclos.
i: SALTO
i+1:
i+2:
j:

IF ID EX M
IF IF

WB
Sig. Instruccin anulada
Actualizacin BTB
ID EX M WB Instruccin salto correcta

2 - La bsqueda en la BTB NO es fructuosa (probabilidad 1-0,9=0,1) y adems luego se salta

(probabilidad 0,6). En este caso la probabilidad es 0,6*0,1. El nmero de ciclos que se pierden en este
tipo de casos es tambin 2 y la explicacin es anloga el del primer caso. Por lo tanto CPB = 0,1 x 0,6 x 2
ciclos.
Finalmente uniendo 1 y 2 queda que:
CPBcontrol = 0,9 x 0,1 x 2 ciclos + 0,1 x 0,6 x 2 ciclos = 0,3. Es decir una instruccin de control supone 1,3
ciclos de media.
Como se dice en el enunciado slo los saltos tomados actualizan la BTB, por lo tanto en caso de fallo (no
est en la BTB) si no se toma el salto el nmero de ciclos de bloqueo son cero.
Si se compara con un DLX normal (sin BTB) se tendra que:
CPBcontrol = 0,6 (porcentaje saltos tomados) x 1 ciclo (anular la instruccin siguiente que se busca por
defecto y buscar la instruccin de salto) = 0,6. Es decir una instruccin de control supone 1,6 ciclos de
media.

12. Dado el siguiente programa:

A
B
C
D

for(i=1;i<=100;i=i+1) {
Y[i]=X[i]/c;
X[i]=X[i]+c;
Z[i]=Y[i]+c;
Y[i]=c-Y[i]; }

Se producen las siguientes dependencias:

- Dependencias reales (RAW): A-C, A-D
- Antidependencias (WAR): B-A, D-C
- Dependencias de salida (WAW): A-D
El renombrado para evitar posibles antidependencias y dependencias de salida quedara como sigue:

A
B
C
D

for(i=1;i<=100;i=i+1) {
T[i]=X[i]/c;
X1[i]=X[i]+c;
Z[i]=T[i]+c;
Y[i]=c-T[i]; }

13. Primero se va a ver el CPI obtenido as como las dependencias y bloqueos que se producen con un
DLX escalar. Esto tambin ayudar a determinar ms tarde el nmero de instrucciones que se debern
intercalar entre los distintos tipos de instrucciones para evitar los bloqueos:

LOOP:
ADD
SW
SUBI
BNEZ
LW

1 2 3
LW
R2, 0(R1) IF ID EX
R4, R2, R3
IF ID
0(R1), R4
IF
R1, R1, #4
R1, LOOP
R2, 0(R1)

4
M
-

5
WB
EX
ID
IF

10 11

12

M
EX
ID
IF

WB
M WB
EX M WB
ID EX M WB
IF IF ID EX M

Se producen dos bloqueos debidos a dependencias de datos y otro ms debido a dependencias de control
(instruccin de salto). Por lo tanto el nmero total de ciclos necesarios para ejecutar el bucle ser:
(5 + CPBdatos + CPBcontrol) * N iteraciones = (5 + 2 + 1)*N = 8N
Para calcular el CPI se tienen: 8 ciclos por iteracin para 5 instrucciones CPI = 8/5 = 1,6
Ahora se va a pasar a desenrollar el anterior programa para poder aprovechar mejor las caractersticas
superescalares del procesador. Hay que tener en cuenta que se van a poder emitir dos instrucciones al
mismo tiempo (una de tipo ALU o salto y la otra de acceso a memoria) por lo que las dependencias a
estudiar ya no van a ser solamente entre instrucciones individuales sino entre pares de instrucciones.
Cuntas veces hay que desenrollar el bucle? Como en principio no se dice nada se empezar lo ms
sencillo y se desenrollar el bucle dos veces. Primero se duplica el cuerpo del bucle dos veces y luego se
reordenan las instrucciones:

LW
ADD
SW
SUBI

R2, 0(R1)
R4, R2, R3
0(R1), R4
R1, R1, #4

LW
ADD
SW

R2, 0(R1)
R4, R2, R3
0(R1), R4

LW
ADD
SW
SUBI

R5, 0(R1)
R6, R5, R3
0(R1), R6
R1, R1, #4

LW
ADD
SW
SUBI

R5, -4(R1)
R6, R5, R3
-4(R1), R6
R1, R1, #8

BNEZ R1, LOOP

NOP

LW
NOP

R2, 0(R1)

LW
SUBI

R5, -4(R1)
R1, R1, #8

ADD
NOP

R4, R2, R3

ADD
SW

R6, R5, R3
8(R1), R4

SW
4(R1), R6
BNEZ R1, LOOP

BNEZ R1, LOOP

Como se puede ver no se aprovecha todo el paralelismo que nos ofrece el procesador. As en las dos
emisiones de los pares de instrucciones 1 y 3 se han de recurrir a los NOP-s ya que no es posible buscar
instrucciones con las que se puedan rellenar los huecos sobrantes. Hay que fijarse tambin en las
instrucciones de acceso a memoria (LW y SW) se han tenido que modificar los ndices para el clculo de
la direccin.
Con este resultado ya podemos calcular el nmero de ciclos necesario para ejecutar este programa
desenrollado. Se tiene ahora que CPBdatos = 0 y CPBcontrol = 1. Ciclos bucle:
(5 + CPBdatos + CPBcontrol) * N iteraciones / 2 = (5 + 0 + 1)*N/2 = 3N
Para calcular el CPI se tienen: 6 ciclos para 8 instrucciones CPI = 6/8 = 0,75
Este CPI todava se aleja algo del ideal de 0,5 es decir, una instruccin se ejecuta en medio ciclo o lo que
es lo mismo: en un ciclo de reloj se ejecutan dos instrucciones. Sin embargo el CPI obtenido si que es
claramente mejor que el 1,6 obtenido con el DLX escalar.
Si se hubiese hecho loop-unrolling de 3 para aprovechar ms an el paralelismo el cdigo hubiese
quedado tal como sigue:

LW
ADD
SW
SUBI

R2, 0(R1)
R4, R2, R3
0(R1), R4
R1, R1, #4

LW
ADD
SW
SUBI

R5, 0(R1)
R6, R5, R3
0(R1), R6
R1, R1, #4

LW
ADD
SW
SUBI

R8, 0(R1)
R10, R8, R3
0(R1), R10
R1, R1, #4

BNEZ R1, LOOP

NOP

LW
ADD
SW

R2, 0(R1)
R4, R2, R3
0(R1), R4

LW
ADD
SW

R5, -4(R1)
R6, R5, R3
-4(R1), R6

LW
ADD
SW

R8, -8(R1)
R10, R8, R3
-8(R1), R10

SUBI

R1, R1, #12

BNEZ R1, LOOP

LW
NOP

R2, 0(R1)

LW
SUBI

R5, -4(R1)
R1, R1, #12

LW
ADD

R8, 4(R1)
R4, R2, R3

SW
ADD

12(R1), R4
R7, R5, R3

SW
ADD

8(R1), R7
R10, R8, R3

SW
4(R1), R10
BNEZ R1, LOOP

Con este nuevo cdigo se tiene que CPBdatos = 0 y CPBcontrol = 1. Por otro lado el bucle tendr 6 +
CPBcontrol = 7 ciclos. Como se tratan 3 elementos en cada iteracin entonces en total el programa tendr
7*N/3 siendo N el nmero total de elementos del vector.
El CPI ser 7 ciclos / 11 instrucciones = 0,63 aproximadamente, lo cual est todava ms cerca del ideal
0,5.

14. a) Para saber cul es el nmero de sumadores mnimos necesarios hay que examinar las diferentes
etapas del pipeline para comprobar las funciones realizadas y as deducir si habr que utilizar o no
sumadores/ALU-s.
IF
RF
ALU1
MEM
ALU2
WB

Un sumador para calcular la direccin de la siguiente instruccin a ejecutar

Ningn sumador. Slo se decodifica y se buscan los operandos
Un sumador para hacer los clculos de la direccin efectiva: REG. + OFFSET
Ningn sumador. Slo acceso a memoria
Un sumador/ALU para realizar las operaciones aritmtico-lgicas y se evalan las
condiciones de salto
Ningn sumador. En principio slo se escribe en los registros

En total se necesitan 3 sumadores/ALU-s como mnimo.

b) Para determinar todos los posibles desvos se hay que examinar el contenido del pipeline
durante una ejecucin de instrucciones cualquiera y ver dnde se podran aplicar bypass.
1 IF RF ALU1 MEM ALU2 WB
IF RF
ALU1 MEM ALU2 WB
2
IF
RF
ALU1 MEM ALU2 WB
3
IF
RF
ALU1 MEM ALU2 WB
4
IF
RF
ALU1 MEM ALU2 WB
5
- Centrndose en las instrucciones 1 y 2 se puede ver que no tendra mucho sentido hacer un cortocircuito
entre las fases ALU1 ya que slo se hacen clculos de direcciones efectivas y por lo tanto no se calculan
valores que luego vayan a ser escritos en registros. Si podra haber cortocircuito entre las fases MEM ya
que se podra leer un dato que previamente acaba de ser cargado de memoria.
1: LW R6, 0(R5) IF RF ALU1 MEM ALU2 WB
IF RF
ALU1 MEM ALU2 WB
2: SW 0(R8), R6
Sin embargo, algunos de estos tipos de cortocircuitos se pueden evitar mediante tcnicas software
consistentes en optimizacin de cdigo. Para ello la direccin efectiva tendra que coincidir. Ejemplo:
LW R6, 0(R5)
1: LW R6, 0(R5) IF RF ALU1 MEM ALU2 WB
IF RF
ALU1 MEM ALU2 WB NOP (o directamente quitarla)
2: SW 0(R5), R6
- Ms claro parece el cortocircuito entre las fases ALU2. Aqu un valor calculado en una instruccin
anterior se puede utilizar en la siguiente. Ejemplo:
1: ADD R5, R6, R7 IF RF ALU1 MEM ALU2 WB
2: MUL R8, R5, R9
IF RF
ALU1 MEM ALU2 WB
- No hay ms posibilidades entre las instrucciones 1 y 2. Se van a analizar ahora los posibles
cortocircuitos entre las instrucciones 1 y 3. Por la misma razn que en el anterior grupo de cortocircuitos
no tiene sentido realizar bypass entre ALU1 y RF ya que en ALU1 no se escribe ningn valor final en un
registro y RF slo se leen operandos. Si tiene sentido realizar un cortocircuito entre las fases MEM y
ALU1: un valor/operando cargado de memoria puede ser utilizado a continuacin. Ejemplo:
1: LW R7, 0(R5)
IF RF ALU1 MEM ALU2 WB
IF RF
ALU1 MEM ALU2 WB
2:
3: ADD R6, R7, R1
IF
RF
ALU1 MEM ALU2 WB
- Tambin existe la posibilidad de realizar un bypass entre las fases ALU2 y MEM. En este caso un valor
u operando previamente calculado puede ser a continuacin almacenado en memoria. Viene a ser el caso
contrario al del anterior. Ejemplo:
1: ADD R7, R6, R1 IF RF ALU1 MEM ALU2 WB
IF RF
ALU1 MEM ALU2 WB
2:
3: SW 0(R5), R7
IF
RF
ALU1 MEM ALU2 WB

10

- Finalizados todos los posibles cortocircuitos entre la instruccin 1 y 3 queda ver si es posible alguno
entre las instrucciones 1 y 4. Como se ha hecho antes se va a ir examinando la instruccin 4 en todas sus
fases yendo de izquierda a derecha. As en la fase RF existe la posibilidad de necesitar un operando
cargado en la primera instruccin. Ejemplo:
1: LW R7, 0(R5)
IF RF ALU1 MEM ALU2 WB
IF RF
ALU1 MEM ALU2 WB
2:
IF
RF
ALU1 MEM ALU2 WB
3:
4: ADD R7, R7, R1
IF
ALU1 MEM ALU2 WB
RF
- Tambin se puede dar el caso de un cortocircuito entre las fases ALU2 y ALU1 de la misma forma
parecida a como se ha visto anteriormente. Este cortocircuito slo se activara cuando el contenido del
registro de la cuarta instruccin se usase para calcular una direccin efectiva. Ejemplo:
1: ADD R7, R6, R5
IF RF ALU1 MEM ALU2 WB
IF RF
ALU1 MEM ALU2 WB
2:
IF
RF
ALU1 MEM ALU2 WB
3:
4: MUL R8, R4, 0(R7)
IF
RF
ALU1 MEM ALU2 WB
- Por ultimo falta ver los posibles cortocircuitos que se pueden aplicar cuando las instrucciones estn
separadas por otras tres instrucciones en medio. Realmente slo hay una posibilidad: Cuando en el cuarta
instruccin se necesita un operando que proviene de una operacin aritmtica de la primera instruccin.
Ejemplo:
1: ADD R8, R6, R5 IF RF ALU1 MEM ALU2 WB
IF RF
ALU1 MEM ALU2 WB
2:
IF
RF
ALU1 MEM ALU2 WB
3:
IF
RF
ALU1 MEM ALU2 WB
4:
5: ADD R1, R8, R7
IF
RF
ALU1 MEM ALU2 WB
Sin embargo esta bypass se puede evitar suponiendo que este procesador hace lo mismo que el DLX, es
decir, en el primer medio ciclo de la fase WB se escribe y en el segundo medio ciclo de la etapa RF se lee.
c) Para determinar todos los posibles bloqueos de datos no evitables se va a hacer un estudio
similar al anterior. Se van a ir cogiendo pares de instrucciones del siguiente esquema de ejecucin, siendo
la instruccin 1 siempre el primer miembro del par. Todas las dependencias de datos van a ser del tipo
reales (RAW) debido a que se escribe siempre en la fase ltima WB y todas las instrucciones tienen el
mismo nmero de fases. Por lo tanto, las dependencias de tipo WAW y WAR no van a aparecer.
1 IF RF ALU1 MEM ALU2 WB
IF RF
ALU1 MEM ALU2 WB
2
IF
RF
ALU1 MEM ALU2 WB
3
IF
RF
ALU1 MEM ALU2 WB
4
IF
RF
ALU1 MEM ALU2 WB
5
- Se empieza por la 1 y 2 instruccin. Un primer bloqueo no evitable se produce cuando existe una
dependencia real (RAW) entre las fases MEM y ALU1. En este caso la 2 instruccin necesita leer un
operando que todava no se ha cargado de memoria. Este tipo de bloqueos son inevitables y prcticamente
los nicos bloqueos de datos presentes en el DLX. Un detalle bastante importante es que ahora la 2
instruccin debe ser tambin otra de acceso a memoria y no una instruccin aritmtica entre registros.
Ejemplo:
1: LW R8, 0(R7)
IF RF ALU1 MEM ALU2 WB
2: DIV R6, R6, 0(R8)
IF
RF
ALU1 MEM ALU2 WB

11

- Otro posible bloqueo surge cuando la segunda instruccin es una instruccin de acceso a memoria y
necesita un operando calculado en una operacin de la 1 instruccin. Ejemplo:
1: ADD R6, R7, R4 IF RF ALU1 MEM ALU2 WB
2: SW 0(R8), R6
IF
RF
ALU1 MEM ALU2 WB
- Se van a estudiar ahora los posibles bloqueos existentes cuando hay una instruccin en medio. En este
caso un primer bloqueo surge cuando en la 3 instruccin se necesita un operando cargado en la 1
instruccin. Ejemplo:
1: ADD R8, R7, R5
IF RF ALU1 MEM ALU2 WB
IF RF
ALU1 MEM ALU2 WB
2:
3: ADD R6, R5, 0(R8)
IF
RF ALU1 MEM ALU2 WB

d) Para determinar los bloqueos de control hay primero que estudiar cmo y en qu fase se
produce el salto. La direccin del salto se calcula en la fase ALU1 y se resuelve la condicin en ALU2.
Como para resolver la condicin disponemos de una ALU completa las instrucciones de salto condicional
pueden ser ms complejas: cbeq R1,R2, Etiq
El diagrama de fases en caso de salto quedara tal como sigue:
Salto no tomado (apostando por salto no tomado):
i: salto IF RF ALU1 MEM ALU2 WB
IF RF
ALU1 MEM ALU2
i+1:
IF
RF
ALU1 MEM
i+2:
IF
RF
ALU1
i+3:
IF
RF
i+4:

WB
ALU2 WB
MEM ALU2 WB
ALU1 MEM ALU2 WB

Salto tomado (apostando por salto no tomado):

i: salto IF RF ALU1 MEM ALU2 WB
IF RF
ALU1 IF RF ALU1
i+1:
IF
RF
IF RF
i+2:
IF
IF
i+3:
i+4:

MEM
ALU1
RF
IF

ALU2
MEM
ALU1
RF

WB
ALU2 WB
MEM ALU2 WB
ALU1 MEM ALU2 WB

En las etapas IF, RF y ALU1 no se modifica el estado de la mquina por lo que pueden ejecutarse sin
saber si se va a tomar el salto o no. Si el salto no se toma pueden aprovecharse las etapas realizadas,
producindose un nico ciclo de bloqueo. Si por el contrario no se toma hay que repetir las etapas
realizadas antes de conocer la condicin de salto producindose cuatro ciclo de bloqueo.
Al contrario que en el DLX donde se calculaba la direccin de salto y la condicin en la misma etapa,
aqu si tiene sentido apostar por el salto tomado. Esto es debido a que la direccin de salto se calcula antes
que la condicin. Se deja al alumno como tarea estudiar los bloqueos de control en caso de apuesta
por salto tomado.

12

15. a) Si se ejecutase tal cual el cdigo generado en un DLX normal se activaran los siguientes
cortocircuitos y se produciran los siguientes bloqueos. (Nota: en el esquema siguiente y en los
posteriores esquemas faltan las tres primeras instrucciones. La 2 y la 3 producen un cortocircuito
entre las fases EX)
1
1
2
3
4
5
6
7
8
9
10
11
12

10

11 12

ADDI R9, R0, #40 IF ID EX M W

MOVI2FP F2, R9
IF ID EX M W
loop:LD R1, 0(R2)
IF ID EX M W
ADD R3, R1, R1
IF ID EX M W
SW 0(R2), R3
IF ID EX M W
SUBI R2, R2, #4
IF ID EX M W
LF F1, 0(F2)
IF ID EX M W
MULTF F3, F1, F1
IF ID EX
SF 0(F2), F3
IF ID
SUBF F2, F2, F4
IF
BNEQ R2, bucle
loop:LD R1, 0(R2)

13

14

15

16 17

M
EX
ID
IF

W
M
EX
ID
IF

W
M W
EX M W
IF ID EX

Como se puede ver slo se producen dos bloqueos debidos a dependencias de datos tipo RAW
(dependencias reales). Estas dependencias se pueden eliminar intercalando una instruccin entre las
instrucciones de load y la siguiente instruccin aritmtica. Por ejemplo: para el caso del tratamiento del
elemento en vector_int se podra intercalar la instruccin 6 entre la 3 y la 4. Adems habra que
modificar el clculo de la direccin relativa al acceder al elemento del vector en la instruccin 5 de forma
que quede algo as como: SW 4(R2), R3
En la primera iteracin se ejecutan 14 instrucciones en 17 ciclos de reloj para tratar los primeros
elementos de los vectores: 5 para la inicializacin y 12 para el cuerpo. En la segunda y sucesivas
iteraciones se ejecutan 9 instrucciones en 12 ciclos por cada elemento a tratar de vector_int y
vector_float. Asimismo se activan 6 cortocircuitos contando con el que hay entre la 2 y 3 instruccin
(de las que no aparecen en el esquema)
Teniendo en cuenta que se tiene un superescalar de dos habr que agrupar conjuntamente instrucciones de
tipo entero e instrucciones de tipo flotante intentando evitar ese tipo de bloqueo anterior debido a la
dependencia de datos RAW. Como el tratamiento del elemento en vector_int y en vector_float es
independiente podemos emparejar cada load de tipo integer con el load de tipo float. Lo mismo para
las instrucciones aritmticas y los stores. As una reordenacin del cdigo ptima (sin bloqueos) sera la
siguiente:

1
1
2
2
3
3
4
4
5
5
6
6
7
7

1 2
ADDI R9, R0, #40 IF ID
MOVI2FP F2, R9
IF ID
loop:LD R1, 0(R2)
IF
LF F1, 0(F2)
IF
SUBI R2, R2, #4
SUBF F2, F2, F4
ADD R3, R1, R1
MULTF F3, F1, F1
SW 0(R2), R3
SF 0(F2), F3
BNEQ R2, bucle
NOP (instr. Float)
loop:LD R1, 0(R2)
LF F1, 0(F2)

3
EX
EX
ID
ID
IF
IF

4
M
M
EX
EX
ID
ID
IF
IF

5
W
W
M
M
EX
EX
ID
ID
IF
IF

W
W
M
M
EX
EX
ID
ID
IF
-

10

11 12 13 14

W
W
M
M
EX
EX
ID
IF
IF

W
W
M
M
EX
IF
IF

W
W
M
ID
ID

W
EX M W
EX M W

En el esquema falta el tratamiento de las 3 primeras instrucciones que se realizaran en dos pasos: primero
la instruccin ADDI R2, R0, #40 y despus las instrucciones ADDI R9, R0, #4 y MOVI2FP F4, R9 en
paralelo. Como se puede ver ahora, se ejecutan 14 instrucciones en 10 ciclos de reloj para tratar los
primeros elementos de los vectores: 3 para la inicializacin y 7 para el cuerpo del bucle. En la segunda y
sucesivas iteraciones se ejecutan 9 instrucciones en 7 ciclos por cada elemento a tratar de vector_int y
vector_float lo cul representa una mejora en el rendimiento (S) del 12 ciclos /7 ciclos = 1,71 respecto

13

de un procesador DLX tradicional. Otra diferencia respecto al anterior caso es que ahora se activan 5
cortocircuitos en vez de 6.

b) Hay dos formas de plantear la solucin de este ejercicio. Una es suponiendo que el VLIW est
segmentado y otra suponiendo que NO es segmentado. Si se supone que NO es segmentado en cada
instruccin se ejecuta una operacin completa de cada tipo. De esta forma nunca hay dependencias entre
operaciones del mismo tipo en instrucciones continuas y por lo tanto las instrucciones pueden ser emitidas
una detrs de otra sin mayores problemas. El problema es que cada instruccin necesitara 5 ciclos (IF,
ID, EX, M, WB) porque no se aprovecha la segmentacin.
En el caso de que exista una segmentacin completa (pipeline) el sistema ser ms eficiente pero hay que
tener en cuenta las posibles dependencias entre operaciones de un mismo tipo, igual que cuando se tena
un DLX segmentado SIN cortocircuitos. Para ello el compilador deber insertar las correspondientes
instrucciones NOP donde proceda. En el caso del DLX segmentado era el propio procesador el que por
hardware bloqueaba el pipeline. Esta ltima solucin es la que se detalla a continuacin.
Teniendo como referencia el cdigo anterior se puede ver que, ahora al no tener cortocircuitos entre una
instruccin load y la siguiente instruccin que utilice el operando del load, deber al menos haber dos
ciclos de reloj. Lo mismo entre una operacin aritmtica y la operacin store que almacena el resultado
anteriormente calculado.

INSTR.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
(19)

1 acceso a
1 acceso a
memoria para memoria para
flotantes
enteros

1 operaciones
1 operaciones
aritmticas para aritmticas para
flotantes
enteros

1 para saltos

ADDI R2, R0, #40

ADDI R9, R0, #4

MOVI2FP F4, R9

ADDI R9, R0, #40

MOVI2FP F2, R9

LF F1, 0(F2)

LD R1, 0(R2)

SF -4(F2), F3

SW -4(R2), R3

LF F1, 0(F2)

LD R1, 0(R2)

SUBF F2, F2, F4

SUBI R2, R2, #4

MULTF F3, F1, F1

ADD R3, R1, R1

BNEQ R2, bucle

Un hecho curioso y a tener en cuenta es que ahora las operaciones que decrementan los punteros a los
vectores (SUBF F2, F2, F4 y SUBI R2, R2, #4 en la 12 instruccin) pueden ir contenida en la instruccin
13. Con este procesador por tanto se necesitan 18 ciclos de reloj para ejecutar 11 instrucciones en la 1
iteracin. En la 2 y sucesivas se necesitan 8 ciclos por 9 instrucciones. Por lo tanto el rendimiento es
menor que el anterior caso y como se puede ver no se aprovechan todas las capacidades de paralelizacin
de este procesador al quedar muchos huecos (NOPS) en las instrucciones que no se aprovechan para
realizar ms operaciones.
Cmo se podra mejorar el rendimiento? Intentando aumentar el nmero de operaciones que se ejecutan
por instruccin. Para conseguir generar ms operaciones y aumentar el paralelismo la mejor manera es
desenrollar el bucle un nmero determinado de veces (contra ms mejor). De esta forma se generan ms
instrucciones en ensamblador que se pueden llegar a meter como operaciones en las instrucciones VLIW.

14