Realizar un programa para calcular la expresión aX+Y donde a es un escalar

y X e Y son dos vectores de N=64 componentes. Los componentes de los

vectores se encuentran almacenados en memoria de posiciones
consecutivas a partir de dos direcciones, RX y RY conocidas. Además, tanto
el numero a como los componentes de X e Y son números de doble
precisión.
Suponiendo un cauce con las etapas IF, ID,EX, MEM, WB, y que la
multiplicación tarda 5 ciclos y la suma 2 y hay un multiplicador y un
sumador que pueden trabajar en paralelo, estimar el numero de ciclos que
necesitaran y aplicar alguna técnica que permita reducir los atascos(stalls)
para este programa.(NOTA: en las instrucciones de salto, si el salto se
toma, el procesador aborta cualquier instrucción que capta después de
ella)
• El tiempo de ejecución de la iteración es de 16 ciclos, así se realizan N
iteraciones, el tiempo consumido por el programa seria 16xN, pero a este
numero tenemos que sumarle los 4 ciclos correspondientes a las
instrucciones que están fuera del bucle, mas los 3 ciclos que tenemos que
esperar para que termine la ultima instrucción del programa por lo tanto el
programa tardaría:
T(N)= 4 + 16N+3= 16N+7
• Una forma de mejorar las prestaciones del programa es desenrollar el
bucle. En el código que se muestra a continuación, se ha aplicado esta
técnica de forma directa. Es decir, se duplican las instrucciones de una
iteración del bucle sin desenrollar, excepto la instrucción de resta utilizada
para determinar el final de las iteraciones.
Así pues, cada iteración necesita 28 ciclos (en lugar de los 16 del bucle sin
desenrollar), pero hay que ejecutar la mitad de iteraciones (N/2). Por lo
tanto, si a eso se unen los cuatro ciclos de las instrucciones iniciales, y los
tres que hay que esperar para que termine la ejecución de la última
instrucción, el tiempo necesario (suponiendo N par) es:
T(N)= 4 +28N/2 +3=14N+7
De esta forma, el número de ciclos que se reduce es igual al doble del
número de iteraciones del bucle inicial, se puede comprobar que el número
de ciclos obtenido es 903 (N=64 en el programa).
Se puede reducir algo más el tiempo de ejecución si se reordenan las
instrucciones en el código correspondiente al bucle desenrollado
(aprovechando que en cada iteración se tienen más instrucciones para
reordenar). Una posible forma de reordenar las instrucciones se muestra a
continuación.
 start: ld f0,a (1)
add r8,r0,rx (2)
addi r4,r8,#512 (3)
add r12,r0,ry (4)
loop: ld f2,0(r8) (5)
ld f4,0(r12) (7)
multd f2,f0,f2 (6)
ld f6,8(r8) (5’)
ld f8,8(r12) (7’)
addd f4,f2,f4 (8)
multd f6,f0,f6 (6’)
sd 0(r12),f4 (9)
addi r8,r8,#16 (10’)
sub r20,r4,r8 (12)
addd f8,f6,f8 (8’)
sd 8(r12),f8 (9’)
addi r12,r12,#16 (11’)
bnez r20,loop (13)
• Así pues, en cada iteración se pierden cuatro ciclos debido a
dependencias, con respecto al caso ideal en el que cada instrucción tarda
un ciclo. Así pues, como en la iteración hay 14 instrucciones y se pierden
4 ciclos, el tiempo de cada iteración es 14+4=18, más un ciclo que se
pierde siempre después de la instrucción de salto. En total tenemos que
cada iteración necesita 19 ciclos, y por tanto (teniendo en cuenta que N
es par):

Tdesenrollado2(N) = 7 + 19*(N/2) = 7 + 9.5*N

De esta forma, se ganan 4.5 ciclos por iteración con respecto al

desenrollado anterior, y 6.5 ciclos por iteración con respecto a la situación
inicial.
• En el problema anterior se ha supuesto que el procesador abortaba cualquier
instrucción que se captase después de una instrucción de salto. Esta
situación obliga a que se tenga que introducir una instrucción sin utilidad
para el programa (instrucciones de no-operar). Indique qué cambio haría en
el código inicial si el procesador captara y ejecutara normalmente la
instrucción que sigue a una instrucción de salto condicional.

• Una forma posible de aprovechar que las instrucciones que siguen a una
instrucción de salto se ejecutan normalmente es poner la primera instrucción
de una iteración (la instrucción (5)) después de la instrucción de salto. Por
supuesto, en el caso de que no se produzca el salto también se ejecutará, y
habrá que estudiar si esto tiene efectos en la semántica del programa.