ARQUITECTURAS AVANZADAS DE COMPUTADORES

FCEFyN - UNSJ

PRÁCTICA Nº 2: Programación en Assembler del DLX

Ejercicios Resueltos

Ejercicio 1:

a) Escribir el código en assembler de DLX que ejecute las siguientes operaciones: a = b + c y d = e – f

en donde a, b, c, d, e, f son variables de 4 bytes almacenadas consecutivamente en memoria a partir de la
dirección 0x64 según se muestra en la figura. La variable a = a3 a2 a1 a0 en donde a3 es el byte más
significativo y a0 el menos significativo; lo mismo para las otras variables.

Dir. Dir. Contenido

hexa dec. de 8 bits
0x64 100 a3  0(r1)
101 a2
102 a1
103 a0
0x68 104 b3  4(r1)
105 b2
ADDI r1,r0,#0x64 ;inicializa r1 a 0x64 106 b1
LW r2,4(r1) ; b3 b2 b1 b0 r2  b 107 b0
0x6C 108 c3  8(r1)
LW r3,8(r1) ;r3  c c2
ADD r4,r2,r3 ;r4  b + c ⁞ c1
c0
SW 0(r1),r4 ;a  r4 0x70 112 d3  12(r1)
LW r2,16(r1) ;r2  e d2
⁞ d1
LW r3,20(r1) ;r3  f d0
 16(r1)
SUB r4,r2,r3 ;r4  e – f 0x74 116 e3
e2
SW 12(r1),r4 ;d  r4 ⁞ e1
e0
0x78 120 f3  20(r1)
f2
⁞ f1
f0
0x7C 124
⁞
⁞
⁞

0x100 256

⁞ ⁞

1
b) Reescribir el código añadiendo las directivas del ensamblador y determinar dónde se producen riesgos de
datos suponiendo que el diseño del uP no incluye anticipación (forwarding) o atajos o cortocircuitos.
Determinar la cantidad y ubicación de las detenciones en el flujo de las instrucciones que debe efectuar el
uP para resolver las dependencias de datos.

1 .data 0x64
2 ;comienzo de los datos
3 a: .space 4 ;reservo 4 bytes para el resultado a
4 b: .word 150
5 c: .word 3480
6 d: .space 4 ;reservo 4 bytes para el resultado d
7 e: .word 4500
8 f: .word 400
9 .text 0x100
10 ;comienzo del código
M
11 LW r2,b(r0) ; b3 b2 b1 b0 r2  b IF ID EX WB
EX
12 LW r3,c(r0) ;r3  c IF ID M WB
EX
13 ADD r4,r2,r3 ;r4  b + c IF ID M WB

14 SW a(r0),r4 ;a  r4 IF ID EX M WB

M
15 LW r2,e(r0) ;r2  e IF ID EX WB
EX
16 LW r3,f(r0) ;r3  f IF ID M WB
EX
17 SUB r4,r2,r3 ;r4  e – f IF ID M WB

18 SW d(r0),r4 ;d  r4 IF ID EX M WB

Hay un riesgo de datos entre las instrucciones de las líneas 11 y 13, ya que la instrucción 11 extrae
un dato de memoria y lo almacena en el registro r2 en la etapa de WB, que temporalmente se encuentra un
ciclo después de la etapa ID correspondiente a la instrucción 13 que es donde este dato debe ser leído desde
el registro r2. Hay también un riesgo de datos entre las instrucciones de las líneas 12 y 13, ya que la 13
necesita como operando, en la etapa ID, el contenido del registro r3 que deberá estar cargado con el dato
extraído de la memoria por la instrucción 12 y esto sólo se producirá un ciclo después en la etapa de WB de
dicha instrucción 12. Solución: Estos riesgos se resuelven introduciendo dos detenciones en el flujo de la
instrucción 13 (ADD) de manera que la etapa ID de dicha instrucción quede ubicada temporalmente en el
mismo ciclo de la etapa WB de la instrucción 12 y un ciclo después del WB de la instrucción 11.
Hay también un riesgo de datos entre las instrucciones de las líneas 13 y 14 ya que el resultado a ser
almacenado en memoria por la instrucción 14 (contenido del registro r4) debería estar disponible en la etapa
ID de dicha instrucción, que se ubica temporalmente dos ciclos antes de la etapa de WB de la instrucción 13,
que es la etapa en donde el registro r4 es actualizado con el resultado. Solución: hay que introducir dos
detenciones en el flujo de la instrucción 14 (SW) de manera que la etapa ID de dicha instrucción quede
ubicada temporalmente en el mismo ciclo de la etapa WB de la instrucción 13.
Por las mismas razones, existen riesgos de datos entre las instrucciones de las líneas 15 y 17, 16 y 17,
17 y 18 (notar que la secuencia de instrucciones, a menos de la SUB en reemplazo de la ADD, y operandos
utilizados son los mismos que la porción de código anterior) y por lo tanto se implementan las mismas
soluciones (dos detenciones en el flujo de la instrucción 17 (SUB) y otras dos detenciones en el flujo de la
instrucción 18 (SW))

A continuación reescribimos el código (sin las directivas del ensamblador) con la introducción de las
instrucciones NOP que implementan las detenciones necesarias a fin de eliminar los riesgos de datos.

2
 WB
11 LW r2,b(r0) r2
WB
12 LW r3,c(r0) M
r3
13 NOP Detención

14 NOP Detención
ID WB
15 ADD r4,r2,r3 IF
r2,r3
EX M
r4
16 NOP Detención

17 NOP Detención
ID
18 SW a(r0),r4 IF
r4
EX M WB
WB
19 LW r2,e(r0) IF ID EX M
r2
WB
20 LW r3,f(r0) IF ID EX M
r3
21 NOP Detención

22 NOP Detención
ID WB
23 SUB r4,r2,r3 IF
r2,r3
EX M
r4
24 NOP Detención

25 NOP Detención
ID
26 SW d(r0),r4 IF
r4
EX M WB

c) Reordenar el código para tratar de reducir la cantidad de detenciones o bien eliminarlas.

1 .data 0x64
2 ;comienzo de los datos
3 a: .space 4 ;reservo 4 bytes para el resultado a
4 b: .word 150
5 c: .word 3480
6 d: .space 4 ;reservo 4 bytes para el resultado d
7 e: .word 4500
8 f: .word 400
9 .text 0x100
10 ;comienzo del código De esta
11 LW r2,b(r0) WB r2 manera
tenemos un
12 LW r3,c(r0) M WB r3
total de sólo
13 LW r5,e(r0) EX M WB r5 dos
14 LW r6,f(r0) ID EX M WB r6
detenciones
contra las
15 ADD r4,r2,r3 IF ID r2,r3 EX M WB r4 ocho
16 NOP Detención detenciones
del código
17 SUB r7,r5,r6 IF ID r5,r6 EX M WB r7 anterior.
18 SW a(r0),r4 IF ID r4 EX M WB

19 NOP Detención

20 SW d(r0),r7 IF ID r7 EX M WB

3
Ejercicio 2:

Calcular el valor máximo de un arreglo de 10 números de 32 bits almacenados en memoria a partir de la

dirección 500H. Usar el registro r1 para almacenar el máximo, r2 para contener el candidato a máximo y r5
como contador del lazo. Guardar el resultado al final del arreglo, indicando esta posición de memoria por la
etiqueta “mayor”.

a) Escribir el código en assembler de DLX con las directivas del programa ensamblador que ejecute dicha
tarea.
b) Determinar dónde se producen riesgos de datos y de control suponiendo que el diseño del uP no incluye
anticipación (forwarding) o atajos o cortocircuitos. Determinar la cantidad y ubicación de las detenciones
en el flujo de las instrucciones que debe efectuar el uP para resolver las dependencias de datos.
c) Reordenar el código para tratar de reducir la cantidad de detenciones o bien eliminarlas.

Solución a):

.data 0x500 ;carga del puntero de datos

;carga de los datos en memoria a partir de 0x500
inicio: .word 150,45,-3,478,32,-56,-70,608,89,145
mayor: .space 4 ;reserva de 4 bytes para el resultado
.text 0x1000 ; carga del puntero de texto
;carga del código en memoria a partir de 0x1000
main: ADDI
r7,r0,#inicio ;r7 apunta al primer dato (r7) = 0x500
r1,0(r7) ;r1  1º dato
LW
ADDI
r5,r0,#9 ;r5 es el contador del lazo (r5) = 9
otro: ADDI
r7,r7,#4 ;incremento en 4 de r7 (apunta al
;próximo dato)
LW r2,0(r7) ;r2  próximo dato (candidato)
SGT r3,r2,r1 ;si (r2) > (r1) then (r3) = 1
BEQZ r3,no mayor
ADD r1,r2,r0 ;r1  r2
no mayor: SUBI r5,r5,#1 ;decremento en 1 de r5
BNEZ r5,otro
SW mayor(r0),r1 ;almacen. del resultado en memoria

4
 Dir. Contenido
hexa de 8 bits
0x500  0(r7)

1er
Dato

0x504
2do
3 2 1 0 Dato
1er Dato byte 0 byte 1 byte 2 byte 3 0x500
2do Dato 0x504 0x508
3er Dato 0x508
⁞ ⁞ ⁞ ⁞ ⁞
⁞
⁞ ⁞ ⁞ ⁞ ⁞
10mo Dato ⁞
⁞
Resultado
⁞ ⁞ ⁞ ⁞
⁞ ⁞ ⁞ ⁞
⁞ ⁞ ⁞ ⁞ 10mo
0x1000 Dato

Código
⁞ ⁞ ⁞ ⁞ Resultado
⁞ ⁞ ⁞ ⁞ Dato
⁞ ⁞ ⁞ ⁞
Solución b): ⁞
⁞
⁞

0x1000

Código

EX WB
1 main: ADDI r7,r0,#inicio M
r7
ID
2 LW r1,0(r7) EX M WB  Dos detenciones
r7
3 ADDI r5,r0,#9 IF ID EX M WB
ID EX WB
4 otro: ADDI r7,r7,#4 IF
r7
M
r7
ID EX WB
5 LW r2,0(r7) IF M  Dos detenciones
r7 r2
ID EX WB
6 SGT r3,r2,r1 IF M  Dos detenciones
r2 r3
ID
7 BEQZ r3,no mayor IF EX M WB  Dos detenciones
r3
 riesgo de control si se ID WB
8 ADD r1,r2,r0 produce el salto
IF
r2
EX M
r1
EX WB
9 no mayor: SUBI r5,r5,#1 IF ID M
r5
ID
10 BNEZ r5,otro IF EX M WB 2
r5
ID
11 SW mayor(r0),r1  riesgo de control si se produce el salto IF EX M WB
r1

Se deben efectuar dos detenciones en el flujo de las instrucciones 2, 5, 6, 7 y 10 para poder resolver los
riesgos de datos que se presentan. Las instrucciones 5, 6, 7 y 10 se encuentran dentro del lazo, con lo que
suman 8 detenciones en el lazo que debe ejecutarse 9 veces, totalizando así 72 detenciones. Sumando a esto
las 2 detenciones que se producen antes del lazo en la instrucción 2, en la ejecución del programa se
producirán 74 detenciones. A esto hay que sumarle la pérdida de ciclos debidos a los riesgos de control que
se producen, lo que se analiza a continuación.

Las instrucciones 8 y 11 son instrucciones que siguen a saltos condicionales. En el DLX se implementa el
esquema de predicción de “salto no tomado” pasándose a ejecutar la siguiente instrucción antes de conocerse

5
si se cumple la condición de salto, por lo que si el salto se produce se cancela la siguiente instrucción y se
vacía el pipe para pasar a ejecutar la instrucción direccionada por el salto, perdiéndose el tiempo
correspondiente a los ciclos de las etapas ya ejecutadas. La dirección de salto y el resultado de la condición
son conocidas al final de la etapa ID, con lo que la cancelación de la siguiente instrucción solo cuesta un
ciclo. Por lo tanto, el riesgo de control introducido por la instrucción 10 que cierra el lazo, resultará en la
pérdida de 9 – 1 = 8 ciclos. El riesgo de control introducido por la instrucción 7 podría resultar en la pérdida
de hasta un máximo de 9 ciclos.

Para finalizar, falta ver si hay riesgos de datos, cuando se cierra el lazo “otro”, entre el WB de r1 en la
instrucción 8 y la lectura de r1 en la etapa ID de la instrucción 6, para lo cual haremos un “desenrollado”
parcial del lazo tal que contenga dichas instrucciones:

WB
8 ADD r1,r2,r0 M
r1
9 no mayor: SUBI r5,r5,#1 EX M WB
10 BNEZ r5,otro ID EX M WB
11 SW mayor(r0),r1 IF VACIADO DEL PIPE
4 otro: ADDI r7,r7,#4 IF ID EX M WB
5 LW r2,0(r7) IF ID EX M WB
6 SGT r3,r2,r1 ID
IF EX M WB
r1

…y como puede observarse no hay riesgos.

A continuación reescribimos el código (sin las directivas del ensamblador) con la introducción de las
instrucciones NOP que implementan las detenciones necesarias a fin de eliminar los riesgos de datos.

WB
1 main: ADDI r7,r0,#inicio r7
2 NOP Detención
3 NOP Detención
ID
4 LW r1,0(r7) r7
EX M WB

5 ADDI r5,r0,#9 IF ID EX M WB
WB
6 otro: ADDI r7,r7,#4 IF ID EX M
r7
7 NOP Detención
8 NOP Detención
ID WB
9 LW r2,0(r7) IF
r7
EX M
r2
10 NOP Detención
11 NOP Detención
ID WB
12 SGT r3,r2,r1 IF
r2
EX M
r3
13 NOP Detención
14 NOP Detención
ID
15 BEQZ r3,no mayor IF
r3
EX M

16 ADD r1,r2,r0 IF ID EX
no
17 SUBI r5,r5,#1 IF ID
mayor:
18 NOP Det.
19 NOP
20 BNEZ r5,otro
21 SW mayor(r0),r1

6
Solución c:

M WB
1 main: ADDI r7,r0,#inicio EX
r7
WB
2 ADDI r5,r0,#9 ID EX M
r5
ID
3 LW r1,0(r7) IF EX M WB  Una detención
r7
ID M WB
4 otro: ADDI r7,r7,#4 IF
r7
EX
r7
ID WB
5 SUBI r5,r5,#1 IF
r5
EX M
r5
ID EX WB
6 LW r2,0(r7) IF M  Una detención
r7 r2
ID EX WB
7 SGT r3,r2,r1 IF M  Dos detenciones
r2 r3
ID  Dos
8 BEQZ r3,no mayor IF
r3
EX M WB
detenciones
 riesgo de control si se produce el ID M WB
9 ADD r1,r2,r0 salto
IF
r2
EX
r1
ID
10 no mayor: BNEZ r5,otro IF
r5
EX M WB
 riesgo de control si se ID
11 SW mayor(r0),r1 Una Detención → IF EX M WB
produce el salto r1

Se deben efectuar dos detenciones en el flujo de las instrucciones 7 y 8 y una detención en el flujo de las
instrucciones 3, 6 y 11 para poder resolver los riesgos de datos que se presentan. Las instrucciones 6, 7 y 8 se
encuentran dentro del lazo, con lo que suman 5 detenciones en el lazo que debe ejecutarse 9 veces,
totalizando así 45 detenciones. Sumando a esto las detenciones que se producen antes y después del lazo en
las instrucciones 3 y 11 respectivamente, en la ejecución del programa se producirán 47 detenciones. A esto
hay que sumarle la pérdida de ciclos debidos a los riesgos de control que se producen: el riesgo de control
introducido por la instrucción 10 que cierra el lazo, resultará en la pérdida de 9 – 1 = 8 ciclos; el riesgo de
control introducido por la instrucción 8 podría resultar en la pérdida de hasta un máximo de 9 ciclos.

Se propone para el alumno buscar la posibilidad de otra reordenación o programación que logre disminuir los
riesgos.

Ejercicio 3:

Ejecutar las siguientes operaciones entre dos arreglos de datos [ai] y [bi] almacenados en memoria a partir de
las direcciones 1000h y 2000h respectivamente. Cada arreglo posee 90 datos enteros de 4 bytes y la variable
c es un valor entero de 4 bytes almacenado en memoria al final del arreglo [bi].

[ai] = [bi] + c

a) Escribir el código en assembler de DLX con las directivas del programa ensamblador que ejecute dicha
tarea. Cargar el código a partir de la dirección 100h.
b) Determinar dónde se producen riesgos de datos y de control suponiendo que el diseño del uP no incluye
anticipación (forwarding) o atajos o cortocircuitos. Determinar la cantidad y ubicación de las detenciones
en el flujo de las instrucciones que debe efectuar el uP para resolver las dependencias de datos.
c) Reordenar el código para tratar de reducir la cantidad de detenciones o bien eliminarlas.
d) Desenrollar el bucle una cantidad de veces de manera de reducir la cantidad de detenciones o bien
eliminarlas.

3 2 1 0
Código byte 0 byte 1 byte 2 byte 3 0x100
0x104

7
 ⁞ ⁞ ⁞ ⁞ ⁞
⁞ ⁞ ⁞ ⁞ ⁞
a0 0x1000
a1 0x1004
⁞ ⁞ ⁞ ⁞ ⁞
⁞ ⁞ ⁞ ⁞ ⁞
a89
⁞ ⁞ ⁞ ⁞ ⁞
⁞ ⁞ ⁞ ⁞ ⁞
b0 0x2000
b1 0x2004
⁞ ⁞ ⁞ ⁞ ⁞
⁞ ⁞ ⁞ ⁞ ⁞
b89
c

Solución a) y b):

.data 0x1000
a: .space 360 ;reservo 360 bytes para los 90 elementos de [ai]
.data 0x2000
b: .word 10,20,30,35,40,45 ;los restantes 84 valores no están especificados para simplificar
c: .word 459
.text 0x100
main: ADDI r2,r0,#0x1000 ;r2 apunta al vector [ai]
LW r3,c(r0) ;cargar en r3 la variable c
ADDI r4,r0,#90 ;r4 es el contador de lazo
lazo: LW r5,0x1000(r2) ;cargar en r5 el elemento bi
NOP ;dos detenciones debidas al riesgo de datos entre la escritura de r5
NOP ;en la instrucción de carga anterior y la lectura de r5 en la ADD
;siguiente.
ADD r6,r5,r3 ;r6  bi + c
NOP ;dos detenciones debidas al riesgo de datos entre la escritura de r6
NOP ;en la instrucción ADD anterior y la lectura de r6 en la SW siguiente.
SW 0(r2),r6 ;almacenar el resultado r6 como el elemento ai
ADDI r2,r2,#4 ;incremento de r2 en 4 para apuntar al próximo dato (elemento bi).
SUBI r4,r4,#1 ;decremento en 1del contador de lazo.
NOP ;dos detenciones debidas al riesgo de datos entre la escritura de r4
NOP ;en la instrucción SUBI anterior y la lectura de r4 en la instrucción
;de salto condicional BNEZ siguiente.
BNEZ r4,lazo
NOP ;una detención debida al riesgo de control por la ejecución de la
;instrucción BNEZ ya que el salto se resuelve en la etapa ID
;(segunda etapa de la instrucción).

8
De esta manera vemos que tenemos 6 detenciones en el bucle que debe ejecutarse 90 veces, lo que nos da un
total de 540 detenciones en la ejecución del programa. A esto hay que sumarle la pérdida de ciclos debido al
riesgo de control introducido por la instrucción “BNEZ r4,lazo” que cierra el lazo, resultando en la pérdida
de 90 – 1 = 89 ciclos.

Solución c):

A continuación escribimos el código reordenado (sin las directivas del ensamblador) de acuerdo a la
reubicación de las instrucciones indicadas en el punto anterior.

main: ADDI r2,r0,#0x1000 ;r2 apunta al vector [ai]

LW r3,c(r0) ;cargar en r3 la variable c
ADDI r4,r0,#90 ;r4 es el contador de lazo
lazo: LW r5,0x1000(r2) ;cargar en r5 el elemento bi
ADDI r2,r2,#4 ;incremento de r2 en 4 para apuntar al próximo dato.
SUBI r4,r4,#1 ;decremento en 1del contador de lazo.
ADD r6,r5,r3 ;r6  bi + c
NOP ;dos detenciones debidas al riesgo de datos entre la escritura de r6
NOP ;en la instrucción ADD anterior y la lectura de r6 en la SW siguiente.
SW -4(r2),r6 ;almacenar el resultado r6 como el elemento ai
BNEZ r4,lazo
NOP ;una detención debida al riesgo de control por la ejecución de la
;instrucción BNEZ ya que el salto se resuelve en la etapa ID
;(segunda etapa de la instrucción).

Notar que para almacenar el resultado en la posición ai correcta debemos hacerlo con un desplazamiento
negativo de 4 (SW -4(r2),r6) ya que el incremento del puntero r2 lo hacemos ahora antes del
almacenamiento de dicho resultado. De esta manera logramos tener solo 2 detenciones en el bucle, lo que
nos da un total de (2 x 90) = 180 detenciones más los 89 ciclos perdidos debido al riesgo de control
introducido por la instrucción “BNEZ r4,lazo” que cierra el lazo.

Solución d):

A continuación escribimos el código resultante de desenrollar tres veces el bucle:

main: ADDI r2,r0,#0x1000 ;r2 apunta al vector [ai]

LW r3,c(r0) ;cargar en r3 la variable c
ADDI r4,r0,#90 ;r4 es el contador de lazo
lazo: LW r5,0x1000(r2) ;cargar en r5 el elemento bi
LW r6,0x1004(r2) ;cargar en r6 el elemento bi+1
LW r7,0x1008(r2) ;cargar en r7 el elemento bi+2
ADDI r2,r2,#12 ;incremento de r2 en 12 para apuntar al dato i+3
SUBI r4,r4,#3 ;decremento en 3 del contador de lazo.
ADD r8,r5,r3 ;r8  bi + c
ADD r9,r6,r3 ;r9  (bi+1) + c
ADD r10,r7,r3 ;r10  (bi+2) + c
SW -12(r2),r8 ;almacenar el resultado r8 como el elemento ai
SW -8(r2),r9 ;almacenar el resultado r9 como el elemento ai+1
SW -4(r2),r10 ;almacenar el resultado r10 como el elemento ai+2
BNEZ r4,lazo
NOP ;una detención debida al riesgo de control por la ejecución de la
;instrucción BNEZ ya que el salto se resuelve en la etapa ID
;(segunda etapa de la instrucción).

9
Notar que como hemos desenrollado 3 veces el bucle, el lazo se ejecuta 30 veces y no hay en él ninguna
detención, solamente una pérdida de (30 – 1) = 29 ciclos debido al riesgo de control introducido por la
instrucción “BNEZ r4,lazo” que cierra el lazo y que no podemos eliminar.

Ejercicios Propuestos:

Para las tareas indicadas en cada ejercicio, realizar:

a) Escribir el código en assembler de DLX con las directivas del programa ensamblador que ejecute dicha
tarea. Cargar el código a partir de la dirección 100h.
b) Determinar dónde se producen riesgos de datos y de control suponiendo que el diseño del uP no incluye
anticipación (forwarding) o atajos o cortocircuitos. Determinar la cantidad y ubicación de las detenciones
en el flujo de las instrucciones que debe efectuar el uP para resolver las dependencias de datos.
c) Reordenar el código para tratar de reducir la cantidad de detenciones o bien eliminarlas.
d) Desenrollar el bucle una cantidad de veces de manera de reducir la cantidad de detenciones o bien
eliminarlas.

Ejercicio 4:
Intercambiar las ubicaciones en memoria de dos arreglos de datos [ai] y [bi] de 32 bits y 15 elementos
cargados en memoria a partir de las direcciones 1000h y 1200h respectivamente.

Ejercicio 5:
Intercambiar e invertir las ubicaciones en memoria de dos arreglos de datos [ai] y [bi], de manera que el
primer dato de un arreglo pase a ser el último dato del otro arreglo y así sucesivamente hasta el final. Los
arreglos son de 20 elementos de 32 bits y están cargados en memoria a partir de las direcciones 1000h y
1100h respectivamente.

Ejercicio 6:
Incrementar los elementos de un arreglo de datos [ai] de 32 bits de10 elementos cargado en memoria a partir
de la dirección 1050h en el valor de una constante c de 32 bits almacenada en memoria al final del arreglo.
La operación a realizar es: [ai]  [ai] + c.

Ejercicio 7:
Mover (copiar) un arreglo de datos cargado en memoria a otra ubicación de memoria. El arreglo se encuentra
a partir de la dirección 1300h y posee 18 elementos de 32 bits. Se desea moverlo a la ubicación de memoria
que se encuentra a partir de la dirección 1600h.

Ejercicio 8:
Repetir el ejercicio 7 considerando que el arreglo posee 25 elementos de 1 byte.

Ejercicio 9:
Realice el seguimiento del siguiente código de programación en assembler del DLX para especificar cuál es
la tarea que realiza y agregue las directivas para el programa ensamblador.

1 ADDI r1, r0, # 0x 3000

2 ADDI r2, r0, #0
3 ADDI r3, r0, #100
4 Loop LW r4, 0(r1)
5 SGT r5, r4, # 525
6 BEQZ r5, salto
7 ADD r2, r2, r4
8 salto ADDI r1, r1, #4
9 SUBI r3, r3, #1
10 BNEZ r3, loop

10
 11 SW 0(r1), r2
12 TRAP 0

Ejercicio 10:
Idem al ejercicio anterior.

1 ADDI r1, r0, #0x5000

2 ADDI r2, r0, #150
3 ADD r3, r0, r0
4 ADDI r4, r0, #40
5 ADDI r5, r0, #0x4000
6 OTRO: LW r6, 0(r1)
7 SLT r7, r6, r4
8 BNEZ r7, PROX
9 SW 0(r5), r6
10 ADD I r5, r5, #4
11 ADDI r3, r3, #1
12 PROX: ADDI r1, r1, #4
13 SUBI r2, r2, #1
14 BNEZ r2, OTRO
15 SW 0(r5), r3
16 TRAP 0

Ejercicio 11:
Escribir el código en assembler del DLX con las directivas del programa ensamblador que ejecute la
siguiente tarea: generar un arreglo de datos en memoria a partir de la dirección 0x3500 con los valores
extraídos de un arreglo de datos de 200 elementos de 4 bytes cargado en memoria a partir de la dirección
0x4500 y que cumplan con la condición de ser mayores o iguales a 350. Calcular la cantidad de datos
generados y guardar el resultado al final de la tabla. Cargar el código a partir de la dirección 100h.

11