Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
3.
MOV AX, BX
CMP AX, BX
NEG [BX]
LOOP ETIQUETA
INC [BX+DI+100h]
4.
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.
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.
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
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
8.
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
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
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
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
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]; }
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
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
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
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
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
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
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
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
MOVI2FP F4, R9
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)
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